Le langage de programmation ésotérique evil a une opération intéressante sur les valeurs d'octets qu'il appelle "tissage". Il s'agit essentiellement d'une permutation des huit bits de l'octet (peu importe de quelle extrémité nous commençons à compter, car le motif est symétrique):

• Le bit 0 est déplacé vers le bit 2
• Le bit 1 est déplacé vers le bit 0
• Le bit 2 est déplacé vers le bit 4
• Le bit 3 est déplacé vers le bit 1
• Le bit 4 est déplacé vers le bit 6
• Le bit 5 est déplacé vers le bit 3
• Le bit 6 est déplacé vers le bit 7
• Le bit 7 est déplacé vers le bit 5

Pour plus de commodité, voici deux autres représentations de la permutation. En cycle:

(02467531)

Et comme une liste de paires de la cartographie:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

Votre tâche est de visualiser cette permutation, en utilisant les caractères de boîte dessin ─, │, ┌, ┐, └, ┘, ┼(points de code Unicode: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Cette visualisation doit satisfaire les contraintes suivantes:

La première et la dernière ligne sont exactement:

0 1 2 3 4 5 6 7

Entre ceux-ci, vous pouvez utiliser autant de lignes que vous le souhaitez jusqu'à 15 caractères chacune pour s'adapter à vos personnages de dessin de boîte (vous aurez besoin d'au moins 4 lignes). Les lignes doivent commencer verticalement sous l'un des chiffres de la première ligne et se terminer verticalement au-dessus du chiffre correspondant de la dernière ligne. Les huit lignes doivent être connectées et ne peuvent traverser que ┼(ce qui est toujours un croisement, jamais deux lignes tournantes qui se touchent). Le chemin exact des lignes dépend de vous (et trouver un tracé particulièrement golfable est au cœur de ce défi). Une sortie valide serait:

0 1 2 3 4 5 6 7
│ │ └─┼┐│ │ └┐│
└─┼─┐ ││└─┼─┐││
┌─┘ │ ││  │ │││
│ ┌─┼─┘│  │ │││
│ │ │ ┌┼──┘ │││
│ │ │ │└┐ ┌─┼┼┘
│ │ │ │ │ │ │└┐
0 1 2 3 4 5 6 7

Cependant, toute autre mise en page qui connecte correctement les bons chiffres convient également. Veuillez indiquer la sortie choisie dans votre réponse.

Vous pouvez écrire un programme ou une fonction et ne prendre aucune entrée. Générez le diagramme sur STDOUT (ou l'alternative la plus proche) ou sous forme de valeur de retour de fonction sous la forme d'une chaîne ou d'une liste de chaînes (chacune représentant une ligne).

Les règles de code-golf standard s'appliquent, donc le code le plus court (en octets) gagne.

En fait, 69 octets

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)

Essayez-le en ligne! (l'alignement est un peu foiré dans l'interprète en ligne)

A en fait un énorme avantage ici - tous les personnages de dessin de boîte sont dans CP437, donc ils ne sont qu'un octet chacun. Bien que chaque caractère nécessaire puisse théoriquement être codé en 4 bits (car il n'y a que 9 caractères uniques), les 31 octets enregistrés en compressant la chaîne seraient perdus en raison des très faibles capacités de traitement des chaînes. Cela signifie également que toute configuration 8x4 entraînerait le même score. Étant donné que 8x4 semble être la configuration (verticalement) la plus courte possible, c'est optimal.

Merci à Martin pour 3 octets!

Merci à TimmyD pour 4 octets de plus!

Explication:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)
"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+         push the individual lines, using string multiplication to shorten repeated sections
                                                              8r' j   push the string "0 1 2 3 4 5 6 7" (range(8), join on spaces)
                                                                   ;)  make a copy and move it to the bottom of the stack

PowerShell v2 +, 172 153 148 145 142 131 123 octets (81 caractères)

($a=""+0..7)
$b='┌┘'
"│$b$('┌┼─┘'*3)
└┼┐$('│└─┐'*3)
$b$('└┼─┐'*3)│
│ $($b*6)│"
$a

