Pozitif bir tamsayı N ("viralite") verildiğinde, programınız sol üst köşeden aşağı ve / veya sağa doğru uzanan iki uzunluk N dalı olan bir ağacın ASCII-art çizimi oluşturmalıdır .

İlk yıldızdan sonra her dal tarafından alınan yön sağa veya aşağıya doğru olabilir ve bu seçim bir sonraki adımda rastgele ¹ yapılmalıdır .

Örneğin, 5 girdisi verildiğinde, çıktı şöyle görünebilir:

***
* ***
**
 **

İki dalın temas etmesine izin verilir (bitişik hücreler üzerinde olur), ancak üst üste binmez (aynı hücre üzerinde olur), bu nedenle aşağıdakilere izin verilmez:

***
* *
*****
  *
  *

Örnekler

Giriş 1için mümkün olan tek çıkış:

**
*

(Bu, tüm geçerli çıktılarda mevcut olacaktır, çünkü iki dalın aynı yolu izlemesi onların çakışmasına neden olacaktır.)

Aşağıdakileri 3içeren bir giriş için olası çıkışlar :

***
* *
**

**
***
*
*

Giriş için 7:

****
*  **
*   **
*
***
  *

Giriş için 10:

****
*  *      
*********
  *
  *****

Bu kod golfBöylece, en kısa geçerli yanıt (bayt cinsinden) kazanır.

^{1. Bu eşit olarak rastgele (yani her yöne 50/50 şans) veya normal donanıma ulaşabildiğiniz gibi eşit olarak rastgele yakın olmalıdır.}

CJam , 58 51 bayt

