Los autómatas celulares reales son autómatas celulares similares al Juego de la Vida de Conway, en el sentido de que operan en una cuadrícula cuadrada (teóricamente) infinitamente grande, donde cada célula tiene exactamente 8 vecinos, y es uno de los 2 estados, vivo y muerto. .

Sin embargo, estas versiones similares son diferentes de una manera crucial: las reglas para que una célula determinada cobre vida y las reglas para que una célula determinada sobreviva a la próxima generación.

Por ejemplo, el clásico Juego de la Vida usa la regla B3/S23, lo que significa que se necesitan 3 células vivas para crear una nueva, y 2 o 3 vecinos vivos para sobrevivir. Para este desafío, asumiremos que los vecinos no se incluyen a sí mismos, por lo que cada celda tiene exactamente 8 vecinos.

Su tarea es, dada una configuración inicial, una regla de nacimiento, una regla de supervivencia y un número entero positivo (el número de generaciones que se ejecutarán), simular el autómata Life-like usando esas reglas para el número de generaciones dadas en el código más corto posible . La configuración inicial será una matriz cuadrada / matriz bidimensional o una cadena multilínea, puede elegir. Los otros se pueden dar en cualquier formato y método razonable.

Por ejemplo, si la regla de nacimiento era 12345678(cualquier vecino vivo), la regla de supervivencia era 2357y la configuración 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

las siguientes dos generaciones serían

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

Si el número de generaciones dado fuera 10, el resultado sería algo similar a

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

No tiene que manejar los cambios que ocurren fuera de los límites dados por la matriz de entrada, sin embargo, todas las celdas fuera de la matriz comienzan a estar muertas. Por lo tanto, la matriz de entrada puede ser de cualquier tamaño, hasta el valor máximo que su idioma puede admitir. No tiene que dar salida a la placa entre generaciones.

Este es un código de golf, por lo que gana el código más corto.

Casos de prueba

Estos usan la B/Snotación para indicar las reglas utilizadas

B2/S2, generations = 100configuración:

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

Salida:

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 = 12configuración:

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

Salida:

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

Si necesita generar más casos de prueba, puede usar este maravilloso simulador. Asegúrate de limitar el tamaño del tablero

MATL , 24 23 bytes

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

Las entradas son:

• Matriz con regla de nacimiento
• Matriz con regla de supervivencia
• Número de generaciones
• Matriz con configuración de celda inicial, utilizando ;como separador de fila.

Pruébalo en línea! O vea los casos de prueba: 1 , 2 .

Por unos pocos bytes más puedes ver la evolución en el arte ASCII .

Explicación

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

Pruébalo en línea!

Ejemplo de uso:

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

utiliza una cuadrícula aleatoria de 10x10 como inicio, sobrevive con 2 o 3 vecinos, nace con 3 vecinos, traza el resultado en 5 iteraciones.

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

Pruébalo en línea!

Lamentablemente, esto no parece tan golfoso como esperaba.

Entrada : una matriz R y los parámetros de desafío. Salida : la matriz después de R generaciones.

El algoritmo rellena la matriz con ceros para manejar los límites. Luego, iterativamente: primero) aplica la regla de nacimiento y segundo) mata las células preexistentes que no pasaron la regla de supervivencia. El relleno se elimina al regresar.

Pitón 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

Pruébalo en línea!

Toma entrada:

• Rules: [birth,survial]reglas como lista destring . por ejemplo ( ['135','246'])
• generaciones: int
• configuration: matriz cuadrada 2D de 1/0 oTrue/False

Devuelve la matriz 2d de True/False