1 PUNTO DEL TALLER

1. Se define una clase llamada Collatz.

2. En el método main, se inicializa una variable n con el valor 10, que es el número inicial
para el cual se generará la secuencia de Collatz.

3. Se imprime un mensaje que indica que se mostrará la secuencia de Collatz para el número
10.

4. Se llama al método collatz(n) para calcular la secuencia de Collatz para el número 10 y se

almacena el resultado en la variable pasos.

5. Se imprime la secuencia generada y el número de pasos requeridos para llegar a 1.

6. El método collatz(int n) es una función recursiva que toma un número entero n como
argumento y calcula la secuencia de Collatz.

7. En cada llamada a la función collatz, se imprime el valor actual de n.

8. Luego, se verifica si n es igual a 1. Si es igual a 1, la secuencia termina y se devuelve 0 para

indicar que no se cuenta ningún paso adicional.

9. Si n no es igual a 1, se verifica si n es par (se hace esto usando el operador % para

comprobar si el residuo de la división de n por 2 es igual a 0). Si n es par, se divide por 2 y
se llama a collatz(n / 2) de manera recursiva, sumando 1 al resultado para contar el paso
actual.

10. Si n es impar (cuando la condición anterior no se cumple), se multiplica por 3 y se le suma

1, luego se llama a collatz(3 * n + 1) de manera recursiva, también sumando 1 al resultado
para contar el paso actual.

El proceso continúa hasta que n se convierte en 1, momento en el que la secuencia termina y se

cuentan todos los pasos. La función recursiva acumula el número de pasos necesarios para llegar a
1, y ese valor se devuelve y se muestra en el método main.

CODIGO

public class Collatz {

public static void main(String[] args) {
int n = 10;
System.out.println("Secuencia de Collatz para " + n + ":");
int pasos = collatz(n);
System.out.println("\nNúmero de pasos: " + pasos);
}

public static int collatz(int n) {

System.out.print(n + " ");
 // la secuencia termina cuando n llegue a 1, aqui no se cuenta el
paso
if (n == 1) {
return 0;
}

// Si n es par, divídelo por 2; si es impar, multiplica por 3 y

sumale 1
if (n % 2 == 0) {
return 1 + collatz(n / 2); //cuenta el paso actual y sigue
recursivamente
} else {
return 1 + collatz(3 * n + 1); //cuenta el paso actual y sigue
recursivamente
}
}
}

2 PUNTO DEL TALLER

Este código es un programa en Java que calcula la potencia de un número entero utilizando el tipo
de dato BigDecimal para obtener una alta precisión en los cálculos y redondeo correcto.

1. Importa las clases Scanner y BigDecimal del paquete java.util y java.math,

respectivamente. Estas clases se utilizan para leer la entrada del usuario y realizar cálculos
precisos con números decimales.
2. Definición de la clase Potencias.
3. Método main:
 El programa comienza con el método main.
 Crea un objeto Scanner llamado teclado para leer la entrada del usuario desde la consola.
 Solicita al usuario que ingrese la base y el exponente.
 Los valores ingresados se almacenan en las variables base y exponente.
 Cierra el objeto teclado cuando se ha terminado de usar.

4. Verifica si el exponente ingresado es negativo. Si es así, muestra un mensaje de error y

finaliza el programa. El exponente debe ser no negativo para este cálculo.

5. Llamada al método calcularPotencia:

 Si el exponente es no negativo, se llama al método calcularPotencia con los valores de base

y exponente.
 El resultado se almacena en un objeto BigDecimal llamado resultado.
6. Método calcularPotencia:
  Este método toma dos parámetros, base y exponente, y calcula la potencia de base
elevado a exponente.
 Si exponente es igual a 0, devuelve BigDecimal.ONE, que representa 1. Cualquier número
elevado a 0 es 1.
 En caso contrario, realiza un cálculo iterativo utilizando un bucle for.
 Se crea un objeto BigDecimal llamado baseDecimal para almacenar la base en formato
decimal.
 Luego, se realiza un bucle que multiplica resultado por baseDecimal tantas veces como sea
necesario (absoluto de exponente), lo que equivale a elevar base a exponente.
 Si el exponente es negativo, después de completar el bucle, se calcula la inversa de
resultado para obtener el resultado correcto y se redondea con 20 decimales y el método
de redondeo BigDecimal.ROUND_HALF_UP.

