Ezoteryczny język programowania zło ma interesującą operację na wartościach bajtów, które nazywa „tkaniem”. Zasadniczo jest to permutacja ośmiu bitów bajtu (nie ma znaczenia, od którego końca zaczniemy liczyć, ponieważ wzorzec jest symetryczny):

• Bit 0 jest przenoszony na bit 2
• Bit 1 jest przenoszony na bit 0
• Bit 2 jest przenoszony na bit 4
• Bit 3 jest przenoszony na bit 1
• Bit 4 jest przenoszony na bit 6
• Bit 5 jest przenoszony na bit 3
• Bit 6 jest przenoszony na bit 7
• Bit 7 jest przenoszony na bit 5

Dla wygody oto dwie inne reprezentacje permutacji. Jako cykl:

(02467531)

I jako lista par mapowania:

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

Twoim zadaniem jest wizualizacja tej permutacji, stosując znaki materacem rysunek ─, │, ┌, ┐, └, ┘, ┼(Unicode punkty kodowe: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253 ° C). Ta wizualizacja powinna spełniać następujące ograniczenia:

Pierwsza i ostatnia linia to dokładnie:

0 1 2 3 4 5 6 7

Pomiędzy nimi możesz użyć tyle linii, ile chcesz, do 15 znaków, aby pasowały do ​​twoich znaków rysunkowych (potrzebujesz co najmniej 4 linii). Linie powinny rozpoczynać się pionowo pod jedną z cyfr w pierwszym rzędzie i kończyć się pionowo nad odpowiednią cyfrą w ostatnim rzędzie. Osiem linii musi być połączonych i może przecinać tylko ┼(co jest zawsze skrzyżowaniem, nigdy dwie dotykające się linie zwrotne). Dokładne ścieżki linii zależą od ciebie (a znalezienie szczególnie grywalnego układu jest podstawą tego wyzwania). Jednym prawidłowym wyjściem byłoby:

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

Jednak każdy inny układ, który poprawnie łączy prawidłowe cyfry, jest również w porządku. Pokaż swoją odpowiedź w odpowiedzi.

Możesz napisać program lub funkcję i nie będziesz pobierał żadnych danych wejściowych. Wyjście diagramu do STDOUT (lub najbliższej alternatywy) lub jako funkcja zwraca wartość w postaci łańcucha lub listy ciągów (każdy reprezentujący jedną linię).

Obowiązują standardowe zasady gry w golfa , więc wygrywa najkrótszy kod (w bajtach).

Właściwie 69 bajtów

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

Wypróbuj online!(wyrównanie jest trochę popsute w tłumaczu online)

W rzeczywistości ma OGROMNĄ przewagę - wszystkie postacie do rysowania pudełek są w CP437, więc każdy z nich jest tylko bajtem. Chociaż każdy potrzebny znak może teoretycznie być zakodowany w 4 bitach (ponieważ jest tylko 9 unikalnych znaków), 31 bajtów zapisanych przez kompresję łańcucha zostanie utraconych z powodu bardzo słabych możliwości przetwarzania łańcucha. Oznacza to również, że każda konfiguracja 8x4 dałaby ten sam wynik. Ponieważ 8x4 wydaje się być (wertykalnie) najkrótszą możliwą konfiguracją, jest to optymalne.

Dzięki Martin za 3 bajty!

Dzięki TimmyD za jeszcze 4 bajty!

Wyjaśnienie:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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 bajtów (81 znaków)

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

Grałem dalej w tkactwo, eliminując potrzebę kilku zmiennych, używając wbudowanych bloków kodu. Jest to prawdopodobnie kilka bajtów wartości optymalnej.

Zaczynamy od ustawienia $arównego zakresowi, 0..7który został połączony ze spacjami. Wynika to z tego, że domyślnym $ofs(Separator pól wyjściowych) tablicy jest spacja, więc gdy tablica jest strunitowana za pomocą""+ (z takim operatorem, PowerShell spróbuje niejawnie rzutować obiekt po prawej stronie jako obiekt po lewej stronie), wynikiem jest zakres oddzielony spacją.

Jest to zamknięte w parens, co dodaje wynik do potoku. Następnie ustawiamy jedną zmienną pomocniczą $b, po której następują cztery wiersze danych wyjściowych z odpowiednią zmienną na miejscu (rozdzieloną dosłownymi znakami nowej linii) i używamy wbudowanych bloków kodu dla powtarzających się sekcji, a następnie $aponownie. Cztery linie i $asą również umieszczane w potoku, a dane wyjściowe są niejawne na końcu.

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 bajtów

Edycja: Ups, okazało się, że użyłem |znaku potoku zamiast U + 2502 │w części funkcji, zaktualizowałem liczbę bajtów.

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

Zwraca ciąg.

Wydajność:

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

Dodatkowo: Korzystając z metody @ TimmyD, mam kolejne 167-bajtowe rozwiązanie:

(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 bajtów

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>

Jako dzwonek natychmiast rozpoznałem to jako pierwsze dwa rzędy Plain Hunt Major (zauważ, że połączone zdjęcie używa 1-8 zamiast 0-7).

Pyth - 119 104 100 81 bajtów

Niezwykle prosty. (Tym razem jego bajty).

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

Wypróbuj online tutaj .

Ukradłem również dane wyjściowe @ TimmyD:

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

MS-DOS Batch, 136 bajtów

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

Korzystanie z wyjścia @ TimmyD. Może to również działać w Windows Batch, ale moja strona kodowa to CP850, a nie CP437.

MATLAB / Octave, 112 109 bajtów

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]

Wydajność:

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

Mój kod oparty jest na wyjściach @Dendrobium i @Neil .

/// , 112 bajtów (100 znaków)

/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

Dzięki @MartinEnder za -3 bajty!
Dzięki @MartinEnder za -9 bajtów!
Dzięki @MartinEnder (OP) za wskazanie 15-znakowego wykluczenia

Wykorzystuje @ TimmyD @ Marco

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

Python3, 209 bajtów

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

Zwraca ciąg.

Dzięki @Mego za uratowanie 2 bajtów!

Kredyty ciała postaci są dostępne na @TimmyD!

Szpule , 99 bajtów (87 znaków)

$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

Wykorzystuje dane wyjściowe @ Marco (zamień co 16 znak na nowy wiersz (regex: (.{15}). ->)\1\n )).

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

Bash + GNU sed, 140 bajtów

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'

Wydajność:

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

Korzystanie z danych wyjściowych @ TimmyD : 142 bajty

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'

Wydajność:

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

Tcl , 205 bajtów

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

Wypróbuj online!

wyjścia

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

SOGL V0.12 , 64 bajty

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

Wypróbuj tutaj!

Wzór skradziony z PowerShell