Bugünün meydan okuması, bu örnekte olduğu gibi güzel sanatlar gibi bir ikili ağacı çizmek :

                               /\
                              /  \
                             /    \
                            /      \
                           /        \
                          /          \
                         /            \
                        /              \
                       /                \
                      /                  \
                     /                    \
                    /                      \
                   /                        \
                  /                          \
                 /                            \
                /                              \
               /\                              /\
              /  \                            /  \
             /    \                          /    \
            /      \                        /      \
           /        \                      /        \
          /          \                    /          \
         /            \                  /            \
        /              \                /              \
       /\              /\              /\              /\
      /  \            /  \            /  \            /  \
     /    \          /    \          /    \          /    \
    /      \        /      \        /      \        /      \
   /\      /\      /\      /\      /\      /\      /\      /\
  /  \    /  \    /  \    /  \    /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Girdi olarak pozitif bir tamsayı verilecektir. Bu giriş ağacın yüksekliğidir . Yukarıdaki örnek altı yüksekliğe sahiptir.

Tam bir program veya bir işlev sunabilirsiniz ve varsayılan IO yöntemlerimizden herhangi birini kullanmakta özgürsünüz . Örneğin, ağacı basmak, yeni satırlı bir dize döndürmek, 2d karakterli bir dizi döndürmek, ağacı bir dosyaya kaydetmek vb. İzin verilir.

Her satırdaki arka boşluklara izin verilir.

İşte bazı girdi örnekleri ve bunlara karşılık gelen çıktılar:

1:
/\

2:
 /\
/\/\

3:
   /\
  /  \
 /\  /\
/\/\/\/\

4:
       /\
      /  \
     /    \
    /      \
   /\      /\
  /  \    /  \
 /\  /\  /\  /\
/\/\/\/\/\/\/\/\

5:
               /\
              /  \
             /    \
            /      \
           /        \
          /          \
         /            \
        /              \
       /\              /\
      /  \            /  \
     /    \          /    \
    /      \        /      \
   /\      /\      /\      /\
  /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Ne yazık ki, çıktı katlanarak büyüyor, bu nedenle daha büyük örnekler göstermek zor. İşte 8 için çıktıya bir link .

Her zamanki gibi, bu bir kod golf mücadelesidir, bu nedenle standart boşluklar uygulanır ve seçtiğiniz dilde mümkün olan en kısa programı yazmaya çalışın.

Mutlu golf!

Python 2,77 bayt

S=s=i=2**input()
while s:print S/s*('/'+' '*(s-i)+'\\').center(s);i-=2;s/=s/i

Sonda boşluklarla yazdırır ve hata ile sonlandırılır.

Ben bu kod aldı Gönderirken için ben Anarşi Golf üzerinde yarattığı bir meydan okuma , artı bir tek baytlık iyileştirme xsot tarafından bulundu. 128'in kodlanmış değeri olarak değiştirildi 2**input().

Fikir, çıktının her satırının bir veya daha fazla kez kopyalanan bir bölüm olduğudur. Giriş bölmesinden sonraki yarıda her bir bölümün bir kopyası bulunur, sonraki bölümden sonraki çeyrekte iki bölümden oluşur ve birçok bölüme sahip son satıra kadar /\.

Her segment bir vardı /ve \arasında, aynı zamanda doğru uzunlukta pede dış boşluk olan,. Dış dolgu ile yapılır center.

Değişken s, her bölümdeki akımı izler ve bölüm sayısı S/stoplam genişliğin ağaç genişliği olmasını sağlar S. Satır numarası i2 ile sayılır ve değerin syarısı olduğunda , bir bölme oluşur ve bölüm genişliği yarıya çıkar. Bu ifade ile yapılır s/=s/i. Ne zaman iulaşır 0, bu programı sonlandırır hata veriyor.

Anagolf yalnızca program gönderimlerine izin verdiğinden, muhtemelen daha kısa olduğunu düşündüğüm özyinelemeli bir işlev olasılığını keşfetmedim.

V , 32 bayt

é\é/À­ñLyPÄlx$X>>îò^llÄlxxbPò
|

Çevrimiçi deneyin!

HexDump:

00000000: e95c e92f c0ad f116 4c79 50c4 6c78 2458  .\./....LyP.lx$X
00000010: 3e3e eef2 5e6c 6cc4 6c78 7862 50f2 0a7c  >>..^ll.lxxbP..|

