Il malefico linguaggio di programmazione esoterico ha un'interessante operazione sui valori di byte che chiama "tessitura". È essenzialmente una permutazione degli otto bit del byte (non importa da quale fine iniziamo il conteggio, poiché il modello è simmetrico):

• Il bit 0 viene spostato nel bit 2
• Il bit 1 viene spostato sul bit 0
• Il bit 2 viene spostato sul bit 4
• Il bit 3 viene spostato sul bit 1
• Il bit 4 viene spostato sul bit 6
• Il bit 5 viene spostato sul bit 3
• Il bit 6 viene spostato sul bit 7
• Il bit 7 viene spostato sul bit 5

Per comodità, ecco altre due rappresentazioni della permutazione. Come un ciclo:

(02467531)

E come un elenco di coppie della mappatura:

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

Il vostro compito è quello di visualizzare questa permutazione, utilizzando i caratteri scatolari disegno ─, │, ┌, ┐, └, ┘, ┼(Unicode su: U + 2500, U + 2502, U + 250C, U + 2510 U + 2514, U + 2518, U + 253C). Questa visualizzazione dovrebbe soddisfare i seguenti vincoli:

La prima e l'ultima riga sono esattamente:

0 1 2 3 4 5 6 7

Tra questi, puoi usare tutte le linee che vuoi fino a un massimo di 15 caratteri ciascuna per adattare i caratteri del riquadro (avrai bisogno di almeno 4 linee). Le linee dovrebbero iniziare verticalmente sotto una delle cifre della prima riga e terminare verticalmente sopra la cifra corrispondente nell'ultima riga. Le otto linee devono essere collegate e possono attraversare solo via ┼(che è sempre un incrocio, mai due linee di svolta che si toccano). I percorsi esatti delle linee dipendono da te (e trovare un layout particolarmente golfabile è il nucleo di questa sfida). Un output valido sarebbe:

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

Tuttavia, anche qualsiasi altro layout che collega correttamente le cifre giuste va bene. Si prega di mostrare l'output scelto nella risposta.

È possibile scrivere un programma o una funzione e non accetta alcun input. Invia il diagramma a STDOUT (o alternativa più vicina) o come valore di ritorno di una funzione sotto forma di una stringa o di un elenco di stringhe (ognuna delle quali rappresenta una riga).

Si applicano le regole standard del code-golf , quindi vince il codice più breve (in byte).

In realtà, 69 byte

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

Provalo online! (l'allineamento è un po 'incasinato nell'interprete online)

In realtà qui ha un enorme vantaggio: tutti i caratteri di disegno della scatola sono in CP437, quindi sono solo un byte ciascuno. Sebbene ogni carattere necessario potrebbe teoricamente essere codificato in 4 bit (poiché ci sono solo 9 caratteri univoci), i 31 byte salvati comprimendo la stringa andrebbero persi a causa delle scarse capacità di elaborazione delle stringhe. Ciò significa anche che qualsiasi configurazione 8x4 comporterebbe lo stesso punteggio. Poiché 8x4 sembra essere la configurazione (verticalmente) più corta possibile, questo è ottimale.

Grazie a Martin per 3 byte!

Grazie a TimmyD per altri 4 byte!

Spiegazione:

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

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

Ho golfato ulteriormente la tessitura, eliminando la necessità di diverse variabili utilizzando blocchi di codice in linea. Questo è probabilmente entro pochi byte dall'ottimale.

Iniziamo impostando $auguale all'intervallo 0..7che è stato unito insieme agli spazi. Questo perché l'impostazione predefinita $ofs(Output Field Separator) per un array è uno spazio, quindi quando l'array viene sottoposto a stringhe con ""+(con un operatore come questo, PowerShell proverà a lanciare implicitamente l'oggetto di destra come oggetto di sinistra), il risultato è l'intervallo separato da spazio.

È incapsulato in parentesi, il che aggiunge il risultato alla pipeline. Quindi impostiamo una variabile di un helper $b, seguita da quattro righe di output con la variabile appropriata in atto (divisa con newline letterali) e usando blocchi di codice inline per sezioni ripetute, seguite da $anuovo. Le quattro linee e $asono anche posizionate sulla pipeline e l'output è implicito alla fine.

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 byte

Modifica: Whoops, ho scoperto che stavo usando il pipe pipe |invece di U + 2502 │in parte della funzione, conteggio byte aggiornato.

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

Restituisce una stringa.

Produzione:

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

Extra: usando il metodo di @ TimmyD, ho un'altra soluzione da 167 byte:

(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 byte

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>

Come suonatore di campane, ho immediatamente riconosciuto questo come le prime due file di Plain Hunt Major (nota che l'immagine collegata usa 1-8 invece di 0-7).

Pyth - 119 104 100 81 byte

Estremamente semplice. (Questa volta in realtà è byte).

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

Provalo online qui .

Ho anche rubato l'output di @ TimmyD:

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

Lotto MS-DOS, 136 byte

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

Usando l'output di @ TimmyD. Questo potrebbe funzionare anche in Windows Batch, ma la mia tabella codici è CP850, non CP437.

MATLAB / Octave, 112 109 byte

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]

Produzione:

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

Il mio codice si basa sulle uscite di @Dendrobium e @Neil .

/// , 112 byte (100 caratteri)

/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

Grazie @MartinEnder per -3 byte!
Grazie @MartinEnder per -9 byte!
Grazie a @MartinEnder (OP) per aver segnalato la regola dei 15 caratteri

Usa l' output di @ TimmyD's @ Marco

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

Python3, 209 byte

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

Restituisce una stringa.

Grazie a @Mego per aver salvato 2 byte!

I crediti del corpo del personaggio vanno a @TimmyD!

Sprects , 99 byte (87 caratteri)

$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 l'output di @ Marco (sostituisci ogni 16 caratteri con una nuova riga (regex: (.{15}).-> \1\n)).

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

Bash + GNU sed, 140 byte

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'

Produzione:

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

Utilizzando l' output di @ TimmyD : 142 byte

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'

Produzione:

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

Tcl , 205 byte

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

Provalo online!

uscite

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

SOGL V0.12 , 64 byte

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

Provalo qui!

Modello rubato dalla PowerShell