Przejedź się na Reading, jeśli zdasz Go, zbierz 200 $

39

Zarząd Monopolu

W ramach tego wyzwania golfowego budujemy grę planszową Monopoly.

Zasady:

  • Nie wkładaj żadnych danych.
  • Wyjmij planszę 11x11, gdzie każda postać ASCII tworząca planszę jest pierwszą literą każdej spacji amerykańskiej wersji planszy Monopoly.
  • Znaki muszą być oddzielone spacjami.
  • Go powinien zacząć się w prawym dolnym rogu.

Dokładny ciąg do wyprodukowania to

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

Zauważ, że od dołu z prawej do dołu z lewej strony kwadraty są następujące:

G --> Go
M --> Mediterranean Avenue
C --> Community Chest
B --> Baltic Avenue
I --> Income Tax
...
J --> Jail

Edytuj Wow! na pewno wam się podobało! :)

jacksonecac
źródło
7
Nie chcę być kozłem ofiarnym, ale ... jak mija się Go przechodząc do Boardwalk?
Sp3000,
4
Jeśli jesteś na deptaku :)
jacksonecac
8
Które nie można zdobyć karty szansy, jeśli jesteś na deptaku :(
jacksonecac
27
Nie zawiodłem was wszystkich
jacksonecac,
3
Czy dozwolone są spacje końcowe?
Adnan,

Odpowiedzi:

36

Siatkówka , 74 bajty


FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
S_`(._.)
_
9$*
\B

1

Przedostatnie i ostatnie wiersze powinny zawierać pojedynczą spację.

Wypróbuj online!

Wyjaśnienie


FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Zastępuje to (puste) wejście ciągiem w drugim wierszu.

S_`(._.)

Jest to etap podzielony, który rozdziela ciąg wokół dopasowań wyrażenia regularnego (._.)(to znaczy dowolnych trzech znaków z _pośrodku). Powodem, dla którego umieściliśmy całe wyrażenie regularne w grupie, jest to, że podzielone etapy zwracają również wyniki przechwytywania grup. Np. Dzielenie abcdsię bcdaje [a, d], ale podzielenie go b(c)daje [a, c, d]. W ten sposób otrzymujemy wszystkie ._.części w osobnych wierszach, ale także 11-znakowe części na początku i na końcu. Używamy _opcji pomijania pustych wyników między poszczególnymi ._.dopasowaniami. Wynik byłby następujący:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Następnie przetwarzamy podkreślenia:

_
9$*

To zastępuje każdy znak podkreślenia dziewięcioma 1. Powodem, dla którego używamy 1tutaj s zamiast spacji, jest to, że ułatwia wstawianie spacji w następnej kolejności.

\B

Pamiętaj, że w drugiej linii jest spacja. To wstawia spację w każdej pozycji, która nie jest granicą słowa, tj. Wszędzie oprócz początku i końca linii.

1

I wreszcie, wszystkie te zastępujemy również 1spacjami.

Martin Ender
źródło
1
Dobra robota! To było szybkie!
jacksonecac,
39
+1 dla (._.).
Destructible Lemon,
^ miał właśnie powiedzieć, że ahha
jazzboy
25

Galaretki , 44 bajtów

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G

Wypróbuj online!

Pomysł

Jeśli usuniemy co drugą kolumnę i transponujemy wiersze z kolumnami, otrzymamy następującą tablicę.

FNTCSPVSESJ
K         C
C         V
I         C
I         O
B         R
A         I
V         B
W         C
M         M
GPNCPSCPLBG

Teraz możemy obrócić każdą kolumnę o jedną jednostkę w prawo, przesuwając wszystkie pozostałe pola w prawo.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Następnie usuwamy pozostałe przestrzenie i zastąpić karetki z literą D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Teraz zastępujemy każdą literę indeksem opartym na 1 w alfabecie.

10  6 14 20  3 19 16 22 19  5 19  4  3 11  4 22  3  4  3  9  4 15  9  4 18
 2  4  9  1  4  2 22  4  3 23  4 13 13  4  7  7 16 14  3 16 19  3 16 12  2

Następnie konwertujemy tę tablicę cyfr z bazy bijective 23 na liczbę całkowitą.

54580410997367796180315467139871590480817875551696951051609467717521

Teraz przekształcamy tę liczbę całkowitą w bazę bijective 250 .

  2 232  57  78 163  84 132  77 228 144  27 100  77 176 195
 42   9  55  83 167 155   1 210 125 211   4 232 119  20

Na koniec używamy tych cyfr do indeksowania strony kodowej Jelly .

£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ

Są to zakodowane dane, które uwzględnimy w programie ( 29 bajtów ). Aby uzyskać pożądany wynik, wystarczy odwrócić powyższe kroki.

Kod

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G  Main link. No arguments.

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’               Convert the string from bijective
                                              base 250 (using the indices in
                                              Jelly's code page) to integer.
                               ḃ23            Convert that integer to bijective
                                              base 23.
                                  ṣ4          Split the resulting array at
                                              occurrences of 4.
                                    ịØA       Replace the remaining digits in the
                                              resulting 2D array with the
                                              corresponding uppercase letters.
                                       z⁶     Zip/transpose rows and columns,
                                              padding shorter rows with spaces.
                                         ṙ1   Rotate the rows one unit down.
                                           G  Grid; join rows by spaces, columns
                                              by linefeeds.
Dennis
źródło
5
Dziękuję za szczegółowe wyjaśnienie. Zawsze interesujące jest obserwowanie procesu odpowiadającego na pytania dotyczące golfowego kodu. :)
XtraSimplicity
11
Code Golf - gdzie normalnie jest widzieć liczbę w bazie 250 i bazie 23.
corsiKa
Niezła technika kompresji. Dlaczego transpozycja jest konieczna?
ETHprodukcje
@ETHproductions Galaretka nie ma atomu wypełniającego, więc mogę albo ręcznie wypełnić wszystkie rzędy spacjami na tej samej długości, albo użyć dyferencyjnego zamka błyskawicznego ( z) z wypełniaczem.
Dennis,
16

05AB1E , 48 47 bajtów

Dzięki Emignie za uratowanie bajtu!

•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

Wyjaśnienie:

Najpierw kompresja. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•to skompresowana wersja następującego numeru:

120860198958186421497710412212513392855208073968557051584380118734764403017

Następnie jest konwertowany na bazę 33 , co daje następujący ciąg:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Zera są zastępowane 9 spacjami , przy użyciu następującego kodu ¾9ð×:. Następnie Sdzielimy ciąg na postacie i kroimy je na 11 elementów (zakończonych 11ô). Otrzymujemy następującą dwuwymiarową tablicę:

[['F', 'K', 'C', 'I', 'I', 'B', 'A', 'V', 'W', 'M', 'G'], 
 ['N', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['T', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'N'], 
 ['C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'S'], 
 ['V', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'L'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B'], 
 ['J', 'C', 'V', 'C', 'O', 'R', 'I', 'B', 'C', 'M', 'G']]

Mamy gridify tę tablicę »i wyjście to pośrednio.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Adnan
źródło
3
Kompresja z 0 zamiast D oszczędza bajt•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
Emigna,
@Emigna Ach, to sprytne! Dzięki :).
Adnan,
12

Python 2, 89 bajtów

l='%s '*11+'\n'
print(l+'%s%20s\n'*9+l)%tuple("FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG")

Tworzy szablon

? ? ? ? ? ? ? ? ? ? ? 
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
? ? ? ? ? ? ? ? ? ? ? 

zastępować literami poprzez formatowanie ciągów. Szablon używa dwóch rodzajów linii:

  • Zewnętrzna linia l11 kopii litery plus spacja, a następnie nowa linia. Jest również używany w pierwszej i ostatniej linii. Ma spację końcową.
  • Wewnętrzna linia znaku, następnie znak poprzedzony 19 znakami spacji, a następnie nowa linia. Jest kopiowany 9 razy dla linii środkowych.

Python 3.5 może zapisać bajt z rozpakowaniem krotki (*'...',).

xnor
źródło
1
Przejście na Python 3.5 powinno oszczędzić bajt.
Dennis,
9

PowerShell v2 +, 131 123 114 110 99 bajtów

'F K C I I B A V W M G
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
J C V C O R I B C M G'-replace0,(" "*19)

To tylko dosłowny ciąg z nowymi liniami umieszczonymi na rurociągu, z odrobiną -replacena końcu, aby zamienić 0w 19spacje. Pierwszy i ostatni wiersz są dosłowne. Mając tylko 10 pól i niewiele powtórzeń, nie było wystarczająco dużo miejsca na grę w golfa. Ciąg ten pozostawia się w potoku, a dane wyjściowe za pośrednictwem niejawnego mają Write-Outputmiejsce po zakończeniu programu.

PS C:\Tools\Scripts\golfing> .\take-a-ride-on-reading.ps1
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
AdmBorkBork
źródło
9

JavaScript ES6 REPL , 105 102 101 bajtów

Tutaj nie dzieje się nic ciekawego. Wklej w konsoli, aby zobaczyć pożądane wyniki

Zaoszczędzono 3 bajty dzięki @Arnauld
Zaoszczędzono jeszcze 1 bajt dzięki @Neil

`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

Bassdrop Cumberwubwubwub
źródło
Nie sądzę, aby REPL było dozwolone.
NoOneIsHere
1
Udało mi się ogolić kolejny bajt. Zamień 1s na spacje i użyj tego wyrażenia regularnego:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
Neil,
Innym sposobem na ogolenie innego bajtu jest zastąpienie 1s spacjami i użycie tej funkcji:a=>a-1?a.repeat(18):a+' '
ETHproductions
@Neil dzięki, uwielbiam twoje podejście!
Bassdrop Cumberwubwubwub
7

/// , 100 98 bajtów

/s/    //p/ssss   //q/pC
SpP
//!/ C /F K!I I B A V W M G 
NpP
TpN
CqPpS
VqEpL
SpB
J!V!O R I B!M G 

Wypróbuj online!

Z jakiegoś tajemniczego powodu wydaje się, że po Gs są spacje końcowe . Bez nich mój kod miałby 96 bajtów.

Dzięki 42545 (ETHproductions) i 56258 (daHugLenny) za zmniejszenie 1 bajta każdy!

Erik the Outgolfer
źródło
@ETHproductions Może błędny link? Nie mogę zapisać takiego bajtu.
Erik the Outgolfer,
Czy to nie 98 bajtów, jeśli usuniesz spację po Gs w pierwszym i ostatnim wierszu?
Emigna,
1
@Emigna Wiem, ale dokładne dane wyjściowe je zawierają, więc ich nie usunę.
Erik the Outgolfer,
Mój zły, spróbuj tego .
ETHproductions
6

Turtlèd , 72 bajty

"K C I I B A V W M G">"GPNCPSCPLBG">"G M C B I R O C V C J">"JSESVPSCTNF

Wypróbuj online

>obraca żółwia, "foo"zapisuje struny na siatce. ostatni "był możliwy

Zniszczalna cytryna
źródło
5

V , 75, 62 , 59 bajtów

iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./& 

Wypróbuj online!

Ponieważ ten kodel zawiera znaki spoza ASCII, oto zrzut heksowy:

0000000: 6946 4b43 4949 4241 5657 4d47 0a4e 5054  iFKCIIBAVWMG.NPT
0000010: 4e43 4353 5050 5356 4353 5045 4c53 420a  NCCSPPSVCSPELSB.
0000020: 4a43 5643 4f52 4942 434d 471b 2df2 39e1  JCVCORIBCMG.-.9.
0000030: 206c 6c69 0af2 cd2e 2f26 20               lli..../& 

Wyjaśnienie. Najpierw wprowadzamy następujący tekst:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Następnie <esc>wracamy do trybu normalnego. W tym momencie kursor znajduje się w trzeciej linii ostatniego G. Dogodnie jest polecenie, aby umieścić nas w pierwszej kolumnie linii tuż nad kursorem. To polecenie jest -. Następnie, gdy skończymy w drugiej linii (w N), uruchamiamy następującą pętlę:

ò9á lli
ò

Wyjaśnienie:

ò           " Recursively:
 9á         "   Append 9 spaces
    ll      "   Move to the right twice. This will fail on the last time because there isn't a space to move into
      i     "   Enter a newline
ò           " End

Teraz bufor wygląda następująco:

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

Teraz używamy skompresowanego wyrażenia regularnego, aby zastąpić każdy znak tym znakiem i spacją. To jest ta Í./&część. To przekłada się na następujące wyrażenie regularne vim:

:%s/./& /g

Co znaczy:

:%          " On any line
  s/        " Substitute
    ./      " Any character with
      & /   " That same character and a space
         g  " Allow for multiple substitutions on the same line
DJMcMayhem
źródło
4

R, 149 146 bajtów

Nie tak imponujące, ale też nie jestem pewien, jak by to wyglądało. Wykorzystanie pastejakoś to moje pierwsze przypuszczenie. Porównaj z surowym tekstem 241 bajtów.

x=strsplit("NTCSPVSESPNCPSCPLB","")[[1]];cat("F K C I I B A V W M G\n");for(i in 1:9)cat(x[i],rep("",18),x[i+9],"\n");cat("J C V C O R I B C M G")

Skrzypce R.

Billywob
źródło
4

Python 2, 108 bajtów

Nieznacznie różni się od drugiej odpowiedzi w Pythonie, nie używając zamiany, tylko sprzężenia łańcuchowe.

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))
TFeld
źródło
1
Wiedziałem, że zip jest drogą do przodu! Miałem prawie takie samo rozwiązanie do 118 wcześniej i zamierzałem zagrać w golfa tego wieczoru. Brakowało mi mapy. Chyba mnie do tego pobiłeś. +1
ElPedro,
4

Perl, 90 bajtów

Bardzo nudne podejście, nie mogę wymyślić lepszego sposobu na zmniejszenie ... Wymaga -Ebez dodatkowych kosztów. Generuje dodatkową spację na końcu każdego wiersza. -2 bajty dzięki @Dada !

say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr

Stosowanie

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'
Dom Hastings
źródło
2 bajty krótszy (ale w zasadzie tego samego kodu, jak ty) perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Zamień \nna dosłowne znaki nowej linii, aby dostać się do 90).
Dada,
@Dada Ahhh, o wiele ładniejszy! Dzięki!
Dom Hastings,
„dużo fajnie” znalazłoby rozwiązanie 40-bajtowe, ale dzięki: D
Dada
4

Jolf, 72 bajty

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"wΖhζ♣

Wymień wszystkie z \x05, lub spróbować go tutaj!

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."..."wΖhζ♣
Ζ0                                   ζ = 0
   ,ahtht"111"                       a box of width&height 11, with borders "1"
  ρ           '.d                    replace each char in that string with...
                 ?=H♣                 is it a space?
                     Q♣                if so, return two spaces.
                                      otherwise
                        ."..."         get the Nth member of this string
                              wΖhζ      where N = (++ζ) - 1
                       +          ♣      and add a space to the end

To daje pożądany ciąg.

Conor O'Brien
źródło
3

Java 7, 177 165 142 131 bajtów

String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM".replace("_","         ").replace(""," ");}

-15 bajtów dzięki @BassdropCumberwubwubwub .
-11 bajtów dzięki @Numberknot .

Kod niepoznany i testowy:

Wypróbuj tutaj.

class M{
  static String c(){
    return "FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM"
      .replace("_","         ").replace(""," ");
  }

  public static void main(String[] a){
    System.out.print(c());
  }
}

Wynik:

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
Kevin Cruijssen
źródło
1
String c(){String s=" ";return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace(""," ").replace("_",s);}za 150 (zauważ, że
zmiana stosu
@BassdropCumberwubwubwub Umm .. wyświetla tylko 3 spacje między „pionowymi ścianami”, zamiast 19 .. Oto ideał twojego kodu.
Kevin Cruijssen
Stąd moja uwaga, powinno być więcej spacji, sale wymiana stosów usunęła je. Oto ideone , teraz nawet w 142 bajtach
Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Ah ok. Nie wiedziałem, że myślisz między s=" ". W takim przypadku jest rzeczywiście krótszy. I .‌​replace(""," ").replace("_",s);może .replace("_",s).‌​replace(""," ");zamiast tego być o dodatkowe -8 bajtów
Kevin Cruijssen
1
String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace("_","&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;").replace(""," ");}( 131 bajtów )
Numberknot
3

Befunge, 120 bajtów

<v"FKCIIBAVWMG NPTNCCSPPSVCSPELSB $JCVCORIBCMG "
:<,*48 ,_v#-*48<
>1-:#v_\,>$52*, :48*-!#v_,54*
^,*84<         ^p19*88$<

Pierwszy wiersz ma ciąg do wydrukowania w odwrotnej kolejności (wygląda na to, że tak nie jest, ale kod przewija się wstecz w tym wierszu). Druga linia drukuje górny i dolny wiersz. Trzecia linia i lewa strona czwartej linii drukują środkowe rzędy, a mały fragment w prawym dolnym rogu robi ciekawą rzecz: przesuwa kursor z powrotem do drugiego rzędu, aby wydrukować ostatni wiersz, ale po jego zakończeniu skwitowany.

Jak widać w pierwszym wierszu, łańcuchy są oddzielone spacjami, aby rozróżnić pierwszy, środkowy i ostatni wiersz. Spacje mogą być dowolne, a gdybym użył znaków ASCII 0–9, mógłbym z łatwością zapisać 4 bajty. $, Który widzisz, to po prostu śmieciowy znak, który musi tam być i można go zastąpić dowolnym spacją.


źródło
3

J, 77 73 bajtów

' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5

Zauważ, że 43 bajty, ponad połowa wszystkich, są używane tylko dla ciągu ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Wyjaśnienie

Najpierw utwórz listę

   |i:5
5 4 3 2 1 0 1 2 3 4 5
   5-|i:5
0 1 2 3 4 5 4 3 2 1 0

Następnie przygotuj tabelę czasową

   */~5-|i:5
0 0  0  0  0  0  0  0  0 0 0
0 1  2  3  4  5  4  3  2 1 0
0 2  4  6  8 10  8  6  4 2 0
0 3  6  9 12 15 12  9  6 3 0
0 4  8 12 16 20 16 12  8 4 0
0 5 10 15 20 25 20 15 10 5 0
0 4  8 12 16 20 16 12  8 4 0
0 3  6  9 12 15 12  9  6 3 0
0 2  4  6  8 10  8  6  4 2 0
0 1  2  3  4  5  4  3  2 1 0
0 0  0  0  0  0  0  0  0 0 0

Następnie sprawdź równość z zerem

   0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1

Spłaszcz go, znajdź sumy sumaryczne i pomnóż elementarnie

   ,0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
   +/\,0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 12 12 12 12 12 12 12 12 12 13 14 14 14 14 14 14 14 14 14 14 15 16 16 16 16 16 16 16 16 16 16 17 18 18 18 18 18 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 23 24 24 24 24 24 24 24 24 24 24 25 26 26 26 26 26 26 26 26 26 26 27 28 28 28 28 28 28 28 28 28 28 29 30 31 32 33 34 35 36 37 38 39 40
   (*+/\),0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 0 0 0 0 0 0 0 0 0 13 14 0 0 0 0 0 0 0 0 0 15 16 0 0 0 0 0 0 0 0 0 17 18 0 0 0 0 0 0 0 0 0 19 20 0 0 0 0 0 0 0 0 0 21 22 0 0 0 0 0 0 0 0 0 23 24 0 0 0 0 0 0 0 0 0 25 26 0 0 0 0 0 0 0 0 0 27 28 0 0 0 0 0 0 0 0 0 29 30 31 32 33 34 35 36 37 38 39 40

Następnie połącz z zerami, podziel go na podlisty o długości 22, upuść nagłówek każdej podlisty i użyj wartości jako wskaźników w ciągu ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'

   ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
mile
źródło
Najlepsze, co mogłem uzyskać za pomocą ogólnej kompresji ciągów, to 90 bajtów:(' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '
Conor O'Brien,
@ ConorO'Brien Tak, ciężko jest grać w golfa kompresją łańcuchów w J, gdy inne języki mają słowniki i wbudowaną kompresję.
mil
@ ConorO'Brien Próbowałem trochę pograć w golfa z twoim pomysłem i dostałem go do 76 bajtów_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '
mil
3

Właściwie 74 bajty

"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%

Wypróbuj online!

Ten program działa na tej samej podstawowej zasadzie, co odpowiedź Python 2 xnor .

Objaśnienie (nowe znaki zastąpiono \ndla przejrzystości):

"%s"9⌐α' j                                       ' '.join(["%s"]*11)
;                                                duplicate
"%s%20s"9α'\nj                                   '\n'.join(["%s%20s"]*9)
(                                                move bottom of stack to top
k'\nj                                            '\n'.join(stack)
"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%                    %tuple(longstring)
Mego
źródło
3

C # 6, 192 190 bajtów

using System.Linq;
string f()=>string.Join("\n","FKCIIBAVWMG~N!P~T!N~C!C~S!P~P!S~V!C~S!P~E!L~S!B~JCVCORIBCMG".Replace("!","         ").Split('~').Select(s=>string.Join(" ",s.Select(c=>c))));

Bez spacji; bez końca nowej linii.

Proste rozwiązanie. Zacznij od literału. Replace !o 9 spacji. Następnie Splitna 11 ciągów znaków ~i dalej do char(wewnętrznego Select). Dodaj spację do każdej postaci, a następnie z Joinpowrotem do 11 ciągów znaków. Wreszcie kolejny Joinznak nowej linii.

Link nr
źródło
3

Ruby, 92

Pełny program, drukuje na standardowe wyjście za pomocą $> <<

40.times{|i|$><<"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"[i]+(i%29>9?[$/,' '*19][i%2]:' ')}

Do wydrukowania jest 40 liter. Litery od 10 do 28 występują naprzemiennie, po których następuje nowa linia lub ' '*19. Wcześniejsze i późniejsze litery są oddzielone pojedynczymi spacjami.

Level River St
źródło
3

Perl, 115 112 bajtów

print FKCIIBAVWMG=~s/(.)/\1 /gr.NPTNCCSPPSVCSPELSB=~s/(.)(.)/"\n$1".$"x19 .$2/gre."\nJCVCORIBCMG"=~s/(.)/\1 /gr;

Daje następujące dane wyjściowe:

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

Pierwszy i ostatni wiersz wyniku mają spację końcową. Kod wykorzystuje zamienniki wyrażeń regularnych oraz fakt, że jeśli obiekty nie są zdefiniowane, są one interpretowane jako ciągi znaków (np. FKCIIBAVWMG jest traktowany jako „FKCIIBAVWMG”. Nie można pobrać cudzysłowów z ostatniego wiersza z powodu poprzedzającego nowego wiersza, który Nigdzie indziej nie mogłem finagle.

Edycja 1: Zapisano 3 bajty, zastępując " "je $", usuwając nawiasy zewnętrzne i wstawiając spację po wydruku, a także usuwając nawiasy wokół $"x19i dodając spację (aby .nie były interpretowane jako dziesiętne)

Gabriel Benamy
źródło
Nadal możesz zapisać kilka bajtów: s/(.)/\1 /można je zastąpić s/./$& /. Upuść ostatni średnik. Użyj sayzamiast print(do tego trzeba dodać -M5.010lub użyć -Ezamiast -e, ale oba są bezpłatne (patrz tutaj )). Dosłowne nowe znaki zamiast \n.
Dada,
2

Python 2, 116 bajtów

Całkiem proste, z jakiegokolwiek powodu, mimo że zamiana sznurka jest tak pełna, to była najlepsza rzecz, jaką mogłem wymyślić. Być remoże użycie może być krótsze.

print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace(' ! ','\n').replace('@',' '*17)
Kade
źródło
print'F K C I I B A V W M G\nN@P\nT@N\nC@C\nS@P\nP@S\nV@C\nS@P\nE@L\nS@B\nJ C V C O R I B C M G'.replace('@',' '*19)ma również 116 bajtów bez użycia sprzężenia, jeśli chcesz być bardziej bezpośredni. Alternatywnie, print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace('! ','\n').replace('@',' '*17)wynosi 115 bajtów, jeśli dozwolone jest końcowe białe znaki. (Argumentem zastępującym jest „!”, Zamiast „!”.)
MichaelS,
2

Partia, 171 bajtów

@echo F K C I I B A V W M G
@set s=NPTNCCSPPSVCSPELSB
:l
@echo %s:~0,1%                   %s:~1,1%
@set s=%s:~2%
@if not "%s%"=="" goto l
@echo J C V C O R I B C M G
Neil
źródło
2

GameMaker Language, 148 bajtów

Wiem, że to dość proste, ale nie sądzę, że można to pokonać w GML ...

a="                   "return"F K C I I B A V W M G #N"+a+"P#T"+a+"N#C"+a+"C#S"+a+"P#P"+a+"S#V"+a+"C#S"+a+"P#E"+a+"L#S"+a+"B#J C V C O R I B C M G "
Timtech
źródło
1
Dzięki @NiCkNewman, ale faktycznie użyłem go już wcześniej na tej stronie - codegolf.stackexchange.com/search?q=GameMaker
Timtech
Rozumiem, myślałem o zrobieniu trochę GDScriptjęzyka z Godotsilnika gry. Ale nie jestem pewien, czy byłoby w porządku :)
NiCk Newman
Ach, gdyby tylko deska była większa; string_repeat(" ",19)ma taką samą długość jak " ".
u54112,
1
@NiCkNewman To powinno być w porządku, powiedz mi, jeśli napiszesz :)
Timtech
@lastresort Wiem ... GML pozwala na sztuczki polegające na rozbijaniu elementów, ale jego polecenia są tak szczegółowe ...
Timtech
2

Pip , 64 bajty

63 bajty kodu, +1 dla -Sflagi.

.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"

Wypróbuj online!

Wyjaśnienie

Zastosowani operatorzy:

  • . (binarne) konkatenuje (działa na pozycjach na listach).
  • X(binarne) mnoży ciąg. ( sjest zmienną wstępnie zainicjalizowaną " ").
  • ^ (unary) dzieli ciąg na listę znaków.
  • .*jest innym sposobem podziału łańcucha na znaki. Składa się z jedności ., która nie ma op-stringów, w połączeniu z *meta-operatorem, który mapuje jednoargumentowy operator na każdy element w (iterowalnym) operandzie. Użycie .*"..."pozwala nam zaoszczędzić bajt nad (^"...")- nawiasy byłyby wymagane, ponieważ .ma wyższy priorytet niż ^.
  • PEdołącza element do listy. AEdołącza element do listy.

Na tym tle oto kod krok po kroku:

.*"NTCSPVSES"

['N 'T 'C 'S 'P 'V 'S 'E 'S]

.sX19

["N                   "
 "T                   "
 "C                   "
 "S                   "
 "P                   "
 "V                   "
 "S                   "
 "E                   "
 "S                   "]

.^"PNCPSCPLB"

["N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

PE^"FKCIIBAVWMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

AE^"JCVCORIBCMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"
 ['J 'C 'V 'C 'O 'R 'I 'B 'C 'M 'G]]

Gdy ten wynik jest automatycznie drukowany, -Sflaga dołącza do list podrzędnych w spacjach i listy głównej w znakach nowej linii, dając pożądany wynik.

DLosc
źródło
2

C 171 156 bajtów

i,j;char*b="FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG ";f(){for(i=1;*b;j=i%21==0?putchar(*b++),puts(""),i++,*b++:i<21||i>210?i&1?*b++:32:32,putchar(j),i++);}

Wyprowadza również znak nowej linii ... Prawdopodobnie można go nieco pograć w golfa.

cleblanc
źródło
2

Perl 5, 92 86 bajtów

  • zaoszczędził 6 bajtów dzięki Dadzie

$a="%s "x11;printf"$a
"."%s%20s
"x9 .$a,FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG=~/./g

Zastosowania sprintf, dopełnienie i operator powtarzania łańcucha x.

simbabque
źródło
Niezłe rozwiązanie. Można zaoszczędzić kilka bajtów chociaż: zamienia \nz dosłownych znaków nowej linii, nie trzeba spacji między xoperatorem a numer, który następuje, i wreszcie wymienić split//,xxxz xxx=~/./g.
Dada
1

Haskell, 128 125 114 bajtów

mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]

Wypróbuj tutaj

  • ((:" ")=<<)is concatMap (\a -> [a,' '])- wstawia, dodając spację za każdą literą na wejściu
Angs
źródło
1

PowerShell, 95 bajtów

Zainspirowany @ AdmBorkBork za odpowiedź .

'FKCIIBAVWMG
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
JCVCORIBCMG'-replace0,(' '*9)-replace'.','$0 '

Wyjaśnienie

Pierwszy operator zastępujący tworzy prostokąt 11x11.

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

Drugi operator zastępujący wstawia spację po każdym znaku. Wynik ma końcowe spacje.

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
mazzy
źródło