Carlos Fernández García

Ejercicio 1

Crea un programa en Java que utilice un Stack para realizar las siguientes operaciones básicas: Apilar (agregar) cinco números enteros al Stack. Mostrar el contenido del Stack. Desapilar (eliminar) los números uno por uno, mostrando cada número eliminado. Al finalizar, mostrar un mensaje indicando que el Stack está vacío.

Ejercicio 2

Gestión de Deshacer y Rehacer en un Editor de Texto Imagina que estás desarrollando una funcionalidad para un editor de texto que permite deshacer y rehacer cambios realizados en el contenido. Crea un programa en Java que implemente lo siguiente: Utiliza dos pilas (Stack): Una pila para registrar las operaciones realizadas (pila de deshacer). Otra pila para guardar las operaciones deshechas (pila de rehacer). El programa debe permitir las siguientes opciones: Agregar texto al final del contenido actual. Eliminar el último texto agregado. Deshacer la última operación (agregar o eliminar texto). Rehacer una operación previamente deshecha. Mostrar el contenido actual. Consideraciones: Cada operación debe registrarse en la pila de deshacer. Al realizar una acción de deshacer, la operación correspondiente debe transferirse a la pila de rehacer. Al agregar o eliminar texto después de un deshacer, la pila de rehacer debe vaciarse. Asegúrate de manejar errores, como intentar deshacer cuando la pila de deshacer está vacía. Ejemplo de interacción del programa: Copiar código Contenido actual: "" (vacío) 1. Agregar texto ("Hola") 2. Agregar texto (" Mundo") Contenido actual: "Hola Mundo" 3. Deshacer última operación Contenido actual: "Hola" 4. Rehacer última operación Contenido actual: "Hola Mundo" 5. Eliminar último texto agregado Contenido actual: "Hola"

package stack;

import java.util.Scanner;
import java.util.Stack;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Crea una instancia del menú y lo muestra al usuario.
        MenuEjercicio2 menu = new MenuEjercicio2();
        menu.mostrarMenu();
    }
}

class Texto {
    // Pila que contiene el contenido actual del editor de texto.
    private Stack<String> contenido = new Stack<>();
    // Pila para almacenar las operaciones realizadas, usada para deshacer.
    private Stack<String> pilaDeshacer = new Stack<>();
    // Pila para almacenar las operaciones deshechas, usada para rehacer.
    private Stack<String> pilaRehacer = new Stack<>();

    /**
     * Agrega una palabra al contenido actual del editor.
     * Registra la operación en la pila de deshacer y limpia la pila de rehacer.
     * 
     * @param entrada Scanner para capturar la entrada del usuario.
     */
    public void agregarPalabra(Scanner entrada) {
        System.out.println("Introduce una palabra:");
        String palabra = entrada.nextLine().trim(); // Lee y elimina espacios innecesarios.

        if (palabra.isEmpty()) {
            System.out.println("No se puede agregar un espacio en blanco.");
            return;
        }

        // Registra la operación en la pila de deshacer y limpia la pila de rehacer.
        pilaDeshacer.push("ADD " + palabra);
        pilaRehacer.clear();
        contenido.push(palabra); // Agrega la palabra al contenido.
        System.out.println("Palabra agregada correctamente.");
        mostrarContenido();
    }

    /**
     * Elimina la última palabra del contenido.
     * Registra la operación en la pila de deshacer y limpia la pila de rehacer.
     */
    public void eliminarUltimaPalabra() {
        if (contenido.isEmpty()) {
            System.out.println("No hay palabras para eliminar.");
            return;
        }

        // Registra la palabra eliminada en la pila de deshacer.
        String ultimaPalabra = contenido.pop();
        pilaDeshacer.push("DEL " + ultimaPalabra);
        pilaRehacer.clear(); // Limpia la pila de rehacer.
        System.out.println("Palabra eliminada: " + ultimaPalabra);
        mostrarContenido();
    }

