Езотерична мова програмування зла має цікаву операцію над значеннями байтів, які вона називає "плетінням". По суті це перестановка восьми біт байта (не має значення, з якого кінця ми почнемо рахувати, оскільки шаблон є симетричним):

• Біт 0 переміщується в біт 2
• Біт 1 переміщено в біт 0
• Біт 2 переміщується в біт 4
• Біт 3 переміщений в біт 1
• Біт 4 переміщено в біт 6
• Біт 5 переміщується в біт 3
• Біт 6 переміщений в біт 7
• Біт 7 переміщений в біт 5

Для зручності ось два інших зображення перестановки. Як цикл:

(02467531)

І як список пар відображення:

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

Ваше завдання полягає в тому, щоб візуалізувати цю перестановку, використовуючи поле малювання символів ─, │, ┌, ┐, └, ┘,┼ (Unicode кодових точок: U +2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253С). Ця візуалізація повинна відповідати наступним обмеженням:

Перший і останній рядки:

0 1 2 3 4 5 6 7

Між ними ви можете використовувати стільки ліній, скільки вам потрібно, до 15 символів кожен, щоб відповідати вашим символам для малювання поля (вам знадобиться щонайменше 4 рядки). Рядки повинні починатися вертикально під однією з цифр першого ряду і закінчуватися вертикально над відповідною цифрою в останньому рядку. Вісім ліній повинні бути з'єднані і можуть перетинатися лише через ┼(який завжди є перетином, ніколи дві лінії повороту, які торкаються). Точні шляхи ліній залежать від вас (а пошук особливо грізного макета є основою цього завдання). Один дійсний вихід буде:

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

Однак будь-який інший макет, який правильно з'єднує правильні цифри, теж добре. Будь ласка, покажіть вибраний результат у своїй відповіді.

Ви можете написати програму або функцію, але не буде брати жодного вводу. Виведіть діаграму або в STDOUT (або найближчу альтернативу) або як функцію повернення значення у вигляді рядка або списку рядків (кожна представляє один рядок).

Діють стандартні правила гольф-коду , тому виграє найкоротший код (у байтах).

Власне, 69 байт

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

Спробуйте в Інтернеті! (вирівнювання трохи заплутане в онлайн-перекладачі)

Насправді тут є ВЕЛИЧЕЗНА перевага - усі символи малювання коробки знаходяться у CP437, тому вони є лише байтом. Хоча теоретично кожен необхідний символ може бути закодований у 4 біти (оскільки всього 9 унікальних символів), 31 байт, збережений стисканням рядка, буде втрачений через дуже погані можливості обробки рядків. Це також означає, що будь-яка конфігурація 8x4 призведе до однакової оцінки. Оскільки 8x4 виявляється (вертикально) найкоротшою можливою конфігурацією, це оптимально.

Дякую Мартіну за 3 байти!

Дякую TimmyD за ще 4 байти!

Пояснення:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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 bytes (81 chars)

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

I golfed the weaving further, eliminating the need for several variables by using inline code blocks. This is probably within a few bytes of optimal.

Почнемо з встановлення $aрівного діапазону, 0..7який з'єднаний з пробілами. Це тому, що за замовчуванням $ofs(роздільник поля вихідних даних) для масиву є пробіл, тому коли масив є строковим з ""+(з таким оператором, PowerShell намагатиметься неявно віддати праворучний об'єкт як лівий об’єкт), Результат - розділений пробіл діапазону.

Це інкапсульовано в паренах, що додає результат на трубопровід. Потім ми встановлюємо одну допоміжну змінну $b, а потім чотири рядки виведення з відповідною змінною на місці (розділити з буквальними новими рядками) та використовуючи вбудовані кодові блоки для повторних розділів, за якими $aзнову. Чотири лінії і $aтакож розміщуються на конвеєрі, а висновок неявний в кінці.

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 байт

Редагувати: Уооп, виявилось, що я використовував трубну |схему замість U + 2502 │в частині функції, оновлену кількість байтів.

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

Повертає рядок.

Вихід:

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

Додатково: Використовуючи метод @ TimmyD, у мене є ще 167-байтне рішення:

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

As a bell-ringer I immediately recognised this as the first two rows of Plain Hunt Major (note that the linked image uses 1-8 instead of 0-7).

Pyth - 119 104 100 81 bytes

Extremely simple. (Its actually bytes this time).

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

Try it online here.

I also stole @TimmyD's output:

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

MS-DOS Batch, 136 bytes

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

Using @TimmyD's output. This might work in Windows Batch too, but my code page there is CP850, not 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]

Output:

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

My code is based on the ouputs of @Dendrobium and @Neil.

///, 112 bytes (100 chars)

/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

Thanks @MartinEnder for -3 bytes!
Thanks @MartinEnder for -9 bytes!
Thanks @MartinEnder (OP) for pointing 15-char rule out

Uses @TimmyD's @Marco's output

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

Returns a string.

Thanks to @Mego for saving 2 bytes!

Credits of the character body go to @TimmyD !

Sprects, 99 bytes (87 chars)

$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

Uses @Marco's output (replace every 16th character with a newline (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'

Output:

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

Using @TimmyD's output: 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'

Output:

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"

Try it online!

outputs

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

SOGL V0.12, 64 bytes

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

Try it Here!

Pattern stolen from the powershell