Tuval , 11 bayt

/║╶╷［ｌ＼；∔↔║

Burada dene!

Açıklama:

/║          push `/\` ("/" palindromized so this is a Canvas object)
  ╶╷[       repeat input-1 times
     l        get the width of the ToS
      \       create a diagonal that long
       ;∔     prepend that to the item below
         ↔    reverse the thing horizontally
          ║   and palindromize it horizontally

Haskell , 140 138 135 bayt

e n=[1..n]>>" "
n!f=(e n++).(++e n)<$>f
f 0=[]
f n=1!f(n-1)++['/':e(2*n-2)++"\\"]
b n|n<2=f 1|t<-b$n-1,m<-2^(n-2)=m!f m++zipWith(++)t t

Çevrimiçi deneyin! İle ara b 5, dizelerin bir listesini döndürür.

Oldukça baskı kullanımı:

*Main> putStr . unlines $ b 5
               /\
              /  \
             /    \
            /      \
           /        \
          /          \
         /            \
        /              \
       /\              /\
      /  \            /  \
     /    \          /    \
    /      \        /      \
   /\      /\      /\      /\
  /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

(bazıları) Açıklama:

• e nbir dizi nboşluk üretir
• n!fpedleri dizeleri listedeki her dize file nmekanlarda sol ve sağ
• f nBir de bir "zirve" çizer ntarafından 2ndikdörtgenin
• b n İki küçük ağacı birleştirerek ikili ağacı çizer ve üstlerine yeni bir tepe noktası yerleştirir.

Düzenleme: -3 bayt Zgarb sayesinde!

J , 49 43 42 bayt

' /\'{~(|.,-)"1@(=@i.@#,-)^:(<:`(,:@,&*-))

Bu, sayı alan ve 2B karakter dizisini döndüren bir fiili değerlendirir. Çevrimiçi deneyin!

açıklama

İlk önce bir yardımcı fiil yineleyerek -1, 0 ve 1 değerlerinin bir matrisini oluşturdum ve sonra sayıları karakterlerle değiştirdim. Yardımcı fiil bir sonraki yinelemenin sağ yarısını oluşturur, sonra gerisini üretmek için yatay olarak yansıtır. Aşağıdaki açıklamada, ,2B dizileri dikey olarak birleştirir ve 1D dizileri yatay olarak birleştirir.

