Autômatos celulares semelhantes à vida são autômatos celulares semelhantes ao Jogo da Vida de Conway, na medida em que operam em uma grade quadrada infinitamente grande (teoricamente), onde cada célula tem exatamente 8 vizinhos e é um dos 2 estados, vivo e morto. .

No entanto, essas versões semelhantes são diferentes de maneira crucial: as regras para uma determinada célula ganhar vida e as regras para uma determinada célula sobreviver até a próxima geração.

Por exemplo, o clássico Game of Life usa a regra B3/S23, o que significa que são necessárias 3 células vivas para gerar uma nova e 2 ou 3 vizinhos vivos para sobreviver. Para esse desafio, assumiremos que os vizinhos não se incluem, portanto cada célula tem exatamente 8 vizinhos.

Sua tarefa é, dada uma configuração inicial, uma regra de nascimento, uma regra de sobrevivência e um número inteiro positivo (o número de gerações a serem executadas), simular o autômato do tipo Life usando essas regras para o número de gerações indicado no código mais curto possível . A configuração inicial será uma matriz quadrada / matriz bidimensional ou uma sequência multilinha, você pode escolher. Os outros podem ser fornecidos em qualquer formato e método razoável.

Por exemplo, se a regra de nascimento era 12345678(qualquer vizinho vivo), a regra de sobrevivência era 2357e a configuração inicial era

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

as próximas duas gerações seriam

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

Se o número de gerações dado fosse 10, o resultado seria algo parecido com o

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

Você não precisa lidar com as mudanças que ocorrem fora dos limites fornecidos pela matriz de entrada; no entanto, todas as células fora da matriz começam inoperantes. Portanto, a matriz de entrada pode ter qualquer tamanho, até o valor máximo que seu idioma pode suportar. Você não precisa produzir o quadro entre gerações.

Este é um código de golfe, portanto o código mais curto vence.

Casos de teste

Eles usam a B/Snotação para indicar as regras usadas

B2/S2, generations = 100configuração:

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

Resultado:

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 = 12configuração:

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

Resultado:

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

Se você precisar gerar mais casos de teste, poderá usar este maravilhoso simulador. Certifique-se de limitar o tamanho da placa

MATL , 24 23 bytes

xx:"tt3Y6Z+1Gm<8M2Gmb*+

As entradas são:

• Matriz com regra de nascimento
• Matriz com regra de sobrevivência
• Número de gerações
• Matriz com configuração inicial da célula, usando ;como separador de linhas.

Experimente online! Ou veja os casos de teste: 1 , 2 .

Por mais alguns bytes, você pode ver a evolução na arte ASCII .

Explicação

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

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}}]&

Experimente online!

Exemplo de uso:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

usa uma grade aleatória de 10x10 como início, sobrevive com 2 ou 3 vizinhos, nasce com 3 vizinhos, obtém o resultado da plotagem em 5 iterações.

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

Experimente online!

Infelizmente, isso não parece tão bom quanto eu esperava.

Entrada : uma matriz R e os parâmetros de desafio. Saída : a matriz após as gerações R.

O algoritmo preenche a matriz com zeros para manipular os limites. Em seguida, iterativamente: 1) aplica a regra de nascimento e 2) mata as células pré-existentes que não passaram na regra de sobrevivência. O estofamento é removido ao retornar.

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

Experimente online!

Toma entrada:

• Rules: [birth,survial]regras como lista de string. por exemplo. ( ['135','246'])
• generações: int
• configuration: matriz quadrada 2D de 1/0ouTrue/False

Retorna 2d matriz de True/False