Biorąc pod uwagę, w jakikolwiek sposób i porządek,

• wymiary (w dowolnej kolejności)

• prawdopodobieństwo (w dowolnym formacie)

• liczba iteracji (możesz wybrać, czy liczyć stan początkowy, czy nie)

wykonaj jedną z następujących czynności:

• animować lub

• wypisuje każdy krok lub

• zwraca listę stanów

wypełnione przestrzenią niebo o tych wymiarach.

Dla każdej iteracji:

• każda postać nieba ma podane prawdopodobieństwo zostania *

• Osiem otaczających postaci *staje się
  \ | /
-      -
/ | \, jeśli nie stają się gwiazdami,

• jeśli znak jest w zasięgu dwóch *s, uczyń go anX

Przykład

Niebo 7 × 22 (klatka tylko dla przejrzystości - nie wysyłaj klatki)

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

z prawdopodobieństwem 1% może się stać

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

i następny krok

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

i wtedy

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

i

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

i tak dalej

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

ES6, 520 496 bajtów

Przycinanie i wszystko inne powinno teraz działać.

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

Zobacz animację!

Zaoszczędź 24 bajty dzięki wskazówce Zachariego.

Stare rozwiązanie, 478 bajtów (z błędem przycinania)

Wydaje mi się, że wszystkie reguły są prawidłowe, jednak rozwiązanie ma problem z przycinaniem, w którym wszystko wychodzące z prawej / lewej strony owija się wokół jednej linii niżej / wyżej po przeciwnej stronie.

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

Zobacz stare.

APL (Dyalog) , 65 znaków lub 71 bajtów *

Monity o wymiary (wiersze, kolumny), a następnie o iteracje (nie licząc stanu początkowego), a następnie o prawdopodobieństwo (jak nw ¹⁄ ₙ ).

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

Wypróbuj online!

⎕⍴'' zachęty do wprowadzania i stosowania, że do r eshape pusty ciąg znaków, dopełnienie spacjami, ile potrzeba

⊢ dać to

… Pytaj⍣⎕  o dane wejściowe i zastosuj następującą funkcję do powyższego ( ⍵ ) tyle razy:

 ... {... } wyprowadzić funkcję korzystając z poniższego funkcji jako argumentu ( ⍺⍺ ), w następujący sposób:

  ⎕←⍵ wypisz argument

  ⍺⍺ zastosować następującą funkcję:

   … ⌺3 3 Zastosuj następującą funkcję w sąsiedztwie każdego elementu 3 × 3 Moore:

    ⎕{… } Uzyskaj dane wejściowe i użyj go jako argumentu ( ⍺⍺ ), aby uzyskać nową funkcję

     ?⍺⍺ losowa liczba całkowita wśród pierwszych ⍺⍺ liczb całkowitych

     1= Wartość logiczna, jeśli jest równa jeden

     : Jeśli prawda:

      '*' zwrócić gwiazdę

     ⋄ jeszcze:

      ,⍵ ravel (spłaszcz) argument (sąsiedztwo Moore)

      4⌽ obracaj go cyklicznie cztery kroki w lewo

      1↓ upuść jeden element (oryginalne centrum)

      '*'= Lista boolowska gdzie równa się gwiazdce

      b← przechowuj to jako b

      +/ zsumuj to

      2≤ Wartość logiczna, jeśli dwa lub więcej

      : Jeśli prawda:

       'X' zwraca X

      ⋄ jeszcze:

       b/'-/|\\|/-' użyj b, aby przefiltrować ciąg

       ⊃ wybierz pierwszy, jeśli nie ma, wybierz prototyp (spację)

^{* Aby uruchomić w Dyalog Classic, po prostu zastąpić ⌺z⎕U233A} .