Carlos Fernández García

Ejercicio 1

Crea un programa en Java que utilice una PriorityQueue para gestionar números enteros. Realiza las siguientes operaciones: Añadir números: Agrega los números 10, 5, 20, y 15 a la PriorityQueue. Mostrar el número más pequeño: Utiliza el método peek() para imprimir el elemento de mayor prioridad (el menor número en este caso). Eliminar números: Usa el método poll() para eliminar el elemento de mayor prioridad (el menor número) e imprímelo. Mostrar los elementos restantes: Después de cada eliminación, imprime los elementos que quedan en la PriorityQueue.

Ejercicio 2

Crea un programa en Java que utilice una PriorityQueue para gestionar tareas pendientes en un sistema. Cada tarea tiene un nombre (String) y una prioridad (entero). Realiza las siguientes operaciones: Añade las siguientes tareas a la PriorityQueue: "Enviar informe" con prioridad 2. "Revisar correos" con prioridad 5. "Preparar presentación" con prioridad 1. "Llamar a cliente" con prioridad 3. Muestra la tarea con mayor prioridad (menor número) utilizando el método peek(). Elimina y muestra las tareas en orden de prioridad usando el método poll(), imprimiendo su nombre y prioridad. Una vez completadas todas las tareas, imprime un mensaje indicando que no hay más tareas pendientes.

package priorityqueue;

import java.util.PriorityQueue;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Crear tareas con sus respectivas prioridades
        Tarea tarea1 = new Tarea(2, "Enviar informe");
        Tarea tarea2 = new Tarea(5, "Revisar correos");
        Tarea tarea3 = new Tarea(1, "Preparar presentación");
        Tarea tarea4 = new Tarea(3, "Llamar al cliente");

        // Crear la PriorityQueue para gestionar las tareas
        PriorityQueue<Tarea> listaTareas = new PriorityQueue<>();

        // Añadir las tareas a la cola
        listaTareas.add(tarea1);
        listaTareas.add(tarea2);
        listaTareas.add(tarea3);
        listaTareas.add(tarea4);

        // Mostrar la tarea con mayor prioridad sin eliminarla
        System.out.println("La tarea con más prioridad es: " + listaTareas.peek());

        // Eliminar y mostrar las tareas en orden de prioridad
        while (!listaTareas.isEmpty()) {
            Tarea tareaEliminada = listaTareas.poll(); // Elimina la tarea con mayor prioridad
            System.out.println("Eliminando tarea: " + tareaEliminada.getNombre() + 
                               " con prioridad " + tareaEliminada.getPrioridad());
        }

        // Verificar si la cola está vacía y mostrar un mensaje
        if (listaTareas.isEmpty()) {
            System.out.println("No quedan tareas pendientes.");
        }
    }
}

class Tarea implements Comparable<Tarea> {
    // Atributos de la tarea
    private int prioridad;
    private String nombre;

    // Constructor para inicializar los atributos
    public Tarea(int prioridad, String nombre) {
        this.prioridad = prioridad;
        this.nombre = nombre;
    }

    // Getters y setters para acceder/modificar los atributos
    public int getPrioridad() {
        return prioridad;
    }

    public void setPrioridad(int prioridad) {
        this.prioridad = prioridad;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    // Método toString para representar la tarea como texto
    @Override
    public String toString() {
        return "Tarea [prioridad=" + prioridad + ", nombre=" + nombre + "]";
    }

    // Implementación de compareTo para definir el orden en PriorityQueue
    @Override
    public int compareTo(Tarea o) {
        // Ordenar por prioridad de menor a mayor
        return Integer.compare(this.prioridad, o.prioridad);
    }
}

Ejercicio 3

Crea un programa en Java que gestione una lista de pacientes en un hospital utilizando una PriorityQueue. Cada paciente tiene un nombre (String) y un nivel de urgencia (entero, donde 1 es el más urgente). Realiza las siguientes operaciones: Agrega los siguientes pacientes a la PriorityQueue: "Juan Pérez" con nivel de urgencia 3. "María López" con nivel de urgencia 1. "Carlos Gómez" con nivel de urgencia 4. "Ana Torres" con nivel de urgencia 2. Muestra el paciente con mayor urgencia utilizando el método peek(). Atiende a los pacientes en orden de urgencia utilizando el método poll(). Por cada paciente atendido, imprime su nombre y nivel de urgencia. Permite al usuario agregar nuevos pacientes manualmente, ingresando su nombre y nivel de urgencia desde la consola. Pregunta si desea agregar más pacientes hasta que el usuario indique que no. Al final, si no hay más pacientes pendientes, muestra un mensaje indicando que "No quedan pacientes en espera".

package priorityqueue;

import java.util.PriorityQueue;
import java.util.Scanner;

public class Ejercicio3 {

