Reto
Dados dos dígitos 0-9 como entrada, genera un dominó (del conjunto de dominó doble nueve ) con este número de pips (puntos) en las dos caras. Las diez caras posibles se ven así (separadas por tuberías):
| | o| o|o o|o o|o o o|o o o|o o o|o o o
| o | | o | | o | | o |o o|o o o
| |o |o |o o|o o|o o o|o o o|o o o|o o o
O en líneas separadas:
-----
o
-----
o
o
-----
o
o
o
-----
o o
o o
-----
o o
o
o o
-----
o o o
o o o
-----
o o o
o
o o o
-----
o o o
o o
o o o
-----
o o o
o o o
o o o
Formatos de entrada
Puede recibir información en cualquier formato razonable, que incluye pero no se limita a:
- Dos enteros, cadenas o matrices singleton separadas;
- Un solo entero de 0-99;
- Una matriz de dos enteros;
- Una cadena de dos dígitos.
Formatos de salida
- Las dos caras pueden estar alineadas horizontalmente, separadas por tuberías de la siguiente manera:
o|o o
| o
o |o o
- O pueden estar alineados verticalmente, separados por guiones así:
o
o
-----
o o
o
o o
- Si lo desea, puede generar un borde alrededor del dominó.
- También puede optar por generar una lista de líneas, una lista de las dos caras o una combinación de estas.
- Puede usar cualquier carácter que no sea un espacio en blanco para los pips (que usé
o
). - Si realmente lo desea, puede usarlo
0
para espacios en blanco y1
para los pips, oFalse
/True
(o el equivalente de su idioma) si genera una matriz. - Puede eliminar el espacio en blanco entre columnas; Esta es una salida válida para 7, 7:
ooo|ooo
o | o
ooo|ooo
- Cualquiera de las caras puede girarse 90 grados. Esta también es una salida válida para 7, 7:
o o|o o o
o o o| o
o o|o o o
- Es posible que tenga tanto / poco espacio en blanco inicial / final como desee, siempre que la parte principal de la salida aún se ajuste a las otras restricciones.
- Cada cara debe tener 3 líneas de alto, incluso si las líneas están vacías. Para 0, 1 no puede generar esto:
-----
o
Pero podrías generar esto:
-----
o
Del mismo modo, si estaba generando una lista de dos listas de líneas, podría hacerlo [["", "", ""], ["", " o", ""]]
, pero no [[""], [" o "]]
.
Tanteo
Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma.
[2, 1]
, ¿podría salir[[[0,0,1],[0,0,0],[1,0,0]],[[0,0,0],[0,1,0],[0,0,0]]]
?[0,5,21,29,31]
Son todos los números importantes aquí mis amigos.Respuestas:
Python 2 ,
10197926864 bytesPruébalo en línea!
Créditos
fuente
0
yFalse
son iguales en Python, por lo que debería estar bien).C (gcc) ,
252242269262241235220 bytesEstaba en el desbordamiento de pila para sockets en python, cuando apareció, dijo ¿por qué no? primer código de golf, así que no estoy completamente seguro si seguí las reglas al 100% (y si no, y alguien quiere robar mi proverbial cookie y arreglarla, que así sea). Con 'o' y '',
255 245 272 265 244 238228 bytes. reemplace +48 con * 79 + 32.Pruébalo en línea!
Cómo funciona:
uso un cambio de bit y bit a bit y para encontrar si un punto debe ser claro o un pip, luego compensar el 0 o 1 al valor ASCII correcto. se equivoca en 4 y 5, por lo que necesitaban algo de reparación. En realidad agregó algunos bytes. fue capaz de eliminar varios bytes eliminando una máscara y simplemente usando 1 (doh)
Un agradecimiento especial al Sr. Xcoder por los 7 bytes menos al eliminar un exceso de #define
Changes: eliminado memset -21 bytes. rehizo la lógica de bits para 6, 4, 2 para depender de 8 | 4 y 2, 8 | 4, 8 | 4 | 2, respectivamente. -6 bytes. eliminó nuevas líneas adicionales mediante el uso de pone en lugar de printf, que también es más corto. acortó la matriz a 11, eliminando la asignación adicional. -15 bytes. AHORA creo que es lo mejor que puedo hacer.
fuente
'\n'
puede ser sustituido por10
. (porque en C, los tipos de datos char también son tipos de datos enteros) Algunoschar
pueden ser reemplazados porint
. (u omitir por completo)Jalea , 20 bytes
Pruébalo en línea!
Versión alternativa, salida original,
333231 bytes¡Gracias a @ user202729 por jugar golf en 1 byte!
Pruébalo en línea!
Cómo funciona
Primero,
“¤o.ƤẸʠṚ’
un literal entero en la base biyectiva 250 establece el valor de retorno en 1086123479729183 .Luego,
B¬
convierte el valor de retorno a binario y toma el NOT lógico de cada dígito, produciendo la matrizLuego,
s5ŒB
divide esa matriz en trozos de longitud 5 , luego rebota cada trozo, convirtiendo abcde en abcdedcba , produciendoAhora,
ị@
recupera el elemento j th y k th de esta matriz, donde j, k es el primer argumento del programa. Tenga en cuenta que la indexación se basa en 1 y es modular, por lo que el elemento cero también es el décimo.Finalmente,
s€3
divide cada trozo de longitud nueve en tres trozos de longitud tres.fuente
3
está utilizando0
para los pips, no1
como todos los demás.“¤o.ƤẸʠṚ’
Deberia trabajar.Jalea , 13 bytes
Pruébalo en línea!
Combinando la idea de Dennis de usar
ŒB
(rebote) en esta respuesta y la observación de Xcali en esta respuesta para obtener 13 bytes.Jalea , 28 bytes
(con bonita impresión)
Solo ahora sé que el literal de cadena Jelly se termina automáticamente ...
Pruébalo en línea!
fuente
⁽½ÑD
conduce a menos bytecount que la respuesta de EriktheOutgolfer“¤¦¢¬‘
aquíPHP
155, 150 bytesToma una matriz de enteros como entrada. Para las pruebas:
Formato de salida:
Compruébalo en vivo aquí
Mi solución
Para mi solución, utilicé una matriz que consta de números bit a bit (potencias de 2). Se puede visualizar así:
Y luego una matriz de almacenamiento que consiste en las posiciones de bits para los pips de cada dominó correlacionados por el índice numerado:
Tan solo para aclarar:
0
o valor0
sería el dominó en blanco, que siempre es falso.1
o valor16
sería el dominó número uno y en la matriz que está en el centro16
.2
o valor68
sería el dominó número dos y en la matriz que está arriba a la derecha4
y abajo a la izquierda64
o4|64
5
o valor341
sería el dominó número cinco y en la matriz que es1|4|16|64|256
9
o valor511
sería el dominó número nueve y en la matriz es la combinación de todos los bits.Una vez que se establece que es una cuestión bastante simple de bucle por 9 posiciones en la matriz, y el establecimiento
$x
de2
la potencia de$i
Luego hacemos un bit a bit y
&
mientras iteramos por esos puntos. Entonces, por ejemplo, sake usará el ejemplo 2 de arriba yx
usaré espacios en lugar de eso por razones de claridad visual:68 & 1 ? 0 : 'x'
que da como resultado'x'
68 & 2 ? 0 : 'x'
que da como resultado'x'
68 & 4 ? 0 : 'x'
que da como resultado0
68 & 8 ? 0 : 'x'
que da como resultado'x'
68 & 16 ? 0 : 'x'
que da como resultado'x'
68 & 32 ? 0 : 'x'
que da como resultado'x'
68 & 64 ? 0 : 'x'
que da como resultado0
68 & 128 ? 0 : 'x'
que da como resultado'x'
68 & 256 ? 0 : 'x'
que da como resultado'x'
Cuando se completa el ciclo, terminamos con esta cuerda
"xx0xxx0xx"
.A continuación, añadimos la frontera
"---xx0xxx0xx"
a ella (que en realidad empezar con la frontera, pero lo que sea) .Y finalmente chunk_split () en 3 para:
No dudes en hacerme saber lo que piensas.
fuente
**
introducido en PHP 5.6 en lugar depow()
php.net/manual/en/language.operators.arithmetic.php^
pero es el XOR bit a bit ... jajaja$argv
. La sobrecarga de la función en PHP suele ser de 13 bytes.Perl 5 ,
107 7670+ 1 (= 70 bytes-a
)Perl 5 , 70 bytes
Pruébalo en línea!
Utiliza 0 para espacios en blanco y 1 para pips. Método bastante simple: observe que a medida que el dígito sube, una vez que un pip está "encendido", nunca se "apaga", excepto el que está en el medio. En la posición media, está activado para todos los números impares. Por lo tanto, para cada posición, es una simple cuestión de verificar si el dígito es mayor que el último dígito para el que está desactivado. El
||0
crea salida cuando la condición es falsa. En Perl, falso es loundef
que sale como nulo.fuente
JavaScript (ES6),
7978 bytesGuardado 1 byte gracias a @ETHproductions
Toma entrada en la sintaxis de curry
(a)(b)
y genera un dominó ASCII vertical.Manifestación
Mostrar fragmento de código
Versión horizontal,
8079 bytesGuardado 1 byte gracias a @ETHproductions
Toma la entrada como una matriz de 2 enteros y genera un dominó ASCII horizontal.
Manifestación
Mostrar fragmento de código
fuente
n>d|0
o(+d?n>d:n)&1
APL (Dyalog) , 25 bytes
Pruébalo en línea!
-2 gracias a ngn .
El formato de salida es un poco extraño: esta función devuelve una matriz que contiene dos matrices con forma 3,3, cada una de las cuales contiene 0s y 1s.
fuente
2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨
C (gcc) , 115 bytes
Pruébalo en línea!
fuente
Javascript (ES6), 87 bytes
fuente
Haskell - 88 caracteres
Toma una lista de dos números que indican las caras, devuelve una lista de la lista de la lista de bool. No es tan breve, pero la solución me parece interesante.
fuente
map
lugar derepeat
yzipWith
: ¡map$(<$>[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]]).map.flip($)
Pruébelo en línea!Pip ,
32272421 bytes-3 bytes gracias a @DLosc
Pruébalo en línea!
Explicación:
fuente
3517
lugar de una lista[3 5o7]
. ;)> <> , 57 + 3 = 60 bytes
Pruébalo en línea . Salidas como dominó vertical con 1s para puntos, 0s para espacios en blanco y 9s para separadores así:
Técnicamente, esto puede extenderse hasta 12 valores ingresados.
Versión antigua:
> <> , 76 + 3 = 79 bytes
Pruébalo en línea . Salidas como un dominó vertical con 1s para puntos y 0s para espacios en blanco de esta manera:
fuente
Carbón ,
46444339 bytesPruébalo en línea! El enlace es a la versión detallada del código. Explicación:
Lea dos enteros y mapeelos en la tabla de búsqueda. Luego mapee sobre el resultado. (Esto captura efectivamente el resultado de forma temporal).
Los resultados se imprimen implícitamente en líneas separadas, con una línea en blanco adicional entre cada cara porque los resultados están anidados.
Mueve hacia arriba y dibuja la línea divisoria entre las caras.
Versión horizontal anterior de 43 bytes:
Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:
Trabaja verticalmente.
Imprime la línea divisoria.
Posición al inicio de la primera cara.
Lea dos enteros y mapeelos en la tabla de búsqueda.
Prepárese para producir hasta 9
o
s.Pero comience una nueva columna cada tres
o
s.Convierta los 5 bits inferiores del código ASCII a binario, y luego refleje la salida para los 4
o
s restantes .fuente
Jalea , 16 bytes
Pruébalo en línea!
Usó la estrategia de Neil y la descompresión de base para generar los valores; salidas como una matriz binaria. Toma una lista como entrada.
Explicación:
fuente
APL + WIN,
4947 bytesEditado según el comentario de Adam, gracias, para ejecutarse con índice de origen cero.
Solicita la entrada de pantalla como un vector de enteros uno para cada cara.
El resultado es de la forma:
para una entrada de
7 3
y0 5
Explicación:
fuente
⎕IO←0
para salvarte a ti mismo1+
?Python 2 , 121 bytes
Pruébalo en línea!
Reducido a 121 usando una lambda después de regresar y releer las reglas. Ahora genera una lista de líneas.
Versión anterior con salida bien formateada:
Python 2 ,
156153147141 bytesPruébalo en línea!
-3 con gracias a @NieDzejkob
Toma la entrada como 2 enteros y las salidas en formato vertical con 0 = espacio y 1 = punto.
fuente
Pyt ,
220154 bytesSegundo intento (154 bytes)
Explicación:
Primer intento (220 bytes):
Explicación:
Pruébalo en línea!
fuente
05AB1E , 34 bytes
Pruébalo en línea!
Esto fue difícil porque 05AB1E tiene un relleno incorrecto.
Explicación básica:
fuente
SmileBASIC,
9269 bytesEjemplo:
Esto es lo que sucede cuando sus reglas no son lo suficientemente estrictas.
fuente
FALSO,
116807870696663615958 bytessigo trabajando en esto ...
fuente
Viruta ,
142135 bytesPruébalo en línea!
La entrada es una cadena de dígitos. Utiliza ceros como los pips. Dibuja los pips para un número, lee el siguiente byte de entrada. Si no hay un byte siguiente, termina, de lo contrario dibuja el divisor y ve a comenzar.
Cada
Z
(oz
) corresponde a un carácter de salida, están posicionados para disparar en orden de arriba a abajo. El capitalizadoA
,B
,C
, yD
corresponden a los cuatro bits bajos de la entrada (que es todo lo que miramos, por lo que"34" == "CD" == "st" ...
). La minúsculab
,d
,e
,f
corresponden a varios bits de la salida.También puede hacer fichas de dominó de longitud infinita; Intenta dar
0123456789
como entrada.fuente
PHP, 116 bytes
requiere PHP 5.5 o posterior. Ejecutar
-nr
o probarlo en línea .fuente
C (gcc) ,
150146 bytesPruébalo en línea!
fuente