Défi

Avec deux chiffres 0 à 9 en entrée, génère un domino (du jeu de neuf domino ) avec ce nombre de points (pips) sur les deux faces. Voici les dix faces possibles (séparées par des tuyaux):

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

Ou sur des lignes séparées:

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

Formats d'entrée

Vous pouvez prendre des entrées dans n'importe quel format raisonnable, y compris, mais sans s'y limiter:

• Deux entiers séparés, des chaînes ou des tableaux singleton;
• Un seul entier de 0 à 99;
• Un tableau de deux entiers;
• Une chaîne de deux chiffres.

Formats de sortie

• Les deux faces peuvent être alignées horizontalement, séparées par des tuyaux comme suit:

    o|o   o
     |  o  
o    |o   o

• Ou ils peuvent être alignés verticalement, séparés par des traits d'union comme ceci:

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

• Vous pouvez créer une bordure autour du domino si vous le souhaitez.
• Vous pouvez également choisir de générer une liste de lignes, une liste des deux faces ou une combinaison de celles-ci.
• Vous pouvez utiliser n'importe quel caractère non-blanc pour les pépins (j'ai utilisé o).
• Si vous le souhaitez vraiment, vous pouvez utiliser 0pour les espaces blancs et 1pour les pépins, ou False/ True(ou l'équivalent de votre langue) pour générer un tableau.
• Vous pouvez supprimer les espaces entre les colonnes. c'est une sortie valide pour 7, 7:

ooo|ooo
 o | o 
ooo|ooo

• Toutes les faces peuvent être pivotées de 90 degrés. C'est aussi une sortie valide pour 7, 7:

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

• Vous pouvez avoir autant / peu de blancs que vous le souhaitez, à condition que la partie principale de la sortie corresponde toujours aux autres contraintes.
• Chaque face doit avoir 3 lignes de hauteur, même si les lignes sont vides. Pour 0, 1 vous ne pouviez pas sortir ceci:

-----

  o

Mais vous pouvez sortir ceci:

-----

  o

De même, si vous produisiez une liste de deux listes de lignes, vous pourriez le faire [["", "", ""], ["", " o", ""]], mais pas [[""], [" o "]].

Notation

C'est du code-golf , donc le code le plus court en octets dans chaque langue gagne.

Python 2 , 101 97 92 68 64 octets

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

Essayez-le en ligne!

Crédits

• Réduit de 101 octets à 92 par M. Xcoder
• Réduit de 92 octets à 68 par Jonathan Allan ( Dennis )
• Réduit de 68 octets à 64 par totalementhumain

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

J'étais sur le débordement de pile pour les sockets en python, quand cela est apparu, pourquoi pas? premier code de golf, donc je ne suis pas tout à fait sûr d’avoir suivi les règles à 100% (et si ce n’est pas le cas et si quelqu'un veut voler mon cookie proverbial et le réparer, qu’il en soit ainsi). Avec 'o' et '', 255 245 272 265 244 238 228 octets. remplacez +48 par * 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);}}

Essayez-le en ligne!

Comment ça marche?
J'utilise un bit shift et bit à bit pour trouver si un spot doit être dégagé ou un pip, puis décaler le 0 ou le 1 sur la valeur ASCII correcte. ça déconne sur 4 et 5, alors ils avaient besoin de réparation. effectivement ajouté quelques octets. était capable de supprimer plusieurs octets en enlevant un masque et en utilisant simplement 1 (doh)

Un merci spécial à M. Xcoder pour les 7 octets de moins en supprimant un excès de #define
Changements: memset -21 octets supprimé. refait la logique des bits pour 6, 4, 2 pour dépendre de 8 | 4 & 2, 8 | 4, 8 | 4 | 2, respectivement. -6 octets. supprime les nouvelles lignes supplémentaires en utilisant des options de vente au lieu de printf, qui est également plus courte. raccourci le tableau à 11, en supprimant l'affectation supplémentaire. -15 octets. MAINTENANT, je pense que c'est le mieux que je puisse faire.

Gelée , 20 octets

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

Essayez-le en ligne!

Version alternative, sortie originale, 33 32 31 octets

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

Merci à @ user202729 pour le golf d'un octet!

Essayez-le en ligne!

Comment ça marche

Tout d'abord, “¤o.ƤẸʠṚ’un littéral entier dans la base bijective 250 définit la valeur de retour sur 1086123479729183 .

Ensuite, B¬convertit la valeur de retour en binaire et prend le NON logique de chaque chiffre, donnant le tableau

00001001000010110100101011110011101111101111100000

Ensuite, s5ŒBdivise ce tableau en morceaux de longueur 5 , puis rebondit chaque morceau, transformant abcde en abcdedcba , donnant

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Maintenant, ị@récupère les j ^ème et k ^ème items de ce tableau, où j, k est le premier argument du programme. Notez que l'indexation est 1 et modulaire, l'élément zeroth est également le dixième.

