Dato un numero binario, il tuo compito è creare un 'ramo' di quel numero, con una profondità di 2.

Ad esempio, dato 0come input, dovresti generare esattamente questo:

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

Questo dovrebbe essere abbastanza autoesplicativo su come dovrebbero essere creati i rami. Profondità 2 significa che calcoliamo le diramazioni per numeri fino a 2 numeri più lunghi. Calcoliamo anche i rami in ordine, con gli zeri in alto e quelli in basso.

Altri casi di test:

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

Regole

• Non riceverai mai caratteri nell'input diversi da 1e 0.
• 0 < length of input < 11.
• Spazio bianco finale consentito alla fine delle linee.

Gelatina , 39 38 byte

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

Provalo online!

Come?

L'arte da stampare è:

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

Dove si Ntrova la stringa di input ed Lè una stringa di spazi della lunghezza della stringa di input.

Come tale è costituito da otto componenti ( L, N, /, 0, il carattere di nuova riga, \, 1, e il carattere di spazio) e pertanto possono essere memorizzati come numero in base 8 (che può essere compresso come numero in base 250 in gelatina). L' ṃatomo combina la conversione di base e l'indicizzazione in un elenco (in effetti si possono definire cifre arbitrarie da utilizzare).

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

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

Modifica: salvato 11 byte grazie a @ 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)

dimostrazione

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)

Provalo online!

• salvato 8 byte grazie a JonathanAllan (Uso della funzione lambda)

La stringa di formato stampata appare come:

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

Questo sembra già buono per una stringa di lunghezza di 1. Tutto quello che dobbiamo fare è sostituire l con spazi di lunghezza pari a quello di g e, ovviamente, g deve essere sostituito dalla stringa originale

Python 3.6, 172 153 128 byte

Letteralmente non diventa più semplice di così ... Questo è in realtà più breve del mio tentativo originale di generarlo con un algoritmo. Che 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 byte grazie a @Leo
-25 byte grazie a @ L3viathan

C, 170 168 byte

Grazie a @Neil per aver salvato due 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);}

Provalo online!

Python 3 , 96 byte

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

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

Provalo online! I caratteri non stampabili non vengono visualizzati correttamente; il formato stringa è lo stesso di officialaimm , ma con \x01for le \x02for g.

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

Utilizza la sostituzione di stringhe con Python 3 flessibiletranslate . L'elenco di traduzioni è [s,' '*len(s),s]mappato \x01su ' '*len(s)e \x02su s. I caratteri più grandi restano invariati perché forniscono indici fuori limite per l'elenco. \x00non può essere utilizzato perché un byte null viene letto come fine del programma, quindi la prima voce viene sprecata.

PHP , 128 byte

Solo un semplice output

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

Provalo online!

Impilato , 81 byte

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

Provalo online!

Purtroppo non molto interessante. Ecco la parte più interessante:

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

Fondamentalmente si tratta di interpolazione di stringhe, ma 10 byte più brevi di quelli incorporati.

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

Provalo online!

L'input è il seguente:

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

Funziona utilizzando un modello di base e aggiungendo spazi e caratteri dove necessario.

Il conteggio dei byte è aumentato perché Ørjan Johansen ha capito che all'inizio non gestiva la spaziatura. Ma il problema è noto risolto.

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

Provalo online!

L'input è una stringa di 0 e 1 di lunghezza 1 o 2! Sono 0,01,10 o 11!

+12 byte - corretta la spaziatura in \ per input di lunghezza due.

Carbone , 34 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｐ<³

Stampa le coppie di sinistra di / s e \s.

←⮌θ

Stampa l'ingresso giustificato a destra nella posizione corrente.

Ｆ²«

Passa attraverso i rami.

Ｊ³⁻×⁴ι²

Sposta la posizione del ramo. Possiamo farlo perché la radice è stata stampata giustificata a destra in modo che il ramo centrale sia sempre nella stessa posizione assoluta.

θ

Stampa l'input.

Ｐ<²

Stampa la coppia giusta di /e \.

Ｉι

Stampa il suffisso del ramo.

↗

Passa alla prima foglia.

Ｆ²«

Passa attraverso le foglie.

Ｐ⁺⁺θικ

Stampa l'input e il suffisso di ramo e foglia.

↓↓

Passa alla foglia successiva. Nota: se lo spazio bianco finale fosse accettabile, Ｆ²⁺⁺⁺θι궶si risparmierebbe un byte.