[TT]{_2_m*\f.+{:-},mR}ri*]ee{~\)S*\{'*t}/}%::a:.+N*

Çevrimiçi deneyin!

Temel fikir, [0 0]tüm ara sonuçları toplayarak her öğeye 0 veya 1 ile tekrar tekrar eklememizdir (üst üste binmeyi önlemek için başlangıçta hiçbir zaman eşit olmadıklarından emin olmak).

[[0 0] [0 1] [0 2] [0 2] [1 3]]

Daha sonra, her bir alt dizinin *orijinal dizide karşılık gelen çift tarafından verilen dizinlerde ve diğer her yerde boşluklarda bulunduğu geniş bir dizi dizisi oluştururuz .

["*"
 "**"
 "* *"
 "* * "
 " * * "]

Bu, çıkış matrisinin diyagonal dilimlerini verir (burada, soldan sağa hareket etmenin, gerçek matristeki yukarıdan sağa-soldan aşağı hareket etmesine karşılık gelir).

Daha sonra ::a:.+"diyagonalleştirmeyi" ve elde edilen çizgileri elde etmek için kullanabiliriz:

[ "**** "
  "*  *"
  "** "
  " *"
  ""     ]

Odun kömürü , 31 24 bayt

Ｆ²«Ｊ⁰¦⁰Ｆ⊕θ«¿ι*↓*≔‽²ι¿ＫＫ↗

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Başlangıçta ilk adımı rastgele yapmanın daha kolay olacağını düşündüm ama ilk dalı öngörülebilir kılmak daha golfe dönüştü. Açıklama:

Ｆ²«

Dizin değişkenini kullanarak iki kez döngü yapın i. (Bu aslında örtük bir liste üzerinden yinelenir, bu nedenle idöngü içinde değişiklik yapmak güvenlidir .)

Ｊ⁰¦⁰

Tuvalin kökenine atlayın.

Ｆ⊕θ«

Döngü N+1süreleri.

¿ι*↓*

A yazdırın *, ancak değerine bağlı olarak imleci sağa veya imlecin altına bırakın i.

‽²ι

iİç döngünün sonraki yinelemesi için değerini rastgele ayarlayın .

¿ＫＫ↗

Eğer mevcut karakter bir ise *, bu ikinci dal olduğumuz anlamına gelir ve sağ yerine aşağı indik, bu yüzden düzeltmek için sağa hareket edin. (İlk dal her zaman aşağı doğru başlar, bu nedenle ikinci dal her zaman üstündedir, yani sadece dikey bir çarpışmayı kontrol etmemiz gerekir.)

Java 10, 273 272 268 239 bayt

n->{var c=new char[++n][n];for(var d:c)java.util.Arrays.fill(d,' ');for(int i=0,j=0,k=0,l=0,r=0,s=0,t=0,u=0;n-->0;){c[i+=r][j+=s]=c[k+=t][l+=u]=42;do{r=t=2;r*=Math.random();t*=Math.random();s=r^1;u=t^1;}while(i+r==k+t&j+s==l+u);}return c;}

Burada çevrimiçi deneyin .

29 bayt golf yaptığı için Kevin Cruijssen'e teşekkürler .

Ungolfed sürümü:

n -> { // lambda taking an int as argument
    var c = new char[++n][n]; // the output; increment the virality since the root does not count
    for(var d : c) // for every line
        java.util.Arrays.fill(d,' '); // initialize it with spaces
    for(int i = 0, j = 0, // coordinates of the first branch
            k = 0, l = 0, // coordinates of the second branch
            r = 0, s = 0, // offsets for the first branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
            t = 0, u = 0; // offsets for the second branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
        n-- > 0; ) { // decrement virality and repeat as many times
        c[i+=r][j+=s] = c[k+=t][l+=u] = 42; // move according to offsets and place an '*' for each branch, 42 is ASCII code
        do { // randomly pick offsets for both branches
            r = t = 2; // Math.random() provides results in [0,1)
            r *= Math.random(); // flip a coin for the first branch
            t *= Math.random(); // flip another coin for the second
            s = r^1; // set s to 0 if r=1, to 1 if r=0
            u = t^1; // set u to 0 if t=1, to 1 if t=0
        } while(i+r==k+t&j+s==l+u); // repeat if the branches overlap
    }
    return c; // return the output
}

Perl 5 , 208 124 122 118 bayt

Satırları, girintileri ve yorumları olmayan 118 bayt. Alır N stdin'den:

@b=1..2;                            #number of branches is 2
for(1..<>){                         #add length <> (the input) to each branch
  ($x,$y)=@$_                       #get where current branch has its tip now
 ,.5>rand?$x++:$y++                 #increase either x or y
 ,$o[$y][$x]++&&redo                #try again if that place is already occupied
 ,$_=[$x,$y]                        #register new tip of current branch
   for@b                            #...and do all that for each branch 
}
say map$_||!$i++?'*':$",@$_ for@o;  #output the branches

Çevrimiçi deneyin!

Python 2 , 204 bayt

from random import*
N=input()
s=eval(`[[' ']*-~N]*-~N`)
s[0][0]='*'
I=x,y=1,0
J=X,Y=0,1
exec"s[y][x]=s[Y][X]='*';i,j,k,l=choice((J+I,I+I,I+J,J+J)[x-2<X:]);x+=i;y+=j;X+=k;Y+=l;"*N
for i in s:print`i`[2::5]

Çevrimiçi deneyin!

Perl 5 -a , 97 96 93 92 bayt

Sağ, aşağı veya kapalı diyagonal önyargıları yoktur.

#!/usr/bin/perl -a
@;=[1];map{$x=$y=0;map++(.5<rand?$x:$y)*$;[$y][$x]++&&redo,1.."@F"}1,2;say+($","*")[@$_]for@

Çevrimiçi deneyin!

PHP, 118 bayt

for($r="*",$w=$argn+2;$argn--;$r[$q+=rand(0,$r[$q+1]<"*")?:$w]=$r)$r[$p+=rand(!$i++,1)?:$w]=$r;echo wordwrap($r,$w-1);

Elvis operatörü için PHP 5.4 veya üstü gerekir. Değiştir ?:ile ?1:eski PHP.

Pipo ile çalıştırın -nRveya çevrimiçi deneyin .

Kırmızı , 195190 bayt

func[n][g: func[s][i: 0 d: s while[i < n][b/(d): #"*"until[r: 1 if 1 = random 2[r: n + 1]b/(d + r) =#" "]d: d + r
i: i + 1]]b:""loop n[loop n[append b" "]append b"^/"]b/1: #"*"g n + 2 g 2 b]

Çevrimiçi deneyin!

Okunabilir:

f: func[n][
    g: func[s][
        i: 0
        d: s
        while[i < n][
            b/(d): #"*"
            until[
                r: 1 if 1 = random 2[r: n + 1]
                b/(d + r) = #" "
            ]
            d: d + r
            i: i + 1
        ]
    ]
    b: ""
    loop n[loop n[append b " "]append b "^/"]
    b/1: #"*"
    g n + 2
    g 2
    b
]

Jöle , 50 43 41 bayt

2ḶẊ⁸С+\‘Ṗ
⁸ÇU;Ǥ⁻Q$¿
‘,þ`⁼€þÇS+»þ`Ị$ị⁾* 

Çevrimiçi deneyin!

Bu yazmak gerçekten eğlenceliydi. Çok daha uygun bir yöntem olabilir. Muhtemelen bu yöntemde golf yapmak da mümkündür.

Bunu gönderdikten hemen sonra ,þ`yerine kullanabileceğimi fark ettim aþ,""oþ`Ɗ.

R , 148142 bayt

n=scan();`~`=sample;o=r=k=1;l=c(1,n);for(i in 1:n){r=r+l~1;t=l~1;k=k+"if"(k+t-r,t,l[l!=t]);o=c(o,r,k)};write(c(" ","*")[1:n^2%in%o+1],1,n,,"")

Çevrimiçi deneyin!

Ayrıca, çıktı spesifikasyonunu karşılamasa da, iki dalı ayırt edebilirsiniz: Çevrimiçi deneyin!

Açıklama:

Dizinden başlayarak , sırasıyla veya öğesini ekleyerek 1dal için rastgele bir sağ veya sol hareket seçiyoruz . Sonra dal için başka bir sağ veya sol hareket seçeriz ve eğer nereye gideceğini keserse, diğer yönü seçeriz. Sonra ve içine endeks olarak , bu değerleri olarak ayarlayın . Tekrar eden zamanlar sonucu yazdırırız.rn1krrkm"*"n-1

Jöle , 39 38 bayt

ḣ2+\€Ẏ
2Rd¤ṗẊÇ⁻Q$$¿Ç0,0ṭ‘Ṭ€×þ/$€Sị⁾* Y

Çevrimiçi deneyin!

Her ne kadar ilgisiz görünse de, dburada bir baytı kurtarmak için kullanışlıdır (önceki yaklaşımım üzerinden).

Piton 2 , 191 187 176 bayt

from random import*
n=input()
p,q=c=1,1j;s={p,q,0}
exec'z=choice(c);q,p=p+[z,1+1j-z][p+z in s],q;s|={q};'*2*~-n
R=range(n+1)
for y in R:print''.join(' *'[y+x*1jin s]for x in R)

Çevrimiçi deneyin!

Python, formun karmaşık sayıları için yerel desteğe sahiptir a+bj; Bu, bazı 2-B problemlerini biraz daha izlenebilir hale getirir ...