Kejahatan bahasa pemrograman esoterik memiliki operasi yang menarik pada nilai byte yang disebutnya "tenun". Ini pada dasarnya adalah permutasi dari delapan bit byte (tidak masalah dari mana kita mulai menghitung, karena polanya simetris):

• Bit 0 dipindahkan ke bit 2
• Bit 1 dipindahkan ke bit 0
• Bit 2 dipindahkan ke bit 4
• Bit 3 dipindahkan ke bit 1
• Bit 4 dipindahkan ke bit 6
• Bit 5 dipindahkan ke bit 3
• Bit 6 dipindahkan ke bit 7
• Bit 7 dipindahkan ke bit 5

Untuk kenyamanan, berikut adalah dua representasi lain dari permutasi. Sebagai sebuah siklus:

(02467531)

Dan sebagai daftar pasangan pemetaan:

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

Tugas Anda adalah untuk memvisualisasikan permutasi ini, menggunakan karakter kotak-gambar ─, │, ┌, ┐, └, ┘, ┼(kode Unicode poin: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Visualisasi ini harus memenuhi batasan-batasan berikut:

Baris pertama dan terakhir persis:

0 1 2 3 4 5 6 7

Di antara itu, Anda dapat menggunakan sebanyak mungkin garis yang Anda inginkan masing-masing hingga 15 karakter agar sesuai dengan karakter menggambar kotak Anda (Anda membutuhkan setidaknya 4 baris). Garis harus mulai secara vertikal di bawah salah satu digit di baris pertama dan berakhir secara vertikal di atas angka yang sesuai di baris terakhir. Delapan garis harus terhubung, dan hanya dapat melewati ┼(yang selalu merupakan persimpangan, tidak pernah dua garis yang saling bersentuhan). Jalur yang tepat dari garis-garis itu terserah Anda (dan menemukan tata letak khusus golf adalah inti dari tantangan ini). Satu output yang valid adalah:

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

Namun, tata letak lain yang menghubungkan dengan benar digit yang tepat juga baik. Tolong tunjukkan hasil pilihan Anda dalam jawaban Anda.

Anda dapat menulis suatu program atau fungsi dan tidak akan mengambil input apa pun. Keluarkan diagram baik ke STDOUT (atau alternatif terdekat) atau sebagai nilai pengembalian fungsi dalam bentuk string atau daftar string (masing-masing mewakili satu baris).

Standar kode-golf aturan berlaku, sehingga kode terpendek (dalam bytes) menang.

Sebenarnya, 69 byte

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

Cobalah online! (perataan sedikit kacau di penerjemah online)

Sebenarnya memiliki keunggulan BESAR di sini - semua karakter menggambar kotak berada di CP437, jadi masing-masing hanya satu byte Meskipun setiap karakter yang diperlukan secara teoritis dapat dikodekan dalam 4 bit (karena hanya ada 9 karakter unik), 31 byte yang disimpan dengan mengompresi string akan hilang karena kemampuan pemrosesan string yang sangat buruk. Ini juga berarti bahwa konfigurasi 8x4 akan menghasilkan skor yang sama. Karena 8x4 tampaknya merupakan konfigurasi (vertikal) terpendek yang mungkin, ini optimal.

Terima kasih untuk Martin selama 3 byte!

Terima kasih kepada TimmyD untuk 4 byte lagi!

Penjelasan:

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

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

Saya bermain golf lebih jauh, menghilangkan kebutuhan untuk beberapa variabel dengan menggunakan blok kode inline. Ini mungkin dalam beberapa byte optimal.

Kami mulai dengan menyetel $asama dengan rentang 0..7yang telah digabungkan dengan spasi. Ini karena default $ofs(Output Field Separator) untuk sebuah array adalah spasi, jadi ketika array tersebut dikompilasi dengan ""+(dengan operator seperti ini, PowerShell akan mencoba untuk secara implisit melemparkan objek kanan sebagai objek kiri), hasilnya adalah rentang yang dipisahkan ruang.

Itu diringkas dalam parens, yang menambahkan hasilnya ke dalam pipa. Kami kemudian menyiapkan satu variabel pembantu $b, diikuti oleh empat baris output dengan variabel yang sesuai di tempat (dipisah dengan baris baru literal), dan menggunakan blok kode sebaris untuk bagian berulang, diikuti oleh $alagi. Keempat garis dan $ajuga ditempatkan pada pipa, dan output tersirat di akhir.

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

Sunting: Whoops, ternyata saya menggunakan pipa |char bukan U + 2502 │di bagian fungsi, diperbarui jumlah byte.

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

Mengembalikan string.

Keluaran:

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

Ekstra: Menggunakan metode @ TimmyD, saya punya solusi 167 byte lainnya:

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

Sebagai bell-ringer, saya segera mengenali ini sebagai dua baris pertama dari Plain Hunt Major (perhatikan bahwa gambar yang ditautkan menggunakan 1-8 bukannya 0-7).

Pyth - 119 104 100 81 byte

Sangat sederhana. (Ini sebenarnya byte saat ini).

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

Cobalah online di sini .

Saya juga mencuri output @ TimmyD:

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

MS-DOS Batch, 136 byte

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

Menggunakan output @ TimmyD. Ini mungkin bekerja di Windows Batch juga, tetapi halaman kode saya ada CP850, bukan CP437.

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

Keluaran:

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

Kode saya didasarkan pada ouputs dari @Dendrobium dan @ Neil .

/// , 112 byte (100 karakter)

/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

Terima kasih @MartinEnder untuk -3 byte!
Terima kasih @MartinEnder untuk -9 byte!
Terima kasih @MartinEnder (OP) untuk menunjukkan aturan 15-char

Menggunakan output @ TimmyD @ 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

Mengembalikan string.

Terima kasih kepada @Mego karena telah menghemat 2 byte!

Penghargaan badan karakter diberikan ke @TimmyD!

Sprects , 99 byte (87 karakter)

$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

Menggunakan output @ Marco (ganti setiap karakter ke-16 dengan baris baru (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'

Keluaran:

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

Menggunakan output @ 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'

Keluaran:

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"

Cobalah online!

output

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

SOGL V0.12 , 64 byte

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

Coba Di Sini!

Pola dicuri dari PowerShell