Spiel des Lebens und der Müdigkeit

10

Stewies Spiel des Lebens und der Müdigkeit ist dem bekannteren Spiel des Lebens von Conway ziemlich ähnlich .

Das Universum des Stewie-Spiels für Leben und Müdigkeit (GoLF) ist ein unendliches zweidimensionales orthogonales Gitter quadratischer Zellen, von denen sich jede in einem von drei möglichen Zuständen befindet, lebendig, tot oder müde. Jede Zelle interagiert mit ihren acht Nachbarn, dh den Zellen, die horizontal, vertikal oder diagonal benachbart sind. Zu jedem Zeitpunkt treten folgende Übergänge auf:

  • Jede lebende Zelle mit weniger als zwei lebenden Nachbarn stirbt, als ob sie durch Unterbevölkerung verursacht würde.
  • Jede lebende Zelle mit zwei oder drei lebenden Nachbarn lebt für die nächste Generation weiter.
  • Jede lebende Zelle mit mehr als drei lebenden Nachbarn stirbt wie durch Überbevölkerung.
  • Jede tote Zelle mit genau drei lebenden Nachbarn wird wie durch Reproduktion zu einer lebenden Zelle.
  • Jede Zelle, die seit zwei aufeinanderfolgenden Generationen lebt, stirbt wie durch Müdigkeit. Es kann erst in der nächsten Generation wieder zum Leben erwachen
  • Jede Zelle, die sich außerhalb der Grenze des Eingangsgitters befindet, ist tot, als wäre sie von einer Klippe gefallen.

Herausforderung:

Ihre Herausforderung besteht darin, ein Raster mit Dimensionen n-mal-m zu nehmen, das den Anfangszustand eines GoLF und eine ganze Zahl p darstellt , und den Zustand des Spiels nach p Generationen auszugeben .

Regeln:

  • Eingabe- und Ausgabeformate sind optional, aber die Eingabe- / Ausgabegitter sollten dieselbe Darstellung haben
  • Sie können beliebige druckbare Symbole auswählen, um lebende und tote Zellen darzustellen (ich verwende sie 1für lebende Zellen und 0für tote Zellen).
  • Sie können wählen, ob Sie 0 oder 1 indiziert haben. In den Beispielen p=1bedeutet der Zustand nach einem Schritt.
  • Der kürzeste Code in jeder Sprache gewinnt
  • Eingebaute Funktionen für die zellulare Automatisierung sind zulässig

Testfälle:

In den Beispielen habe ich nur das Eingaberaster in die Eingabe aufgenommen, nicht p . Ich habe Ausgänge für verschiedene p- Werte bereitgestellt . Sie dürfen nur das Raster ausgeben, das zu einem bestimmten Eingang p gehört .

Input:
0   0   0   0   0
0   0   1   0   0
0   0   1   0   0
0   0   1   0   0
0   0   0   0   0

--- Output ---
p = 1
0   0   0   0   0
0   0   0   0   0
0   1   1   1   0
0   0   0   0   0
0   0   0   0   0

p = 2
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0

p = 3 -> All dead
---

Input:
0   1   0   0   0   0
0   0   1   0   0   0
1   1   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

--- Output ---
p = 1
0   0   0   0   0   0
1   0   1   0   0   0
0   1   1   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

p = 2
0   0   0   0   0   0
0   0   0   0   0   0
1   0   0   0   0   0
0   1   1   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 3
0   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   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 4 -> All dead
Input
0   1   1   0   1   1   0
1   1   0   1   1   1   1
0   1   0   0   0   1   0
0   0   0   1   1   0   1
1   0   0   1   0   1   1
0   0   1   1   0   1   1
1   1   0   0   0   0   1

--- Output ---
p = 1
1   1   1   0   0   0   1
1   0   0   1   0   0   1
1   1   0   0   0   0   0
0   0   1   1   0   0   1
0   0   0   0   0   0   0
1   0   1   1   0   0   0
0   1   1   0   0   1   1

p = 2
1   0   0   0   0   0   0
0   0   0   0   0   0   0
1   0   0   1   0   0   0
0   1   1   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   1   1   0   0   0   

