Dato, in qualsiasi modo e ordine,

• dimensioni (nell'ordine che desideri)

• una probabilità (in qualunque formato tu voglia)

• numero di iterazioni (puoi scegliere se contare o meno lo stato iniziale)

effettuare una delle seguenti operazioni:

• animare, o

• emette ogni passaggio di, o

• restituisce un elenco di stati di

un cielo pieno di spazi di quelle dimensioni.

Per ogni iterazione:

• ogni personaggio del cielo ha la probabilità data di diventare a *

• gli otto personaggi che lo circondano *diventano
  \ | /
-      -
/ | \, se non diventano stelle, tuttavia,

• se un personaggio si trova nel raggio di due *s, rendilo unX

Esempio

Il cielo 7 × 22 (solo per chiarezza della cornice - non emettere la cornice)

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

potrebbe con l'1% di probabilità di diventare

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

e il prossimo passo

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

e poi

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

e

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

e così via

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

ES6, 520 496 byte

Il ritaglio e tutto il resto dovrebbero funzionare ora.

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

Guarda l'animazione!

Risparmio di 24 byte grazie al suggerimento di Zacharý.

Vecchia soluzione, 478 byte (con bug di clipping)

Penso di aver corretto tutte le regole, tuttavia la soluzione ha un problema di ritaglio in cui tutto ciò che esce da destra / sinistra si avvolge attorno a una riga inferiore / superiore sul lato opposto.

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

Visualizza vecchio.

APL (Dyalog) , 65 caratteri o 71 byte *

Richiede le dimensioni (righe, colonne), quindi le iterazioni (senza contare lo stato iniziale), quindi la probabilità (come n in ¹⁄ ₙ ).

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

Provalo online!

⎕⍴'' pronta per l'input e l'uso che per r eshape una stringa vuota, imbottitura con spazi come necessario

⊢ cedere quello

... ⍣⎕ richiede l'immissione e applica la seguente funzione sopra ( ⍵ ) più volte:

 ... {... } derivare una funzione usando la seguente funzione come operando ( ⍺⍺ ), come segue:

  ⎕←⍵ stampa l'argomento

  ⍺⍺ applica la seguente funzione:

   ... ⌺3 3 applica la seguente funzione sul quartiere Moore 3 × 3 di ciascun elemento:

    ⎕{... } ottieni input e usalo come operando ( ⍺⍺ ) per derivare una nuova funzione

     ?⍺⍺ numero intero casuale tra i primi ⍺⍺ numeri interi

     1= Booleano se uguale a uno

     : se è vero:

      '*' restituire una stella

     ⋄ altro:

      ,⍵ ravel (appiattire) l'argomento (il quartiere di Moore)

      4⌽ ruotalo ciclicamente di quattro passi verso sinistra

      1↓ rilascia un elemento (il centro originale)

      '*'= Elenco booleano uguale a una stella

      b← memorizzalo come b

      +/ sommalo

      2≤ Booleano se due o superiore

      : se è vero:

       'X' restituisce una X

      ⋄ altro:

       b/'-/|\\|/-' usa b per filtrare la stringa

       ⊃ scegli il primo, se non ce ne sono, scegli il prototipo (uno spazio)

^{* Per eseguire in Dyalog Classic, è sufficiente sostituirlo ⌺con⎕U233A} .