给定一个二进制数字，您的任务是创建一个深度为2的该数字的“分支”。

例如，0作为输入，您应该完全输出以下内容：

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

这应该是分支机构如何创建的完全自我解释。深度2表示我们计算最多2个数字的分支。我们还按顺序计算分支，顶部为零，底部为零。

更多测试用例：

0

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

1

     /100
  /10
 /   \101
1
 \   /110
  \11
     \111

00

       /0000
   /000
  /    \0001
00
  \    /0010
   \001
       \0011

01

       /0100
   /010
  /    \0101
01
  \    /0110
   \011
       \0111

10

       /1000
   /100
  /    \1001
10
  \    /1010
   \101
       \1011

11

       /1100
   /110
  /    \1101
11
  \    /1110
   \111
       \1111

规则

• 除了1和之外，您将永远不会在输入中收到任何字符0。
• 0 < length of input < 11。
• 行尾允许尾随空格。

果冻，39 38 字节

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’

在线尝试！

怎么样？

要印刷的艺术品是：

L  L /N00
L /N0
L/ L \N01
N
L\ L /N10
L \N1
L  L \N11

where N是输入字符串，L是输入字符串长度的空格。

因此，它是由8种成分（L，N，/，0，换行符，\，1，和空格字符），因此可以被存储作为基-8号（其可被压缩为在果冻碱-250号）。的ṃ（要使用的有效地一个可以限定任意位数）原子联合收割机基转换和索引到一个列表中。

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - Main link: binary string s  e.g. "100"
 ⁶                                     - space character
  ẋ                                    - repeat by:
L                                      -     length(s)                    [' ',' ',' ']
    W                                  - wrap s in a list                 [['1','0','0']]
   ,                                   - pair               [[' ',' ',' '],['1','0','0']]
      “/0¶\1 ”                         - char list: ['/','0',<newline>,'\',','1',' ']

     ;                                 - concatenate        [[' ',' ',' '],['1','0','0'],'/','0',<newline>,'\',','1',' ']
                “ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - base 250 number: 91531517467460683226372755994113932025707662527
              ṃ@                       - base decompression [reversed @arguments]
                                        -     this uses the concatenated list above as
                                        -     the 8 digits of that number in base 8.
                                        - implicit print

分批，178个 170 159字节

@set/pb=
@set s=%b:0= %
@set s=%s:1= %
@set e=@echo %s%
%e%  %s% /%b%00
%e% /%b%0
%e%/ %s% \%b%01
@echo %b%
%e%\ %s% /%b%10
%e% \%b%1
%e%  %s% \%b%11

编辑：由于@ ConorO'Brien，节省了11个字节。

JavaScript（ES6），112字节

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

演示版

let f =

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

console.log(f('0'))
console.log(f('11'))
console.log(f('101'))

Python 3中，117个 109字节

lambda k:'ll   /g00\nl /g0\nl/l  \g01\ng\nl\l  /g10\nl \g1\nll   \g11'.replace('l',' '*len(k)).replace('g',k)

在线尝试！

• 由于JonathanAllan节省了8个字节（使用lambda函数）

打印时的格式字符串如下所示：

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

对于长度为1的字符串，这看起来已经不错了，我们所要做的就是用等于g的长度的空格替换l，当然，用原始字符串替换g。

蟒3.6，172个 153 128字节

从字面上看，没有比这更直接的方法了……实际上，这比我最初用算法生成它的尝试要短。多么悲伤。

k=input()
l=len(k)
b=' '*l
print(f'{b*2}   /{k}00\n{b} /{k}0\n{b}/ {b}\\{k}01\n{k}\n{b}\\ {b}/{k}10\n{b} \\{k}1\n{b*2} \\{k}01')

-19个字节感谢@Leo
-25个字节感谢@ L3viathan

C，170个 168字节

感谢@Neil节省了两个字节！

n;f(char*s){n=strlen(s);printf("%*c%s00\n%*c%s0\n %*c%*c%s01\n%s\n %*c%*c%s10\n%*c%s1\n%*c%s11",2*n+4,47,s,n+2,47,s,n,47,n+3,92,s,s,n,92,n+3,47,s,n+2,92,s,2*n+4,92,s);}

在线尝试！

Python 3，96字节

lambda s:"""   /00
 /0
/  \01

\  /10
 \1
   \11""".translate([s,' '*len(s),s])

在线尝试！无法打印的字符无法正确显示；字符串格式与Officialaimm相同，但使用\x01for l和\x02for g。

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

在Python 3的flexible中translate使用字符串替换。该转换表[s,' '*len(s),s]映射\x01到' '*len(s)和\x02到s。任何较大的字符都不会更改，因为它们给出的索引超出了列表的范围。\x00由于无法读取空字节作为程序结尾，因此无法使用，因此浪费了第一个条目。

PHP，128字节

只有一个简单的输出

<?=$b=str_pad("",strlen($a=$argn)),"$b   /{$a}00\n$b /{$a}0\n$b/$b  \\{$a}01\n$a\n$b\\$b  /{$a}10\n$b \\{$a}1\n$b$b   \\{$a}11";

在线尝试！

堆叠式，81位元组

{!n#'' '*@s's  s /n00
s /n0
s/ s \n01
n
s\ s /n10
s \n1
s  s \n11' '\l'$#~1/repl}

在线尝试！

不幸的是，它不是很有趣。这是最有趣的部分：

'\l'$#~1/repl
         repl     replace all
'\l'              letters
    $#~           by evaluating
       1/         over one argument (otherwise, it would evaluate the "last" thingy)

这基本上是字符串内插，但是比内置的短10个字节。

///，116字节

/[/\\\///x///*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

在线尝试！

输入如下：

/[/\\\///x/INPUT HERE!!!!!!!!//*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

通过使用基本模板并在需要的地方添加空格和字符来工作。

字节数增加了，因为ØrjanJohansen意识到起初它不处理间距。但是问题是已知的。

Python 2，101,91字节 113个字节

lambda y:'   ++/_00\n +/_0\n+/  +\\_01\n_\n+\\  +/_10\n +\\_1\n   ++\\_11'.replace('_',y).replace('+',' '*len(y))

在线尝试！

输入是长度为1或2的0和1的字符串！那是0,01,10或11！

+12个字节-纠正了两个输入长度\中的间距。

木炭，34字节

Ｐ<³←⮌θＦ²«Ｊ³⁻×⁴ι²θＰ<²Ｉι↗Ｆ²«Ｐ⁺⁺θικ↓↓

在线尝试！链接是详细版本的代码。说明：

Ｐ<³

打印左对/s和\s。

←⮌θ

在当前位置右对齐打印输入。

Ｆ²«

遍历分支。

Ｊ³⁻×⁴ι²

移动分支的位置。我们之所以这样做，是因为根是右对齐打印的，因此中间分支始终位于相同的绝对位置。

θ

打印输入。

Ｐ<²

打印正确的一对/和\。

Ｉι

打印分支后缀。

↗

移到第一片叶子。

Ｆ²«

循环树叶。

Ｐ⁺⁺θικ

打印输入以及分支和叶子后缀。

↓↓

移至下一页。注意：如果可接受尾随空格，Ｆ²⁺⁺⁺θι궶则将节省一个字节。