Die esoterische Programmiersprache evil hat eine interessante Operation für Bytewerte, die sie "Weben" nennt. Es ist im Wesentlichen eine Permutation der acht Bits des Bytes (es spielt keine Rolle, von welchem ​​Ende aus wir zu zählen beginnen, da das Muster symmetrisch ist):

• Bit 0 wird nach Bit 2 verschoben
• Bit 1 wird nach Bit 0 verschoben
• Bit 2 wird nach Bit 4 verschoben
• Bit 3 wird nach Bit 1 verschoben
• Bit 4 wird nach Bit 6 verschoben
• Bit 5 wird nach Bit 3 verschoben
• Bit 6 wird nach Bit 7 verschoben
• Bit 7 wird nach Bit 5 verschoben

Der Einfachheit halber sind hier zwei weitere Darstellungen der Permutation. Als Zyklus:

(02467531)

Und als Liste von Paaren des Mappings:

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

Ihre Aufgabe ist es, diese Permutation sichtbar zu machen, die Box-Zeichnen von Buchstaben mit ─, │, ┌, ┐, └, ┘, ┼(Unicode - Codepunkte: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Diese Visualisierung sollte die folgenden Einschränkungen erfüllen:

Die erste und letzte Zeile sind genau:

0 1 2 3 4 5 6 7

Dazwischen können Sie beliebig viele Zeilen mit jeweils bis zu 15 Zeichen für die Zeichen Ihrer Box verwenden (Sie benötigen mindestens 4 Zeilen). Die Zeilen sollten vertikal unter einer der Ziffern in der ersten Zeile beginnen und vertikal über der entsprechenden Ziffer in der letzten Zeile enden. Die acht Linien müssen verbunden sein und dürfen sich nur überkreuzen ┼(das ist immer eine Kreuzung, niemals zwei sich berührende Wendelinien). Die genauen Wege der Linien liegen bei Ihnen (und die Suche nach einem besonders golffähigen Layout ist der Kern dieser Herausforderung). Eine gültige Ausgabe wäre:

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

Jedes andere Layout, das die richtigen Ziffern richtig verbindet, ist jedoch auch in Ordnung. Bitte zeigen Sie Ihre gewählte Ausgabe in Ihrer Antwort.

Sie können ein Programm oder eine Funktion schreiben und nehmen keine Eingaben vor. Geben Sie das Diagramm entweder an STDOUT (oder an die nächstgelegene Alternative) oder als Funktionsrückgabewert in Form einer Zeichenfolge oder einer Liste von Zeichenfolgen (die jeweils eine Zeile darstellen) aus.

Es gelten die Standardregeln für Code-Golf , sodass der kürzeste Code (in Byte) gewinnt.

Eigentlich 69 Bytes

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

Probieren Sie es online! (Die Ausrichtung ist im Online-Interpreter ein wenig durcheinander)

Tatsächlich hat dies einen RIESIGEN Vorteil: Alle Box-Zeichen befinden sich im CP437, sie sind also jeweils nur ein Byte. Obwohl jedes benötigte Zeichen theoretisch in 4 Bits codiert werden könnte (da es nur 9 eindeutige Zeichen gibt), würden die durch Komprimieren der Zeichenfolge gesparten 31 Bytes aufgrund der sehr schlechten Stringverarbeitungsfähigkeiten von Actually verloren gehen. Dies bedeutet auch, dass jede 8x4-Konfiguration die gleiche Punktzahl ergibt. Da 8x4 die (vertikal) kürzeste mögliche Konfiguration zu sein scheint, ist dies optimal.

Danke an Martin für 3 Bytes!

Danke an TimmyD für 4 weitere Bytes!

Erläuterung:

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

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

Ich habe das Weben weiter vertieft und durch die Verwendung von Inline-Codeblöcken die Notwendigkeit mehrerer Variablen beseitigt. Dies liegt wahrscheinlich innerhalb weniger Bytes des Optimums.

Wir beginnen mit der Einstellung $ades Bereichs 0..7, der mit Leerzeichen verbunden wurde. Dies liegt daran, dass der Standardwert $ofs(Ausgabefeldtrennzeichen) für ein Array ein Leerzeichen ist. Wenn das Array also ""+mit einem String versehen wird (mit einem Operator wie diesem versucht PowerShell, das rechte Objekt implizit als linkes Objekt umzuwandeln ). Das Ergebnis ist der durch Leerzeichen getrennte Bereich.

Das ist in Parens eingekapselt, was das Ergebnis in die Pipeline einfügt. Wir $brichten dann eine One-Helper-Variable ein , gefolgt von vier Ausgabezeilen mit der entsprechenden Variablen (aufgeteilt mit wörtlichen Zeilenumbrüchen) und verwenden Inline-Codeblöcke für Wiederholungsabschnitte, gefolgt von einer $aerneuten Ausgabe . Die vier Zeilen und $awerden ebenfalls in der Pipeline platziert, und die Ausgabe erfolgt am Ende implizit.

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: Whoops, stellte sich heraus, dass ich in einem Teil der Funktion das Pipe- |Zeichen anstelle von U + 2502 verwendet habe │. Die Anzahl der Bytes wurde aktualisiert.

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

Gibt eine Zeichenfolge zurück.

Ausgabe:

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

Extra: Mit der @ TimmyD-Methode habe ich eine weitere 167-Byte-Lösung:

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

Als Klingelton erkannte ich dies sofort als die ersten beiden Zeilen von Plain Hunt Major (beachten Sie, dass das verknüpfte Bild 1-8 anstelle von 0-7 verwendet).

Pyth - 119 104 100 81 Bytes

Extrem einfach. (Diesmal sind es tatsächlich Bytes).

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

Probieren Sie es hier online aus .

Ich habe auch die Ausgabe von @ TimmyD gestohlen:

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

MS-DOS-Stapel, 136 Byte

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

Verwendung der @ TimmyD-Ausgabe. Dies funktioniert möglicherweise auch in Windows Batch, aber auf meiner Codepage befindet sich CP850, nicht 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]

Ausgabe:

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

Mein Code basiert auf den Ausgängen von @Dendrobium und @Neil .

/// 112 Bytes (100 Zeichen)

/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

Danke @MartinEnder für -3 Bytes!
Danke @MartinEnder für -9 Bytes!
Vielen Dank an @MartinEnder (OP) für den Hinweis auf die 15-Zeichen-Regel

Verwendet die @ TimmyD @ Marco Ausgabe

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

Gibt eine Zeichenfolge zurück.

Vielen Dank an @Mego für das Speichern von 2 Bytes!

Credits des Charakterkörpers gehen an @TimmyD!

Korrigiert , 99 Bytes (87 Zeichen)

$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

Verwendet die Ausgabe von @ Marco (ersetzen Sie jedes 16. Zeichen durch eine neue Zeile (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'

Ausgabe:

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

Verwendung der Ausgabe von @ 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'

Ausgabe:

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"

Probieren Sie es online!

Ausgänge

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

SOGL V0.12 , 64 Bytes

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

Probieren Sie es hier aus!

Muster aus der Powershell gestohlen