Junta de monopolio

Para este desafío de código de golf construiremos el juego de mesa Monopoly.

Reglas:

• No tomes ninguna entrada.
• Imprima una placa de 11x11 donde cada carácter ASCII que forma la placa es la primera letra de cada espacio de la versión estadounidense de la placa Monopoly.
• Los caracteres deben estar separados por espacios.
• Go debería comenzar en la parte inferior derecha.

La cadena exacta para producir es

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 

Tenga en cuenta que de abajo a la derecha a la izquierda los cuadrados son los siguientes:

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

Editar Wow! ¡Seguro que les gustó este! :)

Retina , 74 bytes

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

1

Las líneas tercera a última y última deben contener un solo espacio.

Pruébalo en línea!

Explicación

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Esto reemplaza la entrada (vacía) con la cadena en la segunda línea.

S_`(._.)

Esta es una etapa dividida, que divide la cadena alrededor de las coincidencias de la expresión regular (._.)(es decir, tres caracteres con un _en el medio). La razón por la que colocamos toda la expresión regular en un grupo es que las etapas divididas también devuelven los resultados de capturar grupos. Por ejemplo, dividir abcdalrededor bcda [a, d], pero dividirlo b(c)da [a, c, d]. De esta manera, obtenemos todas las ._.partes en líneas separadas, pero también las partes de 11 caracteres al principio y al final. Usamos la _opción para omitir resultados vacíos entre las ._.coincidencias individuales . El resultado sería este:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

A continuación procesamos los guiones bajos:

_
9$*

Esto reemplaza cada guión bajo con nueve 1s. La razón por la que usamos 1s aquí en lugar de espacios de inmediato es que hace que sea más fácil insertar los espacios de relleno a continuación.

\B

Recuerda que hay un espacio en la segunda línea. Esto inserta un espacio en cada posición que no es un límite de palabra, es decir, en todas partes excepto al principio y al final de las líneas.

1

Y finalmente, reemplazamos todos esos 1s con espacios también.

Jalea , 44 bytes

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

Pruébalo en línea!

Idea

Si eliminamos cada segunda columna y transponemos filas con columnas, obtenemos el siguiente tablero.

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

Ahora, podemos rotar cada columna una unidad hacia la derecha, moviendo todos los espacios restantes hacia la derecha.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

A continuación, se elimina el resto de espacios y saltos de línea reemplazamos con la letra D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Ahora, reemplazamos cada letra con su índice basado en 1 en el 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

Luego, convertimos esta matriz de dígitos de la base biyectiva 23 a entero.

54580410997367796180315467139871590480817875551696951051609467717521

Ahora, convertimos este entero a la base biyectiva 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 estos dígitos para indexar en la página de códigos de Jelly .

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

Estos son los datos codificados que incluiremos en el programa ( 29 bytes ). Para producir la salida deseada, solo tenemos que invertir los pasos anteriores.

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

¡Gracias a Emigna por guardar un byte!

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

Explicación:

Primero algo de compresión. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•es una versión comprimida del siguiente número:

120860198958186421497710412212513392855208073968557051584380118734764403017

Después de eso, esto se convierte en base 33 , lo que da como resultado la siguiente cadena:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Los ceros se reemplazan por 9 espacios , utilizando el siguiente código ¾9ð×:. Después de eso, Sdividimos la cadena en caracteres y los dividimos en piezas de 11 elementos (hecho con 11ô). Obtenemos la siguiente 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']]

Nos gridify esta matriz con »y salida implícitamente.

Utiliza la codificación CP-1252 . Pruébalo en línea!

Python 2, 89 bytes

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

Crea la plantilla.

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

para sustituir en letras a través del formato de cadena. La plantilla usa dos tipos de líneas:

• La línea externa lde 11 copias de letra más espacio, luego una nueva línea. También se usa para la primera y última línea. Tiene un espacio posterior.
• La línea interna de un personaje, luego un personaje precedido por 19 caracteres de espacios de relleno, luego una nueva línea. Se copia 9 veces para las líneas centrales.

Python 3.5 puede guardar un byte con el desempaquetado de tuplas (*'...',).

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 es solo una cadena literal con nuevas líneas colocadas en la tubería, con un poco -replaceal final para convertirlas 0en 19espacios. La primera y la última línea son textuales. Con solo 10 espacios y poca repetición, de lo contrario, no había suficiente espacio para jugar al golf. Esta cadena se deja en la tubería, y la salida por vía implícita Write-Outputocurre al finalizar el 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

No hay mucho interesante pasando aquí. Pegue en la consola para ver los resultados deseados.

Guardado 3 bytes gracias a @Arnauld
Guardado 1 byte más gracias 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 

Pruébalo en línea!

Por alguna misteriosa razón, parece haber espacios detrás del Gs. Sin ellos, mi código habría sido de 96 bytes.

¡Gracias a 42545 (ETHproductions) y 56258 (daHugLenny) por reducir 1 byte cada uno!

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

Pruébalo en línea

>gira la tortuga, "foo"escribe cadenas en la cuadrícula. el último "fue elidable

V , 75, 62 , 59 bytes

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

Pruébalo en línea!

Dado que este codel contiene caracteres no ASCII, aquí hay 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..../& 

Explicación. Primero, ingresamos el siguiente texto:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Luego, volvemos <esc>al modo normal. En este punto, el cursor está en la tercera línea de la última G. Convenientemente, hay un comando para colocarnos en la primera columna de la línea justo encima del cursor. Ese comando es -. Luego, una vez que terminamos en la segunda línea (en la N), ejecutamos el siguiente ciclo:

ò9á lli
ò

Explicación:

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

Ahora, el búfer se ve así:

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

Ahora usamos una expresión regular comprimida para reemplazar cada personaje con ese personaje y un espacio. Esa es la Í./&parte Esto se traduce en el siguiente vim regex:

:%s/./& /g

Lo 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, 149146 bytes

No es tan impresionante, pero tampoco estoy seguro de cómo se jugaría esto. Explotar de pastealguna manera es mi primera suposición. Compare con el texto sin formato 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")

Violín R

Python 2, 108 bytes

Ligeramente diferente a la otra respuesta de Python, sin usar reemplazos, solo cadenas se unen.

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

Perl, 90 bytes

Enfoque bastante aburrido, no se me ocurre una mejor manera de reducir ... Requiere -Esin costo adicional. Emite un espacio adicional al final de cada línea. -2 bytes gracias 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ζ♣

¡Reemplace todo ♣con \x05, o pruébelo aquí!

Ζ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

Esto le da la cadena deseada.

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 gracias a @BassdropCumberwubwubwub .
-11 bytes gracias a @Numberknot .

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

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

La primera línea tiene la cadena que se imprimirá al revés (parece que no, pero el código va hacia atrás en esa línea). La segunda línea imprime las filas superior e inferior. La tercera línea y el lado izquierdo de la cuarta línea imprimen las filas del medio, y el pequeño trozo en la parte inferior derecha hace algo interesante: mueve el cursor hacia la segunda fila para imprimir la última línea, pero después de terminarla, en paz.

Como puede ver en la primera línea, las cadenas están separadas por espacios para distinguir entre la primera, la mitad y la última fila. Los espacios pueden ser cualquier otra cosa, y si usara caracteres ASCII 0-9, podría haber guardado fácilmente 4 bytes. El $ que ve es solo un carácter basura que tiene que estar allí y podría reemplazarse con cualquier cosa que no sea un espacio.

J, 77 73 bytes

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

Tenga en cuenta que 43 bytes, más de la mitad del total, se utilizan solo para la cadena ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Explicación

Primero, haz una 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

Luego haga su tabla de tiempos

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

Luego prueba la igualdad con cero

   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

Aplane, encuentre las sumas acumulativas y multiplique por elementos

   ,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

Luego, únase con ceros, divídalo en sublistas de longitud 22, suelte el encabezado de cada sublista y use los valores como índices en la cadena ' 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

En realidad , 74 bytes

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

Pruébalo en línea!

Este programa funciona con el mismo principio básico que la respuesta Python 2 de xnor .

Explicación (líneas nuevas reemplazadas \npor claridad):

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

Sin espacio final; sin rastro de nueva línea.

Una solución sencilla. Comience con la cadena literal. Replace !por 9 espacios. Luego Spliten 11 cadenas por ~, y más a chars (interior Select). Agregue un espacio a cada carácter, luego Joinvuelva a 11 cadenas. Finalmente otro Joinpor personaje de nueva línea.

Ruby, 92

Programa completo, imprime en stdout usando $> <<

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

Hay 40 letras en total para trazar. Las letras 10 a 28 alternan entre ser seguidas por una nueva línea o ' '*19. Las letras anterior y posterior están separadas por espacios individuales.

Perl, 115 112 bytes

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

Produce el siguiente resultado:

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 primera y la última fila de salida tienen un espacio final. El código utiliza reemplazos de expresiones regulares y el hecho de que si los objetos no están definidos, se interpretan como cadenas (por ejemplo, FKCIIBAVWMG se trata como "FKCIIBAVWMG". No se pudieron eliminar las comillas de la última fila debido a la nueva línea anterior, que No podría encontrar ningún otro lugar.

Edición 1: guardado 3 bytes reemplazándolos " "con $", eliminando los paréntesis externos e insertando un espacio después de la impresión, y eliminando los paréntesis $"x19y agregando un espacio después (para .que no se interprete como un decimal)

Carbón , 66 bytes

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

Pruébalo en línea!

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

Sin competencia, 36 bytes

Python 2, 116 bytes

Bastante sencillo, por cualquier razón, aunque el reemplazo de cadenas es tan detallado que fue lo mejor que se me ocurrió. Posiblemente el uso repodría ser más corto.

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

Lenguaje GameMaker, 148 bytes

Sé que es bastante básico, pero no creo que esto se pueda superar en 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 -Sbandera.

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

Pruébalo en línea!

Explicación

Operadores utilizados:

• . (binario) se concatena (opera por elemento en las listas).
• X(binario) cadenas-multiplica. ( ses una variable preinicializada a " ").
• ^ (unario) divide una cadena en una lista de caracteres.
• .*es otra forma de dividir una cadena en caracteres. Consiste en unario ., que es un no operativo en cadenas, emparejado con el *metaoperador, que asigna un operador unario a cada elemento en su operando (iterable). El uso .*"..."nos permite guardar un byte sobre (^"...")- los paréntesis serían necesarios porque .tiene mayor prioridad que ^.
• PEantepone un elemento a una lista. AEagrega un elemento a una lista.

Con ese trasfondo, aquí está el código paso a paso:

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

Cuando este resultado se imprime automáticamente, la -Sbandera se une a las sublistas en los espacios y la lista principal en las nuevas líneas, dando el resultado deseado.

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

También muestra un carácter de nueva línea al final ... Probablemente podría jugar un poco más.

Perl 5, 92 86 bytes

• ahorrado 6 bytes gracias a Dada

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

Usos sprintf, relleno y el operador de repetición de cadena x.

Haskell, 128 125 114 bytes

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

Pruébalo aquí

• ((:" ")=<<)is concatMap (\a -> [a,' '])- rellena agregando un espacio detrás de cada letra en su entrada

Powershell, 95 bytes

Inspirado por la respuesta de @ AdmBorkBork .

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

Explicación

El primer operador de reemplazo forma el rectángulo 11x11.

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

El segundo operador de reemplazo inserta un espacio después de cada carácter. El resultado tiene espacios finales.

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