    /**
     * Deshace la última operación realizada (agregar o eliminar).
     * Transfiere la operación a la pila de rehacer.
     */
    public void deshacer() {
        if (pilaDeshacer.isEmpty()) {
            System.out.println("No hay operaciones para deshacer.");
            return;
        }

        // Recupera la última operación de la pila de deshacer.
        String operacion = pilaDeshacer.pop();
        String[] partes = operacion.split(" ", 2); // Divide la operación en tipo y palabra.

        if (partes[0].equals("ADD")) {
            // Si la operación fue agregar, elimina la palabra del contenido.
            String palabra = contenido.pop();
            pilaRehacer.push("ADD " + palabra); // Transfiere la operación a la pila de rehacer.
        } else if (partes[0].equals("DEL")) {
            // Si la operación fue eliminar, restaura la palabra al contenido.
            String palabra = partes[1];
            contenido.push(palabra);
            pilaRehacer.push("DEL " + palabra); // Transfiere la operación a la pila de rehacer.
        }

        System.out.println("Se ha deshecho la última operación.");
        mostrarContenido();
    }

    /**
     * Rehace una operación previamente deshecha.
     * Transfiere la operación a la pila de deshacer.
     */
    public void rehacer() {
        if (pilaRehacer.isEmpty()) {
            System.out.println("No hay operaciones para rehacer.");
            return;
        }

        // Recupera la última operación de la pila de rehacer.
        String operacion = pilaRehacer.pop();
        String[] partes = operacion.split(" ", 2); // Divide la operación en tipo y palabra.

        if (partes[0].equals("ADD")) {
            // Si la operación fue agregar, restaura la palabra al contenido.
            contenido.push(partes[1]);
            pilaDeshacer.push("ADD " + partes[1]); // Transfiere la operación a la pila de deshacer.
        } else if (partes[0].equals("DEL")) {
            // Si la operación fue eliminar, elimina la palabra del contenido.
            String palabra = contenido.pop();
            pilaDeshacer.push("DEL " + palabra); // Transfiere la operación a la pila de deshacer.
        }

        System.out.println("Se ha rehecho la última operación.");
        mostrarContenido();
    }

    /**
     * Muestra el contenido actual del editor de texto.
     */
    public void mostrarContenido() {
        if (contenido.isEmpty()) {
            System.out.println("El contenido está vacío.");
        } else {
            System.out.println("Contenido actual: " + String.join(" ", contenido));
        }
    }
}

class MenuEjercicio2 {
    // Instancia de la clase Texto para gestionar el contenido.
    private Texto texto = new Texto();
    private Scanner entrada = new Scanner(System.in); // Scanner para capturar entrada del usuario.

    /**
     * Muestra el menú principal y gestiona las opciones seleccionadas por el usuario.
     */
    public void mostrarMenu() {
        int opcion = 0;
        do {
            // Muestra las opciones del menú.
            System.out.println("\n--- Menú Editor de Texto ---");
            System.out.println("1. Agregar palabra");
            System.out.println("2. Eliminar última palabra");
            System.out.println("3. Deshacer");
            System.out.println("4. Rehacer");
            System.out.println("5. Mostrar contenido");
            System.out.println("6. Salir");
            System.out.print("Escoge una opción: ");

            try {
                opcion = Integer.parseInt(entrada.nextLine()); // Lee y convierte la opción a entero.
                gestionarOpcion(opcion); // Procesa la opción seleccionada.
            } catch (NumberFormatException e) {
                System.out.println("Por favor, introduce un número válido.");
            }
        } while (opcion != 6); // Repite mientras el usuario no elija salir.
    }

    /**
     * Gestiona la opción seleccionada por el usuario en el menú.
     * 
     * @param opcion La opción seleccionada.
     */
    private void gestionarOpcion(int opcion) {
        switch (opcion) {
            case 1 -> texto.agregarPalabra(entrada);
            case 2 -> texto.eliminarUltimaPalabra();
            case 3 -> texto.deshacer();
            case 4 -> texto.rehacer();
            case 5 -> texto.mostrarContenido();
            case 6 -> {
                System.out.println("Saliendo del programa...");
                entrada.close();
            }
            default -> System.out.println("Opción no válida. Inténtalo de nuevo.");
        }
    }
}