	public static void main(String[] args) {
		// Crear una instancia de la clase Paciente
		Paciente paciente = new Paciente();
		
		// Cargar los pacientes iniciales en la PriorityQueue
		paciente.cargaPacientesInicial();
		
		// Mostrar al paciente con mayor urgencia (menor valor de prioridad)
		System.out.println("El paciente con mayor urgencia es --> " + 
			paciente.listaPacientes.peek().getNombre() + 
			" con prioridad " + paciente.listaPacientes.peek().getUrgencia());
		
		// Atender pacientes en orden de urgencia hasta que la lista esté vacía
		while (!paciente.listaPacientes.isEmpty()) {
			Paciente pacienteAtendido = paciente.listaPacientes.poll();
			System.out.println("Atendido el paciente -> " + pacienteAtendido.getNombre() + 
				"  con prioridad -> " + pacienteAtendido.getUrgencia());
		}
		
		// Verificar si todos los pacientes iniciales han sido atendidos
		if (paciente.listaPacientes.isEmpty()) {
			System.out.println("Todos los pacientes iniciales han sido atendidos");
		}
		
		char respuesta = ' ';
		String nombre = "";
		int prioridad = 0;
		Scanner entrada = new Scanner(System.in);
		
		// Bucle para permitir al usuario agregar más pacientes manualmente
		while (true) {
			System.out.println("¿Quieres agregar más pacientes? (s)(n)");
			respuesta = entrada.nextLine().toLowerCase().charAt(0);
			
			if (respuesta != 's' && respuesta != 'n') {
				// Validar respuesta del usuario
				System.out.println("La respuesta tiene que ser 's' o 'n'");
			} else if (respuesta == 's') {
				// Agregar un nuevo paciente
				while (true) {
					System.out.println("Introduce el nombre del paciente:");
					nombre = entrada.nextLine();
					
					if (nombre.trim().isEmpty()) {
						// Validar que el nombre no esté vacío
						System.out.println("El nombre no puede quedar vacío, introdúcelo de nuevo");
					} else {
						break;
					}
				}
				
				while (true) {
					try {
						System.out.println("Introduce el número de urgencia");
						prioridad = Integer.parseInt(entrada.nextLine());
						
						if (prioridad < 1) {
							// Validar que la prioridad sea mayor que 0
							System.out.println("El nivel de prioridad tiene que ser mayor que 0, introdúcelo de nuevo");
						} else {
							break;
						}
						
					} catch (NumberFormatException e) {
						// Manejar errores de formato en la entrada de prioridad
						System.err.println("Formato de urgencia no válido, introdúcelo de nuevo");
					}
				}
				
				// Crear y agregar el nuevo paciente a la lista
				Paciente pacienteAgregado = new Paciente(prioridad, nombre);
				paciente.listaPacientes.add(pacienteAgregado);
				System.out.println("Nuevo paciente agregado con éxito");
				
			} else {
				// Salir del bucle si el usuario no desea agregar más pacientes
				break;
			}
		}
		
		// Verificar si hay pacientes pendientes
		if (paciente.listaPacientes.isEmpty()) {
			System.out.println("No hay pacientes en espera");
		} else {
			// Mostrar la lista de pacientes pendientes
			System.out.println("Listado de pacientes en espera:");
			for (Paciente paciente1 : paciente.listaPacientes) {
				System.out.println("Nombre: " + paciente1.getNombre() + 
					" Prioridad: " + paciente1.getUrgencia());
			}
		}
	}

}

class Paciente implements Comparable<Paciente> {

	// PriorityQueue que almacena a los pacientes
	PriorityQueue<Paciente> listaPacientes = new PriorityQueue<Paciente>();
	
	int urgencia; // Nivel de urgencia del paciente
	String nombre; // Nombre del paciente
	
	// Constructor por defecto
	public Paciente() {
		
	}
	
