Dato lo stato di una griglia quadrata di Game of Life, determina se potrebbe essersi evoluto da uno stato precedente o se fosse stato creato. Cioè, identificare se lo stato è uno stato "Giardino dell'Eden" .

Ingresso

Una griglia quadrata di stati, con 1 che indica "vivo" e 0 che indica "morto". Se lo desideri, puoi scegliere due simboli distinguibili anziché 0 e 1.

La lunghezza laterale della griglia non sarà zero, ma può essere qualsiasi numero naturale 1 <= N <= 20.

Una o tutte le celle esterne alla griglia di input potrebbero essere attive in questa generazione e alcune o tutte potrebbero essere state attive nella generazione precedente. L'universo da considerare è infinito, quindi non ci sono condizioni al contorno. I bordi dell'input non sono i bordi dell'universo. In particolare, la griglia non si avvolge.

L'input può essere nella forma di una stringa delimitata da righe o di una singola stringa. Se lo desideri, puoi prendere la lunghezza laterale o l'area della griglia come input aggiuntivo (prima o dopo la griglia).

Formati di input accettabili:

010,101,010

010101010

010
101
010
3 010101010

Produzione

"Creato" se non è possibile uno stato precedente (inclusi stati più grandi della griglia di input) che porterebbe allo stato di input sulla generazione successiva.

"Evoluto" se esiste almeno un possibile stato precedente (inclusi stati maggiori della griglia di input) che porterebbe allo stato di input sulla generazione successiva.

Se lo desideri, puoi utilizzare due stringhe o numeri distinguibili anziché "Creato" e "Evoluto".

Si noti che il possibile stato precedente non deve essere distinto dall'input. Se uno stato ha se stesso come la prossima generazione, allora dovrebbe essere considerato evoluto.

Casi test

010
101
010 Evolved

0101110100
0010101001
1011100110
0101111101
1001001111
1111001001
1011111010
0110011101
1001010100
0010111010 Created

Il test case creato è tratto dalla pagina Game of Life di Achim Flammenkamp .

Nota

Grazie a trichoplax per aver scritto questa sfida e l'ho adottata da qui

Java - 1254 byte - una soluzione molto scadente

import java.util.Arrays;
public class z{
static boolean u=1>0,v=0<1;
public static void main(String[] a){
int y=a.length,x=a[0].length();Boolean[][] l=new Boolean[x][y];for(int i=0;i<a.length;i++){l[i]=m(a[i]);}
Boolean[] n=new Boolean[x*y];for(int i=0;i<n.length;i++){n[i]=v;}
while(n.length==x*y){Boolean[][] o=new Boolean[x][y];for(int i=0; i<n.length;i++){o[i%x][i/x]=n[i];}
n=p(n);o=q(o,x,y);int r=0;for(int i=0;i<x*y;i++){if(o[i%x][i/x]&&l[i%x][i/x])r++;}
if(r==x*y){System.out.println("evolved");return;}}System.out.println("created");}
public static Boolean[][] q(Boolean[][] o,int bx,int by){Boolean[][] s=new Boolean[bx][by];for(int x=0; x<bx; x++){for(int y=0;y<by;y++){
int t=0;for(int tx=-1;tx<2;tx++){for(int ty=-1;ty<2;ty++){if(ty+y<0||ty+y>by-1||tx+x<0||tx+x>bx-1)continue;if(o[tx+x][ty+y]){t++;}}}
if(t>1&&t<4){s[x][y]=u;}else{s[x][y]=v;}}}return s;}
public static Boolean[] p(Boolean[] b){boolean w=u;Boolean[] x=new Boolean[b.length];for(int i=0;i<b.length;i++){if(w&&b[i]){x[i]=u;w=u;}else if(b[i]||w){x[i]=u;w=v;}else{x[i]=v;w=v;}
}if(w){x=Arrays.copyOf(x,x.length+1);x[x.length]=u;}return x;}
public static Boolean[] m(String s){Boolean[] x=new Boolean[s.length()];for(int i=0;i<s.length();i++){x[i]=s.charAt(i)=='1';}return x;}}

Prende l'input dalla riga di comando.

Cosa fa

Nessun trucco di fantasia qui, semplicemente una soluzione di forza bruta. Passa attraverso ogni possibile scheda iniziale di dimensioni X, Y e lo scorre una volta attraverso l'algoritmo Game of Life e lo verifica rispetto alla scheda di input. Ciò richiede MOLTO tempo, poiché ogni scheda di dimensioni x per y ha 2 ^ (x * y) combinazioni possibili. Ci sono voluti quasi 10 minuti per eseguire una scheda 4x5. Stupidamente sciocco per qualcosa di più semplice di quello che è.

Se è possibile che fosse una tavola evoluta, stampa "evoluta" e, se non poteva essere evoluta, stampa "creata".