Dibujame un dominó

35

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 0para espacios en blanco y 1para los pips, o False/ 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 , por lo que gana el código más corto en bytes en cada idioma.

ETHproducciones
fuente
Entonces, para la entrada [2, 1], ¿podría salir [[[0,0,1],[0,0,0],[1,0,0]],[[0,0,0],[0,1,0],[0,0,0]]]?
Dennis
@Dennis Correcto.
ETHproductions
2
¿El separador entre las caras tiene que ser guiones, o puede ser algún otro valor consistente?
Jo King
@JoKing Diré que puedes usar cualquier personaje coherente que no sean los que ya estás usando.
ETHproductions
[0,5,21,29,31]Son todos los números importantes aquí mis amigos.
Magic Octopus Urn

Respuestas:

14

Python 2 , 101 97 92 68 64 bytes

lambda*a:[[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]]for n in a]

Pruébalo en línea!

Créditos

Neil
fuente
@ Mr.Xcoder actualizado de nuevo.
Neil
1
El formato es opcional. Devolver un par de matrices ahorra al menos 22 bytes.
Dennis
1
68 bytes sin formato (tenga en cuenta que 0y Falseson iguales en Python, por lo que debería estar bien).
Jonathan Allan
@JonathanAllan Muy inteligente, actualizado.
Neil
64 bytes. Si tiene que hacer una lambda, la comprensión de una lista es probablemente más corta.
totalmente humano
12

C (gcc) , 252 242 269 262 241 235 220 bytes

Estaba 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 238 228 bytes. reemplace +48 con * 79 + 32.

#define Q(P,R)(R>>P&1)+48
char a[11];i=0;f(char*c){char b=c[0];a[3]=a[7]='\n';a[5]=Q(0,b);a[1]=a[9]=Q(3,b);a[2]=a[8]=Q(2,b)|a[1];a[0]=a[10]=Q(1,b)|a[2];a[4]=a[6]=a[1]|Q(2,b)&Q(1,b);puts(a);if(i++<1){puts("---");f(c+1);}}

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.

Andrew Baumher
fuente
77
Bienvenido a PPCG!
Shaggy
Hola, bienvenido a PPCG! Puede acortar su código un poco más, 245 bytes
Sr. Xcoder
'\n'puede ser sustituido por 10. (porque en C, los tipos de datos char también son tipos de datos enteros) Algunos charpueden ser reemplazados por int. (u omitir por completo)
usuario202729
Hasta 184 bytes aquí, pero todavía es más que el actual c golf, entonces.
Andrew Baumher
173
Andrew Baumher
10

Jalea , 20 bytes

“¤o.ƤẸʠṚ’B¬s5ŒBị@s€3

Pruébalo en línea!

Versión alternativa, salida original, 33 32 31 bytes

“¤o.ƤẸʠṚ’ṃ⁾ os5ŒBị@s€3K€€Zj€”|Y

¡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, convierte el valor de retorno a binario y toma el NOT lógico de cada dígito, produciendo la matriz

00001001000010110100101011110011101111101111100000

Luego, s5ŒBdivide esa matriz en trozos de longitud 5 , luego rebota cada trozo, convirtiendo abcde en abcdedcba , produciendo

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Ahora, ị@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€3divide cada trozo de longitud nueve en tres trozos de longitud tres.

Dennis
fuente
1
Todavía me parece magia, pero aprecio el intento de una explicación. Admitiré que la culpa es probablemente mía, ya que solo soy un humilde desarrollador web PHP
ArtisticPhoenix
Se 3está utilizando 0para los pips, no 1como todos los demás.
Jonathan Allan
“¤o.ƤẸʠṚ’Deberia trabajar.
Jonathan Allan
@JonathanAllan ¡Gracias! No estoy seguro de cómo sucedió eso ...
Dennis
8

Jalea , 13 bytes

⁽½ÑD<;ḂŒBs3µ€

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

⁽½ÑD<;ḂŒBị⁾o Ks6Yµ€j“¶-----¶

Pruébalo en línea!

