Dado un número binario, su tarea es crear una 'rama' de ese número, con una profundidad de 2.

Por ejemplo, dado 0como entrada, debe generar exactamente esto:

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

Esto debería explicarse por sí mismo de cómo se deben crear las ramas. La profundidad 2 significa que calculamos ramas para números de hasta 2 números más largos. También calculamos las ramas en orden, con ceros en la parte superior y unos en la parte inferior.

Más casos de prueba:

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

Reglas

• Nunca recibirá caracteres en la entrada que no sean 1y 0.
• 0 < length of input < 11.
• Se permiten espacios en blanco al final de las líneas.

Jalea , 39 38 bytes

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

Pruébalo en línea!

¿Cómo?

El arte a imprimir es:

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

Donde Nestá la cadena de entrada y Les una cadena de espacios de la longitud de la cadena de entrada.

Como tal, se compone de ocho componentes ( L, N, /, 0, el carácter de nueva línea, \, 1, y el carácter de espacio) y por lo tanto pueden ser almacenados como un número de base-8 (que puede ser comprimido como un número de base 250 en Jelly). El ṃátomo combina la conversión de base y la indexación en una lista (efectivamente, uno puede definir dígitos arbitrarios para ser utilizados).

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

Lotes, 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: Guardado 11 bytes gracias 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)

Manifestació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 , 117109 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)

Pruébalo en línea!

• guardado 8 bytes gracias a JonathanAllan (Uso de la función lambda)

La cadena de formato cuando se imprime se ve así:

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

Esto ya se ve bien para una cadena de longitud 1. Todo lo que tenemos que hacer es reemplazar l por espacios de longitud igual a la de gy, por supuesto, g debe ser reemplazada por la cadena original

Python 3.6, 172 153 128 bytes

Literalmente no se vuelve más directo que esto ... Esto es en realidad más corto que mi intento original de generarlo con un algoritmo. Qué 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 gracias a @Leo
-25 bytes gracias a @ L3viathan

C, 170 168 bytes

¡Gracias a @Neil por guardar dos 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);}

Pruébalo en línea!

Python 3 , 96 bytes

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

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

Pruébalo en línea! Los caracteres no imprimibles no se muestran correctamente; el formato de cadena es el mismo que el de officialaimm , pero con \x01for ly \x02for g.

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

Utiliza la sustitución de cadenas con Python 3's flexibletranslate . La lista de traducción se [s,' '*len(s),s]asigna \x01a ' '*len(s)y \x02para s. Los caracteres más grandes no cambian porque dan índices que están fuera de los límites de la lista. \x00no se pudo utilizar porque se lee un byte nulo como final del programa, por lo que se desperdicia la primera entrada.

PHP , 128 bytes

Solo una salida simple

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

Pruébalo en línea!

Apilado , 81 bytes

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

Pruébalo en línea!

No muy interesante, desafortunadamente. Aquí está la parte más interesante:

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

Esto es básicamente una interpolación de cadenas, pero 10 bytes más corto que el incorporado.

/// , 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

Pruébalo en línea!

La entrada es la siguiente:

/[/\\\///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 utilizando una plantilla básica y agregando espacios y caracteres donde sea necesario.

El recuento de bytes aumentó porque Ørjan Johansen se dio cuenta de que al principio no manejaba el espacio. Pero el problema es saber arreglado.

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

Pruébalo en línea!

¡La entrada es una cadena de 0 y 1 de longitud 1 o 2! ¡Eso es 0,01,10 u 11!

+12 bytes: se corrigió el espaciado en \ para la entrada de longitud dos.

Carbón , 34 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｐ<³

Imprime los pares izquierdos de / sy \s.

←⮌θ

Imprima la entrada justificada a la derecha en la posición actual.

Ｆ²«

Recorre las ramas.

Ｊ³⁻×⁴ι²

Mueve la posición de la rama. Podemos hacer esto porque la raíz se imprimió justificada a la derecha para que la rama central esté siempre en la misma posición absoluta.

θ

Imprime la entrada.

Ｐ<²

Imprima el par correcto de /y \.

Ｉι

Imprime el sufijo de la rama.

↗

Moverse a la primera hoja.

Ｆ²«

Recorre las hojas.

Ｐ⁺⁺θικ

Imprima la entrada y el sufijo de rama y hoja.

↓↓

Pasar a la siguiente hoja. Nota: Si el espacio en blanco al final fuera aceptable, Ｆ²⁺⁺⁺θι궶se ahorraría un byte.