Il gioco della vita e la fatica di Stewie è abbastanza simile al più famoso gioco della vita di Conway .

L'universo di Stewie's Game of Life and Fatigue (GoLF) è una griglia ortogonale bidimensionale infinita di celle quadrate, ognuna delle quali si trova in uno dei tre stati possibili, vivo, morto o stanco. Ogni cellula interagisce con i suoi otto vicini, che sono le celle adiacenti orizzontalmente, verticalmente o diagonalmente. Ad ogni passaggio nel tempo, si verificano le seguenti transizioni:

Ogni cellula viva con meno di due vicini vivi muore, come se fosse causata da sottopopolazione.
Qualsiasi cellula viva con due o tre vicini vivi vive alla generazione successiva.
Ogni cellula viva con più di tre vicini vivi muore, come se fosse sovrappopolata.
Qualsiasi cellula morta con esattamente tre vicini vivi diventa una cellula viva, come per riproduzione.
Ogni cellula che è stata in vita per due generazioni consecutive muore, come se fosse affaticata. Non può tornare alla vita fino alla prossima generazione
Qualsiasi cella che si trova al di fuori del limite della griglia di input è morta, come se fosse caduta da una scogliera.

Sfida:

La tua sfida è prendere una griglia di dimensioni n-per-m che rappresenta lo stato iniziale di un GoLF e un numero intero p , e generare lo stato del Gioco dopo p generazioni.

Regole:

I formati di input e output sono facoltativi, ma le griglie input / output devono avere la stessa rappresentazione
Puoi scegliere qualsiasi simbolo stampabile per rappresentare le cellule vive e morte (userò 1per le cellule vive e 0per le cellule morte).
Puoi scegliere se hai 0 o 1 indicizzato. Negli esempi, p=1indica lo stato dopo un passaggio.
Vince il codice più corto in ogni lingua
Sono consentite le funzioni integrate per l'automazione cellulare

Casi test:

Negli esempi, ho incluso solo la griglia di input nell'input, non p . Ho fornito output per vari valori p . Devi solo generare la griglia che accompagna un dato input p .

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

_{Sì, sono consapevole che tutti i semi iniziali non finiranno in tutte le cellule morte.}

— Stewie Griffin
fonte

Dovresti forse chiarire che l'elemento di transizione 5 viene applicato "contemporaneamente" agli articoli 1--4, ovvero si basa sullo stato prima di aver applicato 1--4

— Luis Mendo,

2

" cellule, ognuna delle quali si trova in uno dei due possibili stati, viva o morta " sembra una definizione deliberatamente perversa dato che la successiva regola della fatica può essere espressa solo in un automa standard finito facendo sì che ogni cellula abbia tre stati (morto, nuovo vivo, vivo per due generazioni consecutive)

— Peter Taylor,

1

Ho una regola golosa per questo se qualcuno lo vuole.

— Calcolatrice

6

Giocare a GoD, eh?

— Adám,

3

MATL , 34 30 25 byte

5 byte rimossi grazie a un suggerimento di @CalculatorFeline !

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

Provalo online!

Gli input sono una matrice e un numero. La matrice utilizza ;come separatore di righe. Le matrici per i tre casi di test sono inserite come

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

Spiegazione

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
fonte

1

Puoi spiegarci 3Y6più in dettaglio? Inoltre, se l'elemento centrale del kernel fosse .5, puoi controllare CGOL con just 2<value<4. Potrebbe aiutare.

— Calcolatrice

@CalculatorFeline È un ottimo suggerimento, grazie! Ha portato al salvataggio di 5 byte, usando il doppio della maschera e quindi testandolo 5<=value<=7. Per quanto riguarda 3Y6, è solo un letterale predefinito. C'è anche 1Y6, che è il 4-vicinato

— Luis Mendo il

1

Huh. In realtà ha funzionato. Neat.

— Calcolatrice

3

APL (Dyalog Classic 16.0) , 59 byte

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

Provalo online! (emulato su Classic 15.0)

APL (Dyalog Unicode 16.0) , 85 byte

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

Provalo online! (emulato su Unicode 15.0)

Richiede la griglia e quindi p . Stampa la nuova griglia dopo p generazioni.

Si noti che questo utilizza la nuova ⌺primitiva (Stencil) che non è inclusa nel set di caratteri Classic, quindi una versione più breve e una versione con meno byte.

Spiegazione da seguire ...

— Adamo
fonte

Il formato di visualizzazione di APL è piacevole :-)

— Luis Mendo,

@LuisMendo In realtà, non è "APL", ma piuttosto l'interprete effettua un callback a questa funzione APL quando vuole eseguire l'output. La funzione quindi analizza ciò che vogliamo produrre e lo modifica di conseguenza. Spiegazione per la displayfunzione è qui .

— Adám,

3

Golly RuleLoader, 295 byte

@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

La griglia di input deve essere incollata, i confini sono nel nome della regola (ad es. 5* 3È Y:P5,3), premere spazio per avanzare.

— CalculatorFeline
fonte

2

Java 8, 333 byte

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

Spiegazione:

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
fonte