tried to add dijkstra implementation

tp6_enirely/tp6/LSC.py

@@ -0,0 +1,260 @@
+"""
+Librairie des Listes Simplement Chaînées.
+
+Elle met à distribution cette structure de données et son interface.
+
+@author: L. JOANNIC
+"""
+
+
+# ############################################################################
+
+class Liste_Simplement_Chainee(object):
+    """
+    Classe des Listes Simplement Chainees.
+
+    Attributs
+        - _tete : None si vide, Maillon sinon.
+
+    Méthodes
+        - est_vide
+        - ajouter_en_tete
+        - tete
+        - queue
+    """
+
+    def __init__(self):
+        """
+        Construire une instance de Liste Simplement Chainee.
+
+        Returns
+        -------
+        None.
+
+        """
+        self._tete = None
+        return None
+
+    def est_vide(self):
+        """
+        Tester si l'instance est vide.
+
+        Returns
+        -------
+        bool
+            Vrai ssi la liste est vide.
+
+        """
+        return (self._tete is None)
+
+    def ajouter_en_tete(self, element):
+        """
+        Ajouter l'élément en tête de liste.
+
+        Parameters
+        ----------
+        element : type de donnee
+            Donnnée à ajouter à la liste.
+
+        Returns
+        -------
+        resultat : Liste_Simplement_Chainee
+            La liste à abonder.
+
+        """
+        resultat = Liste_Simplement_Chainee()
+        resultat._tete = Maillon(element, self)
+        return resultat
+
+    def tete(self):
+        """
+        Renvoyer la donnée stockée en tête de liste.
+
+        Returns
+        -------
+        type de donnee quelconque
+            donnee en tete.
+
+        """
+        assert not(self.est_vide()), "Liste Vide"
+        return self._tete.donnee
+
+    def queue(self):
+        """
+        Renvoyer la sous-liste suivant le maillon de tete.
+
+        Returns
+        -------
+        Liste_Simplement_Chainee
+            Queue de la liste.
+
+        """
+        assert not(self.est_vide()), "Liste Vide"
+        return self._tete.suite
+
+
+# ############################################################################
+
+def creer_liste_vide():
+    """
+    Créer une liste simplement chainee vide.
+
+    Returns
+    -------
+    Liste_Simplement_Chainee
+        Liste vide.
+
+    Effets de bord
+    --------------
+        Aucun
+    """
+    return Liste_Simplement_Chainee()
+
+
+def est_vide(liste):
+    """
+    Tester si la liste simplement chainee est vide.
+
+    Parameters
+    ----------
+    liste : Liste Simplement Chainee
+        Liste à tester.
+
+    Returns
+    -------
+    bool
+        Vrai ssi la liste est vide.
+
+    Effets de bord
+    --------------
+        Aucun
+    """
+    return liste.est_vide()
+
+
+def ajouter_en_tete(liste, element):
+    """
+    Inserer un element en tete de liste simplemeent chainee.
+
+    Parameters
+    ----------
+    liste : LSC
+        Liste à abonder.
+    element : type de donnee
+        Donnee à aouter.
+
+    Returns
+    -------
+    LSC, copie de liste à laquelle element a été ajouté en tete.
+
+    Effets de bord
+    --------------
+        Aucun
+    """
+    return liste.ajouter_en_tete(element)
+
+
+def tete(liste):
+    """
+    Consulter la tete de liste.
+
+    Parameters
+    ----------
+    liste : LSC
+        Liste à consulter.
+
+    Returns
+    -------
+    type de donnée
+        valeur de la tete de liste.
+
+    Effets de bord
+    --------------
+        Aucun
+    """
+    return liste.tete()
+
+
+def queue(liste):
+    """
+    Renvoyer la liste sans sa tete.
+
+    Parameters
+    ----------
+    liste : LSC
+        Liste à étêter.
+
+    Returns
+    -------
+    LSC
+        Liste sans son maillon de tête.
+
+    Effets de bord
+    --------------
+        Aucun
+    """
+    return liste.queue()
+
+
+def afficher_liste(liste, taille=-1):
+    """
+    Afficher la liste en format de présentation.
+
+    Parameters
+    ----------
+    liste : LSC
+        Liste à énumérer.
+
+    Returns
+    -------
+    None.
+
+    Effets de bord
+    --------------
+        Affichage à l'écran.
+
+    """
+    reste = liste
+    compteur = 0
+    print('+-----\n|')
+    while not(est_vide(reste)) and (taille == -1 or compteur < taille):
+        print('+- {}\n|'.format(str(tete(reste))))
+        reste = queue(reste)
+        compteur += 1
+    print('+-----')
+    return None
+
+# ############################################################################
+
+class Maillon(object):
+    """
+    Classe des Maillons d'une Liste Simplement Chainee.
+
+    Attributs
+        - donnee : donnee stockee dans le maillon
+        - suite : liste simplemement chainee suivant le maillon
+    """
+
+    def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
+        """
+        Construire une instance de la classe des Maillons.
+
+        Parameters
+        ----------
+        donnee : type de donnee, optional
+            Donnee initiale dans le Maillon. The default is None.
+        suite : LSC, optional
+            Sous-liste suivant le Maillon courant.
+            The default is Liste_Simplement_Chainee().
+
+        Returns
+        -------
+        None.
+
+        """
+        self.donnee = donnee
+        self.suite = suite
+        return None
+
+
+# ############################################################################

