Cambia las reglas de la vida

15

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

caird coinheringaahing
fuente
¿Es la simulación toroidal?
Erik the Outgolfer
@EriktheOutgolfer no, ya que la matriz es (teóricamente) de tamaño infinito
caird coinheringaahing
Además, ¿podemos suponer que la matriz dada es cuadrada?
Erik the Outgolfer
2
@EriktheOutgolfer "cuadrícula cuadrada infinitamente grande"
caird coinheringaahing
Pero no dice que pueda asumir que ... se editará.
Erik the Outgolfer

Respuestas:

9

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
Luis Mendo
fuente
¿Se pueden guardar bytes cambiando el orden de las entradas? Al xxprincipio me parece un poco derrochador ...
Erik the Outgolfer
@EriktheOutgolfer No veo cómo. Necesito eliminar los dos primeros para ellos volver a utilizar más adelante varias veces (una por cada iteración), y las otras entradas ya están implícitos ahora
Luis Mendo
Ah, ¿entonces "borrar" las entradas las agrega a algún tipo de lista de entradas?
Erik the Outgolfer
@EriktheOutgolfer Sí. La entrada MATL es interactiva, lo que significa que el programa no sabe de antemano cuántas entradas hay. Aquí, eliminar de una pila vacía hace que una entrada se tome implícitamente. Una vez tomadas, cada entrada se copia en el portapapeles G, y se pueden recuperar más tarde.
Luis Mendo
3

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.

Kelly Lowder
fuente
Lástima que la construcción sea solo unidimensional (
corrígeme
Estoy usando el "CellularAutomaton" incorporado con una regla totalista de 9 vecinos. Gran parte del código convierte las entradas de supervivencia / nacimiento en un número de regla.
Kelly Lowder
1

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.

NofP
fuente
buen conteo de bytes!
Giuseppe
Me las arreglé para llegar a 217 bytes, pero si podemos encontrar exactamente un campo de golf más, podemos llegar al 216que es al menos un cubo ...
Giuseppe
1

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

TFeld
fuente