	// Constructor con parámetros
	public Paciente(int urgencia, String nombre) {
		this.urgencia = urgencia;
		this.nombre = nombre;
	}
	
	// Getter y setter para urgencia
	public int getUrgencia() {
		return urgencia;
	}

	public void setUrgencia(int urgencia) {
		this.urgencia = urgencia;
	}

	// Getter y setter para nombre
	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	@Override
	public int compareTo(Paciente o) {
		// Comparar pacientes por nivel de urgencia (menor nivel es más urgente)
		return Integer.compare(this.urgencia, o.urgencia);
	}
	
	// Método para cargar pacientes iniciales en la lista
	public void cargaPacientesInicial() {
		// Crear y agregar pacientes predefinidos
		Paciente paciente1 = new Paciente(3, "Juan Perez");
		Paciente paciente2 = new Paciente(1, "Maria Lopez");
		Paciente paciente3 = new Paciente(4, "Carlos Gomez");
		Paciente paciente4 = new Paciente(2, "Ana Torres");
		
		listaPacientes.add(paciente1);
		listaPacientes.add(paciente2);
		listaPacientes.add(paciente3);
		listaPacientes.add(paciente4);
		
		// Indicar que la carga inicial fue exitosa
		System.out.println("Carga inicial de pacientes realizada con éxito");
	}
}

Ejercicio 4

Crea un programa en Java que gestione las tareas de un equipo de soporte técnico utilizando una PriorityQueue. Cada tarea tendrá una descripción (String), un nivel de prioridad (entero, donde 1 es el más urgente), y una fecha de creación (LocalDate). El programa debe realizar las siguientes operaciones: Agregar tareas predefinidas a la PriorityQueue, por ejemplo: "Revisar servidor" con prioridad 2, creado el 1 de diciembre de 2024. "Actualizar sistema operativo" con prioridad 3, creado el 5 de diciembre de 2024. "Atender fallo crítico en red" con prioridad 1, creado el 10 de diciembre de 2024. "Respaldo de base de datos" con prioridad 4, creado el 8 de diciembre de 2024. Mostrar la tarea más urgente sin eliminarla usando el método peek(). Procesar y resolver las tareas en orden de prioridad utilizando el método poll(). Por cada tarea resuelta, muestra su descripción, nivel de prioridad y fecha de creación. Permitir al usuario agregar nuevas tareas manualmente, ingresando la descripción, el nivel de prioridad y la fecha de creación. Pregunta si desea agregar más tareas hasta que el usuario indique que no. Listar las tareas pendientes en la cola al final del programa, mostrando la descripción, nivel de prioridad y fecha de creación para cada tarea. Si no hay tareas pendientes, muestra un mensaje indicando que "No hay tareas pendientes".


package priorityqueue;

import java.time.LocalDate;
import java.time.format.TextStyle;
import java.util.Locale;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Se crea un objeto del sistema para gestionar las tareas
        Sistema tarea = new Sistema();
        tarea.tareasIniciales(); // Carga de tareas iniciales predefinidas

        // Mostrar la tarea más urgente sin eliminarla utilizando peek()
        System.out.println("La tarea más urgente es -> " + tarea.listaTareas.peek().getTarea() +
                "\nPrioridad --> " + tarea.listaTareas.peek().getPrioridad() +
                "\nFecha de creación --> " + tarea.listaTareas.peek().getFechaCreacion());

        // Procesar las tareas en orden de prioridad utilizando poll()
        while (!tarea.listaTareas.isEmpty()) {
            Sistema tareaCompletada = tarea.listaTareas.poll(); // Elimina la tarea más prioritaria
            System.out.println("Tarea completada: " + tareaCompletada.getTarea());
            System.out.println("Prioridad: " + tareaCompletada.getPrioridad());
            System.out.println("Fecha creación: " + tareaCompletada.getFechaCreacion());
        }

        // Gestión de ingreso manual de nuevas tareas por el usuario
        char respuesta = ' ';
        Scanner entrada = new Scanner(System.in);

