V2

Problema 1: Sistema de Navegación Web

Un navegador web permite a los usuarios visitar diversas páginas y navegar entre ellas utilizando los botones «Atrás» y «Adelante». El sistema guarda el historial de las páginas visitadas en el orden en que fueron abiertas.

Las páginas son guardadas no como Strings sino como objetos de la clase PaginaWeb que contienen el url, el nombre de la página web, la fecha de acceso, y cantidad de visitas diarias.

Acciones:

1. El usuario visita las siguientes páginas, en orden:

   • www.google.com

   • www.wikipedia.org

   • www.github.com

   • www.medium.com

2. El usuario presiona «Atrás» dos veces para regresar a páginas anteriores.

3. Luego, el usuario presiona «Adelante» una vez.

4. Después de eso, visita una nueva página: www.stackoverflow.com.

5. Finalmente, presionar «Atrás» de nuevo.

// 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();
  }
}

import java.util.Date;
public class PaginaWeb{
    String url;
    String nombre;
    String fecha_acceso;
    Integer cantidad_visitas;

    public PaginaWeb(String url, String nombre, String fecha_acceso, Integer cantidad_visitas){
        this.url = url;
        this.nombre = nombre;
        this.fecha_acceso = fecha_acceso;//new Date(fecha_acceso);
        this.cantidad_visitas = cantidad_visitas;
    }

    @Override
    public String toString(){
        return "  Url: %s, Nombre: %s, Fecha de Acceso: %s, Cantidad Visitas: %d.".formatted(url, nombre, fecha_acceso, cantidad_visitas);    
    }
}

public class PrimerPunto{
    public static void main(String [] args){
        Pila<PaginaWeb> paginas = new Pila<>();

        // 1
        paginas.push(new PaginaWeb("www.google.com", "Google", "2024-10-22", 8500));
        paginas.push(new PaginaWeb("www.wikipedia.org", "Wikipedia", "2024-10-22", 4300));
        paginas.push(new PaginaWeb("www.github.com", "GitHub", "2024-10-22", 100));
        paginas.push(new PaginaWeb("www.medium.com", "Medium", "2024-10-22", 183));
        System.out.println("Punto 1:\n"+paginas);

        // 2
        paginas.pop();
        paginas.pop();
        System.out.println("Punto 2:\n"+paginas);

        // 3
        paginas.push(new PaginaWeb("www.github.com", "GitHub", "2024-10-22", 100));
        System.out.println("Punto 3:\n"+paginas);

        // 4
        paginas.push(new PaginaWeb("www.stackoverflow.com", "Stackoverflow", "2024-10-22", 150));
        System.out.println("Punto 4:\n"+paginas);

        // 5
        paginas.pop();
        System.out.println("Punto 5:\n"+paginas);

        System.out.println("Final del punto:\n"+paginas);
    }
}
new PrimerPunto().main(null);

Punto 1:
  Url: www.medium.com, Nombre: Medium, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 183.
  Url: www.github.com, Nombre: GitHub, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 100.
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Punto 2:
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Punto 3:
  Url: www.github.com, Nombre: GitHub, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 100.
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Punto 4:
  Url: www.stackoverflow.com, Nombre: Stackoverflow, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 150.
  Url: www.github.com, Nombre: GitHub, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 100.
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Punto 5:
  Url: www.github.com, Nombre: GitHub, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 100.
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Final del punto:
  Url: www.github.com, Nombre: GitHub, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 100.
  Url: www.wikipedia.org, Nombre: Wikipedia, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 4300.
  Url: www.google.com, Nombre: Google, Fecha de Acceso: 2024-10-22, Cantidad Visitas: 8500.

Preguntas:

• ¿Qué estructura de datos usarías para manejar el historial de páginas anteriores y por qué?

  RTA: Las pilas la estructura de datos adecuada puesto que dar atras es quitar la última página visitada, sigue la estructura FiLO.

• Describe cómo manejarías cada acción utilizando la estructura seleccionada. ¿Qué pasaría con las páginas al presionar «Atrás» y «Adelante»? ¿Qué ocurre al visitar una nueva página después de haber retrocedido?

  RTA: La acción de visitar una página o dar Adelante representan agregar un elemento en la pila, mientras que la acción de Atrás significa quitar un elemento de la pila.

  Si se visita una nueva página después de haber retrocedido se debe agregar de nuevo la página, se pierde el historial de las páginas que estaban adelenta y se crea uno nuevo. Esto se puede evitar haciendo dos pilas: una para las páginas de adelante y otra para las páginas de atras, sin embargo esta solución agrega más dificultad al problema.

• ¿La estructura de datos queda vacía?

  RTA: No, en la pila quedan 3 páginas web.

Problema 2: Gestión de Turnos en una Clínica

La clínica «Salud Total» utiliza un sistema para gestionar los turnos de los pacientes. Los pacientes son atendidos en el orden en que llegan, excepto en casos de emergencia los cuales no tendremos en cuenta. Los pacientes están representados por una clase llamada Pacientes, que tiene 6 atributos que describen la información relevante de cada paciente (nombre, edad, número de paciente, triage, categoria, y otro que se inventen). Al llegar, los pacientes son añadidos a una estructura de datos.

Acciones:

1. Los siguientes pacientes llegan a la clínica en este orden:

   • Paciente 1: Ana Torres

   • Paciente 2: Carlos García

   • Paciente 3: Laura Pérez

2. Luego llega un paciente más pero antes se atiende otro:

   • Paciente 4: José Martínez, emergencia

3. El sistema atiende a dos pacientes.

4. A continuación, llegan dos pacientes más:

   • Paciente 5: María López, consulta regular

   • Paciente 6: Juan Morales, consulta regular

