Ändere die Regeln des Lebens

15

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

Caird Coinheringaahing
quelle
Ist die Simulation toroidal?
Erik der Outgolfer 20.10.17
@EriktheOutgolfer nein, da die Matrix (theoretisch) unendlich groß ist
caird coinheringaahing
Können wir auch annehmen, dass die gegebene Matrix quadratisch ist?
Erik der Outgolfer
2
@EriktheOutgolfer "unendlich großes quadratisches Gitter"
caird coinheringaahing
Aber es heißt nicht, dass Sie davon ausgehen können, dass ... sich ändern wird.
ändern

Antworten:

9

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
Luis Mendo
quelle
Können Sie Bytes sparen, indem Sie die Reihenfolge der Eingaben ändern? Das xxam Anfang erscheint mir etwas verschwenderisch ...
Erik the Outgolfer 20.10.17
@EriktheOutgolfer Ich verstehe nicht wie. Ich muss die ersten beiden löschen, um sie später mehrmals wiederzuverwenden (eine pro Iteration), und die anderen Eingaben sind jetzt bereits implizit
Luis Mendo
Ach so, das "Löschen" der Eingaben fügt sie einer Art Eingabeliste hinzu?
Erik der Outgolfer
@EriktheOutgolfer Ja. Die MATL-Eingabe ist interaktiv, dh das Programm weiß nicht im Voraus, wie viele Eingaben es gibt. Hier bewirkt das Löschen von einem leeren Stapel, dass implizit eine Eingabe vorgenommen wird. Einmal aufgenommen, wird jede Eingabe in die Zwischenablage G kopiert und kann später abgerufen werden.
Luis Mendo
3

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.

Kelly Lowder
quelle
Schade, das eingebaute ist nur eindimensional (korrigieren Sie mich, wenn ich falsch
liege
Ich verwende die integrierte "CellularAutomaton" mit einer totalistischen Regel für 9 Nachbarn. Ein Großteil des Codes wandelt die Überlebens- / Geburtseingaben in eine Regelnummer um.
Kelly Lowder
1

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.

NofP
quelle
schöne Byteanzahl!
Giuseppe
Ich habe es geschafft, es auf 217 Bytes zu bringen, aber wenn wir genau einen weiteren Golf finden können, können wir es schaffen, zu 216dem mindestens ein Würfel gehört ...
Giuseppe
1

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

TFeld
quelle