Enfin, s€3divise chaque morceau de longueur neuf en trois morceaux de longueur trois.

Gelée , 13 octets

⁽½ÑD<;ḂŒBs3µ€

Essayez-le en ligne!

Combinant l'idée de Dennis d'utiliser ŒB(rebond) dans cette réponse et l'observation de Xcali dans cette réponse pour obtenir 13 octets.

Gelée , 28 octets

(avec une jolie impression)

Ce n’est que maintenant que je sais que le littéral de chaîne Jelly se termine automatiquement ...

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

Essayez-le en ligne!

PHP 155 , 150 octets

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

Il faut un tableau d'entiers en entrée. Pour tester:

d([1,2]);

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

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

Format de sortie:

---

 0 

---
  0

0  

Regardez ça en direct ici

Ma solution

Pour ma solution, j'ai utilisé une matrice composée de nombres au niveau du bit (puissance de 2). Cela peut être visualisé comme ceci:

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

Et puis un tableau de stockage composé des positions de bits pour les pépins de chaque domino en corrélation par l'index numéroté:

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

Alors juste pour clarifier:

• exemple 0: l'index 0ou la valeur 0serait le domino vide, qui est toujours faux.
• exemple 1: index 1ou value 16correspond au domino numéro un et à la matrice située au centre 16.
• exemple 2: index 2ou value 68correspond au domino numéro deux et dans la matrice en haut à droite 4et en bas à gauche 64 ou4|64
• exemple 3: index 5ou valeur 341correspond au domino numéro cinq et à la matrice qui est1|4|16|64|256
• Exemple 4: index 9ou value 511correspond au domino numéro neuf et à la combinaison des bits dans la matrice.

Une fois que cela est établi , il est une question assez simple de boucle pour les 9 positions dans la matrice, et la mise $xà 2la puissance de$i

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

Ensuite, nous faisons un peu de temps et &parcourons ces endroits. Ainsi, par exemple, l'exemple 2 ci-dessus sera utilisé xet, à la place, des espaces pour des raisons de clarté visuelle:

• itération 1, 68 & 1 ? 0 : 'x'qui aboutit à'x'
• itération 2, 68 & 2 ? 0 : 'x'qui aboutit à'x'
• itération 3, 68 & 4 ? 0 : 'x'qui aboutit à0
• itération 4, 68 & 8 ? 0 : 'x'qui aboutit à'x'
• itération 5, 68 & 16 ? 0 : 'x'qui aboutit à'x'
• itération 6, 68 & 32 ? 0 : 'x' qui aboutit à'x'
• itération 7, 68 & 64 ? 0 : 'x'qui aboutit à0
• itération 8, 68 & 128 ? 0 : 'x'qui aboutit à'x'
• itération 9, 68 & 256 ? 0 : 'x'qui aboutit à'x'

Lorsque la boucle est terminée, nous nous retrouvons avec cette chaîne "xx0xxx0xx".

Ensuite , nous ajoutons la frontière "---xx0xxx0xx"à elle (je commence en fait avec la frontière, mais peu importe) .

Et finalement nous chunk_split () sur 3 pour:

---
xx0
xxx
0xx

N'hésitez pas à me faire savoir ce que vous pensez.

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

Perl 5 , 70 octets

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

Essayez-le en ligne!

Utilise 0 pour les espaces et 1 pour les pépins. Méthode assez simple: observez que lorsque le chiffre augmente, une fois qu'un pip est "activé", il ne disparaît jamais, sauf pour celui situé au centre. En position centrale, il est activé pour tous les nombres impairs. Ainsi, pour chaque position, il suffit de vérifier si le chiffre est supérieur au dernier chiffre pour lequel il est désactivé. Le ||0crée la sortie lorsque la condition est fausse. En Perl, false correspond undefà la valeur null.

JavaScript (ES6), 79 78 octets

Enregistré 1 octet grâce à @ETHproductions

Accepte la syntaxe de curry (a)(b)et génère un domino ASCII vertical.

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

Démo

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

Version horizontale, 80 à 79 octets

Enregistré 1 octet grâce à @ETHproductions

Prend les entrées sous forme de tableau de 2 entiers et génère un domino ASCII horizontal.

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

Démo

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 octets

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

Essayez-le en ligne!

-2 grâce à ngn .

Le format de sortie est un peu bizarre: cette fonction renvoie un tableau contenant deux tableaux de forme 3, 3 contenant chacun des 0 et des 1.

C (gcc) , 115 octets

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

Essayez-le en ligne!

Javascript (ES6), 87 octets

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 caractères

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

Prend une liste de deux nombres indiquant les visages, retourne une liste de liste de liste de bool. Pas si court mais je trouve la solution intéressante.