        while (true) {
            // Bucle para validar la respuesta del usuario
            while (true) {
                System.out.println("¿Quieres agregar más tareas? (s/n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);

                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser 's' o 'n', introdúcela de nuevo");
                } else {
                    break;
                }
            }

            if (respuesta == 'n') {
                break; // Finaliza si el usuario no quiere agregar más tareas
            } else {
                int prioridad = 0;
                String tareaNueva, fechaCreacion;

                // Validar y capturar la prioridad de la tarea
                while (true) {
                    try {
                        System.out.println("Introduce la prioridad de la tarea");
                        prioridad = Integer.parseInt(entrada.nextLine());
                        if (prioridad < 1) {
                            System.out.println("La prioridad tiene que ser mayor que 0, introdúcela de nuevo");
                        } else {
                            break;
                        }
                    } catch (NumberFormatException e) {
                        System.err.println("Formato de prioridad no válido, introdúcelo de nuevo");
                    }
                }

                // Validar y capturar el nombre de la tarea
                while (true) {
                    System.out.println("Introduce el nombre de la tarea");
                    tareaNueva = entrada.nextLine();

                    if (tareaNueva.trim().isEmpty()) {
                        System.out.println("El nombre de la tarea no puede quedar en blanco, introdúcelo de nuevo");
                    } else {
                        break;
                    }
                }

                // Obtener la fecha del sistema y formatearla
                LocalDate fechaDia = LocalDate.now();
                int dia = fechaDia.getDayOfMonth();
                int anio = fechaDia.getYear();
                String mes = fechaDia.getMonth().getDisplayName(TextStyle.FULL, Locale.getDefault());
                fechaCreacion = dia + " " + mes + " " + anio;

                // Crear la nueva tarea y agregarla a la cola
                Sistema nuevaTarea = new Sistema(prioridad, tareaNueva, fechaCreacion);
                tarea.listaTareas.add(nuevaTarea);
                System.out.println("Tarea agregada con éxito, hay " + tarea.listaTareas.size() + " tarea/s pendiente/s");
            }
        }

        // Mostrar tareas pendientes si las hay
        if (tarea.listaTareas.isEmpty()) {
            System.out.println("No quedan tareas pendientes");
        } else {
            System.out.println("Listado de tareas pendientes");
            int index = 0;
            for (Sistema tareas : tarea.listaTareas) {
                index++;
                System.out.println("Tarea Nº: " + index);
                System.out.println("Nombre: " + tareas.getTarea());
                System.out.println("Prioridad: " + tareas.getPrioridad());
                System.out.println("Fecha de creación: " + tareas.getFechaCreacion());
            }
        }
    }
}

class Sistema implements Comparable<Sistema> {

    private int prioridad; // Prioridad de la tarea
    private String tarea; // Descripción de la tarea
    private String fechaCreacion; // Fecha de creación de la tarea
    PriorityQueue<Sistema> listaTareas = new PriorityQueue<Sistema>(); // Cola de prioridad

    public Sistema() {
    }

    public int getPrioridad() {
        return prioridad;
    }

    public void setPrioridad(int prioridad) {
        this.prioridad = prioridad;
    }

    public String getTarea() {
        return tarea;
    }

    public void setTarea(String tarea) {
        this.tarea = tarea;
    }

    public String getFechaCreacion() {
        return fechaCreacion;
    }

    public void setFechaCreacion(String fechaCreacion) {
        this.fechaCreacion = fechaCreacion;
    }

    public PriorityQueue<Sistema> getListaTareas() {
        return listaTareas;
    }

    public Sistema(int prioridad, String tarea, String fechaCreacion) {
        this.prioridad = prioridad;
        this.tarea = tarea;
        this.fechaCreacion = fechaCreacion;
    }

    @Override
    public String toString() {
        return "Sistema [prioridad=" + prioridad + ", tarea=" + tarea + ", fechaCreacion=" + fechaCreacion + "]";
    }

    @Override
    public int compareTo(Sistema o) {
        // Comparar las tareas según su prioridad
        return Integer.compare(this.prioridad, o.prioridad);
    }

    public void tareasIniciales() {
        // Agregar tareas predefinidas a la cola
        Sistema tarea1 = new Sistema(2, "Revisar servidor", "1 Diciembre 2024");
        Sistema tarea2 = new Sistema(3, "Actualizar sistema operativo", "5 Diciembre 2024");
        Sistema tarea3 = new Sistema(1, "Atender fallo crítico de red", "10 Diciembre 2024");
        Sistema tarea4 = new Sistema(4, "Respaldo de base de datos", "8 Diciembre 2024");

        listaTareas.add(tarea1);
        listaTareas.add(tarea2);
        listaTareas.add(tarea3);
        listaTareas.add(tarea4);

        System.out.println("Tareas de mantenimiento iniciales cargadas con éxito");
    }
}

Ejercicio 5

Gestión de Inscripciones para un Torneo de Ajedrez Crea un programa en Java que gestione las inscripciones para un torneo de ajedrez utilizando una PriorityQueue. Cada inscripción debe incluir los siguientes datos: Nombre del jugador (String) Categoría (entero, donde 1 es la categoría de mayor nivel y 5 la más baja) Hora de inscripción (LocalTime) El programa debe realizar las siguientes operaciones: Cargar inscripciones iniciales: Agregar inscripciones predefinidas con nombres, categorías y horas de inscripción. Por ejemplo: "Carlos López", categoría 2, hora de inscripción 10:30. "Ana García", categoría 1, hora de inscripción 9:45. "Luis Fernández", categoría 3, hora de inscripción 11:15. "Sofía Torres", categoría 2, hora de inscripción 10:00. Mostrar la próxima inscripción a procesar: Usar el método peek() para mostrar el jugador con la mayor prioridad (menor categoría) y, en caso de empate, el jugador inscrito más temprano. Procesar las inscripciones: Utilizar el método poll() para procesar las inscripciones en orden de prioridad, mostrando el nombre del jugador, su categoría y la hora de inscripción. Las inscripciones de categoría más alta (número menor) deben ser procesadas primero; en caso de empate en categoría, se priorizan las inscripciones realizadas más temprano. Permitir nuevas inscripciones: El usuario podrá agregar manualmente más inscripciones ingresando nombre, categoría y hora de inscripción. Repite este proceso hasta que el usuario indique que no desea agregar más inscripciones. Mostrar el estado de las inscripciones pendientes: Si hay jugadores pendientes de ser procesados, mostrar un listado con el nombre, la categoría y la hora de inscripción de cada uno. Si no quedan inscripciones pendientes, mostrar el mensaje "No hay inscripciones pendientes". Notas adicionales: Define una clase Inscripcion que implemente Comparable para gestionar las prioridades según las reglas establecidas. Usa la clase LocalTime para representar la hora de inscripción. Asegúrate de que la prioridad de procesamiento cumpla con los criterios indicados (categoría primero, luego hora de inscripción).


package priorityqueue;

import java.time.LocalTime;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Ejercicio5 {

    public static void main(String[] args) {
        /* Inicialización del torneo y carga de inscripciones iniciales */
        Torneo torneo = new Torneo();
        torneo.inscriptosIniciales();

        /* Uso de Scanner para interactuar con el usuario */
        Scanner entrada = new Scanner(System.in);
        char respuesta = ' ';
        while (true) {
            /* Solicitar si se desean agregar más participantes */
            while (true) {
                System.out.println("¿Quieres agregar más participantes? (s/n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);

                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser 's' o 'n', introdúcela de nuevo");
                } else {
                    break;
                }
            }

            if (respuesta == 'n') {
                break;
            } else {
                /* Agregar un nuevo participante */
                int categoria = torneo.agregarCategoria(entrada);
                String nombre = torneo.agregarNombre(entrada);
                LocalTime hora = torneo.obtenerHora();

                Torneo participanteNuevo = new Torneo(categoria, nombre, hora);
                torneo.agregarParticipante(participanteNuevo);
            }
        }

        /* Mostrar participantes pendientes o mensaje si no quedan */
        if (!torneo.listaParticipantes.isEmpty()) {
            System.out.println("No quedan participantes pendientes");
        } else {
            torneo.mostrarParticipantes();
        }

        entrada.close();
    }

}

class Torneo implements Comparable<Torneo> {

    /* Atributos de la clase Torneo */
    private int categoria;
    private String nombre;
    private LocalTime horaInscripcion;
    PriorityQueue<Torneo> listaParticipantes = new PriorityQueue<Torneo>();

    /* Constructor por defecto */
    public Torneo() {
    }

    /* Constructor con parámetros */
    public Torneo(int categoria, String nombre, LocalTime horaInscripcion) {
        this.categoria = categoria;
        this.nombre = nombre;
        this.horaInscripcion = horaInscripcion;
    }

    /* Getters y Setters */
    public int getCategoria() {
        return categoria;
    }