Ejercicio 3

Crea un programa en Java que utilice una pila (Stack) para invertir el orden de una secuencia de números enteros ingresados por el usuario. Requisitos: Entrada: El usuario debe ingresar una serie de números enteros separados por espacios. Ejemplo: 1 2 3 4 5 Funcionamiento: Almacena los números en una pila. Utiliza la pila para invertir el orden de los números ingresados. Salida: Muestra la secuencia original y la secuencia invertida. Ejemplo: Entrada: 1 2 3 4 5 Salida: Secuencia invertida: 5 4 3 2 1 Consideraciones: Asegúrate de manejar correctamente los casos en los que el usuario no ingrese ningún número o introduzca caracteres no válidos. Permite al usuario realizar varias inversiones consecutivas hasta que decida salir.

Ejercicio 4

Crea un programa en Java que utilice una pila (Stack) para verificar si una secuencia de números enteros ingresados por el usuario es un palíndromo. Requisitos: Entrada: El usuario debe ingresar una secuencia de números enteros separados por espacios. Ejemplo: 1 2 3 2 1. Funcionamiento: Almacena los números en una pila. Verifica si los números forman un palíndromo (es decir, si se leen igual de izquierda a derecha que de derecha a izquierda). Salida: Muestra la secuencia ingresada. Indica si la secuencia es o no un palíndromo. Ejemplo: Entrada: 1 2 3 2 1 Salida: "La secuencia ingresada es un palíndromo." Entrada: 1 2 3 4 5 Salida: "La secuencia ingresada no es un palíndromo."

/* 
Crea un programa en Java que utilice una pila (Stack) para verificar si una secuencia de números enteros 
ingresados por el usuario es un palíndromo.

Requisitos:
Entrada:
- El usuario debe ingresar una secuencia de números enteros separados por espacios. 
  Ejemplo: 1 2 3 2 1.

Funcionamiento:
- Almacena los números en una pila.
- Verifica si los números forman un palíndromo (es decir, si se leen igual de izquierda a derecha que de derecha a izquierda).

Salida:
- Muestra la secuencia ingresada.
- Indica si la secuencia es o no un palíndromo.

Ejemplo:
Entrada: 1 2 3 2 1
Salida: "La secuencia ingresada es un palíndromo."

Entrada: 1 2 3 4 5
Salida: "La secuencia ingresada no es un palíndromo."
*/

package stack;

import java.util.Scanner;
import java.util.Stack;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Pila para almacenar la secuencia original ingresada por el usuario
        Stack<Integer> secuenciaOriginal = new Stack<>();
        // Pila para hacer una copia de la secuencia original
        Stack<Integer> secuenciaCopiaOriginal = new Stack<>();
        // Pila para almacenar la secuencia invertida
        Stack<Integer> secuenciaInvertida = new Stack<>();
        
        // Variable para dividir la entrada del usuario
        String[] numeros;
        // Scanner para leer la entrada del usuario
        Scanner entrada = new Scanner(System.in);
        String cadena = "";

        // Leer la secuencia de números ingresada por el usuario
        while (true) {
            System.out.println("Introduce una secuencia de números separados por espacios:");
            cadena = entrada.nextLine();

            try {
                // Dividir la cadena ingresada en números separados
                numeros = cadena.split("\\s+");
                for (String num : numeros) {
                    // Convertir cada número a entero y almacenarlo en la pila original
                    secuenciaOriginal.push(Integer.parseInt(num));
                }
                break; // Salir del bucle si no hay errores
            } catch (NumberFormatException e) {
                // Si se detectan caracteres no numéricos, mostrar un error y reiniciar la pila
                System.err.println("La cadena contiene caracteres no numéricos. Inténtalo de nuevo.");
                secuenciaOriginal.clear();
            }
        }

        // Copiar todos los elementos de la pila original a otra pila
        secuenciaCopiaOriginal.addAll(secuenciaOriginal);

        // Crear la pila invertida sacando los elementos de la copia
        for (int i = 0; i < secuenciaOriginal.size(); i++) {
            // Agregar a la pila invertida los elementos que se extraen de la copia
            secuenciaInvertida.push(secuenciaCopiaOriginal.pop());
        }

        // Comparar si la pila original es igual a la pila invertida
        if (secuenciaOriginal.equals(secuenciaInvertida)) {
            System.out.println("La secuencia ingresada es un palíndromo.");
        } else {
            System.out.println("La secuencia ingresada no es un palíndromo.");
        }

        // Mostrar las pilas originales e invertidas para verificar el resultado
        System.out.println("Cadena original --> " + secuenciaOriginal);
        System.out.println("Cadena invertida --> " + secuenciaInvertida);

        // Cerrar el Scanner
        entrada.close();
    }
}

