Ya estoy inscrito ¿Todavía no tienes acceso? Nuestros Planes
Ya estoy inscrito ¿Todavía no tienes acceso? Nuestros Planes
1
respuesta

Haz lo que hicimos en el aula Heuristica

Dejo mi codigo, busca el camino según el año y sus cercanos de las consolas.

import heapq

class Producto:
    def __init__(self, nombre, categoria, anio):
        self.nombre = nombre
        self.categoria = categoria
        self.anio = anio

    def __repr__(self):
        return self.nombre


def heuristica(producto):
    return -producto.anio


class AStarRecommendation:

    def __init__(self, productos):
        self.productos = productos
        self.grafo = self.crear_grafo()

    def crear_grafo(self):
        return {
            self.productos[0]: [self.productos[2]],
            self.productos[1]: [self.productos[3]],
            self.productos[2]: [self.productos[6]],
            self.productos[3]: [self.productos[7]],
            self.productos[4]: [self.productos[5]],
            self.productos[5]: [self.productos[8]],
            self.productos[6]: [self.productos[7]],
            self.productos[7]: [self.productos[8]],
            self.productos[8]: []
        }

    def buscar(self, inicio, objetivo):

        cola = []
        heapq.heappush(cola, (heuristica(inicio), inicio))

        visitados = set()
        padres = {}

        while cola:

            _, actual = heapq.heappop(cola)

            if actual in visitados:
                continue

            visitados.add(actual)

            if actual == objetivo:
                break

            for vecino in self.grafo.get(actual, []):

                if vecino not in visitados:

                    heapq.heappush(
                        cola,
                        (heuristica(vecino), vecino)
                    )

                    if vecino not in padres:
                        padres[vecino] = actual

        camino = [objetivo]

        while camino[0] in padres:
            camino.insert(0, padres[camino[0]])

        return camino


productos = [

    Producto("Xbox 360", "Xbox", 2005),
    Producto("PS3", "PlayStation", 2006),
    Producto("Xbox One", "Xbox", 2013),
    Producto("PS4", "PlayStation", 2013),
    Producto("Nintendo Switch", "Nintendo", 2017),
    Producto("Switch OLED", "Nintendo", 2021),
    Producto("Xbox Series S", "Xbox", 2020),
    Producto("PlayStation 5", "PlayStation", 2020),
    Producto("Switch 2", "Nintendo", 2025)

]

recomendador = AStarRecommendation(productos)

inicio = productos[0]
objetivo = productos[8]

camino = recomendador.buscar(inicio, objetivo)

print("Camino recomendado:")

for p in camino:
    print("-", p)
1 respuesta

Hola, Alex. ¿Cómo vas?

Gracias por compartir tus reflexiones y aprendizajes con la comunidad Alura. Me gustó cómo conectaste la actividad de heurística con un ejemplo de consolas, usando el año de lanzamiento como criterio para priorizar los productos más recientes. Tu implementación muestra bien la idea de usar una cola de prioridad con heapq para guiar la búsqueda hacia opciones que cumplen mejor con la regla definida.

Dica: una mejora simple sería revisar si realmente existe un camino entre inicio y objetivo antes de devolverlo; así evitas mostrar un camino incompleto cuando el objetivo no fue alcanzado. Puedes hacerlo guardando una variable como encontrado = False y cambiándola a True cuando actual == objetivo. Cuenta con el apoyo del foro en tu viaje. Saludos y buenos estudios.