Tome un paseo en la lectura, si pasa Go, recoja $ 200

39

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

jacksonecac
fuente
77
No me refiero a ser un fanático pero ... ¿cómo se pasa Go mientras avanza a Boardwalk?
Sp3000
44
Si estás en el paseo marítimo :)
jacksonecac
8
Que no puedes obtener una carta de oportunidad si estás en el paseo marítimo :(
jacksonecac
27
Les fallé a todos
jacksonecac
3
¿Se permiten espacios finales?
Adnan

Respuestas:

36

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.

Martin Ender
fuente
1
¡Buen trabajo! ¡Eso fue rápido!
jacksonecac
39
+1 para (._.).
Destructible Lemon
^ estaba a punto de decir que ahha
jazzboy
25

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.
Dennis
fuente
55
Gracias por la explicación detallada. Siempre es interesante ver el proceso detrás de las respuestas a las preguntas de código de golf. :)
XtraSimplicity
11
Code Golf - donde es perfectamente normal ver un número en la base 250 y la base 23.
corsiKa
Buena técnica de compresión. ¿Por qué es necesaria la transposición?
ETHproductions
@ETHproductions Jelly no tiene un átomo de relleno, por lo que puedo rellenar manualmente todas las filas con espacios a la misma longitud o usar el zip diádico ( z) con un relleno.
Dennis
16

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!

Adnan
fuente
3
Comprimir con 0 en lugar de D ahorra un byte•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
Emigna
@Emigna Ah, eso es inteligente! Gracias :).
Adnan
12

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

xnor
fuente
1
Cambiar a Python 3.5 debería guardar un byte.
Dennis
9

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
AdmBorkBork
fuente
9

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

Bassdrop Cumberwubwubwub
fuente
No creo que REPL esté permitido.
NoOneIsHere
1
Me las arreglé para afeitarme otro byte. Reemplace la 1s con espacios y use esta expresión regular en su lugar:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
Neil
Una forma diferente de eliminar otro byte es reemplazar los 1s con espacios y usar esta función en su lugar:a=>a-1?a.repeat(18):a+' '
ETHproductions
@Neil gracias, me encanta tu enfoque!
Bassdrop Cumberwubwubwub
7

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

Erik el Outgolfer
fuente
@ETHproductions ¿Enlace incorrecto quizás? No puedo guardar ningún byte así.
Erik the Outgolfer
¿No son 98 bytes si elimina el espacio después de la Gs en la primera y última línea?
Emigna
1
@Emigna Lo sé, pero el resultado exacto los contiene, por lo que no los eliminaré.
Erik the Outgolfer
Mi mal, prueba esto .
ETHproductions
6

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

Limón Destructible
fuente
5

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
DJMcMayhem
fuente
4

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

Billywob
fuente
4

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']))
TFeld
fuente
1
¡Sabía que zip era el camino a seguir! Tenía más o menos la misma solución hasta 118 antes e iba a jugar golf esta noche. Me faltaba el mapa. Supongo que me ganaste. +1
ElPedro
4

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'
Dom Hastings
fuente
2 bytes más corto (pero básicamente el mismo código que usted): perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Reemplace \npor líneas nuevas literales para llegar a 90).
Dada
@Dada Ahhh, ¡mucho mejor! ¡Gracias!
Dom Hastings
"mucho bueno" habría sido encontrar una solución de 40 bytes, pero gracias: D
Dada
4

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.

Conor O'Brien
fuente
3

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
Kevin Cruijssen
fuente
1
String c(){String s=" ";return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace(""," ").replace("_",s);}por 150 (tenga en cuenta que stackexchange elimina espacios excesivos)
Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Umm ... esto genera solo 3 espacios entre las 'paredes verticales', en lugar de 19 ... Aquí hay una ideona de su código.
Kevin Cruijssen
De ahí mi nota, debería haber más espacios spero stackexchange los eliminó. Aquí está la ideona , ahora incluso a 142 bytes
Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Ah ok. No sabía que hablabas entre los s=" ". En ese caso es más corto. Y .‌​replace(""," ").replace("_",s);puede ser en .replace("_",s).‌​replace(""," ");cambio por -8 bytes adicionales
Kevin Cruijssen
1
String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace("_","&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;").replace(""," ");}( 131 bytes )
Numberknot
3

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.


fuente
3

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
millas
fuente
Lo mejor que puedo obtener usando una compresión de cadena genérica es 90 bytes:(' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '
Conor O'Brien
@ ConorO'Brien Sí, es difícil jugar a la compresión de cadenas en J cuando otros idiomas tienen diccionarios y compresión integrada.
millas
@ ConorO'Brien Intenté jugar un poco más tu idea y llegué a 76 bytes_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '
millas
3

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)
Mego
fuente
3

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.

Enlace Ng
fuente
3

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.

Level River St
fuente
3

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)

Gabriel Benamy
fuente
Todavía puede guardar algunos bytes: s/(.)/\1 /puede ser reemplazado por s/./$& /. Suelta el punto y coma final. Use en saylugar de print(para eso necesitará agregar -M5.010o usar en -Elugar de -e, pero ambos son gratuitos (ver aquí )). Nuevas líneas literales en lugar de \n.
Dada
2

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)
Kade
fuente
print'F K C I I B A V W M G\nN@P\nT@N\nC@C\nS@P\nP@S\nV@C\nS@P\nE@L\nS@B\nJ C V C O R I B C M G'.replace('@',' '*19)también es de 116 bytes sin usar join si quieres ser más directo. Alternativamente, 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)es de 115 bytes si se permite el espacio en blanco final. (El argumento para reemplazar es '!', En lugar de '!'.)
MichaelS
2

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
Neil
fuente
2

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 "
Timtech
fuente
1
Gracias @NiCkNewman, pero en realidad lo he usado antes en este sitio varias veces - codegolf.stackexchange.com/search?q=GameMaker
Timtech
Ya veo, estaba pensando en hacer algo en el GDScriptlenguaje del Godotmotor del juego. Pero, no estoy seguro si estaría bien :)
NiCk Newman
Ah, si tan solo el tablero fuera más grande; string_repeat(" ",19)tiene la misma longitud que " ".
u54112
1
@NiCkNewman Eso debería estar bien, dime si escribes algo :)
Timtech
@lastresort Lo sé ... GML permite trucos para romper cosas juntas, pero sus comandos son muy detallados ...
Timtech
2

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.

DLosc
fuente
2

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.

cleblanc
fuente
2

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.

simbabque
fuente
Buena solución Sin embargo, puede guardar algunos bytes: reemplaza \ncon nuevas líneas literales, no necesita espacios entre el xoperador y el número que sigue, y finalmente reemplaza split//,xxxcon xxx=~/./g.
Dada
1

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
Angs
fuente
1

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
mazzy
fuente