tp6_enirely/tp6/Pile_LSC.py

@@ -0,0 +1,63 @@
+import LSC as lsc
+from typing import Any
+
+def creer_pile_vide() -> lsc.Liste_Simplement_Chainee:
+    """Crée une pile vide sous forme de liste simplement chaînée.
+
+    Returns:
+        lsc.Liste_Simplement_Chainee: Une pile vide représentée par une liste simplement chaînée.
+    """
+    return lsc.creer_liste_vide()
+
+def est_pile_vide(pile: lsc.Liste_Simplement_Chainee) -> bool:
+    """Vérifie si la pile est vide.
+
+    Args:
+        pile (lsc.Liste_Simplement_Chainee): La pile à vérifier.
+
+    Returns:
+        bool: True si la pile est vide, False sinon.
+    """
+    return lsc.est_vide(pile)
+
+def sommet(pile: lsc.Liste_Simplement_Chainee) -> Any:
+    """Renvoie l'élément au sommet de la pile.
+
+    Args:
+        pile (lsc.Liste_Simplement_Chainee): La pile dont on veut connaître le sommet.
+
+    Returns:
+        Any: L'élément au sommet de la pile.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide."
+    return lsc.tete(pile)
+
+def empiler(pile: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee:
+    """Ajoute un élément au sommet de la pile.
+
+    Args:
+        pile (lsc.Liste_Simplement_Chainee): La pile actuelle.
+        element (Any): L'élément à ajouter au sommet de la pile.
+
+    Returns:
+        lsc.Liste_Simplement_Chainee: La nouvelle pile avec l'élément ajouté.
+    """
+    return lsc.ajouter_en_tete(pile, element)
+
+def depiler(pile: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee:
+    """Retire l'élément au sommet de la pile.
+
+    Args:
+        pile (lsc.Liste_Simplement_Chainee): La pile dont on veut retirer le sommet.
+
+    Returns:
+        lsc.Liste_Simplement_Chainee: La nouvelle pile sans l'élément au sommet.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide!"
+    return lsc.queue(pile)

tp6_enirely/tp6/Pile_List.py

@@ -0,0 +1,62 @@
+from typing import Any
+
+def creer_pile_vide() -> list:
+    """Crée une pile vide sous forme de liste.
+
+    Returns:
+        list: Une pile vide représentée par une liste.
+    """
+    return []
+
+def est_pile_vide(pile: list) -> bool:
+    """Vérifie si la pile est vide.
+
+    Args:
+        pile (list): La pile à vérifier.
+
+    Returns:
+        bool: True si la pile est vide, False sinon.
+    """
+    return len(pile) == 0
+
+def sommet(pile: list) -> Any:
+    """Renvoie l'élément au sommet de la pile.
+
+    Args:
+        pile (list): La pile dont on veut connaître le sommet.
+
+    Returns:
+        Any: L'élément au sommet de la pile.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide!"
+    return pile[-1]
+
+def empiler(pile: list, element: Any) -> list:
+    """Ajoute un élément au sommet de la pile.
+
+    Args:
+        pile (list): La pile actuelle.
+        element (Any): L'élément à ajouter au sommet de la pile.
+
+    Returns:
+        list: La nouvelle pile avec l'élément ajouté.
+    """
+    return pile + [element]
+
+def depiler(pile: list) -> list:
+    """Retire l'élément au sommet de la pile.
+
+    Args:
+        pile (list): La pile dont on veut retirer le sommet.
+
+    Returns:
+        list: La nouvelle pile sans l'élément au sommet.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide!"
+    return pile[:-1]

tp6_enirely/tp6/Pile_Tuple.py

