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.");
        }
    }
}