A linguagem de programação esotérica evil possui uma operação interessante sobre valores de bytes que chama de "tecelagem". É essencialmente uma permutação dos oito bits do byte (não importa de que extremidade começamos a contar, pois o padrão é simétrico):

• O bit 0 é movido para o bit 2
• O bit 1 é movido para o bit 0
• O bit 2 é movido para o bit 4
• O bit 3 é movido para o bit 1
• O bit 4 é movido para o bit 6
• O bit 5 é movido para o bit 3
• O bit 6 é movido para o bit 7
• O bit 7 é movido para o bit 5

Por conveniência, aqui estão duas outras representações da permutação. Como um ciclo:

(02467531)

E como uma lista de pares do mapeamento:

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

Sua tarefa é visualizar esta permutação, usando os personagens de desenho de caixa ─, │, ┌, ┐, └, ┘, ┼(Unicode pontos de código: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Essa visualização deve satisfazer as seguintes restrições:

A primeira e a última linha são exatamente:

0 1 2 3 4 5 6 7

Entre eles, você pode usar quantas linhas desejar, com até 15 caracteres cada, para ajustar os caracteres de desenho da caixa (você precisará de pelo menos 4 linhas). As linhas devem começar verticalmente abaixo de um dos dígitos na primeira linha e terminar verticalmente acima do dígito correspondente na última linha. As oito linhas devem estar conectadas e só podem atravessar via ┼(que é sempre uma travessia, nunca duas linhas de viragem que estão tocando). Os caminhos exatos das linhas são com você (e encontrar um layout particularmente jogável é o cerne deste desafio). Uma saída válida seria:

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

No entanto, qualquer outro layout que conecte corretamente os dígitos corretos também é bom. Por favor, mostre a sua saída escolhida na sua resposta.

Você pode escrever um programa ou função e não aceita nenhuma entrada. Envie o diagrama para STDOUT (ou alternativa mais próxima) ou como um valor de retorno da função na forma de uma string ou uma lista de strings (cada uma representando uma linha).

Aplicam-se as regras de código-golfe padrão , para que o código mais curto (em bytes) vença.

Na verdade, 69 bytes

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

Experimente online! (o alinhamento está um pouco confuso no intérprete on-line)

Na verdade, há uma enorme vantagem aqui - todos os caracteres de desenho da caixa estão no CP437, portanto, são apenas um byte cada. Embora cada caractere necessário possa, teoricamente, ser codificado em 4 bits (já que existem apenas 9 caracteres únicos), os 31 bytes salvos pela compactação da string serão perdidos devido aos recursos de processamento de string muito ruins da Actually. Isso também significa que qualquer configuração 8x4 resultaria na mesma pontuação. Como 8x4 parece ser a configuração mais curta possível (verticalmente), isso é ideal.

Obrigado a Martin por 3 bytes!

Obrigado a TimmyD por mais 4 bytes!

Explicação:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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

Joguei a tecelagem ainda mais, eliminando a necessidade de várias variáveis ​​usando blocos de código em linha. Provavelmente isso está dentro de alguns bytes do ideal.

Começamos definindo $aigual ao intervalo 0..7que foi unido aos espaços. Isso ocorre porque o padrão $ofs(Separador de campo de saída) de uma matriz é um espaço, portanto, quando a matriz é estritamente""+ (com um operador como este, o PowerShell tentará converter implicitamente o objeto da mão direita como o objeto da esquerda), o resultado é o intervalo separado por espaço.

Isso é encapsulado em parênteses, o que adiciona o resultado ao pipeline. Em seguida, configuramos uma variável auxiliar $b, seguida por quatro linhas de saída com a variável apropriada no lugar (dividida com novas linhas literais) e usando blocos de código em linha para seções repetidas, seguidos $anovamente. As quatro linhas e $atambém são colocadas no pipeline, e a saída está implícita no 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

Edit: Opa, aconteceu que eu estava usando o |caractere de pipe em vez de U + 2502 │em parte da função, contagem de bytes atualizada.

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

Retorna uma string.

Saída:

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

Extra: Usando o método do @ TimmyD, tenho outra solução 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), 137 134 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 campainha, reconheci imediatamente isso como as duas primeiras linhas do Plain Hunt Major (observe que a imagem vinculada usa 1-8 em vez de 0-7).

Pitão - 119 104 100 81 bytes

Extremamente simples. (Na verdade, são bytes desta vez).

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

Experimente online aqui .

Eu também roubei a saída de @ TimmyD:

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

Lote do 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 a saída de @ TimmyD. Isso também pode funcionar no Lote do Windows, mas minha página de código é o CP850, não o CP437.

MATLAB / oitava, 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]

Saída:

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

Meu código é baseado nos resultados de @Dendrobium e @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

Obrigado @MartinEnder por -3 bytes!
Obrigado @MartinEnder por -9 bytes!
Obrigado @MartinEnder (OP) por apontar a exclusão de 15 caracteres

Usa a saída 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

Retorna uma string.

Agradecemos ao @Mego por economizar 2 bytes!

Os créditos do corpo do personagem vão para @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

Usa a saída de @ Marco (substitua cada caractere 16 por uma nova linha (regex: (.{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'

Saída:

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

Usando a saída do @ 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'

Saída:

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"

Experimente online!

saídas

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

SOGL V0.12 , 64 bytes

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

Experimente aqui!

Padrão roubado do PowerShell