Cho, theo bất kỳ cách nào và trật tự,

• kích thước (theo bất kỳ thứ tự nào bạn muốn)

• một xác suất (ở bất kỳ định dạng nào bạn muốn)

• số lần lặp (bạn có thể chọn tính trạng thái ban đầu hay không)

làm một trong những điều sau đây:

• hoạt hình, hoặc

• đầu ra từng bước của, hoặc

• trả về một danh sách các tiểu bang

một bầu trời đầy không gian của những kích thước đó.

Đối với mỗi lần lặp:

• mỗi nhân vật trên bầu trời có xác suất trở thành *

• tám nhân vật bao quanh bất kỳ *trở thành
  \ | /
-      -
/ | \, nếu họ không trở thành ngôi sao, tuy nhiên,

• nếu một nhân vật nằm trong phạm vi của hai *s, hãy làm cho nó thành mộtX

Thí dụ

Bầu trời 7 × 22 (chỉ cho khung hình rõ ràng - không xuất khung)

┌──────────────────────┐
│                      │
│                      │
│                      │
│                      │
│                      │
│                      │
│                      │
└──────────────────────┘

với xác suất 1% có thể trở thành

┌──────────────────────┐
│  *                   │
│                      │
│                      │
│                      │
│                      │
│           *          │
│                      │
└──────────────────────┘

và bước tiếp theo

┌──────────────────────┐
│ - - *                │
│ /|\                  │
│          *           │
│                      │
│          \|/         │
│          - -         │
│          /|\         │
└──────────────────────┘

và sau đó

┌──────────────────────┐
│    - -               │
│    /|\  \|/          │
│         - -          │
│         /|\          │
│                      │
│      * *             │
│                      │
└──────────────────────┘

và

┌──────────────────────┐
│                      │
│                      │
│                      │
│                      │
│     \|X|/            │
│     - X -            │
│     /|X|\          * │
└──────────────────────┘

và như thế

┌──────────────────────┐
│                      │
│                      │
│                      │
│                   *  │
│                      │
│                   \|/│
│                   - -│
└──────────────────────┘

ES6, 520 496 byte

Clipping và mọi thứ khác nên làm việc ngay bây giờ.

(w,h,p,i,r=0,s=($=>{while(++r<i)for(j=0,_=$[r]=[],z=$[r-1]||[];j<w*h;){k=j+1,l='*',c=0
n=(j%w&&z[j-1]==l&&++c)|(k%w&&z[k]==l&&++c)?'-':' '
n=(z[j-w]==l&&++c)|(z[j+w]==l&&++c)?'|':n
n=(j%w&&z[j-w-1]==l&&++c)|(k%w&&z[k+w]==l&&++c)?'\\':n
n=(k%w&&z[k-w]==l&&++c)|(j%w&&z[j+w-1]==l&&++c)?'/':n
_[j++]=Math.random()<p?l:c>1?'X':n}})(x=[])||x)=>{c=document.body.children[0],r=0;while(++r<i)setTimeout((k=0)=>{for(r++,c.innerHTML='';k<h;)c.innerHTML+=s[r].slice(k*w,++k*w).join('')+'\n'},90*r);r=0}

Xem hoạt hình!

Đã lưu 24 byte nhờ mẹo của Zacharý.

Giải pháp cũ, 478 byte (có lỗi cắt)

Tôi nghĩ rằng tôi đã có tất cả các quy tắc chính xác, tuy nhiên giải pháp có một vấn đề cắt trong đó mọi thứ thoát khỏi bên phải / bên trái bao quanh một dòng thấp hơn / cao hơn ở phía đối diện.

(w,h,p,i,r=0,s=($=>{while(++r<i)for(j=0,_=$[r]=[],z=$[r-1]||[];j<w*h;){c=0
n=(z[j-1]=='*'&&++c)|(z[j+1]=='*'&&++c)?'-':' '
n=(z[j-w]=='*'&&++c)|(z[j+w]=='*'&&++c)?'|':n
n=(z[j-w-1]=='*'&&++c)|(z[j+w+1]=='*'&&++c)?'\\':n
n=(z[j-w+1]=='*'&&++c)|(z[j+w-1]=='*'&&++c)?'/':n
_[j++]=Math.random()<p?'*':c>1?'X':n}})(x=[])||x)=>{c=document.body.children[0],r=0;while(++r<i)setTimeout((k=0)=>{for(r++,c.innerHTML='';k<h;)c.innerHTML+=s[r].slice(k*w,++k*w).join('')+'\n'},90*r);r=0}

Xem cũ.

APL (Dyalog) , 65 ký tự hoặc 71 byte *

Nhắc nhở cho kích thước (hàng, cột), sau đó cho lặp (không kể trạng thái ban đầu), sau đó cho xác suất (như n trong ¹/ ₙ ).

⎕{1=?⍺⍺:'*'⋄2≤+/b←'*'=1↓4⌽,⍵:'X'⋄⊃b/'-/|\\|/-'}⌺3 3{⍺⍺⎕←⍵}⍣⎕⊢⎕⍴''

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

⎕⍴'' kịp thời cho đầu vào và sử dụng mà để r eshape một chuỗi rỗng, đệm với không gian khi cần thiết

⊢ mang lại rằng

... ⍣⎕ kịp thời cho đầu vào và áp dụng các chức năng sau trên trên ( ⍵ ) mà nhiều lần:

 ... {... } lấy được một chức năng sử dụng bên dưới chức năng như toán hạng ( ⍺⍺ ), như sau:

  ⎕←⍵ in đối số

  ⍺⍺ áp dụng chức năng sau:

   Sự ⌺3 3 áp dụng chức năng sau đây trên vùng lân cận 3 × 3 Moore của mỗi phần tử:

    ⎕{Nhận } được đầu vào và sử dụng nó như toán hạng ( ⍺⍺ ) để lấy một hàm mới

     ?⍺⍺ số nguyên ngẫu nhiên trong số ⍺⍺ số nguyên đầu tiên

     1= Boolean nếu bằng một

     : nếu đúng:

      '*' trả lại một ngôi sao

     ⋄ khác:

      ,⍵ ravel (san phẳng) đối số (khu phố Moore)

      4⌽ xoay nó theo chu kỳ bốn bước sang trái

      1↓ thả một phần tử (trung tâm ban đầu)

      '*'= Danh sách Boolean trong đó bằng một ngôi sao

      b← lưu trữ như b

      +/ tổng hợp

      2≤ Boolean nếu hai hoặc cao hơn

      : nếu đúng:

       'X' trả lại một dấu X

      ⋄ khác:

       b/'-/|\\|/-' sử dụng b để lọc chuỗi

       ⊃ chọn cái đầu tiên, nếu không có cái nào, hãy chọn nguyên mẫu (một khoảng trắng)

^{* Để chạy trong Dyalog Classic, chỉ cần thay thế ⌺bằng⎕U233A} .