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 código de golf , por lo que gana el código más corto en bytes en cada idioma.

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

• Reducido de 101 bytes a 92 por el Sr. Xcoder
• Reducido de 92 bytes a 68 por Jonathan Allan ( Dennis )
• Reducido de 68 bytes a 64 por totalmente humano

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.

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, B¬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.

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!

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.

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.

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

let f =

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

console.log(f(4)(2))
console.log(f(3)(7))

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

let f =

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

console.log(f([4,2]))
console.log(f([3,7]))

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.

C (gcc) , 115 bytes

i;g(x){for(i=0;++i<10;)printf("%c%c",32+(i^5?x>" CEAG@GAEC"[i]-64:x%2),i%3?32:10);}f(a,b){g(a),puts("-----"),g(b);}

Pruébalo en línea!

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>

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.

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.

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

Carbón , 46 44 43 39 bytes

ＥＥ²℅§@APQTUVW^_ＮＥ⪪Ｅ⁹§ o÷ιＸ²↔⁻⁴λ³⪫λ Ｍ⁵↑⁵

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

ＥＥ²℅§@APQTUVW^_Ｎ

Lea dos enteros y mapeelos en la tabla de búsqueda. Luego mapee sobre el resultado. (Esto captura efectivamente el resultado de forma temporal).

  Ｅ⁹                Loop `l` (!) from 0 to 8
            ⁻⁴λ     Subtract from 4
           ↔        Absolute value
         Ｘ²         Power of 2
       ÷ι           Divide into the looked-up value `i`
    § o             Convert to space or o
 ⪪             ³    Split into (3) groups of 3
Ｅ                   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.

Ｍ⁵↑⁵

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

Versión horizontal anterior de 43 bytes:

↶Ｐ³Ｍ⁷←ＦＥ²℅§@APQTUVW^_ＮＦ⁹«Ｆ¬﹪κ³⸿⸿§ o÷ιＸ²↔⁻⁴κ

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.

ＦＥ²℅§@APQTUVW^_Ｎ

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

Ｆ⁹«

Prepárese para producir hasta 9 os.

Ｆ¬﹪κ³⸿⸿

Pero comience una nueva columna cada tres os.

§ o÷ιＸ²↔⁻⁴κ

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

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

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 

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.

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!

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.

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.

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

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

sigo trabajando en esto ...

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.

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 .

C (gcc) , 150 146 bytes

• Guardado cuatro bytes gracias a ceilingcat .

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!