usuario202729
fuente
Aparentemente, mi enfoque ⁽½ÑDconduce a menos bytecount que la respuesta de EriktheOutgolfer “¤¦¢¬‘ aquí
usuario202729
¿No sería mejor reordenar las funciones para que los 13 bytes (superando a Dennis) estén en la parte superior y se puedan ver más fácilmente?
Zacharý
@ Zacharý Solución temporal. Lo arreglará más tarde.
user202729
6

PHP 155 , 150 bytes

function d($a){foreach($a as$n){$o="---";for($i=0;$x=2**$i,$i<9;++$i)$o.=([0,16,68,84,325,341,365,381,495,511])[$n]&$x?0:' ';echo chunk_split($o,3);}}

Toma una matriz de enteros como entrada. Para las pruebas:

d([1,2]);

echo "=========\n";

d([0,1,2,3,4,5,6,7,8,9]);

Formato de salida:

---

 0 

---
  0

0  

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í:

 1  |  2  |  4
 8  | 16  | 32
 64 | 128 | 256

Y luego una matriz de almacenamiento que consiste en las posiciones de bits para los pips de cada dominó correlacionados por el índice numerado:

[0,16,68,84,325,341,365,381,495,511]

Tan solo para aclarar:

  • ejemplo 0: índice 0o valor 0sería el dominó en blanco, que siempre es falso.
  • ejemplo 1: índice 1o valor 16sería el dominó número uno y en la matriz que está en el centro 16.
  • ejemplo 2: índice 2o valor 68sería el dominó número dos y en la matriz que está arriba a la derecha 4y abajo a la izquierda 64 o4|64
  • ejemplo 3: índice 5o valor 341sería el dominó número cinco y en la matriz que es1|4|16|64|256
  • ejemplo 4: índice 9o valor 511serí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 $xde 2la potencia de$i

for($i=0;$x=2**$i,$i<9;++$i)

Luego hacemos un bit a bit y &mientras iteramos por esos puntos. Entonces, por ejemplo, sake usará el ejemplo 2 de arriba y xusaré espacios en lugar de eso por razones de claridad visual:

  • iteración 1, 68 & 1 ? 0 : 'x'que da como resultado'x'
  • iteración 2, 68 & 2 ? 0 : 'x'que da como resultado'x'
  • iteración 3, 68 & 4 ? 0 : 'x'que da como resultado0
  • iteración 4, 68 & 8 ? 0 : 'x'que da como resultado'x'
  • iteración 5, 68 & 16 ? 0 : 'x'que da como resultado'x'
  • iteración 6, 68 & 32 ? 0 : 'x'que da como resultado'x'
  • iteración 7, 68 & 64 ? 0 : 'x'que da como resultado0
  • iteración 8, 68 & 128 ? 0 : 'x'que da como resultado'x'
  • iteración 9, 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:

---
xx0
xxx
0xx

No dudes en hacerme saber lo que piensas.

Fénix Artístico
fuente
Puede acortarlo aún más utilizando el operador de exponenciación **introducido en PHP 5.6 en lugar de pow() php.net/manual/en/language.operators.arithmetic.php
Daniel
@Daniel: ¡Gracias ahorramos 5 bytes! No estaba al tanto de que agregaban eso, siempre trato de usar el ^pero es el XOR bit a bit ... jajaja
ArtisticPhoenix
No creo que se le permita imprimir un borde extra.
12Me21
muéstrame dónde incluso remotamente insinúa eso en el OP.
ArtisticPhoenix
Supongo que esto sería más corto operando $argv. La sobrecarga de la función en PHP suele ser de 13 bytes.
Tito
6

Perl 5 , 107 76 70 + 1 ( -a) = 70 bytes

Perl 5 , 70 bytes

$,="
---
";say map{$_='351
7 7
153'=~s/\d/$_>$&||0/ger=~s/ /$_%2/er}<>

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 ||0crea salida cuando la condición es falsa. En Perl, falso es lo undefque sale como nulo.

Xcali
fuente
4

JavaScript (ES6), 79 78 bytes

Guardado 1 byte gracias a @ETHproductions

Toma entrada en la sintaxis de curry (a)(b)y genera un dominó ASCII vertical.