' /\'{~(|.,-)"1@(=@i.@#,-)^:(<:`(,:@,&*-))  Input is n.
                          ^:(            )  Iterate this verb
                             <:             n-1 times
                               `(       )   starting from
                                    ,&*-    the array 1 -1 (actually sign(n), sign(-n))
                                 ,:@        shaped into a 1x2 matrix:
                                             Previous iteration is y.
                      #                      Take height of y,
                   i.@                       turn into range
                 =@                          and form array of self-equality.
                                             This results in the identity
                                             matrix with same height as y.
                       ,-                    Concatenate with -y, pad with 0s.
       (    )"1@(        )                   Then do to every row:
        |.,-                                 Concatenate reversal to negation.
' /\'{~                                     Finally index entry-wise into string.

JavaScript (ES6), 105 bayt

f=n=>n<2?"/\\":" "+f(n-1).split`/`[0].replace(/|/g,"$`$'$'/$`$`\\$'$'$` \n")+f(n-1).replace(/.*/g,"$&$&")

Sonuç, temel durumdan tekrar tekrar/\ . Alttaki yarım, her satırda kopyalanan önceki durumdur. Üst yarı biraz daha zor oldu; Bir önceki durumu ele almak ve sadece iki tarafı tutmak istiyormuş gibi görünüyorsun ama aynı zamanda genişlikleri ikiye katlamak için ipleri doldurmak konusunda endişelenmeniz gerekiyor, bu yüzden bunun yerine biraz regex sihri yapıyorum. Öndeki boşlukları önceki durumdan alarak ve her noktada bölerek, bu noktadan önce ve sonra boşlukları düşünebilirim. Her maçta 1 öncesi ve 1 sonrası azalan boşluklar; bu konumlandırmak için kullanılabilir /ve\doğru yerlerde. Yeni satırlar ve dolgu da buraya eklenir; bu, her satırdaki sondaki boşluk ve ilk satırdaki manuel olarak eklemek zorunda olduğum ilk alan dışındaki tüm dolguyu önemser. (Sonraki satırlardaki boşluklar eşleşen dizeden gelir).

Kömür , 12 bayt

ＦＮ«→↗⌈Ｘ²⊖ι‖Ｍ

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

 Ｎ              Input as a number
Ｆ «             Loop over implicit range
   →            Move right (because mirroring moves the cursor)
         ι      Current index
        ⊖       Decremented
      Ｘ²        Power of 2
     ⌈          Ceiling
    ↗           Draw diagonal line
          ‖Ｍ    Mirror image

Satır uzunlukları 1, 1, 2, 4, 8 ... 2 ^ (N-2), dolayısıyla garip hesaplama.

Stax , 20 19 bayt

≡mX░R○k╣∙╒ab^◘⌐╖x▼;

Koş ve hata ayıkla

Toplu iş, 218 bayt

@echo off
set/a"n=1<<%1"
set s=set t=
%s%/\
set l=for /l %%i in (2,1,%n%)do call
%l% %s% %%t%% 
%l%:l
:l
echo %t%
set/an-=1,m=n^&n-1
%s%%t: /=/ %
%s%%t:\ = \%
if %m% neq 0 exit/b
%s%%t:/ =/\%
%s%%t: \=/\%

Not: Satır 6 bir boşlukta bitiyor. Dalları hareket ettirerek İşleri 2 olduğu satır hariç, sağ ve uygun her seferinde sol ⁿ dallar yerine çatallı olsun bu durumda ucundan.

Haxe, 181 bayt

function g(n):String return(n-=2)==-1?"/\\":[for(y in 0...1<<n)[for(x in 0...4<<n)x+y+1==2<<n?"/":x-y==2<<n?"\\":" "].join("")].concat([for(y in g(n+1).split("\n"))y+y]).join("\n");

Veya bazı isteğe bağlı boşluklarla:

function g(n):String
  return
    (n -= 2) == -1
    ? "/\\"
    : [ for (y in 0...1 << n)
        [ for (x in 0...4 << n)
          x + y + 1 == 2 << n
          ? "/"
          : x - y == 2 << n
            ? "\\"
            : " "
        ].join("")
      ].concat([ for (y in g(n + 1).split("\n"))
        y + y
      ]).join("\n");

Bir süre önce doğru boyutta bir boşluk karakter dizisi yaratan bir çözüm üzerinde çalıştım, sonra çatallı yolları tekrar tekrar aşağı ve aşağı (ve her yinelemede daha yoğun bir şekilde) yerleştirdim. Olsa da, 230 + bayt kaldı. Buradaki yaklaşım hemen hemen Laikoni'nin Haskell yaklaşımının ne olduğu. Sahip olamadığımdan kaçamadım:String Haxe dönüş türü her zaman bir dize olacağını belirlemek için akıllı yeterli değildir, çünkü.

Bu sadece bir fonksiyondur, işte bunu test etmek için tam bir program:

class Main {
    public static function main(){
        function g(n):String return(n-=2)==-1?"/\\":[for(y in 0...1<<n)[for(x in 0...4<<n)x+y+1==2<<n?"/":x-y==2<<n?"\\":" "].join("")].concat([for(y in g(n+1).split("\n"))y+y]).join("\n");
        Sys.println(g(Std.parseInt(Sys.args()[0])));
    }
}

Yukarıdakileri yerleştirin Main.hx, derleyin haxe -main Main.hx -neko frac.nve ile test edin neko frac.n 4( 4istediğiniz sırayla değiştirin ).

PHP, 188 Bayt

Çevrimiçi sürüm

function f($l,$r=0,$m=1){global$a;for(;$i<$l;$i++)$i<$l/2?$a[$i+$r]=str_repeat(str_pad("/".str_pad("",2*$i)."\\",2*$l," ",2),$m):f($l/2^0,$r+$l/2,2*$m);}f(2**$argv[1]/2);echo join("\n",$a);

Expanded

function f($l,$r=0,$m=1){
global$a;    
for(;$i<$l;$i++)    
$i<$l/2
    ?$a[$i+$r]=str_repeat(str_pad("/".str_pad("",2*$i)."\\",2*$l," ",2),$m)
    :f($l/2^0,$r+$l/2,2*$m);
}
f(2**$argv[1]/2);
echo join("\n",$a);