Dessine moi un domino

35

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 , donc le code le plus court en octets dans chaque langue gagne.

ETHproductions
la source
Donc, pour une entrée [2, 1], je pourrais sortir [[[0,0,1],[0,0,0],[1,0,0]],[[0,0,0],[0,1,0],[0,0,0]]]?
Dennis
@Dennis Correct.
ETHproductions
2
Le séparateur entre les faces doit-il être constitué de tirets ou peut-il s'agir d'une autre valeur cohérente?
Jo King
@JoKing Je dirai que vous pouvez utiliser n'importe quel caractère cohérent autre que ceux que vous utilisez déjà.
ETHproductions
[0,5,21,29,31]sont tous des chiffres importants ici mes amis.
Urne magique Octopus le

Réponses:

14

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

Neil
la source
@ Mr.Xcoder Mis à jour à nouveau.
Neil
1
Le formatage est optionnel. Le renvoi d'une paire de matrices enregistre au moins 22 octets.
Dennis
1
68 octets sans formatage (notez que 0et Falsesont égaux en Python, cela devrait donc être OK).
Jonathan Allan
@ JonathanAllan Très intelligent, mis à jour.
Neil
64 octets. Si vous devez faire un lambda, une compréhension de liste est probablement plus courte.
totalement humain
12

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.

Andrew Baumher
la source
7
Bienvenue chez PPCG!
Shaggy
Bonjour, bienvenue sur PPCG! Vous pouvez raccourcir votre code un peu plus loin, 245 octets
M. Xcoder
'\n'peut être remplacé par 10. (car en C, les types de données char sont également des types de données entiers) Certains charpeuvent probablement être remplacés par int. (ou omettre entièrement)
user202729
Jusqu'à 184 octets ici, mais cela reste plus que l'actuel c golf, donc.
Andrew Baumher
173
Andrew Baumher
10

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

Dennis
la source
1
Cela me semble toujours magique, mais j’apprécie votre tentative d’explication. J'admettrai que la faute est probablement la mienne car je ne suis qu'un modeste développeur Web PHP
ArtisticPhoenix
Le 3utilise 0pour les pépins, pas 1comme tous les autres.
Jonathan Allan
“¤o.ƤẸʠṚ’devrait marcher.
Jonathan Allan
@ JonathanAllan Merci! Je ne sais pas comment cela s'est passé ...
Dennis
8

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!

utilisateur202729
la source
Apparemment, mon approche ⁽½ÑDconduit à moins de compteurs que la réponse d'EriktheOutgolfer “¤¦¢¬‘ ici
user202729
Ne serait-il pas préférable de réorganiser les fonctions de manière à ce que les 13 octets (Dennis) qui sont sortis du golf soient en haut et puissent être vus plus facilement?
Zacharý
@ Zacharý Solution temporaire. Va le réparer plus tard.
user202729
6

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.

ArtistiquePhoenix
la source
Vous pouvez le raccourcir encore davantage en utilisant l'opérateur d'exponentiation **introduit dans PHP 5.6 au lieu de pow() php.net/manual/fr/language.operators.arithmetic.php
Daniel
@ Daniel - Merci, économisé 5 octets! Je ne savais pas qu'ils ajoutaient ça, j'essaie toujours d'utiliser le ^mais c'est le bitwise XOR ... lol
ArtisticPhoenix
Je ne pense pas que vous soyez autorisé à imprimer une bordure supplémentaire.
12 mars 21
montrez-moi où cela fait même allusion à distance dans le PO.
ArtisticPhoenix
Je suppose que ce serait une opération plus courte $argv. La surcharge de la fonction en PHP est généralement de 13 octets.
Titus
6

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.

Xcali
la source
4

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


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

Arnauld
la source
Nice, très similaire à ce que j'avais. Enregistrer un octet avec n>d|0ou(+d?n>d:n)&1
ETHproductions
4

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.

Erik le golfeur
la source
une réécriture pour -2 octets:2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨
ngn
@ ngn merci, c'est intelligent: p
Erik the Outgolfer
2

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>

Herman L
la source
Nice Dominoes ...
Esolanging Fruit
2

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.

Geoff Reedy
la source
Vous pouvez simplement utiliser à la mapplace de repeatet zipWith: map$(<$>[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]]).map.flip($)essayez-le en ligne!
Laikoni
Non-Pointfree enregistre deux octets supplémentaires: essayez-le en ligne!
Laikoni
2

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.
Fruit d'esolanging
la source
1
Félicitations pour avoir gagné la prime Pip! Maintenant que la période de prime est terminée, je peux vous dire: économisez 3 octets en les mappant sur un scalaire 3517plutôt que sur une liste [3 5o7]. ;)
DLosc
1

> <> , 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
Jo King
la source
1

Charbon de bois , 46 44 43 39 octets

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

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

EE²℅§@APQTUVW^_N

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

  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

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.

M⁵↑⁵

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

Version horizontale précédente de 43 octets:

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

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

Travailler verticalement.

P³

Imprimer la ligne de démarcation.

M⁷←

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

FE²℅§@APQTUVW^_N

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

F⁹«

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

F¬﹪κ³⸿⸿

Mais commencez une nouvelle colonne toutes les trois osecondes.

§ o÷ιX²↔⁻⁴κ

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

Neil
la source
Le format de sortie est plutôt libéral, ce qui devrait économiser quelques octets.
Dennis
1
Quelle est cette sorcellerie
ArtisticPhoenix
@Dennis En fait, le format de sortie original est le plus utile, car il me laisse automatiquement de la place pour tracer la ligne de division.
Neil
Oh mon dieu, il y a deux Neils.
Zacharý
2
@ Zacharý En fait, selon la page utilisateur, il y en a huit, ou 40 si vous incluez des personnes dont le nom contient Neil ...
Neil
1

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
Ellie
la source
0

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 
Graham
la source
Pourquoi ne pas utiliser ⎕IO←0pour vous sauver le 1+?
Adám
@Adam Pourquoi pas en effet - paresseux;)
Graham
0

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.

ElPedro
la source
153 octets
NieDzejkob
0

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!

mudkip201
la source
0

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.
Urne Magique De Pieuvre
la source
0

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.

12Me21
la source
0

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

12Me21
la source
0

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.

Phlarx
la source
0

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 .

Titus
la source
0

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!

Jonathan Frech
la source
@ceilingcat Merci.
Jonathan Frech