Bei einer gegebenen Binärzahl besteht Ihre Aufgabe darin, eine Verzweigung dieser Zahl mit einer Tiefe von 2 zu erstellen.

Beispielsweise 0sollten Sie als Eingabe genau Folgendes ausgeben:

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

Dies sollte ziemlich selbsterklärend sein, wie die Zweige erstellt werden sollten. Tiefe 2 bedeutet, dass wir Zweige für Nummern mit einer Länge von bis zu 2 Nummern berechnen. Wir berechnen auch die Zweige in der Reihenfolge, mit Nullen oben und Einsen unten.

Weitere Testfälle:

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

Regeln

• Sie erhalten in der Eingabe niemals andere Zeichen als 1und 0.
• 0 < length of input < 11.
• Leerzeichen am Zeilenende dürfen nachgestellt werden.

Jelly , 39 38 Bytes

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

Probieren Sie es online!

Wie?

Die zu druckende Kunst ist:

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

Wo Nist die Eingabezeichenfolge und List eine Zeichenfolge von Leerzeichen der Länge der Eingabezeichenfolge.

Als solche ist sie von acht Komponenten besteht ( L, N, /, 0, die Zeilenende- Zeichen, \, 1, und das Leerzeichen) , und somit können als Basis-8 - Nummer gespeichert werden (was als Basis-250 - Nummer in Jelly komprimiert werden kann). Das ṃAtom kombiniert Basiskonvertierung und Indexierung in einer Liste (effektiv kann man beliebige zu verwendende Ziffern definieren).

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

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

Bearbeiten: 11 Bytes dank @ ConorO'Brien gespeichert.

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)

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)

Probieren Sie es online!

• 8 Bytes gespart dank JonathanAllan (Verwendung der Lambda-Funktion)

Die Formatzeichenfolge sieht beim Drucken folgendermaßen aus:

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

Dies sieht bereits für eine Zeichenfolge der Länge 1 gut aus. Wir müssen nur l durch Leerzeichen der Länge g ersetzen, und natürlich muss g durch die ursprüngliche Zeichenfolge ersetzt werden

Python 3.6, 172 153 128 Bytes

Einfacher geht es buchstäblich nicht ... Das ist eigentlich kürzer als mein ursprünglicher Versuch, es mit einem Algorithmus zu generieren. Wie traurig.

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 dank @Leo
-25 Bytes dank @ L3viathan

C 170 168 Bytes

Vielen Dank an @Neil für das Speichern von zwei 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);}

Probieren Sie es online!

Python 3 , 96 Bytes

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

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

Probieren Sie es online! Die nicht druckbaren Zeichen werden nicht korrekt angezeigt. Das Format der Zeichenkette ist dasselbe wie das von officialaimm , jedoch mit \x01for lund \x02for g.

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

Verwendet die Zeichenfolgensubstitution in Python 3's flexibletranslate . Die Liste übersetzen [s,' '*len(s),s]Karten \x01zu ' '*len(s)und\x02 zu s. Alle größeren Zeichen bleiben unverändert, da sie Indizes enthalten, die für die Liste außerhalb des zulässigen Bereichs liegen. \x00konnte nicht verwendet werden, da ein Null-Byte als Programmende gelesen wird und der erste Eintrag verschwendet wird.

PHP , 128 Bytes

Nur eine einfache Ausgabe

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

Probieren Sie es online!

Gestapelt , 81 Bytes

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

Probieren Sie es online!

Leider nicht sehr interessant. Hier ist der interessanteste Teil:

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

Dies ist im Grunde eine String-Interpolation, die jedoch 10 Byte kürzer ist als die eingebaute.

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

Probieren Sie es online!

Die Eingabe ist wie folgt:

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

Arbeitet mit einer einfachen Vorlage und fügt bei Bedarf Leerzeichen und Zeichen hinzu.

Die Byteanzahl stieg, weil Ørjan Johansen erkannte, dass der Abstand zunächst nicht verarbeitet wurde. Aber das Problem ist bekanntlich behoben.

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

Probieren Sie es online!

Die Eingabe ist eine Folge von Nullen und Einsen der Länge 1 oder 2! Das ist 0,01,10 oder 11!

+12 Bytes - korrigiert den Abstand in \ für die Eingabe der Länge zwei.

Kohle , 34 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｐ<³

Drucken Sie die linken Paare von /s und \s.

←⮌θ

Gibt die Eingabe rechtsbündig an der aktuellen Position aus.

Ｆ²«

Schlinge dich durch die Zweige.

Ｊ³⁻×⁴ι²

Verschieben Sie die Position des Zweigs. Wir können dies tun, weil die Wurzel rechtsbündig gedruckt wurde, so dass der mittlere Zweig immer an der gleichen absoluten Position ist.

θ

Die Eingabe drucken.

Ｐ<²

Drucken Sie das richtige Paar von /und aus\ .

Ｉι

Drucken Sie das Zweigsuffix.

↗

Gehe zum ersten Blatt.

Ｆ²«

Schlaufe durch die Blätter.

Ｐ⁺⁺θικ

Drucken Sie die Eingabe und das Suffix für Zweig und Blatt.

↓↓

Gehen Sie zum nächsten Blatt. Hinweis: Wenn abschließendes Leerzeichen zulässig ist Ｆ²⁺⁺⁺θι궶, wird ein Byte gespeichert.