Conselho de Monopólio

Para este desafio do código-golfe, estaremos construindo o jogo de tabuleiro Monopoly.

Regras:

• Não aceite nenhuma entrada.
• Crie uma placa 11x11, em que cada caractere ASCII que forma a placa é a primeira letra de cada espaço da versão americana da placa Monopoly.
• Os caracteres devem ser separados por espaços.
• Go deve começar no canto inferior direito.

A string exata a ser produzida é

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 

Observe que da parte inferior direita para a esquerda inferior os quadrados são os seguintes:

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

Editar Uau! vocês com certeza gostaram deste! :)

Retina , 74 bytes

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

1

A terceira a última e a última linha devem conter um único espaço.

Experimente online!

Explicação

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Isso substitui a entrada (vazia) pela string na segunda linha.

S_`(._.)

Este é um estágio dividido, que divide a cadeia de caracteres em torno das correspondências da expressão regular (._.)(ou seja, quaisquer três caracteres com um _no meio). A razão pela qual colocamos toda a regex em um grupo é que os estágios divididos também retornam os resultados da captura de grupos. Por exemplo, dividir abcdao redor bcdá [a, d], mas dividir ao redor b(c)dá [a, c, d]. Dessa forma, obtemos todas as ._.partes em linhas separadas, mas também as partes de 11 caracteres no início e no final. Usamos a _opção para omitir resultados vazios entre as ._.correspondências individuais . O resultado seria este:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Em seguida, processamos os sublinhados:

_
9$*

Isso substitui cada sublinhado por nove 1s. A razão pela qual usamos 1s aqui em vez de espaços imediatamente é que facilita a inserção dos espaços de preenchimento a seguir.

\B

Lembre-se de que há um espaço na segunda linha. Isso insere um espaço em todas as posições que não são um limite de palavras, ou seja, em todos os lugares, exceto no início e no final das linhas.

1

E, finalmente, substituímos todos esses 1s por espaços também.

Geléia , 44 bytes

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

Experimente online!

Idéia

Se removermos cada segunda coluna e transpormos linhas com colunas, obteremos o quadro a seguir.

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

Agora, podemos girar cada coluna uma unidade para a direita, movendo todos os espaços restantes para a direita.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Então, nós remover os espaços restantes e substituir linefeeds com a letra D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Agora, substituímos cada letra pelo seu índice baseado em 1 no 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

Em seguida, convertemos essa matriz de dígitos da base bijetiva 23 para inteiro.

54580410997367796180315467139871590480817875551696951051609467717521

Agora, convertemos esse número inteiro em base bijetiva 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

Finalmente, usamos esses dígitos para indexar na página de códigos de Jelly .

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

Esses são os dados codificados que incluiremos no programa ( 29 bytes ). Para produzir a saída desejada, basta reverter as etapas acima.

Código

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

Agradecemos a Emigna por salvar um byte!

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

Explicação:

Primeiro alguma compressão. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•é uma versão compactada do seguinte número:

120860198958186421497710412212513392855208073968557051584380118734764403017

Depois disso, isso é convertido na base 33 , o que resulta na seguinte sequência:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Os zeros são substituídos por 9 espaços , usando o código a seguir ¾9ð×:. Depois disso, Sdividimos a string em caracteres e os dividimos em pedaços de 11 elementos (terminados com 11ô). Temos a seguinte matriz bidimensional:

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

Nós gridify essa matriz com »e sua saída será implicitamente.

Usa a codificação CP-1252 . Experimente online!

Python 2, 89 bytes

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

Cria o modelo

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

para substituir em letras por formatação de string. O modelo usa dois tipos de linhas:

• A linha externa lde 11 cópias de letra mais espaço e, em seguida, uma nova linha. Também é usado para a primeira e a última linha. Tem um espaço à direita.
• A linha interna de um caractere, depois um caractere precedido por 19 caracteres de espaços de preenchimento e, em seguida, uma nova linha. É copiado 9 vezes para as linhas centrais.

O Python 3.5 pode salvar um byte com a descompactação da tupla (*'...',).

PowerShell v2 +, 131 123 114 110 99 bytes

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

Esta é apenas uma string literal com novas linhas colocadas no pipeline, com um pouco -replaceno final para transformar 0em 19espaços. A primeira e a última linha são literalmente. Com apenas 10 espaços e pouca repetição, não havia espaço suficiente para jogar golfe. Essa sequência é deixada no pipeline e a saída via implícita Write-Outputacontece na conclusão do programa.

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 bytes

Não há muita coisa interessante acontecendo aqui. Cole no console para ver os resultados desejados

Guardou 3 bytes graças a @Arnauld Guardou
mais 1 byte graças 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 bytes

/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 

Experimente online!

Por alguma razão misteriosa, parece haver espaços à direita após o Gs. Sem eles, meu código teria 96 bytes.

Agradecimentos a 42545 (ETHproductions) e 56258 (daHugLenny) por reduzir 1 byte cada!

Turtlèd , 72 bytes

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

Experimente online

>gira tartaruga, "foo"escreve cordas na grade. o último "foi elidável

V , 75, 62 , 59 bytes

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

Experimente online!

Como este codel contém caracteres não ASCII, aqui está um 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..../& 

Explicação. Primeiro, inserimos o seguinte texto:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Então, <esc>voltamos ao modo normal. Neste ponto, o cursor está na terceira linha na última G. Convenientemente, existe um comando para nos colocar na primeira coluna da linha logo acima do cursor. Esse comando é -. Então, quando terminarmos na segunda linha (na N), executamos o seguinte loop:

ò9á lli
ò

Explicação:

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

Agora, o buffer fica assim:

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

Agora usamos um regex compactado para substituir cada caractere por esse caractere e um espaço. Essa é a Í./&parte. Isso se traduz no seguinte regex do vim:

:%s/./& /g

Que 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 bytes

Não é tão impressionante, mas também não tenho certeza de como isso seria jogado no golfe. Explorar de pastealguma forma é o meu primeiro palpite. Compare com o texto bruto de 241 bytes.

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 bytes

Um pouco diferente da outra resposta python, sem substituições, apenas junções de strings.

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

Perl, 90 bytes

Abordagem bastante chata, não consegue pensar em uma maneira melhor de reduzir ... Requer -Esem custo adicional. Gera um espaço adicional no final de cada linha. -2 bytes graças 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 bytes

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

Substitua tudo ♣por \x05, ou tente aqui!

Ζ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

Isso fornece a string desejada.

Java 7, 177 165 142 131 bytes

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 bytes graças a @BassdropCumberwubwubwub .
-11 bytes graças a @Numberknot .

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

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 bytes

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

A primeira linha tem a sequência a ser impressa ao contrário (parece que não é, mas o código está retornando nessa linha). A segunda linha imprime as linhas superior e inferior. A terceira linha e o lado esquerdo da quarta linha imprimem as linhas do meio, e o pequeno pedaço no canto inferior direito faz uma coisa interessante: move o cursor de volta para a segunda linha para imprimir a última linha, mas depois de terminar, sai.

Como você pode ver na primeira linha, as cadeias são separadas por espaços para distinguir entre a primeira, a média e a última. Os espaços podem ser qualquer outra coisa, e se eu usasse caracteres ASCII de 0 a 9, poderia facilmente salvar 4 bytes. O $ que você vê é apenas um caractere de lixo que precisa estar lá e pode ser substituído por qualquer coisa, menos um espaço.

J, 77 73 bytes

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

Observe que 43 bytes, mais da metade do total, são usados ​​apenas para a sequência ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Explicação

Primeiro, faça uma lista

   |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

Então faça a sua tabuada

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

Em seguida, teste a igualdade com 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

Achate, encontre as somas cumulativas e multiplique elemento

   ,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

Em seguida, junte-se aos zeros, divida-o em sublistas de comprimento 22, solte a cabeça de cada sub-lista e use os valores como índices na string ' 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

Na verdade , 74 bytes

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

Experimente online!

Este programa funciona com o mesmo princípio básico da resposta Python 2 do xnor .

Explicação (novas linhas substituídas \npor uma questão de clareza):

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

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

Sem espaço à direita; sem seguir a nova linha.

Uma solução simples. Comece com a string literal. Replace !por 9 espaços. Depois, Splitem 11 cordas por ~e mais para chars (interior Select). Acrescente um espaço a cada caractere e depois Joinvolte para 11 strings. Finalmente outro Joinpor caractere de nova linha.

Ruby, 92

Programa completo, imprime no stdout usando $> <<

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

Existem 40 cartas no total para traçar. As letras 10 a 28 alternam entre ser seguido por uma nova linha ou ' '*19. As letras anteriores e posteriores são separadas por espaços únicos.

Perl, 115 112 bytes

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

Produz a seguinte saída:

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 

A primeira e a última linha de saída têm um espaço à direita. O código utiliza substituições de regex e o fato de que, se os objetos não forem definidos, eles serão interpretados como seqüências de caracteres (por exemplo, FKCIIBAVWMG é tratado como "FKCIIBAVWMG". Não foi possível excluir as aspas da última linha devido à nova linha anterior, que Eu não poderia procurar em nenhum outro lugar.

Editar 1: salvou 3 bytes, substituindo " "por $", removendo os parênteses externos e inserindo um espaço após a impressão, removendo os parênteses ao redor $"x19e adicionando um espaço posteriormente (para .que não seja interpretado como decimal)

Carvão , 66 bytes

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

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

Não-competidor, 36 bytes

Python 2, 116 bytes

Bem simples, por qualquer motivo, mesmo que a substituição de strings seja tão detalhada, foi a melhor coisa que eu pude criar. Possivelmente usando repode ser mais curto.

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)

Lote, 171 bytes

@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

Idioma do GameMaker, 148 bytes

Eu sei que é bastante básico, mas não acho que isso possa ser superado no 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 bytes

63 bytes de código, +1 para -Ssinalizador.

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

Experimente online!

Explicação

Operadores utilizados:

• . (binário) concatena (opera item em listas).
• X(binário) string-multiplica. ( sé uma variável pré-inicializada para " ".)
• ^ (unário) divide uma sequência em uma lista de caracteres.
• .*é outra maneira de dividir uma string em caracteres. Consiste em unário ., que é um não-op em cadeias, emparelhado com o *meta-operador, que mapeia um operador unário para cada item em seu operando (iterável). O uso .*"..."permite salvar um byte em excesso (^"...")- os parênteses seriam necessários porque .tem maior precedência que ^.
• PEprecede um elemento a uma lista. AEanexa um elemento a uma lista.

Com esse pano de fundo, aqui está o código passo a 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 esse resultado é impresso automaticamente, o -Ssinalizador une as sublistas nos espaços e a lista principal nas novas linhas, fornecendo a saída desejada.

C, 171 156 bytes

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

Também gera um caractere de linha nova à direita ... Provavelmente poderia ser um pouco mais complicado.

Perl 5, 92 86 bytes

• economizou 6 bytes graças ao Dada

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

Usos sprintf, preenchimento e o operador de repetição de string x.

Haskell, 128 125 114 bytes

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

Experimente aqui

• ((:" ")=<<)is concatMap (\a -> [a,' '])- almofadas adicionando um espaço atrás de cada letra em sua entrada

PowerShell, 95 bytes

Inspirado na resposta de @ AdmBorkBork .

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

Explicação

O primeiro operador de substituição cria o retângulo 11x11.

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

O segundo operador de substituição insere um espaço após cada caractere. O resultado possui espaços à direita.

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