p = 3
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   1   0   0   0   0
1   1   0   0   0   0   0
0   1   1   0   0   0   0
0   0   1   0   0   0   0
0   0   0   0   0   0   0

p = 4
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   1   0   0   0   0
1   0   0   0   0   0   0
1   0   1   0   0   0   0
0   1   1   0   0   0   0
0   0   0   0   0   0   0

p = 5
0   0   0   0   0   0   0
0   1   0   0   0   0   0
1   0   0   0   0   0   0
0   0   1   0   0   0   0
1   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0

p = 6
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
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

p = 7
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   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

p = 8
0   0   0   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
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 9 -> All dead

Ja, ich bin mir bewusst, dass alle anfänglichen Samen nicht dazu führen, dass alle Zellen tot sind.

code-golf grid matrix cellular-automata game-of-life Stewie Griffin
quelle
Sie sollten vielleicht klarstellen, dass der Übergangspunkt 5 "zur gleichen Zeit" wie die Punkte 1 bis 4 angewendet wird, dh er basiert auf dem Status, bevor er 1 bis 4 angewendet wurde
Luis Mendo
2
" Zellen, von denen sich jede in einem von zwei möglichen Zuständen befindet, lebendig oder tot " scheint eine absichtlich perverse Definition zu sein, da die spätere Ermüdungsregel nur in einem endlichen Standardautomaten ausgedrückt werden kann, indem jede Zelle drei Zustände aufweist (tot, neu) lebendig, lebendig für zwei aufeinanderfolgende Generationen)
Peter Taylor
1
Ich habe eine Golly-Regel dafür, wenn jemand es will.
CalculatorFeline
6
GoD spielen, was?
Adám

Antworten:

3

MATL , 34 30 25 Bytes

5 Bytes entfernt dank eines Vorschlags von @CalculatorFeline !

0ii:"wy*~wt3Y6QZ+5:7mb*]&

Probieren Sie es online aus!

Eingaben sind eine Matrix und eine Zahl. Die Matrix wird ;als Zeilentrennzeichen verwendet. Die Matrizen für die drei Testfälle werden als eingegeben

[0 0 0 0 0; 0 0 1 0 0; 0 0 1 0 0; 0 0 1 0 0;0 0 0 0 0]
[0 1 0 0 0 0; 0 0 1 0 0 0; 1 1 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 1 1 0 1 1 0; 1 1 0 1 1 1 1; 0 1 0 0 0 1 0; 0 0 0 1 1 0 1; 1 0 0 1 0 1 1; 0 0 1 1 0 1 1; 1 1 0 0 0 0 1]

Erläuterung

0     % Push 0. This represents the generation previous to the input one. Actually
      % This should be an array of zeros, but thanks to broadcasting it is
      % equivalent (and saves bytes)
i     % Input: array with starting generation
i     % Input: number of iterations, p.
      % STACK (bottom to top): 0, array with initial generation, p
:"    % Do the following p times
      %   STACK: previous gen, current gen
  wy  %   Swap, duplicate from below
      %   STACK: current gen, previous gen, current gen
  *~  %   Multiply element-wise, negate. This creates a mask of cells that do not 
      %   die of fatigue (they were 0 in the current or in the previous generation)
      %   STACK: current gen, fatigue mask
  wt  %   Swap, duplicate
      %   STACK: Fatigue mask, current gen, current gen
  3Y6 %   Push predefined literal: 8-neighbourhood: [1 1 1; 1 0 1; 1 1 1]
      %   STACK: Fatigue mask, current gen, current gen, 8-neighbourhood
  Q   %   Add 1 element-wise. This gives [2 2 2; 2 1 2; 2 2 2], which will be
      %   used as convolution kernel. Active cells with 2 neighbours will give 5;
      %   inactive cells with 3 neighbours will give 6; and active cells with 3
      %   neighbours will give 7
      %   STACK: Fatigue mask, current gen, current gen, convolution kernel
  Z+  %   2D convolution, keeping size
      %   STACK: Fatigue mask, current gen, convolution result
  5:7 %   Push array [5 6 7]
  m   %   Ismember, element-wise. Cells that give true will survive, unless fatigued
      %   STACK: Fatigue mask, current gen, cells that can survive
  b   %   Bubble up
      %   STACK: Current gen, cells that can survive, fatigue mask
  *   %   Multiply element-wise. This tells which cells survive considering fatigue.
      %   The result is the new generation
      %   STACK: "Current" gen which now becomes old, "new" gen which now becomes
      %   current
]     % End 
&     % Specify that implicit display will show only top of the stack
Luis Mendo
quelle
1
Können Sie das 3Y6näher erläutern? Wenn das mittlere Element des Kernels war .5, können Sie CGOL mit just überprüfen 2<value<4. Könnte helfen.
CalculatorFeline
@CalculatorFeline Das ist ein sehr guter Vorschlag, danke! Dies führte dazu, dass 5 Bytes eingespart wurden, die doppelte Maske verwendet und diese dann getestet wurden 5<=value<=7. Was 3Y6, es ist nur eine vordefinierte wörtliche. Es gibt auch 1Y6, das ist die 4-Nachbarschaft
Luis Mendo
1
Huh. Das hat tatsächlich funktioniert. Ordentlich.
CalculatorFeline
3

