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 2357
y 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/S
notación para indicar las reglas utilizadas
B2/S2
, generations = 100
configuració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 = 12
configuració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
fuente
Respuestas:
MATL ,
2423 bytesLas entradas son:
;
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
fuente
xx
principio me parece un poco derrochador ...Wolfram Language (Mathematica) ,
144122 bytesPruébalo en línea!
Ejemplo de uso:
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.
fuente
R , 256 bytes
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.
fuente
216
que es al menos un cubo ...Pitón 2 ,
156149146 bytesPruébalo en línea!
Toma entrada:
R
ules:[birth,survial]
reglas como lista destring
. por ejemplo (['135','246']
)g
eneraciones:int
c
onfiguration: matriz cuadrada 2D de1/0
oTrue/False
Devuelve la matriz 2d de
True/False
fuente