Wizualizacja tkania bitów

32

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 , więc wygrywa najkrótszy kod (w bajtach).

Martin Ender
źródło
1
Czy moglibyśmy użyć innych symboli dla języków, które nie obsługują Unicode?
flawr
3
Wyzwanie to w istocie sprowadza się do kopiowania wklejenie dostarczonego wyjście ... Jak o zrobieniu permutacji 01234567jako wejście, a następnie podłączając że do 01234567? Abyś sam musiał znaleźć linki? Byłoby to znacznie trudniejsze zadanie, szczególnie w golfa.
shooqie
5
@shooqie Zostało to omówione w piaskownicy. To rzeczywiście byłoby zupełnie inne wyzwanie i zastanawiam się nad tym także w pewnym momencie. Uważam jednak, że w tym wyzwaniu jest dużo więcej niż kopiowanie i wklejanie powyższego przykładu. Istnieje niezliczona ilość dopuszczalnych wyników, a powyższe jest szczególnie trudne do skompresowania, podczas gdy inne (jak te używane w istniejących odpowiedziach) są znacznie bardziej ściśliwe. Wyzwanie polega na znalezieniu pojedynczej ściśliwej struny. To bardzo różni się od automatycznego znajdowania układu w kilku bajtach.
Martin Ender
2
Ktoś musi rozwiązać to w złu.
RK.
3
@Holger Istnieje dobry powód, dla którego tego nie robimy: wtedy ludzie mogliby po prostu zakodować ciąg, pakując go w duże znaki Unicode, które mogą przechowywać informacje o wartości kilku bajtów w jednym znaku. Przykład.
Martin Ender

Odpowiedzi:

13

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
Mego
źródło
1
Technicznie wiele innych odpowiedzi mogło również korzystać z kodowania jednobajtowego, po prostu używając dowolnego kodowania jednobajtowego obsługiwanego przez ich język (jeśli taki istnieje), generując te same bajty, co twój i mówiąc „wynik jest kodowany CP437” , ale wygląda na to, że nikt tego nie zauważył. ¯ \ _ (ツ) _ / ¯
Martin Ender
21

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
AdmBorkBork
źródło
1
Dobra robota z chodzeniem tam i z powrotem na dole. :)
Martin Ender
11

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``
Dendrobium
źródło
8

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).

Neil
źródło
4

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
Maltysen
źródło
3

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.

Neil
źródło
Działa również w systemie Windows, niezależnie od tego, czy korzystasz z CP437 czy CP850.
Holger
@Holger Huh, myślę, że i tak powinienem był spróbować, tylko po to, aby zobaczyć!
Neil
3

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 .

Marco
źródło
1
+1 za wyjście
Erik the Outgolfer
Uwaga: połączony komentarz został usunięty. To OP powiedział, że twoja produkcja jest bardziej golfowa niż @TimmyD.
Erik the Outgolfer
3

/// , 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

Erik the Outgolfer
źródło
0

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!

Yytsi
źródło
2
Nie potrzebujesz tej a,części, co również usunie potrzebę jej wywołania z parametrem.
Mego
0

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

Erik the Outgolfer
źródło
0

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
Marco
źródło
0

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
sergiol
źródło