APL (Dyalog Classic 16.0) , 59 Byte

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⎕U233A 3 3⍣⎕⊢⎕

Probieren Sie es online aus! (emuliert auf Classic 15.0)

APL (Dyalog Unicode 16.0) , 85 Byte

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⌺3 3⍣⎕⊢⎕

Probieren Sie es online aus! (emuliert auf Unicode 15.0)

Fordert zur Eingabe des Rasters und dann zur Eingabe von p auf . Druckt das neue Raster nach p Generationen.

Beachten Sie, dass hierfür das neue ⌺Grundelement (Schablone) verwendet wird, das nicht im klassischen Zeichensatz enthalten ist, daher eine kürzere Version und eine Version mit weniger Bytes.

Erklärung folgt…

Adam
quelle
Das Anzeigeformat von APL ist gut :-)
Luis Mendo
@LuisMendo Eigentlich handelt es sich nicht um "APLs", sondern der Interpreter ruft diese APL-Funktion zurück, wenn er sie ausgeben möchte. Die Funktion analysiert dann, was wir ausgeben möchten, und ändert es entsprechend. Erklärung für die displayFunktion finden Sie hier .
Adám
3

Golly RuleLoader, 295 Bytes

@RULE Y
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var z={1,2}
var y=z
var x=z
var w=z
var u=z
var a={0,z}
var b=a
var c=a
var d=a 
var e=a
var f=a
var g=a 
var h=a
0,z,y,x,0,0,0,0,0,1
z,a,0,0,0,0,0,0,0,0
z,y,x,w,u,a,b,c,d,0
2,a,b,c,d,e,f,g,h,0
1,a,b,c,d,e,f,g,h,2
@COLORS
2 255 0 0

Das Eingaberaster sollte eingefügt werden. Die Grenzen befinden sich im Regelnamen (z. B. 5* 3ist Y:P5,3). Drücken Sie die Leertaste, um fortzufahren .

CalculatorFeline
quelle
2

Java 8, 333 Bytes

int[][]G(int p,int[][]s){for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],i=0;i++<2*p;)for(y=0;y<h;++y)for(x=0;x<w;++x)if(i%2>0){for(n=0,a=y-2;++a<y+2;)for(b=x-2;++b<x+2;)n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;}else s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];return s;}

Erläuterung:

int[][]G(int p,int[][]s){
    for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],       //height, width, vars, temp array
            i=0;i++<2*p;)                                                 //for 2*generations: 1. calculate in temporary t, 2. copying to s
        for(y=0;y<h;++y)                                                  //for each row
            for(x=0;x<w;++x)                                              //for each column
                if(i%2>0){                                                //1. calculate
                    for(n=0,a=y-2;++a<y+2;)                               //n = number of alive cells around [y][x]. row above, at and below y
                        for(b=y-2;++b<y+2;)                               //column left, at and right of x
                            n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;    //if within bounds and not the cell itself, add 1 if alive.
                    t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;     //save next state in temporary, depending on rules. alive cells become 2.
                }
                else                                                      //2. copy temporary t to s
                    s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];                   //if last generation, replace 2 by 1
    return s;
}
Sebastian Matschke
quelle