Lebensechte zellulare Automaten sind zellulare Automaten, die Conways Spiel des Lebens insofern ähnlich sind, als sie auf einem (theoretisch) unendlich großen quadratischen Gitter arbeiten, in dem jede Zelle genau 8 Nachbarn hat und einer von 2 Zuständen ist, nämlich lebendig und tot .

Diese Like-like-Versionen unterscheiden sich jedoch in entscheidender Weise: Die Regeln, nach denen eine bestimmte Zelle zum Leben erweckt wird, und die Regeln, nach denen eine bestimmte Zelle bis zur nächsten Generation überlebt.

Zum Beispiel verwendet das klassische Spiel des Lebens die Regel B3/S23, dh es werden 3 lebendige Zellen benötigt, um eine neue zu gebären, und entweder 2 oder 3 lebende Nachbarn, um zu überleben. Für diese Herausforderung gehen wir davon aus, dass sich die Nachbarn nicht selbst einschließen, sodass jede Zelle genau 8 Nachbarn hat.

Ihre Aufgabe ist es, bei gegebener Startkonfiguration, einer Geburtsregel, einer Überlebensregel und einer positiven Ganzzahl (der Anzahl der auszuführenden Generationen) den lebensechten Automaten zu simulieren, wobei diese Regeln für die Anzahl der Generationen in dem kürzestmöglichen Code verwendet werden . Die Ausgangskonfiguration ist eine quadratische Matrix / ein zweidimensionales Array oder eine mehrzeilige Zeichenfolge, die Sie auswählen können. Die anderen können in jedem vernünftigen Format und Verfahren angegeben werden.

Wenn zum Beispiel die Geburtsregel lautete 12345678(alle lebenden Nachbarn), lautete die Überlebensregel 2357und die Ausgangskonfiguration lautete

0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0

Die nächsten zwei Generationen wären

Generation 1:           Generation 2:

0 0 0 0 0               1 1 1 1 1
0 1 1 1 0               1 1 0 1 1
0 1 0 1 0               1 0 1 0 1
0 1 1 1 0               1 1 0 1 1
0 0 0 0 0               1 1 1 1 1

Wenn die Anzahl der angegebenen Generationen 10 wäre, wäre die Ausgabe etwas im Sinne von

0 1 1 1 0
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
0 1 1 1 0

Sie müssen nicht mit Änderungen umgehen, die außerhalb der durch die Eingabematrix vorgegebenen Grenzen liegen. Alle Zellen außerhalb der Matrix beginnen jedoch tot zu sein. Daher kann die Eingabematrix eine beliebige Größe haben, bis zu dem Maximalwert, den Ihre Sprache unterstützen kann. Sie müssen die Karte nicht zwischen den Generationen ausgeben.

Dies ist ein Code-Golf, also gewinnt der kürzeste Code.

Testfälle

Diese verwenden die B/SNotation, um die verwendeten Regeln anzugeben

B2/S2, generations = 100, Konfiguration:

1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0

Ausgabe:

0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

B1357/S2468, generations = 12, Konfiguration:

1 0 1 0 1 0
0 1 1 0 1 0
1 0 0 0 0 0
0 0 0 0 0 1
1 1 1 1 1 0
0 1 1 0 0 1

Ausgabe:

0 1 0 0 0 0
0 1 1 1 1 0
0 1 0 1 1 0
1 1 1 0 0 0
0 0 1 1 1 0
0 1 1 0 0 0

Wenn Sie mehr Testfälle generieren müssen, können Sie diesen wunderbaren Simulator verwenden. Bitte achten Sie darauf, die Boardgröße zu begrenzen

MATL , 24 23 Bytes

xx:"tt3Y6Z+1Gm<8M2Gmb*+

Eingänge sind:

• Array mit Geburtsregel
• Array mit Überlebensregel
• Anzahl der Generationen
• Matrix mit anfänglicher Zellenkonfiguration, die ;als Zeilentrennzeichen verwendet wird.

Probieren Sie es online! Oder siehe Testfälle: 1 , 2 .

Für ein paar Bytes mehr sehen Sie die Entwicklung in der ASCII-Kunst sehen .

Erläuterung

xx      % Take two inputs implicitly: birth and survival rules. Delete them
        % (but they get copied into clipboard G)
:"      % Take third input implicitly: number of generations. Loop that many times
  tt    %   Duplicate twice. This implicitly takes the initial cell configuration
        %   as input the first time. In subsequent iterations it uses the cell 
        %   configuration from the previous iteration
  3Y6   %   Push Moore neighbourhood: [1 1 1; 1 0 1; 1 1 1]
  Z+    %   2D convolution, maintaining size
  1G    %   Push first input from clipboard G: birth rule
  m     %   Ismember: gives true for cells that fulfill the birth rule
  <     %   Less than (element-wise): a cell is born if it fulfills the birth rule
        %   *and* was dead
  8M    %   Push result of convolution again, from clipboard M
  2G    %   Push second input from clipboard G: survival rule
  m     %   Ismember: gives true for cells that fulfill the survival rule
  b     %   Bubble up the starting cell configuration
  *     %   Multiply (element-wise): a cell survives if it fulfills the survival
        %   rule *and* was alive
  +     %   Add: a cell is alive if it has been born or has survived, and those
        %   are exclusive cases. This produces the new cell configuration
        % Implicit end loop. Implicit display

Wolfram Language (Mathematica) , 144 122 Bytes

CellularAutomaton[{Tr[2^#&/@Flatten@MapIndexed[2#+2-#2[[1]]&,{#2,#3},{2}]],{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,{{#4}}]&

Probieren Sie es online!

Anwendungsbeispiel:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

Verwendet zu Beginn ein 10x10-Zufallsgitter, überlebt entweder mit 2 oder 3 Nachbarn, Geburten mit 3 Nachbarn, Plottergebnis bei 5 Iterationen.

R , 256 Bytes

function(x,B,S,r){y=cbind(0,rbind(0,x,0),0)
n=dim(y)[1]
z=c(1,n)
f=function(h){w=-1:1
b=h%%n+1
a=(h-b+1)/n+1
'if'(a%in%z|b%in%z,0,sum(x[w+b,w+a])-x[b,a])}
while(r){x=y
for(i in 1:n^2){u=f(i-1)
y[i]=u%in%B
y[i]=(y[i]&!x[i])|(x[i]&(u%in%S))}
r=r-1}
y[-z,-z]}

Probieren Sie es online!

Leider sieht das nicht so gut aus, wie ich es mir erhofft hatte.

Eingabe : eine R-Matrix und die Challenge-Parameter. Ausgabe : die Matrix nach R Generationen.

Der Algorithmus füllt die Matrix mit Nullen auf, um die Grenzen zu handhaben. Dann iterativ: 1.) es wendet die Geburtsregel an und 2.) es tötet die vorhandenen Zellen, die die Überlebensregel nicht bestanden haben. Bei der Rückgabe wird die Polsterung entfernt.

Python 2 , 156 149 146 Bytes

lambda R,g,c:g and f(R,g-1,[[`sum(sum(l[y+y/~y:y+2])for l in c[x+x/~x:x+2])-c[x][y]`in R[c[x][y]]for y,_ in e(c)]for x,_ in e(c)])or c
e=enumerate

Probieren Sie es online!

Übernimmt die Eingabe:

• Rules: [birth,survial]Regeln als Liste von string. z.B.(['135','246'] )
• generationen: int
• configuration: Quadratisches 2D-Array von 1/0oderTrue/False

Gibt 2d Array von zurück True/False