El juego de la vida es en realidad un juego de cero jugadores, lo que quiere decir que su

evolución está determinada por el estado inicial y no necesita ninguna entrada de datos
posterior. El tablero de juego es una malla formada por cuadrados ("células") que se extiende
por el infinito en todas las direcciones. Cada célula tiene 8 células vecinas, que son las que están
próximas a ella, incluyendo las diagonales.  Las células que se encuentran en los extremos del
tablero no son adyacentes. Las células tienen dos estados: están "vivas" o "muertas". El estado
de la matriz evoluciona a lo largo de unidades de tiempo discretas (se podría decir que por
turnos). El estado de todas las células se tiene en cuenta para calcular el estado de las mismas
al turno siguiente. Todas las células se actualizan en cada turno. Las transiciones dependen del
número de células vecinas vivas:
   -Una célula muerta con exactamente 3 células vecinas vivas "nace" (al turno siguiente estará
viva).
   -Una célula viva con 2 o 3 células vecinas vivas sigue viva.
   -Una célula viva que tenga 0 o 1 células vecinas muere por “soledad“.
   -Una célula que tenga más de 3 vecinas vivas o permanece muerta o muere por
"sobrepoblación".

Diseña un programa en Java que simule una versión reducida del juego de la vida, teniendo en
cuenta las siguientes restricciones:

   -Las dimensiones de la matriz son N x N, esto es, una matriz cuadrada, que no podrá superar
las 25 casillas de
   largo y ancho.
   -La colocación de las células vivas se podrá realizar de forma aleatoria o bien manualmente
por el usuario.
   -El número de células vivas a poner vendrá determinado por un porcentaje que determine el
usuario por
   teclado. Esto es, suponiendo que el usuario introduce 25% y el tablero es de 10x10, entonces
el número de
   células vivas a colocar sería el 25% de 100 (10*10).
 
Una vez creada la matriz y cargadas las células vivas, se mostrará la 1ª generación o generación
inicial. A continuación se preguntará al usuario si quiere mostrar la generación siguiente o si
quiere terminar. En caso de crear una nueva generación de células, se mostrarán la generación
siguiente y la anterior, para poder comparar los cambios. El juego termina a petición del usuario
o cuando no haya cambios de estados en 3 generaciones sucesivas.
Posible Solución

El problema nos coloca en donde al iniciar el programa ya tiene determinadas las posiciones de
las células en el tablero y este se vaya actualizando.

El problema plantea 4 casos

   -Una célula muerta con exactamente 3 células vecinas vivas "nace" (al turno siguiente estará
viva).
   -Una célula viva con 2 o 3 células vecinas vivas sigue viva.
   -Una célula viva que tenga 0 o 1 células vecinas muere por “soledad “.
   -Una célula que tenga más de 3 vecinas vivas o permanece muerta o muere por
"sobrepoblación".

CONDICIONALES LOS CUALES SE APLICARIAN CON METODOS DE SWITCH/IF USANDO TIPO DE

DATOS BOOLEANOS.

Además de darnos ciertas restricciones a nuestro programa

   -Las dimensiones de la matriz son N x N, esto es, una matriz cuadrada, que no podrá superar
las 25 casillas de
   largo y ancho.
   -La colocación de las células vivas se podrá realizar de forma aleatoria o bien manualmente
por el usuario.
   -El número de células vivas a poner vendrá determinado por un porcentaje que determine el
usuario por
   teclado. Esto es, suponiendo que el usuario introduce 25% y el tablero es de 10x10, entonces
el número de
   células vivas a colocar sería el 25% de 100 (10*10).

Para resolver esto

Lo haríamos de la siguiente forma.

Cumpliendo las restricciones que nos pone el ejercicio

Al correr el programa primero se le pida al usuario la dimensión de la matriz solicitando un

numero entre el 0 al 25.

int tablero[][] = new int[n][n];  
private int[][] estadoActual = new int[DIMENSION][DIMENSION];

Tambien se podria hacer que se imprima toda una rejilla nueva de valores
con un ciclo for constantemente

Así como la cantidad de las células vivas en porcentaje entre 0-100.

totalCelulas = (25/ 100) * (n*n)

Por ultimo la colocación de las células la cual aun no estamos seguros si lo haremos de
forma automática o manualmente por el usuario

Si es de forma automáticamente con el import java.util.Random; nos puede servir

Clases

Tablero

Tablero
Dimensiones
AlmacenarCelulas

Células

Células
Cantidad de células

Estado(bool)

Usuario

Usuario

DeterminarCantidadCelulas
DeterminarDimensionesTablero
ActualizarEstadoDelTablero
DeterminarUbicacionCelulas