Ejercicios tema 8
Ejercicio 1. Crea una matriz 2D de 5×5 que represente las celdas de una cárcel. Llena todas las posiciones con el valor 0, indicando que todas las celdas están vacías.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = new int[5][5];
// Llenar la matriz con 0
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
celdas[i][j] = 0;
}
}
// Imprimir la matriz
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
System.out.print(celdas[i][j] + " ");
}
System.out.println();
}
}
}Ejercicio 2. Supongamos que las celdas [0][1], [2][2] y [4][3] están ocupadas por prisioneros. Actualiza la matriz del ejercicio anterior para reflejar esto usando el valor 1 para las celdas ocupadas.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = new int[5][5];
// Llenar la matriz con 0
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
celdas[i][j] = 0;
}
}
// Marcar las celdas ocupadas
celdas[0][1] = 1;
celdas[2][2] = 1;
celdas[4][3] = 1;
// Imprimir la matriz
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
System.out.print(celdas[i][j] + " ");
}
System.out.println();
}
}
}Ejercicio 3. Cuenta cuántas celdas están ocupadas en la matriz creada en el ejercicio 2.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
int contador = 0;
// Contar las celdas ocupadas
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
if (celdas[i][j] == 1) {
contador++;
}
}
}
System.out.println("Celdas ocupadas: " + contador);
}
}Ejercicio 4. Libera al prisionero de la celda [2][2] en la matriz del ejercicio 2 y actualiza la matriz.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
// Liberar al prisionero
celdas[2][2] = 0;
// Imprimir la matriz
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
System.out.print(celdas[i][j] + " ");
}
System.out.println();
}
}
}Ejercicio 5. Encuentra todas las celdas vacías en la matriz del ejercicio 2 y muestra sus posiciones.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
System.out.println("Celdas vacías:");
// Encontrar las celdas vacías
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
if (celdas[i][j] == 0) {
System.out.println("[" + i + "][" + j + "]");
}
}
}
}
}Ejercicio 6. Transfiere un prisionero de la celda [4][3] a la celda [1][4] en la matriz del ejercicio 2
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
// Transferir el prisionero
celdas[4][3] = 0;
celdas[1][4] = 1;
// Imprimir la matriz
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
System.out.print(celdas[i][j] + " ");
}
System.out.println();
}
}
}Ejercicio 7. Cuenta cuántas celdas vecinas ocupadas tiene la celda [2][2] en la matriz del ejercicio número 2.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
int[][] direcciones = {
{-1, -1}, {-1, 0}, {-1, 1},
{ 0, -1}, { 0, 1},
{ 1, -1}, { 1, 0}, { 1, 1}
};
int x = 2, y = 2;
int contador = 0;
// Contar las celdas vecinas ocupadas
for (int[] dir : direcciones) {
int nuevoX = x + dir[0];
int nuevoY = y + dir[1];
if (nuevoX >= 0 && nuevoX < celdas.length && nuevoY >= 0 && nuevoY < celdas[0].length) {
if (celdas[nuevoX][nuevoY] == 1) {
contador++;
}
}
}
System.out.println("Celdas vecinas ocupadas de [2][2]: " + contador);
}
}💡Inicialización y Declaración: Siempre inicializa tu matriz correctamente después de declararla. Puedes hacerlo en una sola línea para mantener el código limpio y fácil de leer.
💡Uso de Bucles Anidados: Utiliza bucles anidados para recorrer y manipular elementos en la matriz. El bucle externo recorre las filas y el bucle interno recorre las columnas. Esto es esencial para realizar operaciones en cada elemento de la matriz.
Ejercicio 8. Encuentra todos los prisioneros en la fila 0 de la matriz del ejercicio 2 y muestra sus posiciones.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
System.out.println("Prisioneros en la fila 0:");
for (int j = 0; j < celdas[0].length; j++) {
if (celdas[0][j] == 1) {
System.out.println("[0][" + j + "]");
}
}
}
}💡Comprueba Límites: Asegúrate de no exceder los límites de la matriz. Siempre verifica que tus índices estén dentro del rango válido.
Ejercicio 9. Rota la matriz del ejercicio 2 90 grados en el sentido de las agujas del reloj.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
int[][] rotada = new int[celdas[0].length][celdas.length];
// Rotar la matriz 90 grados hacia la derecha
for (int i = 0; i < celdas.length; i++) {
for (int j = 0; j < celdas[i].length; j++) {
rotada[j][celdas.length - 1 - i] = celdas[i][j];
}
}
// Imprimir la matriz rotada
for (int i = 0; i < rotada.length; i++) {
for (int j = 0; j < rotada[i].length; j++) {
System.out.print(rotada[i][j] + " ");
}
System.out.println();
}
}
}Ejercicio 10. Verifica si existe un patrón de escape en la matriz del ejercicio 2, definido como tres celdas ocupadas consecutivas en cualquier fila.
Solución:
public class Main {
public static void main(String[] args) {
int[][] celdas = {
{0, 1, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0}
};
boolean escapeEncontrado = false;
for (int i = 0; i < celdas.length && !escapeEncontrado; i++) {
int consecutivas = 0;
for (int j = 0; j < celdas[i].length; j++) {
if (celdas[i][j] == 1) {
consecutivas++;
if (consecutivas == 3) {
escapeEncontrado = true;
break;
}
} else {
consecutivas = 0;
}
}
}
if (escapeEncontrado) {
System.out.println("¡Patrón de escape encontrado!");
} else {
System.out.println("No se encontró patrón de escape.");
}
}
}