El matemático John Horton Conway creó en un juego matemático en donde se modificaban estados de manera ininterrumpida sin la necesidad de interacción de algún jugador. Esto se hace mediante un autómata celular y una serie de reglas en las cuales se define su muerte, nacimiento o superviviencia. Estos tres estados del autómata permiten la generación infinita de estados. La idea general es mostrar como la evolución logra generar increíbles combinaciones.

Para tener una idea completa del juego, invito a todos los lectores leer un excelente artículo clásico donde se describe en detalle las reglas y algunas características del mismo. [Link]

En esta breve entrada, lo que voy a hacer es presentarles cómo implementar el juego y basada en unas sencillas reglas.

Game of life
Game of life in Python

Reglas del juego:

  • Una nueva célula nace cuando:
    • Si una célula está muerta y en la vecindad existen exáctamente tres células vivas se activa
  • Una célula se muere cuando:
    • Sobre población: 4 Células vivas o mas en su vecindad
    • Aislamiento: No hay células vivas en su vecindad
  • Cuándo sigue viva
    • Cuando existen 2 o 3 células en su vecindad

Ahora bien, cómo definimos una vecidad? Es sencillo, como en todo autómata celular tenermos que definir que puede ver una célula. En este caso vamos a movernos en un plano dos dimencional en forma de rejilla, formalmente lattice. Para poder ilustrar mejor el ejemplo veamos un esquema:


    ---
    -#-
    ---

El símbolo de gato muestra la célula a la cual se está haciendo referencia, y los símbolos menos son las celdas de vecindad.

Si planteamos las reglas en forma de pseudocódigo, obtendríamos:

 

1. muerte
    Si V < 2 o V > 3:
        C.viva = no
2. nace
    Si C.viva != Si y V == 3:
        C.viva = Si
3. vive
    Si V == 2 o V == 3:
        C.viva = Si

A continuación mostraré el código donde se implementa el juego . Para ello se necesitará python3 y las bibliotecas matpotlib y numpy. Para ejecutar el juego se tiene que ejecutar de la sigueinte manera:

$ python li.py SIZE TIMES

Espero esta implementación e introducción les guste.

import numpy as np
import sys
import matplotlib.pyplot as plt
from matplotlib import animation

lifes=[]

def play_life(a):
xmax, ymax = a.shape
b = a.copy()
for x in range(xmax):
for y in range(ymax):
n = np.sum(a[max(x - 1, 0):min(x + 2, xmax), max(y - 1, 0):min(y + 2, ymax)]) - a[x, y] # Definimos vecindad
if a[x, y]:
if n < 2 or n > 3:
b[x, y] = 0 # regla 1 and 3
elif n == 3:
b[x, y] = 1 # regla 4
# Sigue viva cuando hay 2 o tres células en su vecindad
return(b)

def play(size, times):
life = np.zeros((size, size), dtype=np.byte)

lifem = []
for x in range(size):
for y in range(size):
life[x,y]=np.random.binomial(1, 0.2)


for i in range(times):
life = play_life(life)
lifem.append(life.copy())
return lifem

def animate(i):
m = lifes[i]
out = plt.imshow(m, interpolation='nearest', cmap=plt.cm.gray)
return out


if __name__ == "__main__":
if len(sys.argv) != 3:
print("Usage: python3 li.py SIZE TIMES")
sys.exit(1)
size = int(sys.argv[1])
times = int(sys.argv[2])
lifes = play(size,times)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.set_aspect('equal')

anim = animation.FuncAnimation(fig, animate, frames=times-1)
plt.show()

Share This