Étant donné, en aucune façon et dans l'ordre,

• dimensions (dans l'ordre de votre choix)

• une probabilité (dans le format que vous voulez)

• nombre d'itérations (vous pouvez choisir de compter l'état initial ou non)

effectuez l' une des opérations suivantes:

• animer, ou

• sortie à chaque étape de, ou

• retourner une liste d'états de

un ciel rempli d'espaces de ces dimensions.

Pour chaque itération:

• chaque personnage du ciel a la probabilité donnée de devenir un *

• les huit personnages qui l'entourent *deviennent
  \ | /
-      -
/ | \, s'ils ne deviennent pas des stars, cependant,

• si un personnage est dans la plage de deux *s, faites-en unX

Exemple

Le ciel 7 × 22 (cadre pour plus de clarté - ne pas sortir le cadre)

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

pourrait avec 1% de probabilité devenir

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

et la prochaine étape

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

puis

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

et

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

etc

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

ES6, 520 496 octets

L'écrêtage et tout le reste devraient fonctionner maintenant.

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

Voir l'animation!

Enregistré 24 octets grâce à la pointe de Zacharý.

Ancienne solution, 478 octets (avec bug d'écrêtage)

Je pense que toutes les règles sont correctes, mais la solution a un problème d'écrêtage où tout ce qui sort de droite / gauche s'enroule autour d'une ligne plus bas / plus haut du côté opposé.

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

Voir ancienne.

APL (Dyalog) , 65 caractères ou 71 octets *

Demande des dimensions (lignes, colonnes), puis des itérations (sans compter l'état initial), puis des probabilités (comme n dans ¹⁄ ₙ ).

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

Essayez-le en ligne!

⎕⍴'' invite pour l' entrée et l' utiliser pour r Eshape une chaîne vide, le remplissage avec des espaces si nécessaire

⊢ donner que

… ⍣⎕ Demander à entrer et appliquer la fonction suivante sur le dessus ( ⍵ ) autant de fois:

 ... {... } calculer une fonction en utilisant la comme opérande (ci - dessous fonction ⍺⍺ ), comme suit:

  ⎕←⍵ imprimer l'argument

  ⍺⍺ appliquer la fonction suivante:

   … ⌺3 3 Appliquez la fonction suivante sur le voisinage Moore de 3 × 3 de chaque élément:

    ⎕{… } Obtenir une entrée et l'utiliser comme opérande ( ⍺⍺ ) pour dériver une nouvelle fonction

     ?⍺⍺ entier aléatoire parmi les premiers ⍺⍺ entiers

     1= Booléen si égal à un

     : si vrai:

      '*' retourner une étoile

     ⋄ autre:

      ,⍵ défoncer (aplatir) l'argument (le quartier Moore)

      4⌽ le faire tourner cycliquement de quatre pas vers la gauche

      1↓ déposer un élément (le centre d'origine)

      '*'= Liste booléenne où égale à une étoile

      b← stocker cela comme b

      +/ somme cela

      2≤ Booléen si deux ou plus

      : si vrai:

       'X' retourner un X

      ⋄ autre:

       b/'-/|\\|/-' utilisez le b pour filtrer la chaîne

       ⊃ choisissez le premier, s'il n'y en a pas, choisissez le prototype (un espace)

^{* Pour exécuter dans Dyalog Classic, remplacez simplement ⌺par⎕U233A} .