Dado o estado de uma grade quadrada do Jogo da Vida, determine se ela poderia ter evoluído de qualquer estado anterior ou apenas poderia ter sido criada. Ou seja, identifique se o estado é um estado "Jardim do Éden" .

Entrada

Uma grade quadrada de estados, com 1 indicando "vivo" e 0 indicando "morto". Você pode escolher dois símbolos distintos, em vez de 0 e 1, se desejar.

O comprimento lateral da grade não será zero, mas pode ser qualquer número natural 1 <= N <= 20.

Qualquer uma ou todas as células fora da grade de entrada podem estar ativas nesta geração, e qualquer uma ou todas elas podem estar ativas na geração anterior. O universo a ser considerado é infinito, portanto não há condições de contorno. As arestas da entrada não são as arestas do universo. Especificamente, a grade não quebra.

A entrada pode estar na forma de uma sequência delimitada por linha ou uma única sequência. Se desejar, você pode considerar o comprimento lateral ou a área da grade como uma entrada adicional (antes ou depois da grade).

Formatos de entrada aceitáveis:

010,101,010

010101010

010
101
010
3 010101010

Resultado

"Criado" se não houver um estado anterior possível (incluindo estados maiores que a grade de entrada) que levaria ao estado de entrada na próxima geração.

"Evoluiu" se existir pelo menos um estado anterior possível (incluindo estados maiores que a grade de entrada) que levaria ao estado de entrada na próxima geração.

Você pode usar duas seqüências ou números distinguíveis em vez de "Criado" e "Evoluído", se desejar.

Observe que o possível estado anterior não precisa ser diferente da entrada. Se um estado se apresenta como a próxima geração, deve ser considerado evoluído.

Casos de teste

010
101
010 Evolved

0101110100
0010101001
1011100110
0101111101
1001001111
1111001001
1011111010
0110011101
1001010100
0010111010 Created

O caso de teste criado foi retirado da página Game of Life, de Achim Flammenkamp .

Nota

Agradeço à Trichoplax por escrever este desafio e o adotei daqui

Java - 1254 bytes - uma solução muito ruim

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

Recebe entrada via linha de comando.

O que faz

Não há truques sofisticados aqui, simplesmente uma solução de força bruta. Ele percorre todas as placas possíveis de tamanho X, Y e a itera uma vez através do algoritmo Game of Life e a verifica na placa de entrada. Isso leva muito tempo, pois cada placa de tamanho x por y tem 2 ^ (x * y) combinações possíveis. Demorou quase 10 minutos para executar uma placa 4x5. Estupidamente bobo para algo que é mais simples do que é.

Se é possível que fosse um quadro evoluído, ele imprime "evoluiu" e, se não puder ter sido desenvolvido, imprime "criado".