Consiglio di monopolio

Per questa sfida di code-golf costruiremo il gioco da tavolo Monopoli.

Regole:

• Non dare input.
• Stampa una scheda 11x11 in cui ogni carattere ASCII che forma la scheda è la prima lettera di ogni spazio della versione americana della scheda Monopoli.
• I personaggi devono essere separati da spazi.
• Go dovrebbe iniziare in basso a destra.

La stringa esatta da produrre è

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 

Si noti che da in basso a destra in basso a sinistra i quadrati sono i seguenti:

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

Modifica Wow! ragazzi questo è piaciuto sicuramente! :)

Retina , 74 byte

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

1

La terza e l'ultima riga devono contenere un singolo spazio.

Provalo online!

Spiegazione

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Questo sostituisce l'input (vuoto) con la stringa sulla seconda riga.

S_`(._.)

Questo è lo stadio diviso, che divide la stringa attorno alle corrispondenze della regex (._.)(ovvero tre caratteri qualsiasi con una _al centro). Il motivo per cui mettiamo l'intera regex in un gruppo è che le fasi divise restituiscono anche i risultati dei gruppi di acquisizione. Ad esempio, la scissione abcdin giro bcdà [a, d], ma la divisione in giro b(c)dà [a, c, d]. In questo modo otteniamo tutte le ._.parti su linee separate ma anche le parti di 11 caratteri all'inizio e alla fine. Usiamo l' _opzione per omettere i risultati vuoti tra le singole ._.partite. Il risultato sarebbe questo:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Successivamente elaboriamo i trattini bassi:

_
9$*

Questo sostituisce ogni carattere di sottolineatura con nove 1s. Il motivo per cui usiamo 1s qui invece di spazi immediatamente è che semplifica l'inserimento degli spazi di riempimento successivi.

\B

Ricorda che c'è uno spazio sulla seconda riga. Questo inserisce uno spazio in ogni posizione che non è un limite di parola, cioè ovunque tranne all'inizio e alla fine delle linee.

1

E infine, sostituiamo anche tutti quelli 1con spazi.

Gelatina , 44 byte

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

Provalo online!

Idea

Se rimuoviamo ogni seconda colonna e trasponiamo le righe con colonne, otteniamo la seguente scheda.

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

Ora, possiamo ruotare ogni colonna di un'unità a destra, spostando tutti gli spazi rimanenti a destra.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Poi, togliamo gli spazi rimanenti e sostituiamo linefeeds con la lettera D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Ora sostituiamo ogni lettera con il suo indice basato su 1 nell'alfabeto.

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

Quindi, convertiamo questo array di cifre dalla base biiettiva 23 in numero intero.

54580410997367796180315467139871590480817875551696951051609467717521

Ora convertiamo questo numero intero in base biiettiva 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

Infine, usiamo queste cifre per indicizzare nella code page di Jelly .

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

Questi sono i dati codificati che includeremo nel programma ( 29 byte ). Per produrre l'output desiderato, non ci resta che invertire i passaggi precedenti.

Codice

“£ċ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 byte

Grazie a Emigna per aver salvato un byte!

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

Spiegazione:

Prima un po 'di compressione. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•è una versione compressa del seguente numero:

120860198958186421497710412212513392855208073968557051584380118734764403017

Successivamente, questo viene convertito in base 33 , che risulta nella seguente stringa:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Gli zero vengono sostituiti da 9 spazi , utilizzando il seguente codice ¾9ð×:. Successivamente, Ssuddividiamo la stringa in caratteri e li dividiamo in pezzi di 11 elementi (fatto con 11ô). Otteniamo il seguente array bidimensionale:

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

Abbiamo gridify questo array con »ed uscita implicitamente.

Utilizza la codifica CP-1252 . Provalo online!

Python 2, 89 byte

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

Crea il modello

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

sostituire in lettere tramite la formattazione di stringa. Il modello utilizza due tipi di linee:

• La linea esterna ldi 11 copie di lettera più spazio, quindi una nuova riga. È anche usato per la prima e l'ultima riga. Ha uno spazio finale.
• La linea interna di un personaggio, quindi un carattere preceduto da 19 caratteri di spazi di riempimento, quindi una nuova riga. Viene copiato 9 volte per le linee centrali.

Python 3.5 può salvare un byte con il disimballaggio della tupla (*'...',).

PowerShell v2 +, 131 123 114 110 99 byte

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

Questa è solo una stringa letterale con a capo immessi sul gasdotto, con un po ' -replacealla fine di trasformare il 0in 19spazi. La prima e l'ultima riga sono solo alla lettera. Con solo 10 spazi e poca ripetizione altrimenti, non c'era abbastanza spazio per giocare a golf. Questa stringa viene lasciata sulla pipeline e l'output tramite implicito Write-Outputavviene al completamento del programma.

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 byte

Non sta succedendo molto interessante qui. Incolla nella console per vedere i risultati desiderati

Salvato 3 byte grazie a @Arnauld
Salvato 1 byte in più grazie a @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 byte

/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 

Provalo online!

Per qualche misteriosa ragione, sembrano esserci spazi finali dopo la Gs. Senza di essi, il mio codice sarebbe stato di 96 byte.

Grazie a 42545 (ETHproductions) e 56258 (daHugLenny) per ridurre 1 byte ciascuno!

Turtlèd , 72 byte

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

Provalo online

>ruota la tartaruga, "foo"scrive le stringhe sulla griglia. l'ultimo "era elidable

V , 75, 62 , 59 byte

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

Provalo online!

Poiché questo codice contiene caratteri non ASCII, ecco un hexdump:

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..../& 

Spiegazione. Innanzitutto, inseriamo il seguente testo:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Quindi, <esc>torniamo alla modalità normale. A questo punto, il cursore si trova sulla terza riga sull'ultima G. Convenientemente, c'è un comando per posizionarci sulla prima colonna della linea proprio sopra il cursore. Questo comando è -. Quindi, una volta terminato sulla seconda riga (sulla N), eseguiamo il seguente ciclo:

ò9á lli
ò

Spiegazione:

ò           " 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

Ora, il buffer si presenta così:

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

Ora usiamo una regex compressa per sostituire ogni personaggio con quel personaggio e uno spazio. Questa è la Í./&parte. Questo si traduce nel seguente regex vim:

:%s/./& /g

Che significa:

:%          " 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 byte

Non così impressionante ma anche incerto su come questo sarebbe golf. Sfruttare in pastequalche modo è la mia prima ipotesi. Confronta con testo non elaborato di 241 byte.

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

R-violino

Python 2, 108 byte

Leggermente diverso dall'altra risposta di Python, senza l'utilizzo di sostituzioni, solo unioni di stringhe.

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))

Perl, 90 byte

Approccio piuttosto noioso, non riesco a pensare a un modo migliore per ridurre ... Richiede -Esenza costi aggiuntivi. Emette uno spazio aggiuntivo alla fine di ogni riga. -2 byte grazie a @Dada !

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

uso

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

Jolf, 72 byte

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

Sostituisci tutto ♣con \x05o prova qui!

Ζ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

Questo dà la stringa desiderata.

Java 7, 177 165 142 131 byte

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 byte grazie a @BassdropCumberwubwubwub .
-11 byte grazie a @Numberknot .

Codice non testato e test:

Provalo qui.

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());
  }
}

Produzione:

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 byte

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

La prima riga ha la stringa da stampare al contrario (sembra che non lo sia, ma il codice va indietro su quella riga). La seconda riga stampa le righe superiore e inferiore. La terza riga e il lato sinistro della quarta riga stampano le righe centrali e il piccolo pezzo in basso a destra fa una cosa interessante: sposta il cursore sulla seconda riga per stampare l'ultima riga, ma dopo averlo finito, si chiude.

Come puoi vedere nella prima riga, le stringhe sono separate da spazi per distinguere tra la prima, la metà e l'ultima riga. Gli spazi possono essere qualsiasi altra cosa e se avessi usato i caratteri ASCII 0-9, avrei potuto facilmente salvare 4 byte. $ Che vedi è solo un personaggio spazzatura che deve essere lì e potrebbe essere sostituito con qualsiasi cosa tranne uno spazio.

J, 77 73 byte

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

Si noti che 43 byte, oltre la metà del totale, vengono utilizzati solo per la stringa ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Spiegazione

Innanzitutto, fai un elenco

   |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

Quindi crea la sua tabella dei tempi

   */~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

Quindi verifica l'uguaglianza con zero

   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

Appiattiscilo, trova le somme cumulative e moltiplica in modo elementare

   ,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

Quindi unisci con gli zeri, dividilo in elenchi di lunghezza 22, rilascia la testa di ciascun elenco secondario e usa i valori come indici nella stringa ' 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

In realtà , 74 byte

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

Provalo online!

Questo programma funziona in base allo stesso principio di base della risposta Python 2 di xnor .

Spiegazione (newline sostituita con \nper chiarezza):

"%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 byte

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

Senza spazio finale; senza trascinare newline.

Una soluzione semplice. Inizia con la stringa letterale. Replace !di 9 spazi. Quindi Splitin 11 stringhe di ~, e oltre a chars (interno Select). Aggiungi uno spazio a ciascun carattere, quindi Jointorna a 11 stringhe. Finalmente un altro Joindal carattere newline.

Ruby, 92

Programma completo, stampa su stdout usando $> <<

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

Ci sono 40 lettere totali da tracciare. Le lettere da 10 a 28 si alternano all'essere seguite da una nuova riga o ' '*19. Le lettere precedenti e successive sono separate da spazi singoli.

Perl, 115 112 byte

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

Produce il seguente output:

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 

La prima e l'ultima riga dell'output hanno uno spazio finale. Il codice utilizza sostituzioni regex e il fatto che se gli oggetti non sono definiti, vengono interpretati come stringhe (ad esempio FKCIIBAVWMG viene trattato come "FKCIIBAVWMG". Non è possibile estrarre le virgolette dall'ultima riga a causa della riga precedente precedente, che Non potrei finagle altrove.

Modifica 1: salvati 3 byte sostituendoli " "con $", rimuovendo le parentesi esterne e inserendo uno spazio dopo la stampa, rimuovendo le parentesi attorno $"x19e aggiungendo uno spazio in seguito (quindi .non verrebbero interpretati come decimali)

Carbone , 66 byte

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

Provalo 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').

Non competitivo, 36 byte

Python 2, 116 byte

Abbastanza semplice, per qualsiasi motivo, anche se la sostituzione delle stringhe è così dettagliata, è stata la cosa migliore che ho potuto inventare. Probabilmente l'utilizzo repotrebbe essere più breve.

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)

Lotto, 171 byte

@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

Lingua GameMaker, 148 byte

So che è piuttosto semplice, ma non credo che questo possa essere battuto in 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 byte

63 byte di codice, +1 per la -Sbandiera.

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

Provalo online!

Spiegazione

Operatori utilizzati:

• . (binario) concatena (opera in base agli elenchi).
• X(binario) si moltiplica la stringa. ( sè una variabile preinizializzata in " ".)
• ^ (unario) divide una stringa in un elenco di caratteri.
• .*è un altro modo per dividere una stringa in caratteri. Consiste in unario ., che è un no-op su stringhe, associato al *meta-operatore, che mappa un operatore unario su ciascun elemento nel suo (iterabile) operando. Usando .*"..."ci consente di salvare un byte (^"...")- le parentesi sarebbero necessarie perché ha .una precedenza maggiore di ^.
• PEantepone un elemento a un elenco. AEaccoda un elemento a un elenco.

Con quello sfondo, ecco il codice passo dopo passo:

.*"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]]

Quando questo risultato viene stampato automaticamente, il -Sflag unisce le liste secondarie sugli spazi e la lista principale sulle linee nuove, fornendo l'output desiderato.

C, 171 156 byte

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++);}

Emette anche un carattere newline finale ... Probabilmente si potrebbe giocare un po 'più a fondo.

Perl 5, 92 86 byte

• salvato 6 byte grazie a Dada

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

Usi sprintf, riempimento e l'operatore di ripetizione stringa x.

Haskell, 128 125 114 byte

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

Provalo qui

• ((:" ")=<<)is concatMap (\a -> [a,' '])- pads aggiungendo uno spazio dietro ogni lettera nel suo input

Powershell, 95 byte

Ispirato dalla risposta di @ AdmBorkBork .

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

Spiegazione

Il primo operatore di sostituzione crea il rettangolo 11x11.

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

Il secondo operatore sostitutivo inserisce uno spazio dopo ogni carattere. Il risultato ha spazi finali.

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