Le magnifique tiroir à motifs

Bonjour PPCG!

L'autre jour, lorsque j'essayais d'aider quelqu'un sur Stack Overflow, une partie de son problème m'a donné une idée de ce défi.

Tout d'abord, vérifiez la forme suivante:

Où tous les nombres noirs sont l'index des points dans la forme et tous les nombres bleu foncé sont l'index des liens entre les points.

Maintenant, étant donné un nombre hexadécimal pour 0x00000 à 0xFFFFF, vous devez dessiner une forme dans la console en utilisant uniquement un espace de caractères et "■" (l'utilisation du caractère "o" est également acceptable).

Voici quelques exemples où le nombre hexadécimal est entré et la forme est sortie:

0xE0C25 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■
0xC1043 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
              ■   
            ■     
          ■       
        ■         
      ■           
    ■             
  ■               
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE4F27 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xF1957 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■           ■ ■ 
■   ■       ■   ■ 
■     ■   ■     ■ 
■       ■       ■ 
■     ■   ■     ■ 
■   ■       ■   ■ 
■ ■           ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xD0C67 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
  ■             ■ 
    ■           ■ 
      ■         ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■       ■ 
    ■   ■       ■ 
  ■     ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0x95E30 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■ ■ 
    ■   ■   ■   ■ 
      ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■ ■       
        ■   ■     
        ■     ■   
        ■       ■ 
0x95622 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■   
    ■   ■   ■     
      ■ ■ ■       
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■         
        ■         
        ■         
■ ■ ■ ■ ■         
0xC5463 : 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■     ■   
        ■   ■     
        ■ ■       
■ ■ ■ ■ ■         
      ■ ■         
    ■   ■         
  ■     ■         
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE5975 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■     ■ ■ 
■       ■   ■   ■ 
■       ■ ■     ■ 
■       ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xB5E75 :
■ ■ ■ ■ ■       ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xF4C75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■       ■ 
■   ■   ■       ■ 
■     ■ ■       ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■
0xF5D75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 

Voici quelques explications sur son fonctionnement:

0xFFFFF(16) = 1111 1111 1111 1111 1111(2)

Vous avez ici 20 bits, chaque bit indique si un lien existe ou non.

L'index du bit le plus significatif (MSB) est 0 (référence d'image) ou le bit le moins significatif (LSB) est 19 (référence d'image à nouveau).

Voici comment cela fonctionne pour la première forme donnée à titre d'exemple:

0xE0C25(16) = 1110 0000 1100 0010 0101(2)

Cela signifie que vous aurez les liens existants suivants: 0,1,2,8,9,14,17,19.

Si vous mettez en surbrillance les lignes de l'image de référence avec ces chiffres, cela vous donnera cette forme:

■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■

Voici une implémentation Python simple et non gérée si vous avez besoin de plus d'aide:

patterns = [
  0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75
]

def printIfTrue(condition, text = "■ "):
  if condition:
    print(text, end="")
  else:
    print(" "*len(text), end="")

def orOnList(cube, indexes):
  return (sum([cube[i] for i in indexes]) > 0)

def printPattern(pattern):
  cube = [True if n == "1" else False for n in str(bin(pattern))[2::]]
  for y in range(9):
    if y == 0: printIfTrue(orOnList(cube, [0, 2, 3]))
    if y == 4: printIfTrue(orOnList(cube, [2, 4, 9, 11, 12]))
    if y == 8: printIfTrue(orOnList(cube, [11, 13, 18]))
    if y in [0, 4, 8]:
      printIfTrue(cube[int((y / 4) + (y * 2))], "■ ■ ■ ")
      if y == 0: printIfTrue(orOnList(cube, [0, 1, 4, 5, 6]))
      if y == 4: printIfTrue(orOnList(cube, [3, 5, 7, 9, 10, 13, 14, 15]))
      if y == 8: printIfTrue(orOnList(cube, [12, 14, 16, 18, 19]))
      printIfTrue(cube[int((y / 4) + (y * 2)) + 1], "■ ■ ■ ")
    elif y in [1, 5]:
      for i in range(7):
        if i in [2, 5]:
          print(" ", end=" ")
        printIfTrue(cube[y * 2 + (1 - (y % 5)) + i])
    elif y in [2, 6]:
      for i in range(5):
        if i in [1, 2, 3, 4]:
          print(" ", end=" ")
        if i in [1, 3]:
          if i == 1 and y == 2:
            printIfTrue(orOnList(cube, [3, 4]))
          elif i == 3 and y == 2:
            printIfTrue(orOnList(cube, [6, 7]))
          if i == 1 and y == 6:
            printIfTrue(orOnList(cube, [12, 13]))
          elif i == 3 and y == 6:
            printIfTrue(orOnList(cube, [15, 16]))
        else:
          printIfTrue(cube[(y * 2 - (1 if y == 6 else 2)) + i + int(i / 4 * 2)])
    elif y in [3, 7]:
      for i in range(7):
        if i in [2, 5]:
          print("  ", end="")
        ri, swap = (y * 2 - 2) + (1 - (y % 5)) + i, [[3, 6, 12, 15], [4, 7, 13, 16]]
        if ri in swap[0]: ri = swap[1][swap[0].index(ri)]
        elif ri in swap[1]: ri = swap[0][swap[1].index(ri)]
        printIfTrue(cube[ri])
    if y == 0: printIfTrue(orOnList(cube, [1, 7, 8]))
    if y == 4: printIfTrue(orOnList(cube, [6, 8, 10, 16, 17]))
    if y == 8: printIfTrue(orOnList(cube, [15, 17, 19]))
    print()

for pattern in patterns:
  printPattern(pattern)

Bien sûr, ce n'est pas parfait et c'est assez long pour ce qu'il devrait faire, et c'est la raison exacte pour laquelle vous êtes ici!

Rendre ce programme ridiculement court :)

