El lenguaje de programación esotérico evil tiene una operación interesante sobre los valores de bytes que llama "tejido". Es esencialmente una permutación de los ocho bits del byte (no importa desde qué extremo comencemos a contar, ya que el patrón es simétrico):

• El bit 0 se mueve al bit 2
• El bit 1 se mueve al bit 0
• El bit 2 se mueve al bit 4
• El bit 3 se mueve al bit 1
• El bit 4 se mueve al bit 6
• El bit 5 se mueve al bit 3
• El bit 6 se mueve al bit 7
• El bit 7 se mueve al bit 5

Por conveniencia, aquí hay otras dos representaciones de la permutación. Como un ciclo:

(02467531)

Y como una lista de pares de mapeo:

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

Su tarea es visualizar esta permutación, utilizando los caracteres de cuadro de dibujo ─, │, ┌, ┐, └, ┘,┼ (Unicode puntos de código: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Esta visualización debe satisfacer las siguientes restricciones:

La primera y la última línea son exactamente:

0 1 2 3 4 5 6 7

Entre ellos, puede usar tantas líneas como desee de hasta 15 caracteres cada una para adaptarse a los caracteres de su cuadro de dibujo (necesitará al menos 4 líneas). Las líneas deben comenzar verticalmente debajo de uno de los dígitos en la primera fila y terminar verticalmente arriba del dígito correspondiente en la última fila. Las ocho líneas deben estar conectadas y solo pueden cruzarse ┼(lo que siempre es un cruce, nunca dos líneas de giro que se tocan). Los caminos exactos de las líneas dependen de usted (y encontrar un diseño particularmente golfable es el núcleo de este desafío). Una salida válida sería:

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

Sin embargo, cualquier otro diseño que conecte correctamente los dígitos correctos también está bien. Por favor, muestre el resultado elegido en su respuesta.

Puede escribir un programa o función y no tomará ninguna entrada. Envíe el diagrama a STDOUT (o la alternativa más cercana) o como un valor de retorno de función en forma de una cadena o una lista de cadenas (cada una representa una línea).

Se aplican las reglas estándar de código de golf , por lo que gana el código más corto (en bytes).

En realidad, 69 bytes

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

Pruébalo en línea! (la alineación está un poco desordenada en el intérprete en línea)

Realmente tiene una GRAN ventaja aquí: todos los caracteres de dibujo de caja están en CP437, por lo que son solo un byte cada uno. Aunque cada carácter necesario podría codificarse teóricamente en 4 bits (dado que solo hay 9 caracteres únicos), los 31 bytes guardados al comprimir la cadena se perderían debido a las capacidades de procesamiento de cadena muy pobres de Actually. Esto también significa que cualquier configuración de 8x4 daría como resultado la misma puntuación. Dado que 8x4 parece ser la configuración más corta (verticalmente) posible, esta es óptima.

¡Gracias a Martin por 3 bytes!

¡Gracias a TimmyD por 4 bytes más!

Explicación:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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 bytes (81 caracteres)

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

Jugué más el tejido, eliminando la necesidad de varias variables mediante el uso de bloques de código en línea. Esto es probablemente dentro de unos pocos bytes de óptimo.

Comenzamos estableciendo $aun rango igual al rango 0..7que se ha unido con espacios. Esto se debe a que el valor predeterminado $ofs(Separador de campo de salida) para una matriz es un espacio, por lo que cuando la matriz se encadena con ""+(con un operador como este, PowerShell intentará convertir implícitamente el objeto derecho como el objeto izquierdo), el resultado es el rango separado por espacios.

Eso está encapsulado en parens, lo que agrega el resultado a la tubería. Luego configuramos una variable auxiliar $b, seguida de cuatro líneas de salida con la variable apropiada en su lugar (dividida con nuevas líneas literales), y usando bloques de código en línea para las secciones repetidas, seguidas de $anuevo. Las cuatro líneas y $atambién se colocan en la tubería, y la salida está implícita al final.

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 bytes

Editar: Whoops, resultó que estaba usando el |char de tubería en lugar de U + 2502 │en parte de la función, recuento de bytes actualizado.

_=>((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`
`

Devuelve una cadena.

Salida:

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

Extra: Usando el método de @ TimmyD, tengo otra solución de 167 bytes:

(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), 137134 bytes

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>

Como campanero, inmediatamente reconocí esto como las dos primeras filas de Plain Hunt Major (tenga en cuenta que la imagen vinculada usa 1-8 en lugar de 0-7).

Pyth - 119 104 100 81 bytes

Extremadamente simple (Es realmente bytes esta vez).

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

Pruébelo en línea aquí .

También robé la salida de @ TimmyD:

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

Lote MS-DOS, 136 bytes

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

Usando la salida de @ TimmyD. Esto también podría funcionar en Windows Batch, pero mi página de códigos es CP850, no CP437.

MATLAB / Octave, 112 109 bytes

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]

Salida:

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

Mi código se basa en los resultados de @Dendrobium y @Neil .

/// , 112 bytes (100 caracteres)

/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

¡Gracias @MartinEnder por -3 bytes!
¡Gracias @MartinEnder por -9 bytes!
Gracias @MartinEnder (OP) por señalar la regla de 15 caracteres

Utiliza la salida de @ TimmyD's @ Marco

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

Python3, 209 bytes

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

Devuelve una cadena.

¡Gracias a @Mego por guardar 2 bytes!

¡Los créditos del cuerpo del personaje van a @TimmyD!

Sprects , 99 bytes (87 caracteres)

$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

Utiliza la salida de @ Marco (reemplaza cada 16 caracteres con una nueva línea (expresión regular: (.{15}).-> \1\n)).

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

Bash + GNU sed, 140 bytes

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'

Salida:

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

Usando la salida de @ TimmyD : 142 bytes

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'

Salida:

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

Tcl , 205 bytes

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

Pruébalo en línea!

salidas

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

SOGL V0.12 , 64 bytes

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

Pruébalo aquí!

Patrón robado del PowerShell