Diberikan, dengan cara dan ketertiban,

• dimensi (dalam urutan apa pun yang Anda inginkan)

• probabilitas (dalam format apa pun yang Anda inginkan)

• jumlah iterasi (Anda dapat memilih apakah akan menghitung kondisi awal atau tidak)

lakukan salah satu dari yang berikut:

• menghidupkan, atau

• output setiap langkah, atau

• mengembalikan daftar status

langit yang dipenuhi ruang dari dimensi-dimensi itu.

Untuk setiap iterasi:

• setiap karakter langit memiliki peluang untuk menjadi a *

• delapan karakter yang mengelilingi apapun *menjadi
  \ | /
-      -
/ | \, jika mereka tidak menjadi bintang, namun,

• jika sebuah karakter berada dalam kisaran dua *s, buatlah sebuahX

Contoh

Langit 7 × 22 (bingkai hanya untuk kejelasan - jangan menampilkan bingkai)

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

bisa dengan probabilitas 1% menjadi

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

dan langkah selanjutnya

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

lalu

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

dan

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

dan seterusnya

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

ES6, 520 496 byte

Kliping dan yang lainnya harusnya berfungsi sekarang.

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

Lihat animasi!

Disimpan 24 byte berkat tip Zacharý.

Solusi lama, 478 byte (dengan kliping bug)

Saya pikir saya sudah mendapatkan semua aturan yang benar, namun solusinya memiliki masalah kliping di mana semuanya keluar kanan / kiri membungkus satu baris lebih rendah / lebih tinggi di sisi yang berlawanan.

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

Lihat lama.

APL (Dyalog) , 65 karakter atau 71 byte *

Meminta dimensi (baris, kolom), lalu untuk iterasi (tidak menghitung keadaan awal), lalu untuk probabilitas (seperti n pada ¹⁄ ₙ ).

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

Cobalah online!

⎕⍴'' cepat untuk input dan menggunakan itu untuk r eshape string kosong, melapisi dengan spasi yang diperlukan

⊢ hasilkan itu

... ⍣⎕ meminta input dan menerapkan fungsi berikut di atas ( ⍵ ) yang berkali-kali:

 ... {... } mendapatkan fungsi menggunakan fungsi di bawah ini sebagai operan ( ⍺⍺ ), sebagai berikut:

  ⎕←⍵ cetak argumennya

  ⍺⍺ terapkan fungsi berikut:

   … ⌺3 3 Terapkan fungsi berikut pada lingkungan 3 × 3 Moore setiap elemen:

    ⎕{… } Dapatkan input dan gunakan sebagai operan ( ⍺⍺ ) untuk mendapatkan fungsi baru

     ?⍺⍺ bilangan bulat acak di antara bilangan bulat first pertama

     1= Boolean jika sama dengan satu

     : jika benar:

      '*' kembalikan bintang

     ⋄ lain:

      ,⍵ ravel (ratakan) argumen (lingkungan Moore)

      4⌽ putar secara siklis empat langkah ke kiri

      1↓ jatuhkan satu elemen (pusat asli)

      '*'= Daftar Boolean di mana sama dengan bintang

      b← simpan itu sebagai b

      +/ jumlah itu

      2≤ Boolean jika dua atau lebih tinggi

      : jika benar:

       'X' kembalikan X

      ⋄ lain:

       b/'-/|\\|/-' gunakan b untuk menyaring string

       ⊃ pilih yang pertama, jika tidak ada, pilih prototipe (spasi)

^{* Untuk berjalan di Dyalog Classic, cukup ganti ⌺dengan⎕U233A} .