Sfida

Dato due cifre 0-9 come input, emette un domino (dal set di domino doppio-nove ) con questo numero di pip (punti) sulle due facce. Le dieci facce possibili si presentano così (separate da tubi):

     |     |    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 su linee separate:

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

Formati di input

È possibile accettare input in qualsiasi formato ragionevole, incluso ma non limitato a:

• Due interi, stringhe o matrici singleton separate;
• Un singolo intero compreso tra 0 e 99;
• Una matrice di due numeri interi;
• Una stringa di due cifre.

Formati di output

• Le due facce possono essere allineate orizzontalmente, separate da tubi in questo modo:

    o|o   o
     |  o  
o    |o   o

• Oppure possono essere allineati verticalmente, separati da trattini in questo modo:

    o
     
o    
-----
o   o
  o  
o   o

• Se lo desideri, puoi generare un bordo attorno al domino.
• Puoi anche scegliere di produrre un elenco di linee, un elenco delle due facce o una combinazione di queste.
• Puoi usare qualsiasi carattere non bianco per i pips (ho usato o).
• Se lo desideri davvero, puoi usare 0per gli spazi bianchi e 1per i pips, o False/ True(o l'equivalente della tua lingua) se emetti un array.
• È possibile rimuovere lo spazio bianco tra le colonne; questo è un output valido per 7, 7:

ooo|ooo
 o | o 
ooo|ooo

• Qualsiasi faccia può essere ruotata di 90 gradi. Questo è anche un output valido per 7, 7:

o   o|o o o
o o o|  o  
o   o|o o o

• Potresti avere lo spazio bianco iniziale / finale che desideri, purché la parte principale dell'output si adatti ancora agli altri vincoli.
• Ogni faccia deve essere alta 3 linee, anche se le linee sono vuote. Per 0, 1 non è stato possibile generare questo:

-----

  o

Ma si poteva uscita questo:

-----

  o

Allo stesso modo, se stavi producendo un elenco di due elenchi di righe, potresti farlo [["", "", ""], ["", " o", ""]], ma non [[""], [" o "]].

punteggio

Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua.

Python 2 , 101 97 92 68 64 byte

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

Provalo online!

Crediti

• Ridotto da 101 byte a 92 dal signor Xcoder
• Ridotto da 92 byte a 68 di Jonathan Allan ( Dennis )
• Ridotto da 68 byte a 64 di totalmente umano

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

Ero in overflow dello stack per socket in Python, quando è apparso, ha detto perché no? il primo codice golf, quindi non sono del tutto sicuro se ho seguito le regole al 100% (e in caso contrario e qualcuno vuole rubare il mio proverbiale cookie e risolverlo, così sia). Con 'o' e '', 255 245 272 265 244 238 228 byte. sostituire +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);}}

Provalo online!

Come funziona:
utilizzo un bit shift e bit a bit e per scoprire se uno spot deve essere chiaro o un pip, quindi compenso lo 0 o 1 al valore ASCII corretto. si incasina su 4 e 5, quindi avevano bisogno di riparazioni. effettivamente aggiunto alcuni byte. è stato in grado di rimuovere diversi byte rimuovendo una maschera e usando solo 1 (doh)

Un ringraziamento speciale a Mr. Xcoder per i 7 byte in meno rimuovendo un eccesso #define
Modifiche: rimosso memset -21 byte. ridisegnato la logica dei bit per 6, 4, 2 in modo che dipendano rispettivamente da 8 | 4 e 2, 8 | 4, 8 | 4 | 2. -6 byte. rimosse le nuove righe extra usando put anziché printf, che è anche più breve. abbreviato l'array a 11, rimuovendo l'assegnazione aggiuntiva. -15 byte. ORA penso che sia il meglio che posso fare.

Gelatina , 20 byte

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

Provalo online!

Versione alternativa, output originale, 33 32 31 byte

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

Grazie a @ user202729 per giocare a golf a 1 byte!

Provalo online!

Come funziona

Innanzitutto, “¤o.ƤẸʠṚ’un valore intero letterale nella base biiettiva 250 - imposta il valore di ritorno su 1086123479729183 .

Quindi, B¬converte il valore restituito in binario e accetta il NOT logico di ogni cifra, producendo l'array

00001001000010110100101011110011101111101111100000

Successivamente, s5ŒBdivide quell'array in blocchi di lunghezza 5 , quindi rimbalza ogni blocco, trasformando abcde in abcdedcba , cedendo

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Ora, ị@recupera il j ^esima e k ^esimo elemento di questa matrice, dove j, k è il primo argomento del programma. Si noti che l'indicizzazione è basata su 1 e modulare, quindi l'elemento zeroth è anche il decimo.