Ejercicio 5

Crea un programa en Java que utilice una pila (Stack) para gestionar un conjunto de registros de temperaturas diarias y calcular la temperatura más alta y la más baja ingresadas por el usuario. Requisitos: Entrada: El usuario debe ingresar una secuencia de temperaturas, donde cada temperatura es un número entero (puede incluir números negativos). Ejemplo: 30 25 32 28 35 Funcionamiento: Almacena las temperaturas en una pila. Después de ingresar las temperaturas, el programa debe calcular y mostrar: La temperatura más alta. La temperatura más baja. Salida: Muestra la secuencia de temperaturas ingresadas. Muestra la temperatura más alta y la más baja.

package stack;

import java.util.Optional;
import java.util.Scanner;
import java.util.Stack;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crear una pila para almacenar las temperaturas
        Stack<Integer> temperaturas = new Stack<>();
        
        // Crear un objeto Scanner para leer la entrada del usuario
        Scanner entrada = new Scanner(System.in);
        
        // Variable para almacenar la cadena de entrada
        String cadena = "";
        
        // Variable para almacenar las temperaturas separadas
        String[] cadenaSeparada;

        // Bucle para pedir las temperaturas al usuario
        while (true) {
            System.out.println("Introduce las temperaturas separadas por espacios:");
            // Leer la secuencia de temperaturas como una cadena
            cadena = entrada.nextLine();

            try {
                // Separar la cadena en un arreglo usando espacios como delimitadores
                cadenaSeparada = cadena.split("\\s+");

                // Si el usuario no ingresa ninguna temperatura (arreglo vacío), lanzar una excepción
                if (cadenaSeparada.length == 0) {
                    throw new NumberFormatException("No se ingresaron temperaturas");
                }
                
                // Si la cadena es válida, salir del bucle
                break;
            } catch (NumberFormatException e) {
                // Capturar el error si el formato es inválido
                System.out.println("Formato de temperatura no válido. Intenta de nuevo.");
            }
        }

        // Convertir cada cadena de temperatura a un número entero y agregarlo a la pila
        for (String temperatura : cadenaSeparada) {
            // Parsear la temperatura de String a Integer y agregarla a la pila
            temperaturas.push(Integer.parseInt(temperatura));
        }

        // Mostrar las temperaturas ingresadas por el usuario
        System.out.println("Temperaturas ingresadas: " + temperaturas);

        // Usar Streams para calcular la temperatura más alta y más baja de la pila
        Optional<Integer> temperaturaMax = temperaturas.stream().max(Integer::compareTo);
        Optional<Integer> temperaturaMin = temperaturas.stream().min(Integer::compareTo);

        // Verificar si los valores máximos y mínimos están presentes y mostrar los resultados
        if (temperaturaMax.isPresent() && temperaturaMin.isPresent()) {
            // Si hay valores presentes, mostrar la temperatura más alta y la más baja
            System.out.println("La temperatura más alta es: " + temperaturaMax.get() + "ºC");
            System.out.println("La temperatura más baja es: " + temperaturaMin.get() + "ºC");
        } else {
            // Si no hay temperaturas (por alguna razón), informar al usuario
            System.out.println("No se pudo calcular la temperatura más alta y baja.");
        }

        // Cerrar el objeto Scanner para liberar recursos
        entrada.close();
    }
}