Враховуючи двійкове число, ваше завдання - створити "гілку" цього числа, глибина якої становить 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

Де Nвводиться рядок і Lє рядок пробілів довжини вхідного рядка.

Як такий , він складається з восьми компонентів ( 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

Редагувати: Збережено 11 байт завдяки @ ConorO'Brien

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)

Спробуйте в Інтернеті!

• збережено 8 байт завдяки JonathanAllan (Використання лямбда-функції)

Рядок формату при друку виглядає так:

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

Це добре виглядає вже для рядка довжиною 1. Все, що нам потрібно зробити, - це замінити l пробілами довжини, рівними довжині g, і, звичайно, g слід замінити на початковий рядок

Python 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])

Спробуйте в Інтернеті! Недруковані символи відображаються неправильно; формат рядка такий самий, як у офісаалімм , але з \x01для lі \x02для g.

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

Використовує підстановку рядків гнучким Python 3translate . Переклади списку [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

Працює з використанням основного шаблону та додавання пробілів та символів, де потрібно.

Кількість байтів збільшилася, тому що Ørjan Johansen зрозумів, що спочатку він не справляється з інтервалом. Але проблема відома виправлена.

Python 2 , 101,91 байт 113 байт

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

Спробуйте в Інтернеті!

Введення - це рядок 0 і 1 довжиною 1 або 2! Це 0,01,10 або 11!

+12 байт - виправлено інтервал у \ на довжину двох входів.

Вугілля деревне , 34 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

Ｐ<³

Роздрукуйте ліві пари /s і \s.

←⮌θ

Роздрукуйте правильне введення в поточному положенні.

Ｆ²«

Петля через гілки.

Ｊ³⁻×⁴ι²

Перемістіть положення гілки. Ми можемо це зробити, тому що корінь був надрукований правильно-виправдано, щоб середня гілка завжди була в одному абсолютному положенні.

θ

Роздрукуйте вхід.

Ｐ<²

Роздрукуйте праву пару /і\ .

Ｉι

Роздрукуйте суфікс гілки.

↗

Перемістіть до першого листочка.

Ｆ²«

Провести петлю через листя.

Ｐ⁺⁺θικ

Роздрукуйте введення та суфікс гілки та аркуша.

↓↓

Перехід до наступного листка. Примітка: Якщо пробіл пробілів був прийнятним, тоді Ｆ²⁺⁺⁺θι궶збережеться байт.