a=>b=>(g=n=>`351
707
153`.replace(/./g,d=>' o'[(+d?n>d:n)&1]))(a)+`
---
`+g(b)

Manifestación


Versión horizontal, 80 79 bytes

Guardado 1 byte gracias a @ETHproductions

Toma la entrada como una matriz de 2 enteros y genera un dominó ASCII horizontal.

a=>`240|351
686|797
042|153`.replace(/\d/g,d=>' o'[(d<8?(x=a[d&1])>(d|1):x)&1])

Manifestación

Arnauld
fuente
Bonito, muy similar a lo que tenía. Ahorre un byte con cualquiera n>d|0o(+d?n>d:n)&1
ETHproductions
4

APL (Dyalog) , 25 bytes

2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨

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.

Erik el Outgolfer
fuente
una reescritura de -2 bytes:2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨
ngn
@ngn gracias, eso es inteligente: p
Erik the Outgolfer
2

Javascript (ES6), 87 bytes

a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]

f=a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]
<div oninput="o.innerText=JSON.stringify(f(a.value)(b.value))"><input id=a type=number min=1 max=9 value=1><input id=b type=number min=1 max=9 value=1><pre id=o>

Herman L
fuente
Nice DOMinoes ...
Esolanging Fruit
2

Haskell - 88 caracteres

map$zipWith(zipWith($))[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]].repeat.repeat

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.

Geoff Reedy
fuente
Puede usar en maplugar de repeaty zipWith: ¡ map$(<$>[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]]).map.flip($)Pruébelo en línea!
Laikoni
Non-pointfree ahorra dos bytes más: ¡ Pruébelo en línea!
Laikoni
2

Pip , 32 27 24 21 bytes

-3 bytes gracias a @DLosc

FcgP[Yc>_M3517c%2RVy]

Pruébalo en línea!

Explicación:

F                      For each
 c                       character $c
  g                      in the list of inputs:
   P                     Print
    [               ]      an array consisting of
                             an array of bits representing whether
      c>                       $c is greater than
        _M                       each of
          3517                     3, 5, 1, and 7
     Y                       (call this bit array $y),
              c%2            $c mod 2,
                 RV          and the reverse
                   y           of $y.
Fruta Esolanging
fuente
1
¡Felicitaciones por ganar la recompensa Pip! Ahora que el período de recompensa ha terminado, te puedo decir: ahorra 3 bytes al asignar a un escalar en 3517lugar de una lista [3 5o7]. ;)
DLosc
1

> <> , 57 + 3 = 60 bytes

>{:3)$:5)$:1)$:7)$:2%$\ao \
\?%cl999)3$)5:$)1:$)7:/nnn<rp

Pruébalo en línea . Salidas como dominó vertical con 1s para puntos, 0s para espacios en blanco y 9s para separadores así:

001
000
100
999
111
111
111

Técnicamente, esto puede extenderse hasta 12 valores ingresados.

Versión antigua:

> <> , 76 + 3 = 79 bytes

>{:3)$:5)$:1)$a$:7)$:2%$:7)\&?o~?!n\
\?(*a3la"---"a)3$)5:$)1:$a$/$&:)9::<r~p

Pruébalo en línea . Salidas como un dominó vertical con 1s para puntos y 0s para espacios en blanco de esta manera:

001
000
100
---
111
111
111
Jo King
fuente
1

Carbón , 46 44 43 39 bytes

EE²℅§@APQTUVW^_NE⪪E⁹§ o÷ιX²↔⁻⁴λ³⪫λ M⁵↑⁵

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

EE²℅§@APQTUVW^_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).

  E⁹                Loop `l` (!) from 0 to 8
            ⁻⁴λ     Subtract from 4
           ↔        Absolute value
         X²         Power of 2
       ÷ι           Divide into the looked-up value `i`
    § o             Convert to space or o
 ⪪             ³    Split into (3) groups of 3
E                   Map over each group
                ⪫λ  Join the 3 characters with spaces

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.

M⁵↑⁵

Mueve hacia arriba y dibuja la línea divisoria entre las caras.

Versión horizontal anterior de 43 bytes:

