Imprima un rectángulo Pentomino


16

Escriba un programa o función que no tenga entrada pero imprima o devuelva una representación textual constante de un rectángulo formado por los 12 pentominoes distintos :

12 pentominoes

El rectángulo puede tener cualquier dimensión y estar en cualquier orientación, pero los 12 pentominoes deben usarse exactamente una vez, por lo que tendrá un área 60. Cada pentomino diferente debe estar compuesto de un carácter ASCII imprimible diferente (no es necesario usar el letras de arriba).

Por ejemplo, si elige generar esta solución de rectángulo pentomino 20 × 3:

Solución 3x20

La salida de su programa podría verse así:

00.@@@ccccF111//=---
0...@@c))FFF1//8===-
00.ttttt)))F1/8888=-

Alternativamente, puede que le resulte más fácil jugar al golf con esta solución 6 × 10:

000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!

Cualquier solución rectangular servirá, su programa solo necesita imprimir una. (Una nueva línea final en la salida está bien).

Este excelente sitio web tiene muchas soluciones para varias dimensiones de rectángulo y probablemente valga la pena navegar por ellas para asegurarse de que su solución sea lo más breve posible. Este es el código de golf, gana la respuesta más corta en bytes.


15
Bono si es un "quine" en Piet.
mbomb007

@ mbomb007 Eso es prácticamente imposible con solo 12 bloques para jugar: P
Sp3000

No creo que se deban espacios en las fronteras. Pero como lo son, ¿puedo omitir los espacios finales? ¿Recibo una bonificación si imprimo una solución vertical de 5x12 con una I sin espacios al final?
John Dvorak

@ Sp3000 ¿qué tal un programa Piet compuesto completamente por soluciones rectangulares pentomino?
John Dvorak

@ JanDvorak No puede omitir espacios finales si los tiene. Son caracteres como el resto de ASCII imprimible.
Aficiones de Calvin

Respuestas:


1

Pyth, 37 bytes

jc4.HC"&f3ªªwril3:[·)ÌDU[r)ÌDA»

Demostración

Utiliza un enfoque muy sencillo: use bytes hexadecimales como números. Convertir a un número hexadecimal, base 256 codificar eso. Eso le da la cuerda mágica arriba. Para decodificar, use la función de decodificador base 256 de Pyth, convierta a hexadecimal, divida en 4 trozos y únase en líneas nuevas.


5

CJam (44 bytes)

Dado en formato xxd porque contiene caracteres de control (incluida una pestaña sin formato, que juega muy mal con MarkDown):

0000000: 2202 7e0d 8ef3 570d e085 e168 cf27 092c
0000010: a235 0c22 3235 3662 3562 332f 5f2c 2c2e
0000020: 7b32 2f27 412b 662b 7d7a 4e2a 

que decodifica algo a lo largo de las líneas de