C'est le golf de code, donc la réponse la plus courte l'emporte!

JavaScript (ES6), 202 188 187 octets

let f =

n=>`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`.split`,`.map((d,i)=>(k-=d,n)>>i&1&&[..."ooooo"].map(c=>g[p-=(k&3||9)^8]=c,p=k>>2),g=[...(' '.repeat(9)+`
`).repeat(9)],k=356)&&g.join``

console.log(f(0xE0C25))
console.log(f(0xC1043))
console.log(f(0xE4F27))
console.log(f(0xF1957))

Comment ça fonctionne

n =>                                                 // given 'n':
  `0${x = ',16,-54,21,-26,21,21,-26,21,166'}${x},16` // build the list of delta values
  .split`,`.map((d, i) =>                            // split the list and iterate
    (k -= d, n) >> i & 1 &&                          // update 'k', test the i-th bit of 'n'
    [..."ooooo"].map(c =>                            // if the bit is set, iterate 5 times:
      g[                                             // 
        p -= (k & 3 || 9) ^ 8                        // compute the direction and update 'p'
      ] = c,                                         // write a 'o' at this position
      p = k >> 2                                     // initial value of 'p'
    ),                                               //
    g = [...(' '.repeat(9) + `\n`).repeat(9)],       // initialization of the 'g' array
    k = 356                                          // initial value of 'k'
  )                                                  //
  && g.join``                                        // yield the final string

Nous travaillons sur une grille gde 9 lignes de 10 caractères. La grille est initialement remplie d'espaces, avec un saut de ligne tous les 10 caractères.

Chaque segment est défini par une position de départ et une direction.

Les directions sont codées comme suit:

ID | Dir.| Offset
---|-----|-------
 0 |  W  |  -1        Offset encoding formula:
 1 | NE  |  -9        -((ID || 9) ^ 8)
 2 |  N  |  -10
 3 | NW  |  -11

Chaque segment est codé sous forme d'entier:

• la direction est stockée dans les bits # 0 et # 1
• la position de départ est stockée dans les bits # 2 à # 8