Infine, s€3divide ogni pezzo di lunghezza nove in tre pezzi di lunghezza tre.

Gelatina , 13 byte

⁽½ÑD<;ḂŒBs3µ€

Provalo online!

Combinando Dennis l'idea di di usare ŒB(rimbalzare) in questa risposta e l'osservazione di Xcali in questa risposta per ottenere 13 byte.

Gelatina , 28 byte

(con una bella stampa)

Solo ora so che la stringa letterale Jelly viene automaticamente chiusa ...

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

Provalo online!

PHP 155 , 150 byte

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

Prende una matrice di numeri interi come input. Per i test:

d([1,2]);

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

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

Formato di output:

---

 0 

---
  0

0  

Dai un'occhiata live qui

La mia soluzione

Per la mia soluzione ho usato una matrice composta da numeri bit a bit (potenze di 2). Può essere visualizzato in questo modo:

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

E quindi un array di archiviazione costituito dalle posizioni dei bit per i pips di ciascun domino correlato dall'indice numerato:

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

Quindi, solo per chiarire:

• esempio 0: indice 0o valore0 sarebbe il domino vuoto, che è sempre falso.
• esempio 1: indice 1o valore 16sarebbe il domino numero uno e nella matrice che si trova al centro 16.
• esempio 2: indice 2o valore 68sarebbe il numero due domino e nella matrice che è in alto a destra 4e in basso a sinistra 64 o4|64
• esempio 3: indice 5o valore 341sarebbe il numero cinque domino e nella matrice che è1|4|16|64|256
• esempio 4: indice 9o valore 511sarebbe il numero nove domino e nella matrice è la combinazione di tutti i bit.

Una volta che è stabilito è abbastanza semplice questione di loop per i 9 posizioni nella matrice, e l'impostazione $xper 2la potenza di$i

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

Quindi facciamo un po 'E &mentre passiamo attraverso quei punti. Quindi, per esempio, il sake utilizzerà l'esempio 2 dall'alto e userò xinvece gli spazi per motivi di chiarezza visiva:

• iterazione 1, 68 & 1 ? 0 : 'x'che risulta in'x'
• iterazione 2, 68 & 2 ? 0 : 'x'che risulta in'x'
• iterazione 3, 68 & 4 ? 0 : 'x' che risulta in0
• iterazione 4, 68 & 8 ? 0 : 'x' che risulta in'x'
• iterazione 5, 68 & 16 ? 0 : 'x' che risulta in'x'
• iterazione 6, 68 & 32 ? 0 : 'x' che risulta in'x'
• iterazione 7, 68 & 64 ? 0 : 'x'che risulta in0
• iterazione 8, 68 & 128 ? 0 : 'x'che risulta in'x'
• iterazione 9, 68 & 256 ? 0 : 'x'che risulta in'x'

Quando il ciclo è completo, finiamo con questa stringa "xx0xxx0xx" .

Poi aggiungiamo il confine "---xx0xxx0xx"ad esso (in realtà ho iniziare con il confine, ma qualunque cosa) .

E infine abbiamo chunk_split () su 3 per:

---
xx0
xxx
0xx

Sentiti libero di farmi sapere cosa ne pensi.

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

Perl 5 , 70 byte

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

Provalo online!

Usa 0 per gli spazi bianchi e 1 per i pips. Metodo abbastanza semplice: osserva che quando la cifra sale, una volta che un pip è "acceso", non va mai "spento", tranne quello nel mezzo. Nella posizione centrale, è attivo per tutti i numeri dispari. Pertanto, per ciascuna posizione, è semplice verificare se la cifra è maggiore dell'ultima cifra per la quale è disattivata. Il ||0crea uscita quando la condizione è falsa. In Perl, false è undefquale output come null.

JavaScript (ES6), 79 78 byte

Salvato 1 byte grazie a @ETHproductions

Accetta input nella sintassi del curry (a)(b)ed emette un domino ASCII verticale.

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

dimostrazione

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

Versione orizzontale, 80 79 byte

Salvato 1 byte grazie a @ETHproductions

Prende l'input come un array di 2 numeri interi e genera un domino ASCII orizzontale.

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

dimostrazione

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 byte

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

Provalo online!

-2 grazie a ngn .

Il formato di output è un po 'strano: questa funzione restituisce un array contenente due array di forma 3,3 ciascuno contenente 0 e 1.

C (gcc) , 115 byte

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

Provalo online!

Javascript (ES6), 87 byte

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 caratteri

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

Prende un elenco di due numeri che indicano i volti, restituisce un elenco di elenchi di bool. Non così breve ma trovo la soluzione interessante.

Pip , 32 27 24 21 byte

^{-3 byte grazie a @DLosc}

