Với một số nguyên dương N ("virality"), chương trình của bạn sẽ tạo ra một bản vẽ nghệ thuật ASCII của một cây với hai nhánh có chiều dài N kéo dài xuống dưới và / hoặc phải từ góc trên bên trái.

Hướng được thực hiện bởi mỗi nhánh sau dấu hoa thị đầu tiên có thể là hướng phải hoặc hướng xuống và lựa chọn này nên được thực hiện ngẫu nhiên ¹ ở mỗi bước tiếp theo.

Ví dụ: với đầu vào là 5, đầu ra có thể trông như sau:

***
* ***
**
 **

Hai nhánh được phép chạm (nằm trên các ô liền kề), nhưng không trùng nhau (nằm trên cùng một ô), vì vậy những điều sau đây sẽ không được phép:

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

Ví dụ

Đối với đầu vào 1, đầu ra duy nhất có thể là:

**
*

(Điều này sẽ có mặt trong tất cả các đầu ra hợp lệ, vì hai nhánh có cùng một đường dẫn sẽ khiến chúng trùng nhau.)

Đầu ra có thể cho một đầu vào 3bao gồm:

***
* *
**

**
***
*
*

Đối với đầu vào 7:

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

Đối với đầu vào 10:

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

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

^{1. Điều này sẽ ngẫu nhiên thống nhất (nghĩa là cơ hội 50/50 của mỗi hướng) hoặc gần với ngẫu nhiên thống nhất như bạn có thể có trên phần cứng thông thường.}

CJam , 58 51 byte

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

Hãy thử trực tuyến!

Ý tưởng cơ bản là chúng ta bắt đầu bằng [0 0]và sau đó liên tục thêm 0 hoặc 1 vào mỗi phần tử (đảm bảo rằng chúng không bao giờ bằng nhau ngoại trừ lúc bắt đầu để tránh chồng chéo), thu thập tất cả các kết quả trung gian.

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

Sau đó, chúng tôi tạo ra một mảng lớn các mảng trong đó mỗi phân đoạn chứa *tại các chỉ số được cho bởi cặp tương ứng trong mảng ban đầu và khoảng trắng ở mọi nơi khác.

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

Điều này mang lại các lát chéo của ma trận đầu ra (trong đó di chuyển từ trái sang phải tương ứng với việc di chuyển từ trên phải sang dưới cùng bên trái trong ma trận thực tế).

Sau đó, chúng ta có thể sử dụng ::a:.+để "khử chéo" và nhận được các dòng kết quả:

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

Than , 31 24 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Ban đầu tôi nghĩ sẽ dễ dàng hơn để thực hiện bước đầu tiên ngẫu nhiên nhưng hóa ra là người chơi gôn để làm cho nhánh đầu tiên có thể dự đoán được. Giải trình:

Ｆ²«

Lặp lại hai lần, sử dụng biến chỉ số i. (Điều này thực sự lặp lại qua một danh sách ngầm, vì vậy an toàn khi đột biến ibên trong vòng lặp.)

Ｊ⁰¦⁰

Nhảy đến nguồn gốc của vải.

Ｆ⊕θ«

Vòng lặp N+1thời gian.

¿ι*↓*

In một *, nhưng để con trỏ ở bên phải hoặc bên dưới con trỏ tùy thuộc vào giá trị của i.

‽²ι

Chọn ngẫu nhiên giá trị của ilần lặp tiếp theo của vòng lặp bên trong.

¿ＫＫ↗

Nếu ký tự hiện tại là a *, điều này có nghĩa là chúng ta là nhánh thứ hai và chúng ta đã đi xuống thay vì phải, vì vậy hãy di chuyển lên trên để sửa nó. (Nhánh đầu tiên luôn bắt đầu đi xuống nên nhánh thứ hai sẽ luôn ở trên nó, nghĩa là chúng ta chỉ cần kiểm tra va chạm dọc.)

Java 10, 273 272 268 239 byte

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

Hãy thử trực tuyến tại đây .

Cảm ơn Kevin Cruijssen vì đã chơi golf 29 byte.

Phiên bản bị đánh cắp:

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 byte

118 byte không có dòng mới, thụt lề và bình luận. Mất N từ stdin:

@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

Hãy thử trực tuyến!

Python 2 , 204 byte

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]

Hãy thử trực tuyến!

Perl 5 -a , 97 96 93 92 byte

Không có quyền, xuống hoặc tắt thiên vị đường chéo.

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

Hãy thử trực tuyến!

PHP, 118 byte

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

yêu cầu PHP 5.4 trở lên cho toán tử Elvis. Thay thế ?:bằng ?1:cho PHP cũ hơn.

Chạy như ống với -nR hoặc thử trực tuyến .

Màu đỏ , 195 190 byte

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]

Hãy thử trực tuyến!

Có thể đọc được

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
]

Thạch , 50 43 41 byte

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

Hãy thử trực tuyến!

Đây là một trong những thực sự thú vị để viết. Có thể có một số phương pháp tối ưu hơn nhiều. Có lẽ có một số golf để làm trong phương pháp này là tốt.

Ngay sau khi tôi đăng bài này, tôi nhận ra rằng tôi có thể sử dụng ,þ`thay vì aþ,""oþ`Ɗ.

R , 148 142 byte

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

Hãy thử trực tuyến!

Ngoài ra, mặc dù nó sẽ không đáp ứng thông số kỹ thuật đầu ra, bạn có thể phân biệt hai nhánh: Dùng thử trực tuyến!

Giải trình:

Bắt đầu từ chỉ mục 1, chúng tôi chọn ngẫu nhiên một động thái phải hoặc trái cho nhánh rbằng cách thêm nhoặc 1, tương ứng. Sau đó, chúng tôi chọn một di chuyển sang phải hoặc trái cho nhánh kvà nếu nó sẽ giao nhau ở nơi rđang đi, chúng tôi chọn hướng khác. Sau đó, chúng tôi sử dụng rvà klàm chỉ số vào m, đặt các giá trị đó thành "*". Lặp lại n-1lần, sau đó chúng tôi in kết quả.

Thạch , 39 38 byte

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

Hãy thử trực tuyến!

Mặc dù dường như không liên quan, nhưng dở đây rất hữu ích để lưu một byte (theo cách tiếp cận trước đây của tôi).

Python 2 , 191 187 176 byte

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)

Hãy thử trực tuyến!

Python có hỗ trợ riêng cho số phức của biểu mẫu a+bj ; điều này làm cho một số vấn đề 2 chiều trở nên dễ xử lý hơn ...