J'ai approfondi le tissage, éliminant le besoin de plusieurs variables en utilisant des blocs de code en ligne. Il s'agit probablement de quelques octets optimaux.

Nous commençons par définir $aégal à la plage 0..7qui a été jointe avec des espaces. En effet, la valeur par défaut $ofs(Output Field Separator) pour un tableau est un espace, donc lorsque le tableau est stratifié avec ""+(avec un opérateur comme celui-ci, PowerShell essaiera de transposer implicitement l'objet de droite en objet de gauche), le résultat est la plage séparée par des espaces.

C'est encapsulé en parens, ce qui ajoute le résultat sur le pipeline. Nous avons ensuite configuré une variable auxiliaire $b, suivie de quatre lignes de sortie avec la variable appropriée en place (divisée avec des retours à la ligne littéraux), et en utilisant des blocs de code en ligne pour les sections répétées, puis à $anouveau. Les quatre lignes et $asont également placées sur le pipeline, et la sortie est implicite à la fin.

PS C:\Tools\Scripts\golfing> .\visualize-bit-weaving.ps1
0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Javascript ES6, 168 167 octets

Edit: Oups, il s'est avéré que j'utilisais le caractère de tuyau |au lieu de U + 2502 │dans une partie de la fonction, mise à jour du nombre d'octets.

_=>((n=`0 1 2 3 4 5 6 7 `)+[...`6452301`].map(i=>`${(d=n=>`│ `.repeat(n))(i)}└┐│ ${r=d(6)}┌┼┘ ${r}│└┐ ${d(6-i)}`).join``+n).match(/.{16}/g).join`
`

Renvoie une chaîne.

Sortie:

0 1 2 3 4 5 6 7 
│ │ │ │ │ │ └┐│ 
│ │ │ │ │ │ ┌┼┘ 
│ │ │ │ │ │ │└┐ 
│ │ │ │ └┐│ │ │ 
│ │ │ │ ┌┼┘ │ │ 
│ │ │ │ │└┐ │ │ 
│ │ │ │ │ └┐│ │ 
│ │ │ │ │ ┌┼┘ │ 
│ │ │ │ │ │└┐ │ 
│ │ └┐│ │ │ │ │ 
│ │ ┌┼┘ │ │ │ │ 
│ │ │└┐ │ │ │ │ 
│ │ │ └┐│ │ │ │ 
│ │ │ ┌┼┘ │ │ │ 
│ │ │ │└┐ │ │ │ 
└┐│ │ │ │ │ │ │ 
┌┼┘ │ │ │ │ │ │ 
│└┐ │ │ │ │ │ │ 
│ └┐│ │ │ │ │ │ 
│ ┌┼┘ │ │ │ │ │ 
│ │└┐ │ │ │ │ │ 
0 1 2 3 4 5 6 7 

Extra: En utilisant la méthode de @ TimmyD, j'ai une autre solution de 167 octets:

(n=`0 1 2 3 4 5 6 7
`,a=`│┌┘ `,b=`└┼─┐`,d=`┌┼─┘`,f=` │└┐`)=>[n,a,a,a,a,`
`,b,b,b,`└┼┐
┌┘`,d,d,d,`│
│`,f,f,f,` │
`,n].join``

JavaScript (ES6), 137 134 octets

f=
_=>`0
│2525252
1 1 1 1
24242423525252 3 1 1 1 3 242424│
0`.replace(/\d/g,d=>`0 1 2 3 4 5 6 7,└┼┐,┌┘,│
│,│ , │`.split`,`[d])  
;
o.textContent=f();

<pre id=o></pre>

En tant que sonneur de cloche, j'ai immédiatement reconnu qu'il s'agissait des deux premières rangées de Plain Hunt Major (notez que l'image liée utilise 1-8 au lieu de 0-7).

Pyth - 119 104 100 81 octets

