Cái ác ngôn ngữ lập trình bí truyền có một hoạt động thú vị trên các giá trị byte mà nó gọi là "dệt". Nó thực chất là một hoán vị của tám bit của byte (không quan trọng chúng ta bắt đầu đếm từ đâu, vì mẫu này là đối xứng):

• Bit 0 được chuyển sang bit 2
• Bit 1 được chuyển sang bit 0
• Bit 2 được chuyển sang bit 4
• Bit 3 được chuyển sang bit 1
• Bit 4 được chuyển sang bit 6
• Bit 5 được chuyển sang bit 3
• Bit 6 được chuyển sang bit 7
• Bit 7 được chuyển sang bit 5

Để thuận tiện, đây là hai đại diện khác của hoán vị. Như một chu kỳ:

(02467531)

Và như một danh sách các cặp ánh xạ:

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

Nhiệm vụ của bạn là để hình dung hoán vị này, sử dụng các nhân vật hộp vẽ ─, │, ┌, ┐, └, ┘, ┼(Unicode code points: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Hình dung này phải đáp ứng các ràng buộc sau:

Dòng đầu tiên và cuối cùng là chính xác:

0 1 2 3 4 5 6 7

Giữa các dòng đó, bạn có thể sử dụng bao nhiêu dòng tùy thích tối đa 15 ký tự cho mỗi ký tự vẽ hộp của bạn (bạn sẽ cần ít nhất 4 dòng). Các dòng nên bắt đầu theo chiều dọc bên dưới một trong các chữ số trên hàng đầu tiên và kết thúc theo chiều dọc trên chữ số tương ứng trên hàng cuối cùng. Tám đường phải được kết nối và chỉ có thể đi qua ┼(luôn luôn là đường giao nhau, không bao giờ có hai đường rẽ chạm nhau). Các đường chính xác của các dòng là tùy thuộc vào bạn (và tìm một bố cục đặc biệt có thể chơi được là cốt lõi của thử thách này). Một đầu ra hợp lệ sẽ là:

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

Tuy nhiên, bất kỳ bố cục nào khác kết nối chính xác các chữ số bên phải cũng tốt. Vui lòng hiển thị đầu ra bạn đã chọn trong câu trả lời của bạn.

Bạn có thể viết một chương trình hoặc chức năng và sẽ không nhận bất kỳ đầu vào nào. Xuất sơ đồ sang STDOUT (hoặc thay thế gần nhất) hoặc dưới dạng giá trị trả về hàm dưới dạng chuỗi hoặc danh sách các chuỗi (mỗi chuỗi đại diện cho một dòng).

Quy tắc golf tiêu chuẩn áp dụng, vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng.

Trên thực tế, 69 byte

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

Hãy thử trực tuyến! (căn chỉnh là một chút sai lầm trong trình thông dịch trực tuyến)

Trên thực tế có một HUGE lợi thế ở đây - tất cả các hộp vẽ nhân vật trong CP437, vì vậy họ chỉ có một byte mỗi. Mặc dù về lý thuyết, mỗi ký tự có thể được mã hóa thành 4 bit (vì chỉ có 9 ký tự duy nhất), 31 byte được lưu bằng cách nén chuỗi sẽ bị mất do khả năng xử lý chuỗi rất kém. Điều này cũng có nghĩa là bất kỳ cấu hình 8x4 nào cũng sẽ có cùng số điểm. Vì 8x4 dường như là cấu hình ngắn nhất (theo chiều dọc) có thể, nên điều này là tối ưu.

Cảm ơn Martin cho 3 byte!

Cảm ơn TimmyD cho thêm 4 byte!

Giải trình:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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 ký tự)

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

Tôi đã đánh gôn việc dệt thêm, loại bỏ sự cần thiết của một số biến bằng cách sử dụng các khối mã nội tuyến. Điều này có lẽ là trong một vài byte tối ưu.

Chúng tôi bắt đầu bằng cách đặt $abằng với phạm vi 0..7được nối cùng với khoảng trắng. Điều này là do mặc định $ofs(Dấu tách trường đầu ra) cho một mảng là một khoảng trắng, vì vậy khi mảng được xâu ""+chuỗi (với một toán tử như thế này, PowerShell sẽ cố gắng truyền đối tượng bên phải làm đối tượng bên trái), kết quả là phạm vi phân tách không gian.

Điều đó được gói gọn trong các parens, trong đó thêm kết quả vào đường ống. Sau đó, chúng tôi thiết lập một biến trợ giúp $b, theo sau là bốn dòng đầu ra với biến thích hợp được đặt (chia theo dòng mới bằng chữ) và sử dụng các khối mã nội tuyến cho các phần lặp lại, tiếp theo là $amột lần nữa. Bốn dòng và $acũng được đặt trên đường ống, và đầu ra được ẩn ở cuối.

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

Chỉnh sửa: Rất tiếc, hóa ra tôi đang sử dụng ống |char thay vì U + 2502 │trong một phần của chức năng, số byte được cập nhật.

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

Trả về một chuỗi.

Đầu ra:

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

Bổ sung: Sử dụng phương pháp của @ TimmyD, tôi có một giải pháp khác là 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>

Là người rung chuông, tôi ngay lập tức nhận ra đây là hai hàng đầu tiên của Plain Hunt Major (lưu ý rằng hình ảnh được liên kết sử dụng 1-8 thay vì 0-7).

Pyth - 119 104 100 81 byte

Vô cùng đơn giản. (Lần này thực sự là byte).

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

Dùng thử trực tuyến tại đây .

Tôi cũng đã đánh cắp đầu ra của @ 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

Sử dụng đầu ra của @ TimmyD. Điều này cũng có thể hoạt động trong Windows Batch, nhưng trang mã của tôi có CP850, không phải 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]

Đầu ra:

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

Mã của tôi dựa trên các thông số của @Dendrobium và @Neil .

/// , 112 byte (100 ký tự)

/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

Cảm ơn @MartinEnder cho -3 byte!
Cảm ơn @MartinEnder cho -9 byte!
Cảm ơn @MartinEnder (OP) đã chỉ ra quy tắc 15 char

Sử dụng @ TimmyD's @ Marco's output

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

Trả về một chuỗi.

Cảm ơn @Mego đã lưu 2 byte!

Tín dụng của cơ thể nhân vật đi đến @TimmyD!

Sprects , 99 byte (87 ký tự)

$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

Sử dụng đầu ra của @ Marco (thay thế mỗi ký tự thứ 16 bằng một dòng mới (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'

Đầu ra:

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

Sử dụng đầu ra của @ 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'

Đầu ra:

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"

Hãy thử trực tuyến!

đầu ra

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

SOGL V0.12 , 64 byte

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

Hãy thử nó ở đây!

Mô hình bị đánh cắp từ quyền hạn