El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Proyectos Finales

¡Fin!

En esta sección, te proponemos una serie de proyectos finales que te permitirán aplicar y consolidar los conocimientos adquiridos a lo largo del curso. Estos proyectos están diseñados para desafiar tus habilidades y ayudarte a integrar las diferentes estructuras de datos en soluciones prácticas.

Proyecto 1: Sistema de Gestión de Tareas

Descripción

Desarrolla un sistema de gestión de tareas que permita a los usuarios crear, editar, eliminar y organizar tareas. El sistema debe soportar la priorización de tareas y la categorización en diferentes listas.

Requisitos

  1. Listas:
    • Utiliza listas enlazadas para almacenar las tareas.
    • Implementa listas dobles para permitir la navegación hacia adelante y hacia atrás.
  2. Pilas:
    • Usa una pila para implementar una funcionalidad de "deshacer" que permita revertir las últimas acciones realizadas por el usuario.
  3. Colas:
    • Implementa una cola de prioridad para gestionar las tareas según su urgencia.
  4. Interfaz:
    • Crea una interfaz simple (puede ser de consola) para interactuar con el sistema.

Ejemplo de Código

class Tarea:
    def __init__(self, descripcion, prioridad):
        self.descripcion = descripcion
        self.prioridad = prioridad

class Nodo:
    def __init__(self, tarea):
        self.tarea = tarea
        self.siguiente = None
        self.anterior = None

class ListaDoblementeEnlazada:
    def __init__(self):
        self.cabeza = None
        self.cola = None

    def agregar_tarea(self, tarea):
        nuevo_nodo = Nodo(tarea)
        if not self.cabeza:
            self.cabeza = self.cola = nuevo_nodo
        else:
            self.cola.siguiente = nuevo_nodo
            nuevo_nodo.anterior = self.cola
            self.cola = nuevo_nodo

    def mostrar_tareas(self):
        actual = self.cabeza
        while actual:
            print(f"Tarea: {actual.tarea.descripcion}, Prioridad: {actual.tarea.prioridad}")
            actual = actual.siguiente

# Ejemplo de uso
lista_tareas = ListaDoblementeEnlazada()
lista_tareas.agregar_tarea(Tarea("Estudiar para el examen", 2))
lista_tareas.agregar_tarea(Tarea("Comprar víveres", 1))
lista_tareas.mostrar_tareas()

Ejercicio

  1. Implementa las funcionalidades de edición y eliminación de tareas.
  2. Añade la funcionalidad de "deshacer" utilizando una pila.
  3. Implementa la cola de prioridad para gestionar las tareas según su urgencia.

Proyecto 2: Sistema de Navegación GPS

Descripción

Desarrolla un sistema de navegación GPS que permita a los usuarios encontrar la ruta más corta entre dos puntos en una ciudad. El sistema debe soportar la búsqueda de rutas y la visualización de los caminos.

Requisitos

  1. Grafos:
    • Representa la ciudad como un grafo, donde los nodos son ubicaciones y las aristas son caminos entre ellas.
  2. Algoritmos de Caminos Mínimos:
    • Implementa el algoritmo de Dijkstra para encontrar la ruta más corta entre dos ubicaciones.
  3. Interfaz:
    • Crea una interfaz simple (puede ser de consola) para que el usuario ingrese las ubicaciones de inicio y destino.

Ejemplo de Código

import heapq

class Grafo:
    def __init__(self):
        self.vertices = {}

    def agregar_vertice(self, vertice):
        self.vertices[vertice] = []

    def agregar_arista(self, desde, hasta, peso):
        self.vertices[desde].append((hasta, peso))
        self.vertices[hasta].append((desde, peso))

    def dijkstra(self, inicio):
        distancias = {vertice: float('infinity') for vertice in self.vertices}
        distancias[inicio] = 0
        cola_prioridad = [(0, inicio)]
        while cola_prioridad:
            distancia_actual, vertice_actual = heapq.heappop(cola_prioridad)
            if distancia_actual > distancias[vertice_actual]:
                continue
            for vecino, peso in self.vertices[vertice_actual]:
                distancia = distancia_actual + peso
                if distancia < distancias[vecino]:
                    distancias[vecino] = distancia
                    heapq.heappush(cola_prioridad, (distancia, vecino))
        return distancias

# Ejemplo de uso
ciudad = Grafo()
ciudad.agregar_vertice("A")
ciudad.agregar_vertice("B")
ciudad.agregar_vertice("C")
ciudad.agregar_arista("A", "B", 1)
ciudad.agregar_arista("B", "C", 2)
ciudad.agregar_arista("A", "C", 4)

distancias = ciudad.dijkstra("A")
print(distancias)

Ejercicio

  1. Añade más ubicaciones y caminos a la representación del grafo.
  2. Implementa una funcionalidad para mostrar la ruta más corta entre dos ubicaciones específicas.
  3. Mejora la interfaz para que sea más amigable y permita una mejor interacción con el usuario.

Proyecto 3: Sistema de Gestión de Inventarios

Descripción

Desarrolla un sistema de gestión de inventarios para una tienda. El sistema debe permitir agregar, eliminar y buscar productos en el inventario.

Requisitos

  1. Árboles Binarios de Búsqueda:
    • Utiliza un árbol binario de búsqueda (BST) para almacenar y gestionar los productos del inventario.
  2. Operaciones Básicas:
    • Implementa las operaciones de inserción, eliminación y búsqueda en el BST.
  3. Interfaz:
    • Crea una interfaz simple (puede ser de consola) para interactuar con el sistema.

Ejemplo de Código

class Nodo:
    def __init__(self, clave, valor):
        self.clave = clave
        self.valor = valor
        self.izquierda = None
        self.derecha = None

class ArbolBinarioBusqueda:
    def __init__(self):
        self.raiz = None

    def insertar(self, clave, valor):
        if not self.raiz:
            self.raiz = Nodo(clave, valor)
        else:
            self._insertar(self.raiz, clave, valor)

    def _insertar(self, nodo, clave, valor):
        if clave < nodo.clave:
            if nodo.izquierda:
                self._insertar(nodo.izquierda, clave, valor)
            else:
                nodo.izquierda = Nodo(clave, valor)
        else:
            if nodo.derecha:
                self._insertar(nodo.derecha, clave, valor)
            else:
                nodo.derecha = Nodo(clave, valor)

    def buscar(self, clave):
        return self._buscar(self.raiz, clave)

    def _buscar(self, nodo, clave):
        if not nodo:
            return None
        if clave == nodo.clave:
            return nodo.valor
        elif clave < nodo.clave:
            return self._buscar(nodo.izquierda, clave)
        else:
            return self._buscar(nodo.derecha, clave)

# Ejemplo de uso
inventario = ArbolBinarioBusqueda()
inventario.insertar(101, "Producto A")
inventario.insertar(102, "Producto B")
print(inventario.buscar(101))  # Output: Producto A

Ejercicio

  1. Implementa la funcionalidad de eliminación de productos en el BST.
  2. Añade una funcionalidad para listar todos los productos en el inventario.
  3. Mejora la interfaz para que sea más amigable y permita una mejor interacción con el usuario.

Conclusión

Estos proyectos finales te permitirán aplicar los conceptos y técnicas que has aprendido a lo largo del curso. No dudes en personalizar y expandir estos proyectos según tus intereses y necesidades. ¡Buena suerte y feliz programación!

◄ Anterior
◄
¡Fin!
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados