Identificador: asma-aaaj
Introducción
El llamado "Juego de la Vida" fue propuesto por John H. Conway en 1970. En realidad no se trata de un juego, sino de una simulación de la evolución. El juego consiste en una cuadrícula en dos dimensiones de celdas cuadradas, cada una de las cuales puede tener dos estados, viva o muerta. Cada celda tiene ocho celdas vecinas (si la cuadrícula fuera infinita o bien si se trata de una celda interior) contiguas. Las celdas evolucionan de una generación a otra y en cada paso pueden ocurrir las siguientes transiciones:
1. Una celda viva con menos de dos vecinas vivas muere (de soledad),
2. Una celda viva con más de tres vecinas vivas muere (por sobrepoblación),
3. Una celda viva con dos o tres vecinas vivas se conserva viva,
4. Una celda muerta con exactamente tres vecinas vivas pasa a viva.
La primera generación o patrón inicial se genera aleatoriamente. El proyecto consiste en generar un patrón inicial y realizar la simulación un cierto número de generaciones.
Introducción
Elabora un programa que simule el Juego de la Vida. Los datos al programa son:
m, n,
vivas,
numero
Con:
1 ≤ m, n ≤ 20 enteros. Dimensiones del mundo (m renglones, n columnas),
vivas entero. Número inicial de celdas vivas,
numero entero. Representa el número de generaciones que se simularán.
El mundo se representará internamente por medio de un arreglo de dos dimensiones. Si el mundo tiene una dimensión de mxn, se almacenará en el arreglo en los índices del 1 al m para los renglones y del 1 al n para las columnas. Esto con el objeto que el mundo quede enmarcado en un cuadrado de celdas muertas y así todas las celdas tengan ocho vecinas. Es decir, los renglones 0 y m+1, así como las columnas 0 y n+1 serán siempre cero. Las dimensiones máximas del mundo están dadas por la constante TAM.
Especificación de funciones
El programa debe contener las siguientes funciones:
void cero(int mundo[TAM][TAM], int m, int n), esta función pone en cero todas las celdas del arreglo mundo entre los índices 0 y m+1 para los renglones y 0 y n+1 para las columnas. Se usa al inicio del programa.
void genera(int mundo[TAM][TAM], int m, int n, int num), esta función genera la configuración inicial del mundo (de mxn) con exactamente num celdas vivas.
int cuentaVecinos(int mundo[TAM][TAM], int m, int n, int r, int c), esta función regresa como valor el número de vecinas vivas a la celda (r,c) en el mundo de mxn.
void nuevoMundo(int mundo[TAM][TAM], int m, int n, int nuevo[TAM][TAM]), función que calcula la siguiente generación del mundo de mxn, nuevo es el nuevo mundo.
void copia(int mundo[TAM][TAM], int m, int n, int nuevo[TAM][TAM]), como su nombre lo indica, copia el nuevo mundo en el mundo, ambos de dimensiones mxn.
void escribe(int mundo[TAM][TAM], int m, int n), para escribir en la pantalla el mundo de mxn. Si una celda está viva se escribe ‘*’, de lo contrario, si está muerta, se escribe espacio ‘ ‘. Después de escribir el mundo se puede borrar la pantalla para que al escribir sucesivamente los mundo efectivamente se vea como una animación.
La función main() quien se encarga de leer los datos y llamar adecuadamente a las funciones anteriores.
Ejemplo de ejecución
renglones? 10
columnas? 20
numero de celdas? 50
numero de generaciones? 3
* ** *** **
* *** *
* * * ** *
* * * ****
* * * * *
***** * **
***
* *
* * *
* * *
* ** * **
* * * * *
***** *** *
** ***** **
***** * * * *
**** **
* ***** *
*
* *
*
*** **
* ** *
* * * **
*** * ***
* ** * * **
* *
* *
* ** *
*
*
** ***
**** * **
*** **
*** **
** ** *
* * *
*
*
***
Presione una tecla para continuar . . .