Biorąc pod uwagę liczbę binarną, Twoim zadaniem jest utworzenie „gałęzi” tej liczby o głębokości 2.

Na przykład podany 0jako dane wejściowe powinieneś wypisać dokładnie to:

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

Powinno to wyjaśniać, w jaki sposób należy tworzyć oddziały. Głębokość 2 oznacza, że ​​obliczamy gałęzie dla liczb do 2 liczb dłuższych. Gałęzie obliczamy również w kolejności, z zerami na górze i zerami na dole.

Więcej przypadków testowych:

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

Zasady

• Nigdy nie otrzymasz znaków na wejściu innych niż 1i 0.
• 0 < length of input < 11.
• Końcowe białe znaki dozwolone na końcu linii.

Galaretka , 39 38 bajtów

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

Wypróbuj online!

W jaki sposób?

Sztuka do wydrukowania to:

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

Gdzie Njest ciąg wejściowy i Ljest ciągiem spacji o długości wejściowego ciągu.

Jako takie składa się z ośmiu elementów ( L, N, /, 0, znak nowej linii, \, 1, a znak spacji), w związku z tym mogą być przechowywane w postaci wielu baza-8 (który może być ściskany za pomocą numeru w galarecie baza-250). ṃŁączy atom konwersji podstawy i indeksowania na liście (w praktyce można określić dowolnych cyfr do stosowania).

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

Partia, 178 170 159 bajtów

@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

Edycja: Zapisano 11 bajtów dzięki @ ConorO'Brien.

JavaScript (ES6), 112 bajtów

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)

Próbny

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 bajtów

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

Wypróbuj online!

• zaoszczędził 8 bajtów dzięki JonathanAllan (użycie funkcji lambda)

Łańcuch formatu po wydrukowaniu wygląda następująco:

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

Wygląda to dobrze już dla ciągu o długości 1. Wszystko, co musimy zrobić, to zastąpić l odstępami długości równymi g i oczywiście g należy zastąpić oryginalnym ciągiem

Python 3.6, 172 153 128 bajtów

Dosłownie nie staje się prostsze niż to ... To jest faktycznie krótsze niż moja pierwotna próba wygenerowania go za pomocą algorytmu. Jak smutno.

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 bajtów dzięki @Leo
-25 bajtów dzięki @ L3viathan

C 170 170 bajtów

Dzięki @Neil za zapisanie dwóch bajtów!

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

Wypróbuj online!

Python 3 , 96 bajtów

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

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

Wypróbuj online! Znaki niedrukowalne nie są wyświetlane poprawnie; format napisów jest taki sam jak oficjalny , ale \x01dla for li \x02for g.

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

Używa podstawiania ciągów z elastycznym Pythonem 3translate . Lista tłumaczeń jest [s,' '*len(s),s]odwzorowywana \x01na ' '*len(s)i \x02na s. Wszelkie większe znaki pozostają niezmienione, ponieważ dają indeksy, które są poza zakresem dla listy. \x00nie można użyć, ponieważ bajt zerowy jest odczytywany jako koniec programu, więc pierwszy wpis jest marnowany.

PHP , 128 bajtów

Tylko proste wyjście

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

Wypróbuj online!

Skumulowane , 81 bajtów

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

Wypróbuj online!

Niestety niezbyt interesujące. Oto najciekawsza część:

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

Jest to w zasadzie interpolacja ciągów, ale o 10 bajtów krótsza niż wbudowana.

/// , 116 bajtów

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

Wypróbuj online!

Dane wejściowe są następujące:

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

Działa przy użyciu podstawowego szablonu oraz w razie potrzeby dodając spacje i znaki.

Liczba bajtów wzrosła, ponieważ Ørjan Johansen zdał sobie sprawę, że początkowo nie radził sobie z odstępami. Ale problem jest znany.

Python 2 , 101,91 bajtów 113 bajtów

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

Wypróbuj online!

Dane wejściowe to ciąg zer i jedynek o długości 1 lub 2! To jest 0,01,10 lub 11!

+12 bajtów - poprawiono odstępy w \ dla długości dwóch danych wejściowych.

Węgiel drzewny , 34 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｐ<³

Wydrukuj lewe pary /s i \s.

←⮌θ

Wydrukuj dane wyrównane do prawej w bieżącej pozycji.

Ｆ²«

Pętla przez gałęzie.

Ｊ³⁻×⁴ι²

Przesuń pozycję gałęzi. Możemy to zrobić, ponieważ katalog główny został wydrukowany z wyrównaniem do prawej strony, dzięki czemu środkowa gałąź zawsze znajduje się w tej samej pozycji absolutnej.

θ

Wydrukuj dane wejściowe.

Ｐ<²

Wydrukuj właściwą parę /i \.

Ｉι

Wydrukuj przyrostek oddziału.

↗

Przejdź do pierwszego liścia.

Ｆ²«

Pętla przez liście.

Ｐ⁺⁺θικ

Wydrukuj dane wejściowe oraz przyrostek gałęzi i liści.

↓↓

Przejdź do następnego liścia. Uwaga: Jeśli końcowe białe znaki są dopuszczalne Ｆ²⁺⁺⁺θι궶, zapisuje się bajt.