FcgP[Yc>_M3517c%2RVy]

Provalo online!

Spiegazione:

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 byte

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

Provalo online . Emette come un domino verticale con 1s per i punti, 0s per gli spazi bianchi e 9s per i separatori in questo modo:

001
000
100
999
111
111
111

Tecnicamente questo può essere esteso fino a un massimo di 12 valori immessi.

Vecchia versione:

> <> , 76 + 3 = 79 byte

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

Provalo online . Emette come un domino verticale con 1s per punti e 0s per spazi bianchi in questo modo:

001
000
100
---
111
111
111

Carbone , 46 44 43 39 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＥＥ²℅§@APQTUVW^_Ｎ

Leggi due numeri interi e mappali nella tabella di ricerca. Quindi mappa sul risultato. (Questo cattura efficacemente il risultato in modo temporaneo.)

  Ｅ⁹                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

I risultati vengono quindi stampati implicitamente su righe separate, con una riga vuota in più tra ciascuna faccia perché i risultati sono nidificati.

Ｍ⁵↑⁵

Spostati verso l'alto e traccia la linea di demarcazione tra le facce.

Precedente versione orizzontale a 43 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

↶

Lavora in verticale.

Ｐ³

Stampa la linea di demarcazione.

Ｍ⁷←

Posizione all'inizio della prima faccia.

ＦＥ²℅§@APQTUVW^_Ｎ

Leggi due numeri interi e mappali nella tabella di ricerca.

Ｆ⁹«

Preparare l'uscita fino a 9 os.

Ｆ¬﹪κ³⸿⸿

Ma avvia una nuova colonna ogni tre os.

§ o÷ιＸ²↔⁻⁴κ

Convertire i 5 bit inferiori del codice ASCII in binario, quindi eseguire il mirroring dell'output per i restanti 4 os.

Gelatina , 16 byte

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

Provalo online!

Usato Ha la strategia di Neil e la decompressione di base per generare i valori; genera un array binario. Prende un elenco come input.

Spiegazione:

Ç€
 € 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 byte

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

Modificato secondo il commento di Adam, grazie, per eseguire con indice origine zero.

Richiede l'inserimento dello schermo come vettore di numeri uno per ogni faccia.

L'output è nel formato:

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

per un input di 7 3e0 5

Spiegazione:

(+\∊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 byte

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

Provalo online!

Ridotto a 121 usando un lambda dopo essere tornato indietro e rileggere le regole. Ora genera un elenco di righe.

Versione precedente con output ben formattato:

Python 2 , 156 153 147 141 byte

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

Provalo online!

-3 grazie a @NieDzejkob

Accetta input come 2 numeri interi e output in formato verticale con 0 = spazio e 1 = punto.

Pyt , 220 154 byte

Secondo tentativo (154 byte)

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↔ŕ↔ŕ↔

Spiegazione:

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

Primo tentativo (220 byte):

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ᴇ↔⁻łŕ↔ŕŕŕŕŕŕáƇǰ

Spiegazione:

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

Provalo online!

05AB1E , 34 byte

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

Provalo online!

Questo è stato difficile perché 05AB1E ha un'imbottitura scadente.

Spiegazione di base:

• Ci sono 4 modelli significativi qui che sono 2, 4, 6 e 8.
• 3,5,7 e 9 sono gli altri schemi più 1.
• 1 non è significativo a causa della simmetria, se l'ingresso è pari, sottrarre 1 per alternare il bit centrale.
• La commutazione dell'LSB consente di invertire il bit centrale a causa del mirroring.

SmileBASIC, 92 69 byte

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

Esempio:

? 7,2
111
010
111
777
001
000
100

Questo è ciò che accade quando le tue regole non sono abbastanza rigide.

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

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

sto ancora lavorando su questo ...

Patata fritta ,142 135 byte

! 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

Provalo online!

L'input è una stringa di cifre. Usa gli zero come semi. Disegna i pips per un numero, legge il byte di input successivo. Se nessun byte successivo, termina, altrimenti disegna il divisore e vai all'inizio.

Ciascuno Z(o z) corrisponde a un carattere di output, sono posizionati per sparare dall'alto verso il basso. Il capitalizzata A, B, C, e Dcorrispondono alle basse quattro bit di ingresso (che è tutto osserviamo, così "34" == "CD" == "st" ...). Il minuscolo b, d, e, fconforme a vari bit dell'uscita.

Può fare anche domino di lunghezza infinita; prova a dare 0123456789come input.

PHP, 116 byte

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

richiede PHP 5.5 o successivo. Corri con -nro provalo online .

C (gcc) , 150 146 byte

• Risparmiato quattro byte grazie 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);}

Provalo online!