神秘的编程语言Evil对字节值进行了有趣的操作，称之为“编织”。本质上是字节的八位的排列（因为模式是对称的，所以我们从哪一端开始计数并不重要）：

• 位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似乎是（垂直）最短的配置，因此这是最佳的。

感谢Martin 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中，将结果添加到管道中。然后，我们设置一个helper变量$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字节

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>

作为铃声，我立即将其识别为“ 普通狩猎专业”的前两行（请注意，链接的图像使用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 /八度，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的@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！

分割成 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窃取的图案