↶P³M⁷←FE²℅§@APQTUVW^_NF⁹«F¬﹪κ³⸿⸿§ o÷ιX²↔⁻⁴κ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Trabaja verticalmente.

P³

Imprime la línea divisoria.

M⁷←

Posición al inicio de la primera cara.

FE²℅§@APQTUVW^_N

Lea dos enteros y mapeelos en la tabla de búsqueda.

F⁹«

Prepárese para producir hasta 9 os.

F¬﹪κ³⸿⸿

Pero comience una nueva columna cada tres os.

§ o÷ιX²↔⁻⁴κ

Convierta los 5 bits inferiores del código ASCII a binario, y luego refleje la salida para los 4 os restantes .

Neil
fuente
El formato de salida es bastante liberal, lo que debería ahorrar unos pocos bytes.
Dennis
1
¿Qué es esta brujería
ArtisticPhoenix
@Dennis En realidad, el formato de salida original es el más útil, ya que automáticamente me da espacio para dibujar la línea divisoria.
Neil
Oh dios, hay dos Neils.
Zacharý
2
@ Zacharý En realidad, según la página del usuario, hay ocho o 40 si incluye personas cuyos nombres contienen Neil ...
Neil
1

Jalea , 16 bytes

>⁽¤xb8¤;ḂŒḄs3
Ç€

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:

Ç€
 € for €ach input,
Ç  execute the previous line.

>⁽¤xb8¤;ḂŒḄs3
 ⁽¤xb8¤       the array [3, 5, 1, 7]
>             1 if the input is greater than each element, 0 otherwise
       ;Ḃ     append input % 2
         ŒḄ   bounce array
           s3 split into chunks of 3
ellie
fuente
0

APL + WIN, 49 47 bytes

4⌽'|',⌽⍉6 3⍴,⍉(9⍴2)⊤(+\∊0 241 52 24 114,¨16)[⎕]

Editado 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:

1 1 1 | 0 0 1    0 0 0 | 1 0 1
0 1 0 | 0 1 0    0 0 0 | 0 1 0
1 1 1 | 1 0 0    0 0 0 | 1 0 1

para una entrada de 7 3y0 5

Explicación:

(+\∊0 241 52 24 114,¨16) create a vector of integers whose binaries
                         represent the dots on the domino faces

[1+⎕] take input integers as indices to select from above vector

⍉6 3⍴,⍉(9⍴2)⊤ convert selected integers to a 9x2 binary matrix and reshape
              to match the orientation of the domino faces

4⌽'|',⌽ rotate, concatenate centre line markers and rotate again to centre 
Graham
fuente
¿Por qué no usar ⎕IO←0para salvarte a ti mismo 1+?
Adám
@Adam ¿Por qué no? - perezoso;)
Graham
0

Python 2 , 121 bytes

lambda x,y,d="001155777702020202570044557777":[("%03d"%int(bin(int(o))[2:]),"---")[o=="3"]for o in d[x::10]+"3"+d[y::10]]

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 , 156 153 147 141 bytes

x,y=input()
d="001155777702020202570044557777"
a=["%03d"%int(bin(int(o))[2:])for o in d[x::10]+d[y::10]]
for x in a[:3]+["---"]+a[3:]:print x

Prué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.

ElPedro
fuente
153 bytes
NieDzejkob
0

Pyt , 220 154 bytes

Segundo intento (154 bytes)

46281ᴇ8264áĐ9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔

Explicación:

46281ᴇ8264áĐ                                    Pattern matching for every cell but the middle
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹     Make top cell
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ      Make bottom cell
5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔                          Make boundary and combine



Primer intento (220 bytes):

