Dado um número binário, sua tarefa é criar um 'ramo' desse número, com uma profundidade de 2.

Por exemplo, dado 0como entrada, você deve gerar exatamente isso:

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

Isso deve ser bastante autoexplicativo de como os ramos devem ser criados. A profundidade 2 significa que calculamos ramificações para números de até 2 números mais longos. Também calculamos as ramificações em ordem, com zeros na parte superior e outros na parte inferior.

Mais casos de teste:

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

Regras

• Você nunca receberá caracteres na entrada que não sejam 1e 0.
• 0 < length of input < 11.
• Espaço em branco à direita permitido no final das linhas.

Geléia , 39 38 bytes

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

Experimente online!

Quão?

A arte a ser impressa é:

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

Onde Né a sequência de entrada e Lé uma sequência de espaços do comprimento da sequência de entrada.

Como tal, ele é constituído de oito componentes ( L, N, /, 0, o carácter de nova linha, \, 1, e o carácter de espaço) e, portanto, pode ser armazenada como um número de base-8 (que pode ser comprimida como um número de base-250 em geléia). O ṃátomo combina a conversão básica e a indexação em uma lista (efetivamente é possível definir dígitos arbitrários a serem usados).

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

Lote, 178 170 159 bytes

@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

Editar: salvou 11 bytes graças a @ ConorO'Brien.

JavaScript (ES6), 112 bytes

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)

Demo

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 bytes

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

Experimente online!

• economizou 8 bytes graças a JonathanAllan (uso da função lambda)

A cadeia de formato quando impressa é semelhante a:

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

Isso já parece bom para uma sequência de comprimento igual a 1. Tudo o que precisamos fazer é substituir l por espaços de comprimento igual ao de ge e, é claro, g deve ser substituído pela sequência original

Python 3.6, 172 153 128 bytes

Literalmente, não é mais direto do que isso ... Isso é realmente mais curto do que minha tentativa original de gerá-lo com um algoritmo. Que triste.

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 bytes graças a @Leo
-25 bytes graças a @ L3viathan

C, 170 168 bytes

Obrigado a @Neil por salvar dois bytes!

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

Experimente online!

Python 3 , 96 bytes

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

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

Experimente online! Os caracteres não imprimíveis não são exibidos corretamente; o formato da string é o mesmo que o officialaimm , mas com \x01for le \x02for g.

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

Usa substituição de string com o Python 3 flexíveltranslate . A lista de conversão é [s,' '*len(s),s]mapeada \x01para ' '*len(s)e \x02para s. Quaisquer caracteres maiores permanecem inalterados porque fornecem índices fora dos limites da lista. \x00não pôde ser usado porque um byte nulo é lido como final do programa; portanto, a primeira entrada é desperdiçada.

PHP , 128 bytes

Apenas uma saída simples

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

Experimente online!

Empilhados , 81 bytes

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

Experimente online!

Infelizmente não é muito interessante. Aqui está a parte mais interessante:

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

Isso é basicamente interpolação de strings, mas 10 bytes mais curto que o embutido.

/// , 116 bytes

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

Experimente online!

A entrada é a seguinte:

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

Funciona usando um modelo básico e adicionando espaços e caracteres quando necessário.

A contagem de bytes aumentou porque Ørjan Johansen percebeu que não lidava com espaçamento no início. Mas o problema é saber corrigido.

Python 2 , 101,91 bytes 113 bytes

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

Experimente online!

Entrada é uma sequência de 0 e 1 de comprimento 1 ou 2! Isso é 0,01,10 ou 11!

+12 bytes - corrigido o espaçamento em \ para o comprimento de duas entradas.

Carvão , 34 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｐ<³

Imprima os pares esquerdos de /s e \s.

←⮌θ

Imprima a entrada justificada à direita na posição atual.

Ｆ²«

Faça um loop pelos galhos.

Ｊ³⁻×⁴ι²

Mova a posição da ramificação. Podemos fazer isso porque a raiz foi impressa justificada à direita para que o ramo do meio esteja sempre na mesma posição absoluta.

θ

Imprima a entrada.

Ｐ<²

Imprima o par certo de /e \.

Ｉι

Imprima o sufixo da ramificação.

↗

Vá para a primeira folha.

Ｆ²«

Laço através das folhas.

Ｐ⁺⁺θικ

Imprima a entrada e o sufixo de ramificação e folha.

↓↓

Vá para a próxima folha. Nota: Se o espaço em branco à direita fosse aceitável, Ｆ²⁺⁺⁺θι궶ele salvaria um byte.