7. El resultado se devuelve desde el método calcularPotencia y se muestra en la función

main, junto con un mensaje que indica qué número se elevó a qué exponente y cuál es el
resultado.

8. Se maneja una excepción InputMismatchException en caso de que el usuario ingrese

valores que no son números enteros válidos. En ese caso, se muestra un mensaje de error.

CODIGO
import java.util.Scanner;
import java.math.BigDecimal;

//Se usa un bucle iterativo en el método calcularPotencia para evitar la

recursión y mejorar el rendimiento,
// especialmente para exponentes grandes o negativos. La precisión se
establece en 20 decimales
// y se utiliza BigDecimal.ROUND_HALF_UP para redondear correctamente.

public class Potencias {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
try {
System.out.print("Introduce la base: ");
int base = teclado.nextInt();
System.out.print("Introduce el exponente: ");
int exponente = teclado.nextInt();
teclado.close();

if (exponente < 0) {
System.out.println("El exponente debe ser un número no
negativo.");
} else {
BigDecimal resultado = calcularPotencia(base, exponente);
 System.out.println(base + " elevado a " + exponente + "
es igual a " + resultado);
}
} catch (java.util.InputMismatchException e) {
System.out.println("Error: Debes ingresar números enteros
válidos.");
}
}

private static BigDecimal calcularPotencia(int base, int exponente) {

if (exponente == 0) {
return BigDecimal.ONE; // Cualquier número elevado a 0 es 1.
} else {
BigDecimal resultado = BigDecimal.ONE;
BigDecimal baseDecimal = new BigDecimal(base);

for (int i = 0; i < Math.abs(exponente); i++) {

resultado = resultado.multiply(baseDecimal);
}

if (exponente < 0) {
resultado = BigDecimal.ONE.divide(resultado, 20,
BigDecimal.ROUND_HALF_UP);
}

return resultado;
}
}
}
3 PUNTO DEL TALLER

1. Se importan las clases Scanner y ArrayList para permitir la lectura de entrada del usuario y
la gestión de una lista de tareas, respectivamente.
2. Definición de Clases:
 El código define tres clases principales: Tareas, ListaDeTareas, y Principal.
 Tareas representa una tarea con un nombre y un estado (completada o pendiente).
 ListaDeTareas representa una lista de tareas y proporciona métodos para agregar,
completar y mostrar tareas.
 Principal contiene el método main, que es el punto de entrada del programa.

3. Clase Tareas:

 Esta clase tiene dos atributos: nombre y verificar, que representan el nombre de la tarea y
su estado de verificación.
 Un constructor permite crear una instancia de Tareas con un nombre y un estado inicial no
verificado.
 Métodos permiten obtener el nombre y el estado de la tarea, así como marcarla como
completada.

4. Clase ListaDeTareas:

 Esta clase gestiona una lista de objetos de tipo Tareas usando un ArrayList.
 Un constructor crea una lista vacía al iniciar el programa.
 Métodos permiten agregar una nueva tarea a la lista, marcar una tarea como completada y
mostrar todas las tareas en la lista.

5. Método Main (Clase Principal):

El método main es el punto de entrada del programa.

 Crea una instancia de ListaDeTareas llamada lista para gestionar las tareas.
 Utiliza un objeto Scanner para leer la entrada del usuario.
 Inicializa una variable booleana salir para controlar el bucle del menú.
 Muestra un mensaje de bienvenida al usuario.

6. Bucle del Menú:

 Utiliza un bucle while para mostrar un menú de opciones y procesar las selecciones del
usuario hasta que decida salir del programa.

7. Opciones del Menú:

El menú ofrece cuatro opciones:
 Agregar una nueva tarea: Permite al usuario ingresar el nombre de una nueva tarea
que se agrega a la lista.
  Marcar una tarea como completada: Permite al usuario ingresar el índice de una tarea
para marcarla como completada en la lista.
 Mostrar todas las tareas: Muestra todas las tareas en la lista, junto con su índice y su
estado (completada o pendiente).
 Salir del programa: Finaliza el programa cuando el usuario selecciona esta opción.

8. Manejo de Entrada del Usuario:

 El programa utiliza un objeto Scanner para leer la entrada del usuario.

 Utiliza una estructura switch para ejecutar la opción correspondiente seleccionada por el
usuario.
 Para cada opción, solicita la entrada del usuario y realiza las operaciones necesarias en la
lista de tareas.

9. Cierre del Programa:

 Cuando el usuario selecciona la opción "Salir del programa," se cambia el valor de salir
a verdadero, lo que finaliza el bucle del menú y, por lo tanto, termina el programa.

10. Cierre del Scanner:

 El programa cierra el objeto Scanner después de su uso para liberar los recursos.

En resumen, este programa permite al usuario gestionar una lista de tareas, agregar nuevas tareas,
marcar tareas como completadas y mostrar el estado actual de las tareas en la lista. El bucle del
menú permite al usuario realizar estas operaciones hasta que decida salir del programa.

CODIGO
// Importamos la clase Scanner para leer lo escrito por el usuario
// Importamos la clase ArrayList para usarla como lista de tareas
import java.util.Scanner;
import java.util.ArrayList;

// Definimos una clase Tarea que tiene dos atributos: nombre y verficar
class Tareas {
// El nombre de la tarea es una cadena de texto
String nombre;
// El estado de la tarea es un valor booleano que indica si está
completada o no
boolean verificar;

// El constructor de la clase recibe el nombre de la tarea y asigna

el estado verficar a falso
public Tareas(String nombre) {
this.nombre = nombre;
this.verificar = false;
}

// método para obtener el nombre de la tarea

public String getNombre() {
 return this.nombre;
}

// método para obtener la situacion de la tarea

public boolean getVerficar() {
return this.verificar;
}

// método para cambiar el estado de la tarea a verdadero, indicando

que está completada
public void completar() {
this.verificar = true;
}
}

// Definimos una clase ListaDeTareas que tiene un atributo: una lista de

objetos de tipo Tarea
class ListaDeTareas {
// La lista de tareas es un ArrayList de Tarea
ArrayList<Tareas> lista;

// El constructor de la clase crea una lista vacía

public ListaDeTareas() {
this.lista = new ArrayList<Tareas>();
}

// Un método para agregar una nueva tarea a la lista, recibiendo el

nombre de la tarea como parámetro
public void agregarTarea(String nombre) {
// Creamos un objeto de tipo Tarea con el nombre dado
Tareas nuevaTareas = new Tareas(nombre);
// Añadimos el objeto a la lista
this.lista.add(nuevaTareas);
// Mostramos un mensaje de confirmación al usuario
System.out.println("Se ha agregado la tarea: " + nombre);
}

// Un método para marcar una tarea como completada, recibiendo el

índice de la tarea en la lista como parámetro
public void completarTarea(int indice) {
// Verificamos que el índice sea válido, es decir, que esté dentro del
rango de la lista
if (indice >= 0 && indice < this.lista.size()) {
// Obtenemos el objeto de tipo Tarea que corresponde al índice dado
Tareas tareas = this.lista.get(indice);
// Cambiamos el estado del objeto a verdadero, usando el método completar
tareas.completar();
// Mostramos un mensaje de confirmación al usuario, usando el método
getNombre para obtener el nombre de la tarea
System.out.println("Se ha completado la tarea: " +
tareas.getNombre());
} else {
// Si el índice no es válido, mostramos un mensaje de error al usuario
System.out.println("El índice no es válido. Por favor,
ingrese un número entre 0 y " + (this.lista.size() - 1));
}
}
 // Un método para mostrar todas las tareas en la lista, junto con su
índice y su estado
public void mostrarTareas() {
// Verificamos que la lista no esté vacía
if (this.lista.size() > 0) {
// Mostramos un mensaje al usuario indicando el número de tareas en la
lista
System.out.println("La lista tiene " + this.lista.size() + "
tareas:");
// Recorremos la lista con un bucle for, usando una variable i como
contador
for (int i = 0; i < this.lista.size(); i++) {
// Obtenemos el objeto de tipo Tarea que corresponde al índice i
Tareas tareas = this.lista.get(i);
// Mostramos el índice, el nombre y el estado de la tarea, usando los
métodos getNombre y getEstado
System.out.println(i + ". " + tareas.getNombre() + " - "
+ (tareas.getVerficar() ? "Completada" : "Pendiente"));
}
} else {
// Si la lista está vacía, mostramos un mensaje al usuario indicando que
no hay tareas
System.out.println("La lista está vacía. No hay tareas por
mostrar.");
}
}
}

// Definimos una clase Principal que contiene el procedimiento principal

del programa
class Principal {
public static void main(String[] args) {
// Creamos un objeto de tipo ListaDeTareas
ListaDeTareas lista = new ListaDeTareas();
// Creamos un objeto de tipo Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Creamos una variable de tipo booleano para controlar el bucle del menú
boolean salir = false;
// Mostramos un mensaje de bienvenida al usuario
System.out.println("Bienvenido al programa de gestión de
tareas.");
// Mientras no se quiera salir, repetimos el bucle del menú
while (!salir) {
// Mostramos las opciones del menú al usuario
System.out.println("Seleccione una opción:");
System.out.println("1. Agregar una nueva tarea");
System.out.println("2. Marcar una tarea como completada");
System.out.println("3. Mostrar todas las tareas");
System.out.println("4. Salir del programa");
// Leemos la opción elegida por el usuario
int opcion = scanner.nextInt();
// Limpiamos el buffer del scanner
scanner.nextLine();
// Usamos una estructura switch para ejecutar la opción correspondiente
switch (opcion) {
case 1:
// Si la opción es 1, pedimos al usuario que ingrese el nombre de la
nueva tarea
System.out.println("Ingrese el nombre de la nueva
tarea:");
String nombre = scanner.nextLine();
// Llamamos al método agregarTarea de la lista, pasando el nombre como
parámetro
lista.agregarTarea(nombre);
break;
case 2:
// Si la opción es 2, pedimos al usuario que ingrese el índice de la
tarea que quiere completar
System.out.println("Ingrese el índice de la tarea que
quiere completar:");
int indice = scanner.nextInt();
// Llamamos al método completarTarea de la lista, pasando el índice como
parámetro
lista.completarTarea(indice);
break;
case 3:
// Si la opción es 3, llamamos al método mostrarTareas de la lista
lista.mostrarTareas();
break;
case 4:
// Si la opción es 4, cambiamos el valor de la variable salir a
verdadero, para terminar el bucle
salir = true;
break;
default:
// Si la opción no es ninguna de las anteriores, mostramos un mensaje de
error al usuario
System.out.println("Opción inválida. Por favor,
ingrese un número entre 1 y 4.");
break;
}
}
// Cerramos el scanner
scanner.close();

System.out.println("NOTA 5.");
}
}
4 PUNTO DEL TALLER

1. se crea una variable llamada vector que es un arreglo de números enteros (int). Este arreglo
contiene los números {10, 1, 34, 0, 22, -8}. Es como tener una lista de números desordenados.

2. llamamos a un método llamado ordenarPorInsercion y le pasamos nuestro arreglo vector como

argumento. Esto es como decir: "Por favor, ordena estos números utilizando el método de
ordenación por inserción".

3. Iniciamos un bucle (for) que nos permite recorrer cada número en nuestro arreglo. Comenzamos
desde el primer número (índice 0) y avanzamos uno por uno hasta el último número.

4. Dentro del bucle, imprimimos cada número en la pantalla. En este caso, estamos mostrando el
número en la posición i del arreglo y luego dejamos un espacio para separar los números.

5. Después de que el bucle ha recorrido todos los números en el arreglo, hemos terminado de
imprimirlos en la pantalla.

6. A continuación, encontramos otro método llamado ordenarPorInsercion. Este método se utiliza

para ordenar los números en el arreglo utilizando el algoritmo de ordenación por inserción.

7. Dentro del método ordenarPorInsercion, calculamos la longitud del arreglo vector y la

almacenamos en una variable llamada n. Esto nos dice cuántos números hay en el arreglo.

8. Iniciamos un bucle (for) que nos permite recorrer cada número en el arreglo, comenzando
desde el segundo número (índice 1) y avanzando uno por uno hasta el último número.

9. Dentro del bucle, tomamos el número actual en la posición i del arreglo y lo almacenamos en
una variable llamada elementoActual. Este es el número que vamos a intentar colocar en su
posición correcta en el arreglo ordenado.

10. También creamos otra variable llamada j que inicializamos en i - 1. Esta variable nos ayudará a
comparar elementoActual con los números a la izquierda de él en el arreglo.

11. Iniciamos otro bucle (loop) dentro de este bucle principal. Este bucle se ejecutará mientras j
sea mayor o igual a cero (asegurándonos de no salirnos del límite del arreglo) y el número en la
posición j del arreglo sea mayor que elementoActual. Esto significa que estamos buscando la
posición correcta para colocar elementoActual y desplazar los números mayores a la derecha para
hacer espacio.

12. Dentro de este bucle, estamos moviendo un número mayor a la derecha en el arreglo para
hacer espacio para elementoActual. Primero, copiamos el número en la posición j en la siguiente
posición a la derecha (j + 1), y luego decrementamos j para seguir comparando hacia la izquierda.

NOTA: Con la funcion de ordenación proporcionadas por Java Arrays.sort es mas rápido, pero
utilizar el algoritmo de ordenación por inserción en un ejercicio es una excelente manera de
aprender cómo funcionan los algoritmos de ordenación. Puedes ver paso a paso cómo se mueven
los elementos para ordenar el arreglo.
 CODIGO

//metodo de ordenación por Inserción(donde M es menor a 100)

public class OrdenarVector {

public static void main(String[] args) {
int[] vector = {10, 1, 34, 0, 22, -8};

ordenarPorInsercion(vector);

// Imprimir el vector ordenado

for (int i = 0; i < vector.length; i++) {
System.out.print(vector[i] + " ");
}
}

public static void ordenarPorInsercion(int[] vector) {

int n = vector.length;
for (int i = 1; i < n; i++) {
int elementoActual = vector[i];
int j = i - 1;

// Mover los elementos mayores que el elemento actual a la

derecha
while (j >= 0 && vector[j] > elementoActual) {
vector[j + 1] = vector[j];
j--;
}

// Colocar el elemento actual en su posición correcta

vector[j + 1] = elementoActual;
}
}
}
5 PUNTO DEL TALLER

1. se crea una matriz bidimensional (una especie de tabla con filas y columnas). En este caso,
es una matriz de 3x3 que contiene números del 1 al 9. Cada número está en una fila y
columna específica, como una cuadrícula.
2. Establecemos el número que deseamos buscar en la matriz, que en este caso es el número
5.
3. Llamamos al método buscarElementoEnMatriz y le pasamos la matriz matriz y el número
elementoABuscar como argumentos. Esto es como decir: "Por favor, busca el número 5 en
esta matriz".
4. Ahora estamos dentro del método buscarElementoEnMatriz, que es donde ocurre la
búsqueda. Este método toma la matriz y el número a buscar como argumentos.
5. Calculamos el tamaño de la matriz (número de filas o columnas) y lo almacenamos en la
variable n. En este caso, como la matriz es de 3x3, n será igual a 3.
6. Comenzamos un bucle (for) que recorrerá cada fila de la matriz. Comenzamos desde la fila
0 y avanzamos una fila a la vez.
7. Dentro del bucle de filas, comenzamos otro bucle que recorrerá cada columna de la matriz.
Comenzamos desde la columna 0 y avanzamos una columna a la vez.
8. Dentro de estos bucles anidados, estamos verificando si el número en la posición actual de
la matriz (fila y columna) es igual al número que estamos buscando (elementoABuscar,
que es 5 en este caso).
9. Si encontramos el número, mostramos un mensaje que indica en qué fila y columna se
encontró.
10. Después de encontrar el elemento, utilizamos return para salir inmediatamente de la
función buscarElementoEnMatriz. Esto significa que no continuaremos buscando en el
resto de la matriz, ya que ya encontramos lo que buscábamos.
11. Si llegamos a este punto, significa que hemos recorrido toda la matriz y no hemos
encontrado el elemento que estábamos buscando. En este caso, mostramos un mensaje
indicando que el elemento no se encontró en la matriz.

CODIGO

public class BusquedaMatriz {

public static void main(String[] args) {
int[][] matriz = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

int elementoABuscar = 5;

buscarElementoEnMatriz(matriz, elementoABuscar);
}
 public static void buscarElementoEnMatriz(int[][] matriz, int
elementoABuscar) {
int n = matriz.length; // Tamaño de la matriz (n x n)

for (int fila = 0; fila < n; fila++) {

for (int columna = 0; columna < n; columna++) {
if (matriz[fila][columna] == elementoABuscar) {
System.out.println("Elemento encontrado en la fila " +
fila + ", columna " + columna);
return; // Terminamos la búsqueda una vez que se
encuentra el elemento
}
}
}

// El elemento no se encontró en la matriz

System.out.println("Elemento no encontrado en la matriz.");
}
}

6 PUNTO DEL TALLER

Diseñar un algoritmo en pseudocodigo que permita aceptar los (n) elementos de un vector (V) de
componentes enteros y positivos y que permita localizar al tiempo que se introducen los
elementos del vector, los números primos que figuran en el, mostrando su valor y la posición que
ocupan cada uno en el vector. Como única estructura de repetición solamente se podrá usar la de
condición inicial. Deberán disponerse todos los filtros necesarios para que no se produzcan
errores.

programa Java llamado NumerosPrimos que toma la entrada del usuario para crear una matriz de
números enteros y luego verifica si cada elemento es un número primo. Si un número es primo,
imprime un mensaje indicándolo.

Este programa permite al usuario ingresar el tamaño de la matriz y los elementos. Luego verifica si
cada elemento es un número primo e imprime el resultado.

1. Importe la Scanner clase, que permite la entrada del usuario.

2. Defina una clase llamada NumerosPrimos.
3. En el main método:
 Cree un Scanner objeto llamado scanner para recibir la entrada del usuario.
 Pida al usuario que ingrese el tamaño de la matriz ( n).
 Crea una matriz ” V” de números enteros con tamaño n.
 Defina una variable booleana esPrimo para determinar si un número es primo.
 4. Utilice un “ for” bucle para recorrer los elementos de la matriz:
 Pida al usuario que ingrese un número entero ( num).
 Establecido esPrimo de true forma predeterminada.
 Compruebe si num es menor o igual a 1. Si es así, configúrelo esPrimo en false.
 Si num es mayor que 1, use un bucle anidado for para verificar si num es divisible por
cualquier número del 2 al num/2. Si es así, configúrelo esPrimo y false salga del bucle.

Después del ciclo, si esPrimo todavía está true, imprime un mensaje indicando que num es primo y
su posición.

Almacenar num en la matriz V.

Cierra el Scanner.

CODIGO
7 PUNTO DEL TALLER

Diseñar un algoritmo en pseudocodigo que permita cargar una matriz (U) en memoria y
comprobar si la misma es unitaria o no, ¡ojo¡ abandonando la comprobación cuando algún
elemento no sea de la matriz unitaria. Una matriz unitaria de orden (n) es aquella que tiene n filas
(f) y n columnas (c), con todos sus componentes a 0 excepto la diagonal principal que esta a 1

Este programa solicita al usuario ingresar el tamaño de la matriz y luego los elementos de la
misma.

1. Importación de la biblioteca Scanner: En Java, la clase Scannerpermite leer la entrada del

usuario desde la consola. Esto se hace para obtener el tamaño de la matriz (n) y los
elementos de la misma.
2. Solicitud del tamaño de la matriz (n):Se le pide al usuario que ingrese un número que
represente el tamaño de la matriz. Este número determinará cuántas filas y columnas
tendrá la matriz.
3. Creación de la matriz: Una vez que se obtiene el tamaño de la matriz, se crea una matriz
con "n" filas y "n" columnas. Esta matriz es donde se almacenarán los elementos que el
usuario proporciona.
4. Solicitud de elementos de la matriz: El programa le pide al usuario que ingrese los
elementos de la matriz. Utiliza dos bucles anidados para recorrer cada fila y columna de la
matriz y almacena los valores proporcionados por el usuario.
5. Verificación de si la matriz es cuadrada: Antes de verificar si es unitaria, el programa
verifica si la matriz es cuadrada. Esto significa que tiene el mismo número de filas y
columnas. Si no es cuadrado, no puede ser unitario y el programa imprime un mensaje.
6. Verificación de si la matriz es unitaria: Una vez que se confirma que la matriz es cuadrada,
el programa verifica si es unitaria. Esto implica que todos los elementos fuera de
7. Función esMatrizCuadrada: Esta función verifica si una matriz es cuadrada. Comprueba si
el número de filas es igual al número de columnas. Si
8. Función esMatrizUnitaria: Esta función verifica s ifalse; de lo contrario, devuelve true.
CODIGO
8.PUNTO TALLER

El Juego de la Vida de Conway es un autómata celular que sigue reglas simples para evolucionar
una matriz de células a lo largo del tiempo. Cada célula puede estar viva o muerta en una matriz
cuadrada. Las reglas del juego son las siguientes:

1. Si una célula está viva y tiene 2 o 3 células vecinas vivas, sobrevive en la siguiente
generación.

2. Si una célula está muerta y tiene exactamente 3 células vecinas vivas, nace en la siguiente
generación.

3. En cualquier otro caso, la célula muere (por soledad o superpoblación).

Vamos a explicar el código paso a paso:

1. Inicialización de la matriz: Se crea una matriz cuadrada de tamaño MxM (en este ejemplo,
M = 10). Las células de la matriz se inicializan de manera aleatoria, es decir, algunas
estarán vivas (1) y otras estarán muertas (0).

2. Evolución de generaciones: Luego, se ejecuta un bucle que representa el paso del tiempo
o las generaciones. En cada generación, se aplican las reglas del juego a cada célula de
manera simultánea para determinar su estado en la siguiente generación.

3. Función evolucionar: Esta función aplica las reglas del juego para evolucionar la matriz a la
siguiente generación. Se recorre cada célula de la matriz y se calcula su estado en la
siguiente generación según las reglas explicadas anteriormente. Se crea una nueva matriz
para almacenar la siguiente generación.

4. Función contarVecinasVivas: Esta función cuenta el número de células vecinas vivas

alrededor de una célula dada. Utiliza un conjunto de movimientos predefinidos para
verificar las células en las posiciones adyacentes.

5. Impresión de la matriz: Después de cada generación, se imprime la matriz en la consola

para que puedas observar cómo evolucionan las células con el tiempo.

Para "jugar" al Juego de la Vida, simplemente ejecuta el código y observa cómo las células
evolucionan de una generación a otra. Cada generación muestra cómo cambia el estado de todas
las células en la matriz. Puedes modificar los valores de M (el tamaño de la matriz) y
numGeneraciones (el número de generaciones que deseas simular) para experimentar con
diferentes configuraciones.

El juego se juega en el sentido de observar cómo las células vivas y muertas interactúan y
evolucionan según las reglas del juego, sin necesidad de intervención directa del jugador. Es un
ejemplo de autómata celular y un experimento interesante en el campo de la teoría de juegos y la
ciencia computacional.
 CODIGO
import java.util.Arrays;

public class JuegoDeLaVida {

public static void main(String[] args) {
int M = 5; // Cambia este valor para ajustar el tamaño de la
matriz
int[][] matriz = new int[M][M];
int[][] nuevaGeneracion = new int[M][M];

// Inicializa la matriz con valores aleatorios

for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
matriz[i][j] = Math.random() < 0.5 ? 0 : 1;
}
}

// Número de generaciones a simular

int generaciones = 10;

for (int generacion = 0; generacion < generaciones; generacion++)

{
// Imprime la generación actual
System.out.println("Generación " + generacion);
imprimirMatriz(matriz);

// Aplica las reglas del juego para generar la siguiente

generación
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
int vecinasVivas = contarVecinasVivas(matriz, i, j);
if (matriz[i][j] == 1) {
// Regla 1 y 3
if (vecinasVivas == 2 || vecinasVivas == 3) {
nuevaGeneracion[i][j] = 1;
} else {
nuevaGeneracion[i][j] = 0;
}
} else {
// Regla 2
if (vecinasVivas == 3) {
nuevaGeneracion[i][j] = 1;
} else {
nuevaGeneracion[i][j] = 0;
}
}
}
}

// Copia la nueva generación en la matriz original

for (int i = 0; i < M; i++) {
matriz[i] = Arrays.copyOf(nuevaGeneracion[i], M);
}
}
}
 // Cuenta el número de células vecinas vivas
public static int contarVecinasVivas(int[][] matriz, int fila, int
columna) {
int M = matriz.length;
int vecinasVivas = 0;
int[][] direcciones = { { -1, -1 }, { -1, 0 }, { -1, 1 }, { 0, -1
}, { 0, 1 }, { 1, -1 }, { 1, 0 }, { 1, 1 } };

for (int[] direccion : direcciones) {

int vecinaFila = fila + direccion[0];
int vecinaColumna = columna + direccion[1];

if (vecinaFila >= 0 && vecinaFila < M && vecinaColumna >= 0

&& vecinaColumna < M) {
if (matriz[vecinaFila][vecinaColumna] == 1) {
vecinasVivas++;
}
}
}

return vecinasVivas;
}

// Imprime la matriz
public static void imprimirMatriz(int[][] matriz) {
int M = matriz.length;
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
System.out.print(matriz[i][j] + " ");
}
System.out.println();
}
System.out.println();
}
}