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! :)

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.

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.

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!

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 (*'...',).

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

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))

a.innerHTML = 

`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))

<pre id=a>

/// , 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!

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

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

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.

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']))

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'

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.

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

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ą.

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

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)

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.

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.

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)

Węgiel drzewny , 66 bajtów

Ｂ²¹¦¹¹F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN

Wypróbuj online!

Box(21, 11, 'F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN').

Niekonkurencyjne, 36 bajtów

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)

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

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 "

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.

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.

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.

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

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