Pip , 32 27 24 21 octets

^{-3 octets grâce à @DLosc}

FcgP[Yc>_M3517c%2RVy]

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne . Sortie en tant que domino vertical avec 1s pour les points, 0s pour les espaces et 9s pour les séparateurs comme ceci:

001
000
100
999
111
111
111

Techniquement, cela peut être étendu jusqu'à 12 valeurs entrées.

Ancienne version:

> <> , 76 + 3 = 79 octets

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

Essayez-le en ligne . Affiche un domino vertical avec 1s pour les points et 0s pour les espaces, comme ceci:

001
000
100
---
111
111
111

Charbon de bois , 46 44 43 39 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＥＥ²℅§@APQTUVW^_Ｎ

Lire deux entiers et les mapper dans la table de recherche. Puis mappez le résultat. (Cela capture effectivement le résultat dans une situation temporaire.)

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

Les résultats sont ensuite implicitement imprimés sur des lignes séparées, avec une ligne vierge supplémentaire entre chaque face, car les résultats sont imbriqués.

Ｍ⁵↑⁵

Montez et tracez la ligne de démarcation entre les faces.

Version horizontale précédente de 43 octets:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

↶

Travailler verticalement.

Ｐ³

Imprimer la ligne de démarcation.

Ｍ⁷←

Position au début de la première face.

ＦＥ²℅§@APQTUVW^_Ｎ

Lire deux entiers et les mapper dans la table de recherche.

Ｆ⁹«

Préparez-vous à produire jusqu'à 9 os.

Ｆ¬﹪κ³⸿⸿

Mais commencez une nouvelle colonne toutes les trois osecondes.

§ o÷ιＸ²↔⁻⁴κ

Convertissez les 5 bits inférieurs du code ASCII en binaire, puis reproduisez la sortie pour les 4 os restantes .

Gelée , 16 octets

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

Essayez-le en ligne!

Stratégie de Neil utilisée et la décompression de base pour générer les valeurs; les sorties sous forme de tableau binaire. Prend une liste en entrée.

Explication:

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

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

Edité selon le commentaire d'Adam, merci d'exécuter avec l'index d'origine zéro.

Invite à la saisie à l’écran sous forme de vecteur d’entiers un pour chaque visage.

La sortie est de la forme:

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

pour une entrée de 7 3et0 5

Explication:

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

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

Essayez-le en ligne!

Réduit à 121 avec un lambda après avoir relu les règles. Affiche maintenant une liste de lignes.

Version précédente avec une sortie bien formatée:

Python 2 , 156 153 147 141 octets

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

Essayez-le en ligne!

-3 avec merci à @NieDzejkob

Prend les entrées en tant que 2 entiers et les sorties en format vertical avec 0 = espace et 1 = point.

Pyt , 220 154 octets

Deuxième tentative (154 octets)

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

Explication:

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

Première tentative (220 octets):

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

Explication:

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

Essayez-le en ligne!

05AB1E , 34 octets

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

Essayez-le en ligne!

C'était difficile parce que 05AB1E a un mauvais rembourrage.

Explication de base:

• Il y a 4 modèles significatifs ici qui sont 2, 4, 6 et 8.
• 3,5,7 et 9 sont les autres motifs plus 1.
• 1 n'est pas significatif en raison de la symétrie, si l'entrée est paire, soustrayez 1 pour basculer le bit du milieu.
• Basculer le bit de poids faible permet d'inverser le bit du milieu en raison de la mise en miroir.

SmileBASIC, 92 69 octets

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

Exemple:

? 7,2
111
010
111
777
001
000
100

C'est ce qui se passe lorsque vos règles ne sont pas assez strictes.

FALSE, 116 80 78 70 69 66 63 61 61 59 58 octets

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

travaille encore sur ce ...

Puce ,142 135 octets

! 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

Essayez-le en ligne!

L'entrée est une chaîne de chiffres. Utilise les zéros comme les pépins. Dessine les pépins pour un nombre, lit l'octet suivant. S'il n'y a pas d'octet suivant, terminez, sinon dessinez le séparateur et allez au début.

Chacun Z(ou z) correspond à un caractère de sortie, ils sont positionnés pour tirer de haut en bas. Capitalisé A, B, Cet Dcorrespondent aux faibles quatre bits de l'entrée (qui est tout ce que nous regardons, donc "34" == "CD" == "st" ...). Le minuscule b, d, e,f correspondent à différents bits de la sortie.

Peut aussi faire des dominos d’infini; essayez de donner 0123456789comme entrée.

PHP, 116 octets

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

nécessite PHP 5.5 ou une version ultérieure. Courez avec -nrou essayez-le en ligne .

C (gcc) , 150 146 octets

• Sauvegardé quatre octets grâce à 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);}

Essayez-le en ligne!