У эзотерического языка программирования зло есть интересная операция над байтовыми значениями, которую он называет «переплетением». По сути, это перестановка восьми битов байта (не имеет значения, с какого конца мы начинаем считать, поскольку шаблон симметричен):

• Бит 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 + 253c). Эта визуализация должна удовлетворять следующим ограничениям:

Первая и последняя строка точно:

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 байта (81 символ)

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

Я продолжил плетение, исключив необходимость использования нескольких переменных с помощью встроенных блоков кода. Это, вероятно, в пределах нескольких байтов от оптимального.

Мы начинаем с установки $aравного диапазону, 0..7который был объединен с пробелами. Это связано с тем, что по умолчанию $ofs(Разделитель выходных полей) для массива является пробелом, поэтому, когда массив структурируется с помощью ""+(с таким оператором, PowerShell попытается неявно привести правый объект в качестве объекта левой руки), результат - диапазон, разделенный пробелом.

Это заключено в parens, что добавляет результат в конвейер. Затем мы устанавливаем одну вспомогательную переменную $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 байт

Редактировать: Ой, оказалось, что я использовал трубу |char вместо 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 байта

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>

Как звонарь, я сразу узнал это как первые два ряда Plain Hunt Major (обратите внимание, что в связанном изображении используется 1-8 вместо 0-7).

Pyth - 119 104 100 81 байт

Очень просто. (На самом деле это байты на этот раз).

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

Попробуйте это онлайн здесь .

Я также украл вывод @ TimmyD:

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

Пакет MS-DOS, 136 байт

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

Используя вывод @ TimmyD. Это может работать и в Windows Batch, но моя кодовая страница есть CP850, а не CP437.

MATLAB / Octave, 112 109 байт

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]

Выход:

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

Мой код основан на выходах @Dendrobium и @Neil .

/// , 112 байт (100 символов)

/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

Спасибо @MartinEnder за -3 байта!
Спасибо @MartinEnder за -9 байт!
Спасибо @MartinEnder (OP) за указание на правило 15 символов

Использует вывод @ TimmyD's @ Marco

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

Python3, 209 байт

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

Возвращает строку.

Спасибо @Mego за сохранение 2 байта!

Кредиты тела персонажа идут на @TimmyD!

Sprects , 99 байтов (87 символов)

$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

Использует вывод @ Marco (замените каждый 16-й символ новой строкой (регулярное выражение: (.{15}).-> \1\n)).

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

Bash + GNU sed, 140 байт

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'

Выход:

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

Используя вывод @ TimmyD : 142 байта

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'

Выход:

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

Tcl , 205 байт

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

Попробуйте онлайн!

выходы

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

SOGL V0.12 , 64 байта

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

Попробуй здесь!

Узор, украденный из PowerShell