2`↔←Đ4≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2%Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3Ș4≥Đ6²⁺3**⇹¬5«+1ᴇ9△ĐĐĐĐ1ᴇ↔⁻łŕ↔ŕŕŕŕŕŕáƇǰ

Explicación:

2                           Push 2 (this is how many 'cells' to make)
`     ... ł                 While the top of the stack is not zero, loop
↔                           Flip the stack (useless at the beginning, undoes the flip at the end of the loop)
←Đ4≥Đ6²⁺3**⇹¬5«+            Set top-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set top-middle pip
2⁵⇹3Ș                       Space
Đ2≥Đ6²⁺3**⇹¬5«+             Set top-right pip
1ᴇ⇹3Ș                       New line
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-left pip
2⁵⇹3Ș                       Space
Đ2%Đ6²⁺3**⇹¬5«+             Set center pip
2⁵⇹3Ș                       Space
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-right pip
1ᴇ⇹3Ș                       New line
Đ2≥Đ6²⁺3**⇹¬5«+             Set bottom-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set bottom-middle pip
2⁵⇹3Ș                       Space
4≥Đ6²⁺3**⇹¬5«+              Set bottom-right pip
1ᴇ                          New line
9△ĐĐĐĐ                      Add 5 dashes
1ᴇ                          New line
↔⁻ł                         Decrement counter (if >0, loop; otherwise, exit loop)
ŕ↔ŕŕŕŕŕŕ                    Remove all unnecessary items on the stack
áƇǰ                         Push stack to an array, get characters at unicode codepoints given by values in the array, join characters with empty string


Pruébalo en línea!

mudkip201
fuente
0

05AB1E , 34 bytes

•ΩõIº•R2ô¹2÷è¹È-bDg5s-ú.∞3ô»TR„ o‡

Pruébalo en línea!


Esto fue difícil porque 05AB1E tiene un relleno incorrecto.


Explicación básica:

  • Aquí hay 4 patrones significativos que son 2, 4, 6 y 8.
  • 3,5,7 y 9 son los otros patrones más 1.
  • 1 no es significativo debido a la simetría, si la entrada es par, reste 1 para alternar el bit del medio.
  • Al alternar el LSB se puede voltear el bit medio debido a la duplicación.
Urna de pulpo mágico
fuente
0

SmileBASIC, 92 69 bytes

INPUT N,M
DEF Q?N>3;N>5;N>1?N>7;1AND N;N>7?N>1;N>5;N>3
END
Q?777N=M
Q

Ejemplo:

? 7,2
111
010
111
777
001
000
100

Esto es lo que sucede cuando sus reglas no son lo suficientemente estrictas.

12Me21
fuente
0

FALSO, 116 80 78 70 69 66 63 61 59 58 bytes

[$3[>_$.\$]$p:!5p;!1p;!"
"7p;!%1&.."
"..."
"]$s:!"---
"s;!

sigo trabajando en esto ...

12Me21
fuente
0

Viruta ,142 135 bytes

! CvDvB
>v-]-x.
|Z-]-]e
|Z]xe|
|ZR(-'
|Zx.AD
|Zxx]x.
|Zx^-]e
|Z<,(-.
|Zx]xe|
|Zx-]-]e
|Zx-]-x'
|Z<C^D^B
|>x~s
|Zx.
|Zx<
|Zxb
|Z+^~f
`zd

Prué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(o z) corresponde a un carácter de salida, están posicionados para disparar en orden de arriba a abajo. El capitalizado A, B, C, y Dcorresponden a los cuatro bits bajos de la entrada (que es todo lo que miramos, por lo que "34" == "CD" == "st" ...). La minúscula b, d, e, fcorresponden a varios bits de la salida.

También puede hacer fichas de dominó de longitud infinita; Intenta dar 0123456789como entrada.

Phlarx
fuente
0

PHP, 116 bytes

while($i<6)echo strtr(sprintf("%03b",[_011557777,_202020267,_044557777][$i/2][$argv[$i%2+1]]),10,"o "),"|
"[$i++%2];

requiere PHP 5.5 o posterior. Ejecutar -nro probarlo en línea .

Titus
fuente
0

C (gcc) , 150 146 bytes

p(b){printf(" %c",33-b);}P(a){p(a<4),p(a<6),p(a<2),p(23),p(a<8),p(~a&1),p(a<8),p(23),p(a<2),p(a<6),p(a<4),p(23);}f(a,b){P(a),puts(" -----"),P(b);}

Pruébalo en línea!

Jonathan Frech
fuente
@ceilingcat Gracias.
Jonathan Frech