"MAGIC STRING"256b5b3/_,,.{2/'A+f+}zN*

Demostración en línea un poco descuidada que no contiene caracteres de control y, por lo tanto, juega muy bien con las funciones de biblioteca de decodificación de URI del navegador.

El principio básico es que, dado que ninguna pieza abarca más de 5 filas, podemos codificar un desplazamiento desde una función lineal del número de fila de forma compacta (en la base 5, de hecho, aunque no he intentado determinar si este sería siempre el caso )


5

Bash + utilidades comunes de Linux, 50

xxd -s20 -p -c2 $0
#<30 bytes of binary data>

Para recrear esto desde la base64 codificada:

base64 -d <<< eHhkIC1zMjAgLXAgLWMyICQwCiMiImaSaZlmkDAAMwSjRKNEqoGogYhRVVF7UXu7d3s= > pent.sh

Dado que hay 12 pentominoes, sus colores se codifican fácilmente en hexbbles hexadecimales.

Salida:

$ ./pent.sh
2222
6692
6999
6690
3000
3304
a344
a344
aa81
a881
8851
5551
7b51
7bbb
777b
$ 

4

J, 49 bytes

u:64++/\|:3#.inv 1377859090 1567813024 1337683230

Puede elegir las letras de manera que los incrementos máximos entre letras verticalmente adyacentes sean 2. Usamos este hecho para codificar incrementos verticales en base3. Después de eso, creamos las sumas en ejecución y agregamos un desplazamiento para obtener los códigos ASCII de las letras.

Definitivamente golfable. (Todavía no he encontrado una manera de ingresar números de base36 de precisión extendida, pero base36 simple debería ahorrar solo 3 bytes).

Salida:

AAA
ABA
BBB
DBC
DCC
DCC
DEE
DFE
FFE
FGE
FGG
GGH
HHH
IIH
JII
JJI
JKK
JKL
KKL
LLL

Pruébelo en línea aquí.


Muy agradable. Con la codificación base 256 aplicando esta diferencia, la codificación en CJam proporciona 33 bytes ( versión de 48 bytes sin b256 ).
Peter Taylor

¡Esto es asombroso! También funcionaría con el 4x15, que funcionaría bien para empaquetar cuatro números en un byte, si almacena datos a lo ancho en lugar de a lo largo. Necesitaría un diseño que tenga el U pentomino orientado en la dirección correcta. Hay muchos en el enlace de la pregunta.
Level River St

@steveverrill Necesitaría un desplazamiento inicial para eso porque habrá más de 4 piezas comenzando en la primera línea, por lo que no puede codificarlas en base4. Con este desplazamiento adicional (p. Ej., 3#i.5Que es 0 0 0 1 1 1 ... 4 4 4) puede funcionar pero probablemente no será más corto (al menos de la manera que lo intenté).
randomra

2

Microscript II , 66 bytes

Comencemos con la respuesta simple.

"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

Hurra impresión implícita.


1

Rubí

Rev 3, 55bytes

i=1
'S, OJ1*$HCH(#%0'.bytes{|e|puts "%x"%i+=e*130&9011}

Como desarrollo adicional de la idea de Randomra, considere la tabla de resultados y diferencias a continuación. La tabla de diferencias se puede comprimir como antes y expandirse multiplicando por 65 = binario 1000001 y aplicando una máscara 11001100110011. Sin embargo, Ruby no funciona de manera predecible con caracteres de 8 bits (tiende a interpretarlos como Unicode).

Sorprendentemente, la última columna es completamente uniforme. Debido a esto, en compresión podemos realizar un desplazamiento de derechos sobre los datos. Esto garantiza que todos los códigos sean ASCII de 7 bits. En expansión, simplemente multiplicamos por 65 * 2 = 130 en lugar de 65.

La primera columna también es completamente uniforme. Por lo tanto, podemos agregar 1 a cada elemento (32 a cada byte) cuando sea necesario, para evitar cualquier carácter de control. El 1 no deseado se elimina utilizando la máscara 10001100110011 = 9011 en lugar de 11001100110011.

Solution 59 of document linked in question

Start0001

Out  Diff
2223 2222
2433 0210
2433 0000
4445 2012
6555 2110
6577 0022
6687 0110
6887 0200
8897 2010
aa99 2202
caa9 2010
cab9 0010
cbbb 0102
cdbd 0202
cddd 0020

Aunque uso 15 bytes para la tabla, solo uso 6 bits de cada byte, que es un total de 90 bits. De hecho, solo hay 36 valores posibles para cada byte, que son 2.21E23 en total. Eso encajaría en 77 bits de entropía.

Rev 2, 58 bytes, usando el enfoque incremental de Randomra

i=0
'UPEIP@bPHPBETTEPRADT'.bytes{|e|puts "%x"%i+=e*65&819}

Finalmente, algo más corto que la solución ingenua. Enfoque incremental de Randomra, con el método bytepacking de Rev 1.

Rev 1, 72 bytes, versión golfizada de rev 0

Se hicieron algunos cambios en la línea de base para acomodar un reordenamiento del código por razones de golf, pero aún así llegó más tiempo que la solución ingenua.

i=0
'UPUIYD&!)$&V*).);c+*'.bytes{|e|i+=1;puts "%x"%(i/2*273+(e*65&819))}

Los desplazamientos se codifican en cada carácter de la cadena mágica en formato base 4 BAC, es decir, con los 1 que representan el símbolo de la derecha, los 16 que representan el símbolo del medio y el símbolo de la izquierda en la posición del 4. Para extraerlos, el código ASCII se multiplica por 65 (binario 1000001) para dar BACBAC, luego se suma con 819 (binario 1100110011) para dar.A.B.C .

Algunos de los códigos ASCII tienen el conjunto de 7 bits, es decir, son 64 más altos que el valor requerido, para evitar caracteres de control. Debido a que este bit es eliminado por la máscara 819, esto es intrascendente, excepto cuando el valor de Ces 3, lo que provoca un arrastre. Esto debe corregirse solo en un lugar (en lugar de gusarlo c).

Rev 0, versión sin golf

a= %w{000 010 000 201 100 100 011 021 110 120 011 112 111 221 211 221 122 123 112 222}
i=2
a.each{|e|puts "%x"%(i/2*273+e.to_i(16));i+=1} 

Salida

111
121
222
423
433
433
455
465
665
675
677
778
888
998
a99
aa9
abb
abc
bbc
ccc

Explicación

De la siguiente solución, resta la línea base, dando el desplazamiento que almaceno como datos. La línea base se regenera como un número hexadecimal en el código por i/2*273(273 decimal = 111 hexadecimal).

solution   baseline   offset
AAA        AAA        000
ABA        AAA        010
BBB        BBB        000
DBC        BBB        201
DCC        CCC        100
DCC        CCC        100
DEE        DDD        011
DFE        DDD        021
FFE        EEE        110
FGE        EEE        120
FGG        FFF        011
GGH        FFF        112
HHH        GGG        111
IIH        GGG        221
JII        HHH        211
JJI        HHH        221
JKK        III        122
JKL        III        123
KKL        JJJ        112
LLL        JJJ        222

Parece esencialmente el mismo enfoque que el mío, pero has logrado evitar el único delta de 4 que me obligó a codificar en la base 5. Parece que elegí el etiquetado incorrecto para las piezas.
Peter Taylor

Vi tu respuesta después de publicar la mía. No puedo seguir a Cjam, pero por lo que dijiste en tu respuesta es un enfoque similar. De hecho, solo tengo una sola 3en toda la tabla (justo cerca de la parte inferior), así que creo que al aumentar la línea de base en un poco más de 0.5 cada línea, es posible usar la base 3. Siéntase libre de probar eso. (Por razones de golf parece que voy a tener que cambiar ligeramente la línea de base, lo que me da más de 3, y desafortunadamente parece que va a ser 1 byte más que la solución ingenua en Ruby.)
Level River St

En caso de que no estuviera claro antes, mi intención era felicitarlo por hacer un mejor trabajo que yo, no acusarlo de copiar. Y no voy a intentar usar una tasa de crecimiento de 2.5 porque no creo que supere el enfoque de codificación de diferencia de randomra.
Peter Taylor

@ PeterTaylor gracias, entendí que me felicitabas. Por otro lado, entraste primero con básicamente la misma idea y la hiciste mucho más corta, así que también te felicito. Con el enfoque de diferencia de randomra, finalmente puedo ser más corto que la solución ingenua. También funcionaría bien en 4x15 (dado el diseño correcto de pentomino). Así es como lo haría en C o en cualquier otro lenguaje que funcione bien con cadenas de 8 bits. Como Ruby admite unicode, intenta interpretar cadenas de 8 bits como unicode y puede dar algunos mensajes de error molestos.
Level River St

0

Foo, 66 bytes

"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

Esto es carácter por carácter idéntico a la solución de Microscript II anterior ... ¿Asumo que estos lenguajes están relacionados?
Darrel Hoffman

1
@DatrelHoffman no realmente, foo básicamente solo imprime todo entre comillas
Teoc
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.