V1#
Problema 1: Gestión de Tareas en un Sistema#
Un sistema de gestión de tareas permite a los usuarios añadir tareas a una estructura de datos para ser ejecutadas en orden inverso en que fueron recibidas. Las tareas pueden ser de diferentes tipos y, en ciertos casos, pueden requerir atención inmediata.
Las tareas son guardadas no como Strings sino como objetos de la clase Tareas que contienen el nombre de la tarea, el tiempo de duración, la persona que la va a ejecutar, y el costo de cada una.
Acciones:
Se añaden las siguientes tareas a la estructura de datos, en este orden:
Tarea 1: Imprimir documentos
Tarea 2: Enviar correos electrónicos
Tarea 3: Compilar informes
Luego, se recibe una tarea urgente:
Tarea 4: Procesar una solicitud de emergencia
El sistema ejecuta la primera tarea en la estructura de datos.
A continuación, llegan dos tareas más:
Tarea 5: Actualizar la base de datos
Tarea 6: Realizar copias de seguridad
Después, se recibe otra tarea urgente:
Tarea 7: Responder a un cliente importante
Finalmente, se ejecutan tres tareas más de la estructura de datos.
// Clase Nodo que contiene el dato y una referencia al siguiente nodo
class Nodo<T> {
T dato; // Dato que almacenará el nodo
Nodo<T> siguiente; // Referencia al siguiente nodo en la pila
// Constructor
public Nodo(T dato) {
this.dato = dato;
this.siguiente = null;
}
}
// Clase Pila que utiliza nodos
public class Pila<T> {
private Nodo<T> cima; // Referencia al nodo que está en la cima de la pila
private int tamanio; // Variable para llevar el tamaño de la pila
// Constructor: Inicializa la pila vacía
public Pila() {
this.cima = null; // La pila comienza vacía, por lo que la cima es nula
this.tamanio = 0; // Tamaño de la pila es 0
}
// Método para agregar un elemento a la pila (Push)
public void push(T dato) {
Nodo<T> nuevoNodo = new Nodo<>(dato); // Crear un nuevo nodo con el dato
nuevoNodo.siguiente = cima; // El siguiente nodo del nuevo es el que era la cima
cima = nuevoNodo; // Actualizamos la cima para que sea el nuevo nodo
tamanio++; // Incrementamos el tamaño de la pila
}
// Método para remover y devolver el elemento en la cima de la pila (Pop)
public T pop() {
if (isEmpty()) {
System.out.println("Error: La pila está vacía.");
return null; // Devuelve null si la pila está vacía
}
T dato = cima.dato; // Obtener el dato del nodo en la cima
cima = cima.siguiente; // Mover la cima al siguiente nodo
tamanio--; // Reducimos el tamaño de la pila
return dato; // Devolvemos el dato del nodo removido
}
// Método para ver el elemento en la cima sin removerlo (Peek)
public T peek() {
if (isEmpty()) {
System.out.println("Error: La pila está vacía.");
return null; // Devuelve null si la pila está vacía
}
return cima.dato; // Devuelve el dato del nodo en la cima
}
// Método para verificar si la pila está vacía
public boolean isEmpty() {
return cima == null; // Si la cima es null, entonces la pila está vacía
}
// Método que devuelve el tamaño actual de la pila
public int size() {
return tamanio; // Devuelve el número de elementos en la pila
}
// Método para imprimir el contenido de la pila
@Override
public String toString() {
if (isEmpty()) {
return "La pila está vacía.";
}
StringBuilder sb = new StringBuilder();
Nodo<T> actual = cima;
while (actual != null) {
sb.append(actual.dato).append("\n");
actual = actual.siguiente;
}
return sb.toString();
}
}
public class Tarea{
String nombre;
double duracion;
String persona_encargada;
double costo;
public Tarea(String nombre, double duracion, String persona_encargada, double costo){
this.nombre = nombre;
this.duracion = duracion;
this.persona_encargada = persona_encargada;
this.costo = costo;
}
@Override
public String toString(){
return " Nombre: %s, Duración: %f hora, Persona encargada: %s, Costo: %.1f".formatted(nombre, duracion, persona_encargada, costo);
}
}
public class PrimerPunto{
public static void main(String[] args){
Pila<Tarea> tareas = new Pila<>();
// 1
tareas.push(new Tarea("Imprimir documentos", 1, "Sebastian", 120000.5));
tareas.push(new Tarea("Enviar correos electrónicos", 1, "Sebastian", 120000.5));
tareas.push(new Tarea("Compilar informes", 1, "Sebastian", 120000.5));
System.out.println("Punto 1:\n"+tareas);
// 2
tareas.push(new Tarea("Procesar una solicitud de emergencia", 1, "Sebastian", 120000.5));
tareas.pop();
System.out.println("Punto 2:\n"+tareas);
// 3
tareas.pop();
System.out.println("Punto 3:\n"+tareas);
// 4
tareas.push(new Tarea("Actualizar la base de datos", 1, "Sebastian", 120000.5));
tareas.push(new Tarea("Realizar copias de seguridad", 1, "Sebastian", 120000.5));
System.out.println("Punto 4:\n"+tareas);
// 5
tareas.push(new Tarea("Responder a un cliente importante", 1, "Sebastian", 120000.5));
tareas.pop();
System.out.println("Punto 5:\n"+tareas);
// 6
tareas.pop();
tareas.pop();
tareas.pop();
System.out.println("Punto 6:\n"+tareas);
System.out.println("Final del punto:\n"+tareas);
}
}
new PrimerPunto().main(null);
Punto 1:
Nombre: Compilar informes, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Enviar correos electrónicos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Punto 2:
Nombre: Compilar informes, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Enviar correos electrónicos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Punto 3:
Nombre: Enviar correos electrónicos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Punto 4:
Nombre: Realizar copias de seguridad, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Actualizar la base de datos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Enviar correos electrónicos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Punto 5:
Nombre: Realizar copias de seguridad, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Actualizar la base de datos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Enviar correos electrónicos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Punto 6:
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Final del punto:
Nombre: Imprimir documentos, Duración: 1.000000 hora, Persona encargada: Sebastian, Costo: 120000.5
Preguntas:
¿Qué estructura de datos usarías para gestionar las tareas y cómo manejarías la llegada de tareas urgentes?
RTA: Como las tareas deben ser ejecutadas en orden inverso a como fueron recibidas, la estructura de datos apropiada es una pila. El manejo de las tareas urgentes es sencillo con esta estructura de datos, como es urgente apenas llega debe ser ejecutada.
Explica el proceso que seguirías para ejecutar las tareas en el orden adecuado utilizando una cola. ¿Cómo manejarías la atención de las tareas urgentes sin alterar el orden de la cola de tareas regulares?
RTA: Utilizando una cola seria tedioso y nada optimo para manejar las tareas en el orden inverso a como van llegando, puesto que las colas cumplen que son FIFO. Esto se podría solucionar invirtiendo la cola de orden para sacar elementos y retornarla a su estado original. Respecto a las tareas urgentes, estas se podrían manejar utilizando una cola circular o una cola doble, donde se pueden ingresar y sacar elementos de ambos la dos de la cola; otra opción sería crear dos colas, donde la segunda cola, la nueva, funcionaria para agregar la tarea urgente al inicio de la cola.
¿La estructura de datos queda vacía?
RTA: No, solo queda un tarea que fue la primera que se apilo.
Problema 2: Registro de Llamadas en un Centro de Atención#
Un centro de atención telefónica gestiona las llamadas de los clientes, registrando la información relevante sobre cada llamada. Las llamadas son atendidas en el orden en que llegan.
Las llamadas son guardadas no como Strings sino como objetos de la clase Llamadas que contienen el número de la llamada, nombre del cliente, motivo de la llamada, número de donde se llama, y genero del cliente.
Acciones:
Las siguientes llamadas llegan al centro en este orden:
Llamada 1: Cliente A, consulta sobre una factura
Llamada 2: Cliente B, problema técnico
Llamada 3: Cliente C, solicitud de reembolso
Luego llega una llamada, pero otra llamada ya se ha atendido:
Llamada 4: Cliente D, problema crítico con el servicio
Se atiende a dos llamadas.
A continuación, llegan dos llamadas más:
Llamada 5: Cliente E, consulta general
Llamada 6: Cliente F, pregunta sobre un producto
Se recibe otra llamada, pero antes se atienden 2:
Llamada 7: Cliente G, fallo del sistema
Finalmente, se atienden dos llamadas más.
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
public class Fila<T> implements Queue<T> {
private LinkedList<T> elementos;
public Fila() {
elementos = new LinkedList<>();
}
@Override
public boolean add(T e) {
return elementos.add(e); // Agrega un elemento al final de la cola
}
@Override
public boolean offer(T e) {
return elementos.add(e); // Similar a add, pero no lanza una excepción si falla
}
@Override
public T remove() {
if (elementos.isEmpty()) {
throw new NoSuchElementException("La cola está vacía");
}
return elementos.removeFirst(); // Remueve el primer elemento de la cola
}
@Override
public T poll() {
return elementos.isEmpty() ? null : elementos.removeFirst(); // Devuelve y remueve el primer elemento o null si está vacía
}
@Override
public T element() {
if (elementos.isEmpty()) {
throw new NoSuchElementException("La cola está vacía");
}
return elementos.getFirst(); // Devuelve el primer elemento sin removerlo
}
@Override
public T peek() {
return elementos.isEmpty() ? null : elementos.getFirst(); // Devuelve el primer elemento o null si está vacía
}
@Override
public int size() {
return elementos.size(); // Devuelve el tamaño de la cola
}
@Override
public boolean isEmpty() {
return elementos.isEmpty(); // Verifica si la cola está vacía
}
@Override
public boolean contains(Object o) {
return elementos.contains(o); // Verifica si la cola contiene el elemento
}
@Override
public Iterator<T> iterator() {
return elementos.iterator(); // Devuelve un iterador para recorrer los elementos de la cola
}
@Override
public Object[] toArray() {
return elementos.toArray(); // Convierte la cola a un array de objetos
}
@Override
public <U> U[] toArray(U[] a) {
return elementos.toArray(a); // Convierte la cola a un array de un tipo específico
}
@Override
public boolean remove(Object o) {
return elementos.remove(o); // Remueve un objeto de la cola
}
@Override
public boolean containsAll(Collection<?> c) {
return elementos.containsAll(c); // Verifica si la cola contiene todos los elementos de la colección dada
}
@Override
public boolean addAll(Collection<? extends T> c) {
return elementos.addAll(c); // Agrega todos los elementos de la colección dada a la cola
}
@Override
public boolean removeAll(Collection<?> c) {
return elementos.removeAll(c); // Remueve todos los elementos de la colección dada de la cola
}
@Override
public boolean retainAll(Collection<?> c) {
return elementos.retainAll(c); // Retiene solo los elementos presentes en la colección dada
}
@Override
public void clear() {
elementos.clear(); // Limpia todos los elementos de la cola
}
@Override
public String toString() {
return elementos.toString(); // Convierte la lista de elementos a una cadena y la devuelve
}
}
public class Llamada{
int numero_llamada;
String nombre_cliente;
String motivo;
long telefono;
String genero_cliente;
public Llamada(int numero_llamada, String nombre_cliente, String motivo, long telefono, String genero_cliente){
this.numero_llamada = numero_llamada;
this.nombre_cliente = nombre_cliente;
this.motivo = motivo;
this.telefono = telefono;
this.genero_cliente = genero_cliente;
}
@Override
public String toString(){
return "\n Número de la llamada: %d, Nombre del cliente: %s, Motivo: %sm Teléfono: %d, Genero: %s.".formatted(numero_llamada, nombre_cliente, motivo, telefono, genero_cliente);
}
}
public class SegundoPunto{
public static void main(String[] args){
Fila<Llamada> llamadas = new Fila<>();
// 1
llamadas.offer(new Llamada(1, "Cliente A", "Consulta sobre una factura", 3195140529L, "Masculino"));
llamadas.offer(new Llamada(2, "Cliente B", "Problema técnico", 3195140529L, "Masculino"));
llamadas.offer(new Llamada(3, "Cliente C", "Solicitud de reembolso", 3195140529L, "Masculino"));
System.out.println("Punto 1: "+llamadas);
// 2
llamadas.poll();
llamadas.offer(new Llamada(4, "Cliente D", "Problema crítico con el servicio", 3195140529L, "Masculino"));
System.out.println("Punto 2: "+llamadas);
// 3
llamadas.poll();
llamadas.poll();
System.out.println("Punto 3: "+llamadas);
// 4
llamadas.offer(new Llamada(5, "Cliente E", "Consulta general", 3195140529L, "Masculino"));
llamadas.offer(new Llamada(6, "Cliente F", "Pregunta sobre un producto", 3195140529L, "Masculino"));
System.out.println("Punto 4: "+llamadas);
// 5
llamadas.poll();
llamadas.poll();
llamadas.offer(new Llamada(7, "Cliente G", "Fallo del sistema", 3195140529L, "Masculino"));
System.out.println("Punto 5: "+llamadas);
// 6
llamadas.poll();
llamadas.poll();
System.out.println("Punto 6: "+llamadas);
System.out.println("\nFinal del problema: "+llamadas);
}
}
new SegundoPunto().main(null);
Punto 1: [
Número de la llamada: 1, Nombre del cliente: Cliente A, Motivo: Consulta sobre una facturam Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 2, Nombre del cliente: Cliente B, Motivo: Problema técnicom Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 3, Nombre del cliente: Cliente C, Motivo: Solicitud de reembolsom Teléfono: 3195140529, Genero: Masculino.]
Punto 2: [
Número de la llamada: 2, Nombre del cliente: Cliente B, Motivo: Problema técnicom Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 3, Nombre del cliente: Cliente C, Motivo: Solicitud de reembolsom Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 4, Nombre del cliente: Cliente D, Motivo: Problema crítico con el serviciom Teléfono: 3195140529, Genero: Masculino.]
Punto 3: [
Número de la llamada: 4, Nombre del cliente: Cliente D, Motivo: Problema crítico con el serviciom Teléfono: 3195140529, Genero: Masculino.]
Punto 4: [
Número de la llamada: 4, Nombre del cliente: Cliente D, Motivo: Problema crítico con el serviciom Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 5, Nombre del cliente: Cliente E, Motivo: Consulta generalm Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 6, Nombre del cliente: Cliente F, Motivo: Pregunta sobre un productom Teléfono: 3195140529, Genero: Masculino.]
Punto 5: [
Número de la llamada: 6, Nombre del cliente: Cliente F, Motivo: Pregunta sobre un productom Teléfono: 3195140529, Genero: Masculino.,
Número de la llamada: 7, Nombre del cliente: Cliente G, Motivo: Fallo del sistemam Teléfono: 3195140529, Genero: Masculino.]
Punto 6: []
Final del problema: []
Preguntas:
¿Qué estructura de datos usarías para gestionar las llamadas y cómo manejarías la llegada de llamadas urgentes?
RTA: Dado que las llamadas se despachan en el orden que salen, la estructura de datos apropiada es una fila/cola. Para manejar las llamadas urgentes con alta prioridad se deberían colocar al inicio de la cola, esto se puede hacer de dos formas: creando una segunda pila donde el primer dato sea la llamada urgente, o utilizando una cola doble (aquellas a las que se les puede ingresar por delante o detrás).
Describe cómo garantizarías que las llamadas se atiendan en el orden correcto utilizando una estructura de datos para las llamadas.
RTA: utilizando el concepto de FIFO, inherente a las colas, las llamadas se atenderían en el mismo orden en que llegan.
Si existiesen llamadas de emergencia, ¿Cómo se podrían gestionar estos tipos de usuarios?
RTA: Para manejar las llamadas urgentes con alta prioridad se deberían colocar al inicio de la cola, esto se puede hacer de dos formas: creando una segunda pila donde el primer dato sea la llamada urgente, o utilizando una cola doble (aquellas a las que se les puede ingresar por delante o detrás).
Consideraciones Adicionales#
Problema 1 (Gestión de Tareas): Detalla cómo se añaden y ejecutan las tareas en la estructura de datos, y cómo se manejan las tareas urgentes para asegurar que sean atendidas sin afectar el flujo de trabajo general.
Problema 2 (Registro de Llamadas): Analiza cómo las llamadas se registran en la estructura de datos y qué métodos utilizarías para garantizar que las llamadas urgentes sean atendidas de manera eficiente, sin perder el orden de las llamadas regulares.