Par exemple, le segment # 3 commence à la position 55 et utilise la 3ème direction. Par conséquent, il est codé en tant que (55 << 2) | 3 == 223.

Voici la liste résultante des entiers, du segment # 19 au segment # 0:

356,340,394,373,399,378,357,383,362,196,180,234,213,239,218,197,223,202,36,20

Une fois codé en delta, à partir de 356, il devient:

0,16,-54,21,-26,21,21,-26,21,166,16,-54,21,-26,21,21,-26,21,166,16

Qui est finalement codé comme:

`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`

Python 3, 289 octets

def f(n):
 for r in range(9):print(*(" o"[any(n&1<<ord(c)-97for c in"trq|t|t|t|tspon|s|s|s|sml|r|q||p|o|n||m|l|r||qp||o||nm||l|r|p||q|o|m||n|l|rpkih|k|k|k|qomkjgfe|j|j|j|nljdc|i|h||g|f|e||d|c|i||hg||f||ed||c|i|g||h|f|d||e|c|igb|b|b|b|hfdba|a|a|a|eca".split("|")[r*9+c])]for c in range(9)))

Rien d'intelligent, juste du codage en dur.

Rubis, 116 octets

->n{s=[' '*17]*9*$/
20.times{|i|j=i%9
n>>19-i&1>0&&5.times{|k|s[i/9*72+(j>1?~-j/3*8+k*18:j*16)+k*(2--j%3*2)]=?O}}
s}

Cela repose sur quelques schémas que j'ai observés. Tout d'abord, le motif se répète toutes les 9 lignes. Deuxièmement, si les points de départ des lignes horizontales sont choisis de manière appropriée, les directions x parcourent en continu la droite, la gauche, la droite.

Non testé dans le programme de test

f=->n{
   s=[' '*17]*9*$/                    #Setup a string of 9 newline separated lines of 17 spaces.
   20.times{|i|                       #For each of the 20 bits..
     j=i%9                            #The pattern repeats every 9 bits.
     n>>19-i&1>0&&                    #If the relevant bit is set,
     5.times{|k|                      #draw each of the 5 points on the relevant line.
       s[i/9*72+                      #There are 9 lines starting on each row. Row y=0 starts at 0 in the string, row y=1 at 72, etc.
       (j>1?~-j/3*8+k*18:j*16)+       #~-j=j-1. For j=2..8, the starting x coordinates are (0,0,1,1,1,2,2)*8. For j=0 and 1 starting x coordinates are 0 and 16. 
       k*(2--j%3*2)                   #From the starting points, draw the lines right,left,straight. Down movement if applicable is given by conditional k*18 above.
       ]=?O                           #Having described the correct index to modify, overwrite it with a O character.
     }
   }
s}                                    #Return the string.


[0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75].map{|m|puts f[m],'---------'}

Je crois qu'il existe une solution de 112 octets utilisant une chaîne de 20 caractères et un décodage pour définir les paramètres des 20 lignes. J'essaierai cela plus tard si j'ai le temps.

PHP, 142 150 149 octets

for($r="";$c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)if(hexdec($argv[1])>>$i++&1)for($p=96^$c&~$k=3;$k++<8;$p+=7+($c&3?:-6))$r[$p]=o;echo chunk_split($r,9);

imprime la forme autant que nécessaire; c'est-à-dire que si la partie inférieure est vide, elle sera coupée.
Courez avec php -nr '<code>' <input>. Ne pas préfixer l'entrée

Testez-le en ligne

Ajoutez 11 octets pour ne pas couper: insérez ,$r[80]=" "après $r="".

explication du codage

Chaque ligne peut être décrite avec un point de départ et l'une des quatre directions.
Dessin sur une grille 9x9, la position de départ varie de 0,0à 8,4; ou, combinés, de 0à 8*9+4=76. Heureusement, tous les points de départ [0,4,8,36,40,44,72,76]sont divisibles par 4; de sorte que le code de direction [0..3]peut être compressé en bits 0 et 1 -> aucun décalage nécessaire du tout.

Pour un calcul facile du mouvement du curseur, 0est pris pour l'est (seule direction sans mouvement vertical) et [1,2,3]pour le sud-ouest, le sud, le sud-est, où le décalage est 9(pour le mouvement vertical) plus [-1,0,1]-> [8,9,10]-> delta=code?code+7:1.

La direction pour la première et la dernière ligne étant l'est, ce qui donne des codes allant de 0 à 76 [0+0,4+0,0+2,0+3,4+1,4+2,4+3,8+1,8+2,...,44+1,44+2,72+0,76+0]; et xor 96 au niveau du bit sur chaque valeur entraîne des codes ascii imprimables et non problématiques [96,100,98,99,101,102,103,105,106,68, 72,70,71,73,74,75,77,78,40,44]-> `dbcefgijDHFGIJKMN(,. Le code utilise le LSB pour le bit 0, tandis que la ligne 0 correspond au MSB, donc la chaîne doit être inversée. Finito.

panne

for($r="";                  // init result string, loop through line codes
    $c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)
    if(hexdec($argv[1])>>$i++&1)// if bit $i is set, draw line 19-$i:
        for($p=96^$c&~$k=3          // init $k to 3, init cursor to value&~3
            ;$k++<8;                // loop 5 times
            $p+=7+($c&3?:-6)            // 2. map [0,1,2,3] to [1,8,9,10], move cursor
        )
            $r[$p]=o;                   // 1. plot
echo chunk_split($r,9);     // insert a linebreak every 9 characters, print

un peu de golf expliqué

• Puisque ^96n'a aucun effet sur les deux bits inférieurs, il peut être ignoré lors de l'extraction de la direction; il n'est donc pas nécessaire de stocker la valeur dans une variable, ce qui économise 5 octets sur le curseur init.
• Utiliser ~3au lieu d' 124enregistrer un octet et permet le golf suivant:
• L'initialisation du compteur de bouclage $k=3à l'intérieur de l' $paffectation permet d'économiser deux octets
  et cela ne nuit pas à la condition préalable (car la valeur supérieure a toujours un chiffre).
• L'utilisation d'une chaîne pour le résultat a l'initialisation et le tracé les plus courts possibles: lorsqu'un caractère est défini au-delà de la fin d'une chaîne, PHP définit implicitement les caractères manquants à l'espace. Et chunk_splitest le moyen le plus court d'insérer les sauts de ligne.
  Je ne veux même pas savoir combien il en faudrait d’autre.
• 7+($c&3?:-6)est un octet plus court que $c&3?$c%4+7:1.
• Ajouté hexdec()(8 octets) pour satisfaire la restriction d'entrée.

JavaScript, 184 183 178 168 167 octets

f=
n=>[...`<>K[LM]NO\\^k{lm}no|~`].map((e,i)=>n>>i&1&&[0,2,4,6,8].map(i=>a[(e&102)*4+(e&17||15)*i]=`o`,e=~e.charCodeAt()),a=[...(` `.repeat(31)+`
`).repeat(9)])&&a.join``

<input oninput=o.textContent=f(+this.value)><pre id=o>

Était à l'origine de 206 octets, mais la réponse de @ Arnauld m'a inspiré à étudier une solution de tableau unidimensionnel. Edit: 1 octet enregistré grâce à @ edc65. Enregistré 5 15 octets grâce à @Arnauld. Sauvegardé un octet supplémentaire en modifiant le choix des caractères.

Lot, 491 octets

