İkili bir sayı verildiğinde, göreviniz bu sayının derinliği 2 olan bir 'dal' oluşturmaktır.

Örneğin, 0girdi olarak verildiğinde , tam olarak bunun çıktısını almalısınız:

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

Bu, dalların nasıl oluşturulması gerektiğine dair oldukça açıklayıcı olmalıdır. Derinlik 2, 2 sayıya kadar daha uzun rakamlar için dalları hesapladığımız anlamına gelir. Dalları sırayla, üstte sıfır ve altta olmak üzere hesaplıyoruz.

Daha fazla test örneği:

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

kurallar

• Girişte 1ve dışında hiçbir zaman karakter almazsınız 0.
• 0 < length of input < 11.
• Satırların sonunda izleyen boşluk bırakılabilir.

Jöle , 39 38 bayt

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

Çevrimiçi deneyin!

Nasıl?

Basılacak sanat:

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

Burada Ngiriş dize ve Lgiriş dizesi uzunluğu alanlarda bir dizidir.

Bu şekilde sekiz bileşenden oluşur ( L, N, /, 0, satır karakteri, \, 1ve boşluk karakteri) ve bu yüzden (jöle bir baz-250 numarası olarak sıkıştırılabilir) bir taban-8 numara olarak depolanabilir. ṃBir liste halinde atomu birleştiren temel dönüşüm ve indeksleme (etkili bir rasgele basamak tanımlayabilir kullanılmak üzere).

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

Toplu, 178 170 159 bayt

@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

Düzenleme: @ ConorO'Brien sayesinde 11 bayt kaydedildi.

JavaScript (ES6), 112 bayt

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)

gösteri

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 bayt

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

Çevrimiçi deneyin!

• JonathanAllan sayesinde 8 bayt kaydedildi (Lambda fonksiyonunun kullanımı)

Yazdırıldığında biçim dizesi şöyle görünür:

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

Bu zaten 1 uzunluk dizesi için iyi görünüyor. Tek yapmamız gereken l'yi g'nin uzunluğuna eşit boşluklarla değiştirmek ve elbette g orijinal dizeyle değiştirilmek.

Python 3.6, 172 153 128 bayt

Kelimenin tam anlamıyla bundan daha açık olamaz ... Bu aslında bir algoritma ile orijinal oluşturma girişimimden daha kısa. Ne kadar üzücü.

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

@Leo sayesinde -19 bayt
@ L3viathan sayesinde -25 bayt

Cı, 170 168 bayt

İki bayt kaydettiği için @Neil'e teşekkürler!

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

Çevrimiçi deneyin!

Python 3 , 96 bayt

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

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

Çevrimiçi deneyin! Yazdırılamayan karakterler düzgün görüntülenmiyor; dize biçimi officialaimm'lerle aynıdır , ancak \x01for lve \x02for ile birlikte g.

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

Python 3translate ile esnek dize değiştirme kullanır . Tercüme liste [s,' '*len(s),s]eşler \x01için ' '*len(s)ve \x02için s. Daha büyük karakterler değişmez, çünkü bunlar liste için sınırların dışında olan dizinler verir. \x00boş bir bayt bir program sonu olarak okunduğundan kullanılamadı, bu nedenle ilk giriş israf edildi.

PHP , 128 bayt

Sadece basit bir Çıktı

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

Çevrimiçi deneyin!

Yığılmış , 81 bayt

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

Çevrimiçi deneyin!

Ne yazık ki çok ilginç değil. İşte en ilginç kısım:

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

Bu temelde dize enterpolasyonudur, ancak yerleşikten 10 bayt daha kısadır.

/// , 116 bayt

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

Çevrimiçi deneyin!

Girdi aşağıdaki gibidir:

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

Temel bir şablon kullanarak ve gerektiğinde boşluk ve karakterler ekleyerek çalışır.

Bayt sayısı arttı çünkü Ørjan Johansen ilk başta boşluk bırakmadığını fark etti. Ama sorun çözüldü.

Python 2 , 101,91 bayt 113 bayt

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

Çevrimiçi deneyin!

Girdi, 1 veya 2 uzunluğundaki 0'lar ve 1'ler dizesidir! Bu 0,01,10 veya 11!

+12 bayt - uzunluk iki girişi için \ içindeki boşluk düzeltildi.

Kömür , 34 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｐ<³

Sol çiftlerini yazdırın /S ve \s'nin .

←⮌θ

Geçerli konumda sağa yaslanmış girişi yazdırın.

Ｆ²«

Dallar arasında döngü.

Ｊ³⁻×⁴ι²

Dalın konumunu hareket ettirin. Bunu yapabiliriz, çünkü orta dal her zaman aynı mutlak konumda olacak şekilde kök sağa yaslanmıştır.

θ

Girişi yazdırın.

Ｐ<²

Sağ çifti Baskı /ve \.

Ｉι

Şube sonekini yazdırın.

↗

İlk yaprağa geçin.

Ｆ²«

Yaprakların arasından geçin.

Ｐ⁺⁺θικ

Girişi ve dal ve yaprak sonekini yazdırın.

↓↓

Bir sonraki yaprağa git. Not: Sondaki boşluk kabul edilebilirse Ｆ²⁺⁺⁺θι궶bir bayt kaydederdi.