Учитывая заданное двоичное число, ваша задача состоит в том, чтобы создать «ветвь» этого числа с глубиной 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])

Попробуйте онлайн! Непечатные символы отображаются неправильно; формат строки такой же, как и у officialaimm , но с \x01for lи \x02for 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

Работает, используя базовый шаблон и добавляя пробелы и символы, где это необходимо.

Количество байтов увеличилось, потому что Орджан Йохансен понял, что сначала он не обрабатывает интервалы. Но проблема в том, что проблема решена.

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.

←⮌θ

Выведите ввод по правому краю в текущей позиции.

Ｆ²«

Цикл через ветви.

Ｊ³⁻×⁴ι²

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

θ

Распечатайте ввод.

Ｐ<²

Выведите правильную пару /и \.

Ｉι

Распечатать суффикс ветки.

↗

Перейти к первому листу.

Ｆ²«

Перебрать листья.

Ｐ⁺⁺θικ

Напечатайте ввод и суффикс ветви и листа.

↓↓

Перейти к следующему листу. Примечание. Если бы оставшиеся пробелы были приемлемыми, тогда был Ｆ²⁺⁺⁺θι궶бы сохранен байт.