@set n=%1
@for %%i in ("720896 524288 524288 524288 843776 262144 262144 262144 268288" "131072 65536 0 32768 16384 8192 0 4096 2048" "131072 0 98304 0 16384 0 12288 0 2048" "131072 32768 0 65536 16384 4096 0 8192 2048" "165248 1024 1024 1024 89312 512 512 512 10764" "256 128 0 64 32 16 0 8 4" "256 0 192 0 32 0 24 0 4" "256 64 0 128 32 8 0 16 4" "322 2 2 2 171 1 1 1 17")do @set s=&(for %%j in (%%~i)do @set/am=%1^&%%j&call:c)&call echo(%%s%%
:c
@if %m%==0 (set s=%s%  )else set s=%s%o 

Remarque: la dernière ligne se termine par un espace. Mettre un ifconditionnel avec une variable dans une forboucle est au-delà du lot, ce qui nécessite son propre sous-programme. Puisqu'il ne fait rien de visible, je tombe dedans pour sortir. Le ne ~cite pas les chaînes dans la boucle externe permettant à la boucle interne de boucler sur les nombres. Les nombres sont simplement les bitmasks pour tous les endroits où os doit être dessiné.

C, 267 262 260 256 caractères

Compter les échappées comme 1 caractère

void f(int i){char*k="\0\x1\x2\x3\x4\x4\x5\x6\x7\x8\0\x9\x12\x1b\x24\0\xa\x14\x1e\x28\x4\xc\x14\x1c\x2d\x4\xd\x16\x1f\x28\x4\xe\x18\x22\x2c\x8\x10\x18\x20\x28\x8\x11\x1a\x23\x2c\x24\x25\x26\x27\x28\x28\x29\x2a\x2b\x2c\x24\x2d\x36\x3f\x48\x24\x2e\x38\x42\x4c\x28\x30\x38\x40\x48\x28\x31\x3a\x43\x4c\x28\x31\x3a\x43\x4c\x28\x32\x3c\x46\x50\x2c\x35\x3e\x47\x50\x48\x49\x4a\x4b\x4c\x4c\x4d\x4e\x4f\x50";for(int n=0,s,l;n<81;!(++n%9)&&putchar(10))for(s=l=0;s<20;!(++l%5||++s^20)&&putchar(32))if(i<<s&1<<19&&k[l]==n&&putchar(111))break;}

k est une recherche faisant référence aux cases dans lesquelles mettre un «o».

Essayez-le en ligne!

Befunge, 468 octets

~:85+`!#v_86*-:9`7*-48*%\82**+
3%2:/2\<$v0%2:/2\*g02*!g03%2:/2\*!+4g07%2:/2\*g02*!-8g06%2:/2\*g02*!-4g0
g!*20g*^00>50g*\2/:2%00g8-!*40g*\2/:2%30g8-!*20g*\2/:2%60g66+-!*\2/:2%70
`\5:p00:<g^*!-8g00%2:\-10:\p07-g00:p06+g00:p05`3:p04`\5:p03:<0\p02`3:p01
#o 8`#@_^4>*50g*\2/2%00g!*40g*0\>:#<1#\+_$!1+4g,48*,\1+:8`!#^_55+,$\1+:
g03%2:/2<-^!g00%2:/2\*g01*!g03%2:/2\*g01*!g07%2:/2\*!-4g06%2:/2\*g01*!-4
70g4-!*\^>!*50g*\2/:2%00g4-!*40g*\2/:2%30g8-!*10g*\2/:2%60g8-!*10g*\2/:2%

Essayez-le en ligne!

La première ligne lit une chaîne depuis stdin, l'évaluant comme un nombre hexadécimal. Le reste du code est essentiellement une double boucle sur les coordonnées x / y de la grille, avec un calcul booléen massif déterminant si uno doit être sorti pour chaque emplacement.

Il y a fondamentalement une condition distincte pour chacun des 20 points de grille, par exemple (les quatre premiers):

(y==0) * (x<5) * bit0
(y==0) * (x>3) * bit1
(x==0) * (y<5) * bit2
(x==y) * (y<5) * bit3

Et puis une fois que nous avons calculé les 20, nous OU le lot ensemble, et si ce résultat est vrai, nous produisons un o , sinon nous générons un espace.

Befunge n'a rien à faire en termes d'opérations de manipulation de bits, donc pour extraire les bits de l'entrée, nous ne faisons qu'évaluer à plusieurs reprises n%2, puis n/=2pendant que nous progressons dans les 20 calculs de condition.