Diberi nomor biner, tugas Anda adalah membuat 'cabang' dari angka itu, dengan kedalaman 2.

Misalnya, diberikan 0sebagai input, Anda harus menampilkan ini:

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

Ini harus cukup jelas tentang bagaimana cabang harus dibuat. Kedalaman 2 berarti kami menghitung cabang untuk jumlah hingga 2 angka lebih lama. Kami juga menghitung cabang secara berurutan, dengan nol di bagian atas dan yang di bawah.

Lebih banyak kasus uji:

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

Aturan

• Anda tidak akan pernah menerima karakter di input selain 1dan 0.
• 0 < length of input < 11.
• Trailing whitespace diizinkan di akhir baris.

Jelly , 39 38 byte

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

Cobalah online!

Bagaimana?

Seni yang akan dicetak adalah:

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

Di mana Nstring input danL string spasi dari panjang string input.

Karena itu terdiri dari delapan komponen ( L, N, /, 0, karakter baris baru, \, 1, dan karakter ruang) dan karenanya dapat disimpan sebagai dasar-8 nomor (yang dapat dikompresi sebagai angka dasar-250 di Jelly). The ṃmenggabungkan atom konversi dasar dan pengindeksan ke dalam daftar (efektif satu dapat menentukan sewenang-wenang digit yang akan digunakan).

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

Sunting: Disimpan 11 byte berkat @ 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)

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

Cobalah online!

• disimpan 8 byte berkat JonathanAllan (Penggunaan fungsi lambda)

String format ketika dicetak terlihat seperti:

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

Ini sudah terlihat bagus untuk string dengan panjang 1. Yang harus kita lakukan adalah mengganti l dengan spasi dengan panjang yang sama dengan g dan, tentu saja, g harus diganti dengan string asli

Python 3.6, 172 153 128 byte

Secara harfiah tidak menjadi lebih mudah dari ini ... Ini sebenarnya lebih pendek dari upaya awal saya untuk menghasilkannya dengan algoritma. Betapa menyedihkan.

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 terima kasih kepada @Leo
-25 byte terima kasih kepada @ L3viathan

C, 170 168 byte

Terima kasih kepada @Neil untuk menghemat dua 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);}

Cobalah online!

Python 3 , 96 byte

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

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

Cobalah online! Karakter yang tidak patut tidak ditampilkan dengan benar; format string sama dengan format resmi , tetapi dengan \x01untuk ldan \x02untuk g.

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

Menggunakan substitusi string dengan Python 3 yang fleksibeltranslate . Daftar menerjemahkan [s,' '*len(s),s]peta \x01ke ' '*len(s)dan \x02ke s. Setiap karakter yang lebih besar tidak berubah karena mereka memberikan indeks yang di luar batas untuk daftar. \x00tidak dapat digunakan karena byte nol dibaca sebagai akhir program, sehingga entri pertama terbuang sia-sia.

PHP , 128 byte

Hanya Output sederhana

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

Cobalah online!

Ditumpuk , 81 byte

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

Cobalah online!

Sayangnya, tidak terlalu menarik. Inilah bagian yang paling menarik:

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

Ini pada dasarnya adalah string interpolasi, tetapi 10 byte lebih pendek dari builtin.

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

Cobalah online!

Masukan adalah sebagai berikut:

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

Bekerja dengan menggunakan templat dasar, dan menambahkan spasi dan karakter jika diperlukan.

Hitungan byte naik karena Ørjan Johansen menyadari bahwa itu tidak menangani spasi pada awalnya. Tapi masalahnya sudah diperbaiki.

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

Cobalah online!

Input adalah string 0 dan 1 dengan panjang 1 atau 2! Yaitu 0,01,10 atau 11!

+12 byte - mengoreksi jarak dalam \ untuk panjang dua input.

Arang , 34 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｐ<³

Cetak pasangan kiri /s dan \s.

←⮌θ

Cetak input dengan benar pada posisi saat ini.

Ｆ²«

Loop melalui cabang-cabang.

Ｊ³⁻×⁴ι²

Pindahkan posisi cabang. Kita dapat melakukan ini karena root dicetak dengan benar sehingga cabang tengah selalu pada posisi absolut yang sama.

θ

Cetak input.

Ｐ<²

Cetak pasangan kanan /dan \.

Ｉι

Cetak akhiran cabang.

↗

Pindah ke daun pertama.

Ｆ²«

Loop melalui daun.

Ｐ⁺⁺θικ

Cetak input dan akhiran cabang dan daun.

↓↓

Pindah ke daun berikutnya. Catatan: Jika trailing spasi dapat diterima maka Ｆ²⁺⁺⁺θι궶akan menghemat satu byte.