In irgendeiner Weise und Reihenfolge gegeben,

• Maße (in welcher Reihenfolge Sie wollen)

• eine Wahrscheinlichkeit (in welchem ​​Format auch immer Sie wollen)

• Anzahl der Iterationen (Sie können wählen, ob Sie den Anfangszustand zählen möchten oder nicht)

Führen Sie einen der folgenden Schritte aus:

• animieren, oder

• jeden Schritt von oder ausgeben

• Gibt eine Liste der Bundesstaaten zurück

ein raumfüllender Himmel dieser Dimensionen.

Für jede Iteration:

• Jedes Himmelszeichen hat die gegebene Wahrscheinlichkeit, a zu werden *

• die acht Zeichen , die jeder umgeben *werden
  \ | /
-      -
/ | \, wenn sie nicht zu Sternen werden, jedoch

• Wenn sich ein Zeichen im Bereich von zwei *Sekunden befindet, machen Sie es zu einemX

Beispiel

Der 7 × 22 Himmel (Rahmen nur zur Verdeutlichung - geben Sie den Rahmen nicht aus)

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

könnte mit 1% wahrscheinlichkeit werden

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

und der nächste Schritt

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

und dann

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

und

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

und so weiter

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

ES6, 520 496 Bytes

Clipping und alles andere sollte jetzt funktionieren.

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

Animation ansehen!

24 Bytes gespart dank Zacharýs Tipp.

Alte Lösung, 478 Bytes (mit Clipping Bug)

Ich glaube, ich habe alle Regeln richtig verstanden, aber die Lösung hat ein Beschneidungsproblem, bei dem sich alles, was rechts / links austritt, um eine Zeile tiefer / höher auf der gegenüberliegenden Seite dreht.

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

Alt ansehen.

APL (Dyalog) , 65 Zeichen oder 71 Byte *

Fordert zur Eingabe von Dimensionen (Zeilen, Spalten) auf, dann zur Eingabe von Iterationen (ohne Anfangszustand) und dann zur Eingabe der Wahrscheinlichkeit (als n in ¹⁄ ₙ ).

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

Probieren Sie es online!

⎕⍴'' Eingabeaufforderung und verwenden Sie diese, um eine leere Zeichenfolge neu zu formen und nach Bedarf mit Leerzeichen aufzufüllen

⊢ gib das her

... ⍣⎕ zur Eingabe auffordern und die folgende Funktion so oft wie möglich anwenden ( ⍵ ):

 ... {... } leitet eine Funktion , um die Funktion als Operand unter Verwendung von ( ⍺⍺ ), wie folgt:

  ⎕←⍵ Drucken Sie das Argument aus

  ⍺⍺ wende die folgende Funktion an:

   … ⌺3 3 Wende die folgende Funktion auf die 3 × 3-Moore-Nachbarschaft jedes Elements an:

    ⎕{… Eine } Eingabe erhalten und als Operand ( ⍺⍺ ) verwenden, um eine neue Funktion abzuleiten

     ?⍺⍺ zufällige ganze Zahl unter den ersten ⍺⍺ ganzen Zahlen

     1= Boolean wenn gleich eins

     : Wenn wahr:

      '*' Gib einen Stern zurück

     ⋄ sonst:

      ,⍵ das Argument (das Moore-Viertel) verfälschen (verflachen)

      4⌽ Drehe es zyklisch vier Schritte nach links

      1↓ ein Element fallen lassen (die ursprüngliche Mitte)

      '*'= Boolesche Liste, in der ein Stern steht

      b← Speichern Sie das als b

      +/ summiere das

      2≤ Boolean, wenn zwei oder höher

      : Wenn wahr:

       'X' Gib ein X zurück

      ⋄ sonst:

       b/'-/|\\|/-' Verwenden Sie das b , um die Zeichenfolge zu filtern

       ⊃ wähle den ersten aus, wenn es keinen gibt, wähle den Prototyp (ein Leerzeichen)

^{* Um in Dyalog klassisch laufen, einfach ersetzen ⌺mit⎕U233A} .