El juego de la vida

Aquellos puntitos negros no paran de encenderse y apagarse en la pantalla. Me quedo mirándolos durante un buen rato, casi hipnotizado. Se encienden y apagan formando curiosos patrones. Algunos patrones parecen repetirse indefinidamente y otros desaparecen tras un rato. También se van creando nuevas estructuras. Todo ese baile de puntitos me tiene intrigado.
¿Qué te parece, Alberto? -Me pregunta mi buen amigo Descollante.
Es bonito, ¿pero qué es? -Pregunto. Se trata del Juego de la Vida -me responde Descollante.
Se trata de un autómata celular inventado por John Conway, un matemático de la Univesidad de Cambridge. Ayer estuve leyendo un antiguo artículo de Martin Gardner en Scientific American llamado "The fantastic combinations of John Conway's new solitaire game life". En él se describe un curioso juego de cero jugadores en el que una gran cantidad de células nacen y mueren según las condiciones de su entorno inmediato. En cada generación de células unas sobreviven, otras mueren y algunas nacen según unas simples reglas.
Ya veo -dije sin tener muy claro qué finalidad tenía todo aquello. ¿Y cuáles son esas reglas?
Son muy sencillas. En cada generación se evalúa cada célula:
Si una célula está viva en el instante t, morirá en el instante t+1 si menos de dos o más de tres de sus vecinas están vivas en el instante t.
Por el contrario, una célula cobrará vida en el instante t+1 si exactamente tres de sus ocho vecinas están vivas en el instante t.

Pues no parecen unas reglas muy complejas -le dije. Y veo que no has tardado en implementarlo.
Sí, estoy probando una serie de patrones que he encontrado por Internet y que son muy interesantes. Mira, acabo de construir una lanzadera de naves espaciales.

Me pareció algo bastante curioso. ¿Supongo que habrá más patrones interesantes? -pregunté
Claro, mira. Estos son otros que estoy probando.

Ver esos patrones hizo aumentar mi curiosidad, así que nos pusimos a probarlos todos. Así llevávamos un buen rato cuando empezó a hablarme de que el Juego de la Vida era algo más que un simple juego. Mi amigo comenzó a contarme cómo se había demostrado que era posible crear un ordenador a partir de puertas lógicas NAND simuladas dentro de la rejilla del juego. De hecho, era posible construir una Máquina de Turing en su interior.


Bueno Alberto, me dijo mi amigo Descollante. Te reto a buscar nuevos patrones interesantes.
Como nunca he podido resistirme a un reto informático, en cuanto llegué a casa me puse a teclear un pequeño programa en Java para representar el juego. Os dejo aquí una versión simplificada que funciona en modo texto, a modo de referencia por si queréis aventuraros a implementar una versión en modo gráfico y con más funciones. En ella se muestra un ejemplo de patrón estable que a partir de cierta generación se mantiene indefinidamente cambiando entre dos estados.

1. public class JuegoVida {
2.     static int[][] antes = new int[12][12];
3.     static int[][] despues = new int[12][12];
4.     public static void main(String[] args) {
5.         int i,j;
6.         String linea;
7.         antes[5][5]=1;
8.         antes[5][7]=1;
9.         antes[6][6]=1;
10.         antes[7][6]=1;
11.         antes[8][6]=1;
12.         while(true) {
13.             for (i=1 ; i<=10 ; i++) {
14.                 for (j=1 ; j<=10 ; j++) {
15.                     despues[i][j] = nuevoEstado(i,j);
16.                 }
17.             }
18.             // mostrar celulas
19.             for (i=1 ; i<=10 ; i++) {
20.                 linea="";
21.                 for (j=1 ; j<=10 ; j++) {
22.                     if (antes[i][j] == 1)
23.                         linea += "o";
24.                     else
25.                         linea += ".";
26.                 }
27.                 System.out.println(linea);
28.             }
29.             // copiar celulas
30.             for (i=1 ; i<=10 ; i++) {
31.                 for (j=1 ; j<=10 ; j++) {
32.                     antes[i][j] = despues[i][j];
33.                 }
34.             }
35.         System.out.println("-------------------");
36.         try {
37.             Thread.sleep(500);
38.         } catch (Exception e) {}
39.         }
40.     }
41.     private static int nuevoEstado(int i, int j) {
42.         int vecinos;
43.         vecinos = antes[i-1][j-1]+antes[i][j-1]+antes[i+1][j-1];
44.         vecinos += antes[i-1][j]+antes[i+1][j];
45.         vecinos += antes[i-1][j+1]+antes[i][j+1]+antes[i+1][j+1];
46.         if ((vecinos == 3) && (antes[i][j] == 0))
47.             return 1;
48.         else if (((vecinos == 2) || (vecinos == 3)) && (antes[i][j]==1))
49.             return 1;
50.         else
51.             return 0;
52.     }
53. }