DESCARGAR
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner lee = new Scanner(System.in);
// Leemos el tamaño del mundo
// Creamos un objeto que represente el mundo
Mundo mundo = new Mundo(lee.nextInt(),lee.nextInt());
// Leemos el número de células en la posición inicial
int numPos = lee.nextInt();
// Para el número de células iniciales
for (int i = 1; i <= numPos; i++){
// leemos la posición de la célula
// la añadimos al mundo
mundo.ponCelulaEn(lee.nextInt(),lee.nextInt());
}
// Leemos el número de generaciones
int numSim = lee.nextInt();
lee.close();
// Para el número de generaciones leído menos 1
// (la posición inicial es la 1º genración)
for (int i = 1; i < numSim; i++){
// Calculamos el nacimiento y muerte de células
boolean[][] nextGen = mundo.calculaCambiosSigGeneracion();
// Aplicamos los nacimientos y muertes para obtener la siguiente generación
mundo.aplicaCambiosSigGeneracion(nextGen);
}
// Enviamos a la salida estándar el estado del mundo en la última generación
System.out.print(mundo);
}
}
/*
* Clase que implementa un mundo de ciertas dimensiones para simular el juego de la vida.
*/
public class Mundo {
/** Almacena la matriz que representa el mundo,
* cada celda puede ser:<p>
*
*   true: hay célula en la celda<p>
*   false: no hay célula en la celda<p>
*/
private boolean[][] _hayCelula;
/** Crea un objeto que representa el mundo
* de un tamaño dado.
* @param f Número de filas del mundo
* @param c Número de columnas del mundo
*/
public Mundo(int f, int c) {
_hayCelula = new boolean[f][c];
}
/** Añade una célula en la posición dada.
*
* @param f Fila donde se pone la célula.
* @param c Columna donde pone la célula.
*/
public void ponCelulaEn(int f, int c) {
this._hayCelula[f][c] = true;
}
/**
* Calcula qué celdas cambiarán en la siguiente generación del juego de la vida.
* Una celda cambia si tiene una célula y esta muere en la siguiente generación o
* no tiene célula y una célula nacerá en la siguiente generación.
*
* @return devuelve una matriz de booleanos de tamaño igual al mundo actual donde
* una celda tiene el valor true si y solo si cambia su estado en la siguiente
* generación del juego de la vida.
*/
public boolean[][] calculaCambiosSigGeneracion() {
boolean[][] result = new boolean[_hayCelula.length][_hayCelula[0].length];
for (int i=0; i < _hayCelula.length; i++)
for (int j=0; j < _hayCelula[0].length; j++){
int numVec = this.calculaNumVecinas(i,j);
if (_hayCelula[i][j]) {// Si hay célula, esta puede morir
result[i][j] = (numVec == 0 || numVec == 1 || numVec > 3);
} else // si no hay célula, puede nacer
result[i][j] = numVec == 3;
}
return result;
}
private int calculaNumVecinas(int i, int j) {
int num = 0;
for (int l = -1; l < 2; l++)
for (int k = -1; k < 2; k++)
if (this.esCeldaValida(i+l,j+k) && !(l==0 && k==0))
if (_hayCelula[i+l][j+k])
num++;
return num;
}
private boolean esCeldaValida(int i, int j) {
return (0 <= i && i < _hayCelula.length && 0 <= j && j < _hayCelula[0].length);
}
/**
* Aplica los cambios dados en nextGen al estado actual del mundo.
* @param nextGen Una matriz de booleanos donde una celda es true si y sólo si
* en la siguiente generación esa celda cambia: si tiene célula, ésta muere
* y si no tiene célula, nacerá una nueva.
*/
public void aplicaCambiosSigGeneracion(boolean[][] nextGen) {
for (int i=0; i < _hayCelula.length; i++)
for (int j=0; j < _hayCelula[0].length; j++)
_hayCelula[i][j] ^= nextGen[i][j];
}
/**
* Devuelve una cadena que representa el estado actual del mundo.
* Cada fila del mundo viene dada en una línea completa, con una celda vacía representada
* por un punto . y una celda llena representada por un asterísco *.
*/
@Override
public String toString(){
StringBuffer sb = new StringBuffer();
for (int i=0; i < _hayCelula.length; i++){
for (int j=0; j < _hayCelula[0].length; j++){
if (_hayCelula[i][j])
sb.append('*');
else
sb.append('.');
}
sb.append('\n');
}
return sb.toString();
}
}