5. Se atiende a otros dos paciente y después llega otro:

   • Paciente 7: Diana Sánchez, emergencia

6. Finalmente, se atienden un paciente pacientes 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 Paciente{
  String nombre;
  Integer edad;
  Integer no_paciente;
  Integer triage;
  String categoria;
  boolean viene_solo;

  public Paciente(String nombre, Integer edad, Integer no_paciente, Integer triage, String categoria, boolean viene_solo){
      this.nombre = nombre;
      this.edad = edad;
      this.no_paciente = no_paciente;
      this.triage = triage;
      this.categoria = categoria;
      this.viene_solo = viene_solo;
  }

  @Override
  public String toString(){
      return "\n  Nombre: "+nombre+". Edad: "+edad+". Número paciente: "+no_paciente+". Categoria: "+categoria+". Viene solo: "+viene_solo+".";
  }
}

public class SegundoPunto{
    public static void main(String[] args){
        Fila<Paciente> pacientes = new Fila<>();
        // 1
        pacientes.offer(new Paciente("Ana Torres", 27, 1, 1, "A", true));
        pacientes.offer(new Paciente("Carlos Garcia", 17, 2, 1, "A", false));
        pacientes.offer(new Paciente("Laura Perez", 15, 1, 3, "B", true));
        System.out.println("Punto 1:\n"+pacientes);

        // 2
        pacientes.poll();
        pacientes.offer(new Paciente("Jose Martinez", 54, 4, 1, "C", false));
        System.out.println("Punto 2:\n"+pacientes);

        // 3
        pacientes.poll();
        pacientes.poll();
        System.out.println("Punto 3:\n"+pacientes);

        // 4
        pacientes.offer(new Paciente("María López", 8, 5, 1, "C", true));
        pacientes.offer(new Paciente("Juan Morales", 27, 6, 1, "B", true));
        System.out.println("Punto 4:\n"+pacientes);

        // 5
        pacientes.poll();
        pacientes.poll();
        pacientes.offer(new Paciente("Diana Sánchez", 30, 7, 1, "B", true));
        System.out.println("Punto 5:\n"+pacientes);

        // 6
        pacientes.poll();
        System.out.println("Punto 5:\n"+pacientes);

        System.out.println("\nFinal del problema:\n"+pacientes);
    }
}
new SegundoPunto().main(null);

Punto 1:
[
  Nombre: Ana Torres. Edad: 27. Número paciente: 1. Categoria: A. Viene solo: true., 
  Nombre: Carlos Garcia. Edad: 17. Número paciente: 2. Categoria: A. Viene solo: false., 
  Nombre: Laura Perez. Edad: 15. Número paciente: 1. Categoria: B. Viene solo: true.]

Punto 2:
[
  Nombre: Carlos Garcia. Edad: 17. Número paciente: 2. Categoria: A. Viene solo: false., 
  Nombre: Laura Perez. Edad: 15. Número paciente: 1. Categoria: B. Viene solo: true., 
  Nombre: Jose Martinez. Edad: 54. Número paciente: 4. Categoria: C. Viene solo: false.]

Punto 3:
[
  Nombre: Jose Martinez. Edad: 54. Número paciente: 4. Categoria: C. Viene solo: false.]

Punto 4:
[
  Nombre: Jose Martinez. Edad: 54. Número paciente: 4. Categoria: C. Viene solo: false., 
  Nombre: María López. Edad: 8. Número paciente: 5. Categoria: C. Viene solo: true., 
  Nombre: Juan Morales. Edad: 27. Número paciente: 6. Categoria: B. Viene solo: true.]

Punto 5:
[
  Nombre: Juan Morales. Edad: 27. Número paciente: 6. Categoria: B. Viene solo: true., 
  Nombre: Diana Sánchez. Edad: 30. Número paciente: 7. Categoria: B. Viene solo: true.]

Punto 5:
[
  Nombre: Diana Sánchez. Edad: 30. Número paciente: 7. Categoria: B. Viene solo: true.]

Final del problema:
[
  Nombre: Diana Sánchez. Edad: 30. Número paciente: 7. Categoria: B. Viene solo: true.]

Preguntas:

• ¿Qué estructura de datos usarías para gestionar los turnos de los pacientes?

  RTA: Como los pacientes son atendidos en el orden que llegan, FIFO, se utiliza una estructura de datos tipo cola/fila.

• ¿La estructura de datos queda vacía?

  RTA: No, quedan tres páginas en ella.

• Explica el proceso que seguirías para atender a los pacientes en el orden adecuado utilizando la estructura de datos apropiada para los pacientes.

  RTA: Cada vez que un paciente llega es colocado en la cola y cuando son atendidos se retiran de la cola.

• Si existiesen pacientes de emergencia, ¿Cómo se podrían gestionar estos tipos de usuarios?

  RTA: Colocando una pila que se organice por prioridad, dando una prioridad alta para los pacientes de emergencia y una prioridad baja para los pacientes regulares, o agregando la opción de que la pila se pueda llenar desde la cola (sin embargo, esta opción dañaria la estructura). Otra posible opción es haciendo una copia de la pila, más un elemento, y agregando el elemento en la base.

Consideraciones Adicionales

• Problema 1 (Navegación Web): Asegúrate de describir los momentos en que las páginas se agregan o eliminan. Analiza lo que sucede cuando el usuario retrocede y luego visita una nueva página, y cómo afecta eso a la estructura de datos seleccionada de páginas siguientes.

• Problema 2 (Turnos en Clínica): Los pacientes deben ser gestionados en una estructura de datos apropiada, pero los casos de emergencia requieren un manejo especial. Explica cómo asegurarte de que el orden de llegada no se vea afectado por las emergencias, y cómo se continúa el proceso de atención luego de atender un caso urgente.