Extrêmement simple. (C'est en fait des octets cette fois).

js[KjdU8cX."sz¨ú¨ãÆhÆ?\ÕüÓ¼xFNøa"_G"│┌┘└┼─┐ "15K

Essayez-le en ligne ici .

J'ai également volé la sortie de @ TimmyD:

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ │ │
└┼─┐└┼─┐└┼─┐└┐│
┌┘┌┼─┘ └┐│┌┼─┼┘
│ │└┐ ┌─┼┘│└┐└┐
0 1 2 3 4 5 6 7

Lot MS-DOS, 136 octets

@echo 0 1 2 3 4 5 6 7
@echo ³ÚÙ ³ÚÙ ³ÚÙ ³ÚÙ
@echo ÀÅÄ¿ÀÅÄ¿ÀÅÄ¿ÀÅ¿
@echo ÚÙÚÅÄÙÚÅÄÙÚÅÄÙ³
@echo ³ ³À¿ ³À¿ ³À¿ ³
@echo 0 1 2 3 4 5 6 7

Utilisation de la sortie de @ TimmyD. Cela peut également fonctionner dans Windows Batch, mais ma page de codes est CP850, pas CP437.

Matlab / Octave, 112 109 octets

a='0 1 2 3 4 5 6 7';d=['└┐│ ';'┌┼┘ ';'│└┐ '];e=repmat('│ ',3,1);[a;d d d d;e d d d e;a]

Sortie:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Mon code est basé sur les sorties de @Dendrobium et @Neil .

/// , 112 octets (100 caractères)

/8/0 1 2 3 4 5 6 7//9/│//A/└┐//B/┌┼┘/8/C/9 A9 A9 A9//D/9A 9A 9A 9/
AC
B B B B
DA
C 9
9 B B B 9
9 D
8

Merci @MartinEnder pour -3 octets!
Merci @MartinEnder pour -9 octets!
Merci @MartinEnder (OP) pour avoir exclu la règle des 15 caractères

Utilise la sortie de @ TimmyD @ Marco

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Python3, 209 octets

lambda s="0 1 2 3 4 5 6 7\n":s+"│┌┘ │┌┘ │┌┘ │ │\n└┼─┐└┼─┐└┼─┐└┐│\n┌┘┌┼─┘ └┐│┌┼─┼┘\n│ │└┐ ┌─┼┘│└┐└┐\n"+s

Renvoie une chaîne.

Merci à @Mego d'avoir économisé 2 octets!

Les crédits du corps du personnage vont à @TimmyD!

Sprects , 99 octets (87 caractères)

$8
AC
BE
DA
C 9
9E 9
9 D
8$E B B B$D9A 9A 9A 9$C9 A9 A9 A9$B┌┼┘$A└┐$9│$80 1 2 3 4 5 6 7

Utilise la sortie de @ Marco (remplacez chaque 16ème caractère par une nouvelle ligne (expression régulière: (.{15}).->\1\n )).

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Bash + GNU sed, 140 octets

sed 'h
s/$/nxxxacnb b b bnyyycanc xxxcnc b b b cnc yyyc/
:
s/x/ac /
s/y/ca /
s/a/└┐/
s/b/┌┼┘/
t
y/cn/│\n/
G'<<<'0 1 2 3 4 5 6 7'

Sortie:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Utilisation de la sortie de @ TimmyD : 142 octets

sed 'h
s/$/npbcccnsurdddnbeeepnp bbbbbbp/
:
s/b/qt/
s/c/quot/
s/d/psor/
s/e/suor/
t
y/nopqrstu/\n─│┌┐└┘┼/
G'<<<'0 1 2 3 4 5 6 7'

Sortie:

0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Tcl , 205 octets

puts "[set B "0 1 2 3 4 5 6 7"]
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
$B"

Essayez-le en ligne!

les sorties

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
0 1 2 3 4 5 6 7

SOGL V0.12 , 64 octets

└┼─┐³
┘┌┼─┘²
┐│└─┐¹
┌┘┌┘┌┘⁰
│┌²┌┼─²¶└┼¹│└─¹¶┌┘³³³│¶│ ⁰⁰│”8δ@∑Q;O

Essayez-le ici!

Motif volé à la PowerShell