    public void setCategoria(int categoria) {
        this.categoria = categoria;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public LocalTime getHoraInscripcion() {
        return horaInscripcion;
    }

    public void setHoraInscripcion(LocalTime horaInscripcion) {
        this.horaInscripcion = horaInscripcion;
    }

    public PriorityQueue<Torneo> getListaParticipantes() {
        return listaParticipantes;
    }

    public void setListaParticipantes(PriorityQueue<Torneo> listaParticipantes) {
        this.listaParticipantes = listaParticipantes;
    }

    @Override
    public String toString() {
        return "Torneo [categoria=" + categoria + ", nombre=" + nombre + ", horaInscripcion=" + horaInscripcion + "]";
    }

    @Override
    public int compareTo(Torneo o) {
        /* Comparación por categoría y hora de inscripción */
        int categoriaComparison = Integer.compare(this.categoria, o.categoria);
        if (categoriaComparison != 0) {
            return categoriaComparison;
        }
        return this.horaInscripcion.compareTo(o.horaInscripcion);
    }

    public void inscriptosIniciales() {
        /* Cargar inscripciones iniciales */
        Torneo participante1 = new Torneo(2, "Carlos Lopez", LocalTime.of(10, 30, 00));
        Torneo participante2 = new Torneo(1, "Ana Garcia", LocalTime.of(9, 45, 00));
        Torneo participante3 = new Torneo(3, "Luis Fernandez", LocalTime.of(11, 15, 00));
        Torneo participante4 = new Torneo(2, "Sofia Torres", LocalTime.of(10, 00, 00));

        listaParticipantes.add(participante1);
        listaParticipantes.add(participante2);
        listaParticipantes.add(participante3);
        listaParticipantes.add(participante4);

        System.out.println("Participantes ya clasificados para el torneo dados de alta correctamente");

        primerInscripto();
    }

    private void primerInscripto() {
        /* Mostrar el primer jugador inscrito */
        System.out.println("Primer juegador inscripto");
        System.out.println("Nombre -> " + listaParticipantes.peek().getNombre());
        System.out.println("Categoria -> " + listaParticipantes.peek().getCategoria());
        System.out.println("Hora de inscripcion -> " + listaParticipantes.peek().getHoraInscripcion());

        procesarInscripciones();
    }

    private void procesarInscripciones() {
        /* Procesar inscripciones en orden de prioridad */
        int index = 0;
        while (!listaParticipantes.isEmpty()) {
            Torneo torneo = listaParticipantes.poll();
            index++;
            System.out.println("Participante procesado Nº" + index);
            System.out.println("Nombre -> " + torneo.getNombre());
            System.out.println("Categoria -> " + torneo.getCategoria());
            System.out.println("Hora de inscripcion -> " + torneo.getHoraInscripcion());
        }
    }

    public String agregarNombre(Scanner entrada) {
        /* Agregar nombre del participante */
        while (true) {
            System.out.println("Agregar el nombre del participante:");
            this.nombre = entrada.nextLine();

            if (this.nombre.trim().isEmpty()) {
                System.out.println("El nombre no puede quedar en blanco, introducelo de nuevo");
            } else {
                return this.nombre;
            }
        }
    }

    public int agregarCategoria(Scanner entrada) {
        /* Agregar categoría del participante */
        while (true) {
            try {
                System.out.println("Introduce la categoria del participante:");
                this.categoria = Integer.parseInt(entrada.nextLine());

                if (this.categoria < 1) {
                    System.out.println("La categoria tiene que ser mayor que 1, introducela de nuevo");
                } else {
                    return this.categoria;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de categoria no valido, introducela de nuevo");
            }
        }
    }

    public LocalTime obtenerHora() {
        /* Obtener la hora actual como hora de inscripción */
        return LocalTime.now();
    }

    public void agregarParticipante(Torneo participante) {
        /* Agregar un nuevo participante a la cola */
        listaParticipantes.add(participante);
        System.out.println("Particpante nuevo inscripto con exito");
    }

    public void mostrarParticipantes() {
        /* Mostrar los participantes pendientes */
        int index = 0;
        for (Torneo participante : listaParticipantes) {
            index++;
            System.out.println("Participante procesado Nº" + index);
            System.out.println("Nombre -> " + participante.getNombre());
            System.out.println("Categoria -> " + participante.getCategoria());
            System.out.println("Hora de inscripcion -> " + participante.getHoraInscripcion());
        }
    }
}