Cho một số nhị phân, nhiệm vụ của bạn là tạo một "nhánh" của số đó, với độ sâu là 2.

Ví dụ, được đưa ra 0làm đầu vào, bạn nên xuất chính xác điều này:

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

Điều này sẽ khá tự giải thích về cách các nhánh nên được tạo ra. Độ sâu 2 có nghĩa là chúng ta tính toán các nhánh cho số lượng dài hơn 2 số. Chúng tôi cũng tính toán các nhánh theo thứ tự, với các số 0 ở trên cùng và các nhánh ở phía dưới.

Nhiều trường hợp thử nghiệm:

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

Quy tắc

• Bạn sẽ không bao giờ nhận được các ký tự trong đầu vào khác 1và 0.
• 0 < length of input < 11.
• Trailing khoảng trắng cho phép ở cuối dòng.

Thạch , 39 38 byte

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

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

Làm sao?

Nghệ thuật được in là:

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

Trong trường hợp Nlà chuỗi đầu vào và Llà một chuỗi các không gian chiều dài của chuỗi đầu vào.

Như vậy nó bao gồm tám thành phần ( L, N, /, 0, kí tự xuống dòng, \, 1, và nhân vật không gian) và do đó có thể được lưu trữ như một số cơ sở-8 (có thể được nén dưới dạng một số cơ sở-250 trong Jelly). Nguyên ṃtử kết hợp chuyển đổi cơ sở và lập chỉ mục thành một danh sách (thực tế người ta có thể xác định các chữ số tùy ý sẽ được sử dụng).

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

Mẻ, 178 170 159 byte

@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

Chỉnh sửa: Đã lưu 11 byte nhờ @ ConorO'Brien.

JavaScript (ES6), 112 byte

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)

Bản giới thiệu

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 byte

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

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

• đã lưu 8 byte nhờ Jonathan ALLan (Sử dụng chức năng lambda)

Chuỗi định dạng khi được in trông như sau:

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

Điều này có vẻ tốt cho chuỗi có độ dài bằng 1. Tất cả những gì chúng ta phải làm là thay thế l bằng khoảng trắng có độ dài bằng g và dĩ nhiên, g sẽ được thay thế bằng chuỗi gốc

Python 3.6, 172 153 128 byte

Nghĩa đen không đơn giản hơn điều này ... Điều này thực sự ngắn hơn so với nỗ lực ban đầu của tôi trong việc tạo ra nó bằng một thuật toán. Buồn làm sao.

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 byte nhờ @Leo
-25 byte nhờ @ L3viathan

C, 170 168 byte

Cảm ơn @Neil vì đã lưu hai byte!

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);}

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

Python 3 , 96 byte

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

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

Hãy thử trực tuyến! Các ký tự không thể in không hiển thị chính xác; định dạng chuỗi là giống như của officialaimm , nhưng với \x01cho lvà \x02cho g.

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

Sử dụng thay thế chuỗi bằng tính linh hoạt của Python 3translate . Danh sách dịch [s,' '*len(s),s]bản đồ \x01đến ' '*len(s)và \x02đến s. Bất kỳ ký tự lớn hơn đều không thay đổi vì chúng đưa ra các chỉ số nằm ngoài giới hạn cho danh sách. \x00không thể được sử dụng vì byte rỗng được đọc dưới dạng kết thúc chương trình, vì vậy mục nhập đầu tiên bị lãng phí.

PHP , 128 byte

Chỉ một đầu ra đơn giản

<?=$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";

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

Xếp chồng lên nhau , 81 byte

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

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

Thật không thú vị, thật không may. Đây là phần thú vị nhất:

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

Về cơ bản, đây là nội suy chuỗi, nhưng ngắn hơn 10 byte so với nội dung.

/// , 116 byte

/[/\\\///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

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

Đầu vào như sau:

/[/\\\///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

Hoạt động bằng cách sử dụng một mẫu cơ bản, và thêm khoảng trắng và ký tự nếu cần.

Số lượng byte tăng lên vì Ørjan Johansen nhận ra rằng ban đầu nó không xử lý khoảng cách. Nhưng vấn đề là biết cố định.

Python 2 , 101,91 byte 113 byte

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

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

Đầu vào là một chuỗi 0 và 1 có độ dài 1 hoặc 2! Đó là 0,01,10 hoặc 11!

+12 byte - đã sửa khoảng cách trong \ cho độ dài hai đầu vào.

Than , 34 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｐ<³

In các cặp /s và \s bên trái .

←⮌θ

In đầu vào bên phải hợp lý tại vị trí hiện tại.

Ｆ²«

Vòng qua các nhánh.

Ｊ³⁻×⁴ι²

Di chuyển vị trí của chi nhánh. Chúng ta có thể làm điều này bởi vì gốc được in đúng, sao cho nhánh giữa luôn ở cùng một vị trí tuyệt đối.

θ

In đầu vào.

Ｐ<²

In đúng cặp /và\ .

Ｉι

In hậu tố nhánh.

↗

Di chuyển đến lá đầu tiên.

Ｆ²«

Vòng qua lá.

Ｐ⁺⁺θικ

In đầu vào và hậu tố nhánh và lá.

↓↓

Di chuyển đến lá tiếp theo. Lưu ý: Nếu khoảng trắng theo sau được chấp nhận thì Ｆ²⁺⁺⁺θι궶sẽ tiết kiệm được một byte.