@@ -0,0 +1,60 @@
+def creer_pile_vide():
+    """Crée une pile vide sous forme de tuple.
+
+    Returns:
+        tuple: Une pile vide représentée par un tuple vide.
+    """
+    return ()
+
+def est_pile_vide(pile):
+    """Vérifie si la pile est vide.
+
+    Args:
+        pile (tuple): La pile à vérifier.
+
+    Returns:
+        bool: True si la pile est vide, False sinon.
+    """
+    return pile == ()
+
+def sommet(pile):
+    """Renvoie l'élément au sommet de la pile.
+
+    Args:
+        pile (tuple): La pile dont on veut connaître le sommet.
+
+    Returns:
+        _type_: L'élément au sommet de la pile.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide!"
+    return pile[-1]
+
+def empiler(pile, elt):
+    """Ajoute un élément au sommet de la pile.
+
+    Args:
+        pile (tuple): La pile actuelle.
+        elt (_type_): L'élément à ajouter au sommet de la pile.
+
+    Returns:
+        tuple: La nouvelle pile avec l'élément ajouté.
+    """
+    return pile + (elt,)
+
+def depiler(pile):
+    """Retire l'élément au sommet de la pile.
+
+    Args:
+        pile (tuple): La pile dont on veut retirer le sommet.
+
+    Returns:
+        tuple: La nouvelle pile sans l'élément au sommet.
+
+    Raises:
+        AssertionError: Si la pile est vide.
+    """
+    assert not est_pile_vide(pile), "Pile vide!"
+    return pile[:-1]

tp6_enirely/tp6/README.md

@@ -0,0 +1,69 @@
+# Devoir Maison : Gestion de Piles et Notation Polonaise Inverse
+
+Ce devoir présente des fonctions pour manipuler des piles et évaluer des expressions en notation polonaise inverse (NPI).
+
+## Prérequis
+
+Pour exécuter ce devoir, vous aurez besoin de :
+
+- [Python 3.x](https://www.python.org/downloads/) installé sur votre machine.
+
+### Installation de Python
+
+1. **Téléchargez Python** : Allez sur le [site officiel de Python](https://www.python.org/downloads/) et téléchargez la dernière version stable pour votre système d'exploitation.
+
+2. **Installez Python** : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add Python to PATH" lors de l'installation sur Windows.
+
+3. **Vérifiez l'installation** : Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante :
+    ```bash
+    python --version
+    ```
+   Cela devrait afficher la version de Python installée.
+
+## Utilisation des Modules
+
+### Modules Fournis
+
+Le devoir contient les modules suivants :
+
+- `LSC` : Implémentation d'une liste simplement chaînée.
+- `Pile_LSC` : Implémentation d'une pile utilisant une liste simplement chaînée.
+- `Tuple` : Implémentation d'une pile utilisant un tuple.
+- `Liste` : Implémentation d'une pile utilisant une liste.
+
+#### Primitives du Module `LSC`
+
+- `creer_liste_vide()`: Crée une liste vide.
+- `est_vide(liste)`: Vérifie si la liste est vide.
+- `ajouter_en_tete(liste, element)`: Ajoute un élément au début de la liste.
+- `queue(liste)`: Retire le premier élément de la liste.
+- `tete(liste)`: Renvoie le premier élément de la liste.
+
+#### Primitives du Module `Pile_LSC`
+
+- `creer_pile_vide()`: Crée une pile vide sous forme de liste simplement chaînée.
+- `est_pile_vide(pile)`: Vérifie si la pile est vide.
+- `sommet(pile)`: Renvoie l'élément au sommet de la pile.
+- `empiler(pile, element)`: Ajoute un élément au sommet de la pile.
+- `depiler(pile)`: Retire l'élément au sommet de la pile.
+
+## Fichier `test.py`
+
+Le fichier `test.py` contient des exemples d'utilisation des fonctionnalités de gestion de piles et d'évaluation en notation polonaise inverse. 
+
+### Fonctions dans `test.py`
+
+- **Afficher une pile** : Affiche les éléments d'une pile du sommet à la base.
+- **Copier une pile** : Crée une copie d'une pile donnée.
+- **Hauteur de la pile** : Renvoie la hauteur de la pile.
+- **Inverser des éléments** : Inverse les `j` derniers éléments de la pile.
+- **Trouver le maximum** : Renvoie la position du maximum parmi les `i` derniers éléments de la pile.
+- **Tri des crêpes** : Trie les éléments de la pile en utilisant la méthode des crêpes.
+- **Évaluation NPI** : Évalue une expression arithmétique en notation polonaise inverse.
+
+### Exécution de `test.py`
+
+Pour exécuter le script, ouvrez votre terminal, naviguez vers le dossier contenant le fichier `test.py`, puis exécutez la commande suivante :
+
+```bash
+python test.py

tp6_enirely/tp6/npi.py

@@ -0,0 +1,46 @@
+def evaluer_npi(expression):
+    """fais la notation polonaise inversée (NPI) d'une expression arithmétique
+    Args:
+        expression (_type_): String contenant l'expression arithmétique
+
+    Returns:
+        _type_: Integer contenant le resultat.
+    """
+    
+    pile = []
+
+    
+    elements = expression.split()
+
+    for element in elements:
+        if element.isdigit():  
+            pile.append(int(element))
+        else:
+            
+            droite = pile.pop()  
+            gauche = pile.pop()  
+
+            if element == '+':
+                resultat = gauche + droite
+            elif element == '-':
+                resultat = gauche - droite
+            elif element == '*':
+                resultat = gauche * droite
+            elif element == '/':
+                resultat = gauche / droite
+            else:
+                raise ValueError(f"Opérateur inconnu: {element}")
+
+            
+            pile.append(resultat)
+
+    
+    if len(pile) != 1:
+        raise ValueError("L'expression est mal formée.")
+    
+    return pile.pop()  
+
+
+expression = "100 60 / 60 + 90 *"
+resultat = evaluer_npi(expression)
+print(f"Le résultat de l'expression '{expression}' est: {resultat}")

tp6_enirely/tp6/test.py

@@ -0,0 +1,125 @@
+import Pile_LSC as lifo
+from random import shuffle
+
+def afficher(pile):
+    """Affiche les éléments d'une pile du sommet à la base."""
+    print("|----")
+    temp = pile
+    while not lifo.est_pile_vide(temp):
+        print(f"| {lifo.sommet(temp)}")
+        temp = lifo.depiler(temp)
+    print("|----\n")
+
+def copier_pile(pile):
+    """Copie une pile représentée par une liste simplement chaînée."""
+    copie = lifo.creer_pile_vide()
+    pile_temp = lifo.creer_pile_vide()
+
+    while not lifo.est_pile_vide(pile):
+        sommet = lifo.sommet(pile)
+        pile_temp = lifo.empiler(pile_temp, sommet)
+        pile = lifo.depiler(pile)
+
+    while not lifo.est_pile_vide(pile_temp):
+        sommet = lifo.sommet(pile_temp)
+        pile = lifo.empiler(pile, sommet)  
+        copie = lifo.empiler(copie, sommet)  
+        pile_temp = lifo.depiler(pile_temp)
+
+    return copie  
+
+def hauteur_pile(pile):
+    """
+    Renvoie hauteur de la pile.
+    PARAMETRES : pile - pile à analyser.
+    RETURN : hauteur.
+    EFFET DE BORD : Aucune.
+    """
+    n = 0
+    while not lifo.est_pile_vide(pile):
+        n += 1
+        pile = lifo.depiler(pile)
+    return n
+
+def retourner(pile, j):
+    """
+    Inverse j derniers éléments de la pile.
+    PARAMETRES : pile - pile à modifier, j - nombre d'éléments à inverser.
+    RETURN : Aucune.
+    EFFET DE BORD : Modifie la pile.
+    """
+    pile_aux = lifo.creer_pile_vide()
+    
+    for _ in range(j):
+        if lifo.est_pile_vide(pile):
+            break
+        pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile))
+        pile = lifo.depiler(pile)
+
+    while not lifo.est_pile_vide(pile_aux):
+        pile = lifo.empiler(pile, lifo.sommet(pile_aux))
+        pile_aux = lifo.depiler(pile_aux)
+
+def max_pile(pile, i):
+    """
+    Renvoie position du maximum parmi i derniers éléments.
+    PARAMETRES : pile - pile à analyser, i - nombre d'éléments.
+    RETURN : position du maximum.
+    EFFET DE BORD : Aucune.
+    """
+
+    copy = copier_pile(pile)  
+    max_value = lifo.sommet(copy)
+    ind = 1
+    ind_n = 1
+
+    for _ in range(i):
+        if lifo.est_pile_vide(copy):
+            break
+        current = lifo.sommet(copy)
+        if current > max_value:
+            max_value = current
+            ind = ind_n
+        copy = lifo.depiler(copy)
+        ind_n += 1
+        
+    return ind
+
+
+def tri_crepes_iteratif(pile): #ne fonctionne pas
+    """
+    Tri des crêpes en cours.
+    PARAMETRES : pile - pile à trier.
+    RETURN : pile triée.
+    EFFET DE BORD : Modifie la pile.
+    """
+
+    n = hauteur_pile(pile)
+    for i in range(n):
+        max_position = max_pile(pile, n - i)
+        if max_position!= n - i:
+            retourner(pile, n - max_position)
+            retourner(pile, i + 1)
+
+    return pile
+
+
+if __name__ == "__main__":
+    from random import shuffle
+
+    ma_liste = [i for i in range(10)]
+    shuffle(ma_liste)
+
+    print("Liste de départ :", ma_liste)
+
+    ma_pile = lifo.creer_pile_vide()
+    for element in ma_liste:
+        ma_pile = lifo.empiler(ma_pile, element)
+
+    print("\nPile initiale :")
+    afficher(ma_pile)
+    print(max_pile(ma_pile,10))
+    print("Tri des crêpes en cours...")
+    ma_pile = tri_crepes_iteratif(ma_pile)
+    print("Pile après tri :")
+    afficher(ma_pile)