first commit

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/Pile_LSC.py

@@ -0,0 +1,17 @@
+import LSC as lsc
+from typing import Any
+
+def creer_pile_vide() -> lsc.Liste_Simplement_Chainee:
+    return lsc.creer_liste_vide()
+
+def est_pile_vide(liste: lsc.Liste_Simplement_Chainee) -> bool:
+    return lsc.est_vide(liste)
+
+def sommet(liste: lsc.Liste_Simplement_Chainee) -> Any:
+    return lsc.tete(liste)
+
+def empiler(liste: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee:
+    return lsc.ajouter_en_tete(liste,element)
+
+def depiler(liste: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee:
+    return lsc.queue(liste)

TP6/Pile_List.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+
+def creer_pile_vide():
+    return []
+
+
+def est_pile_vide(pile: list):
+    return len(pile) == 0
+
+
+def sommet(pile: list):
+    return pile[-1]
+
+
+def empiler(pile: list, element: Any):
+    return pile + [element]
+
+
+def depiler(pile: list):
+    return pile[:-1]

TP6/Pile_Tuple.py

@@ -0,0 +1,18 @@
+def creer_pile_vide():
+    return ()
+
+
+def est_pile_vide(pile):
+    return pile == ()
+
+
+def sommet(pile):
+    return pile[-1]
+
+
+def empiler(pile, elt):
+    return pile + [elt]
+
+
+def depiler(pile):
+    return pile[:-1]

TP6/test.py

@@ -0,0 +1,90 @@
+import Pile_LSC as lifo
+import LSC as blsc
+from random import shuffle
+
+def afficher(pile):
+    """Affiche les éléments d'une pile du sommet à la base."""
+    print("|----")
+    while not lifo.est_pile_vide(pile):
+        print(f"| {lifo.sommet(pile)}")
+        pile = lifo.depiler(pile)
+    print("|----\n")
+
+def hauteur_pile(pile):
+    """Renvoie la hauteur de la pile sans la modifier."""
+    copie = pile
+    n = 0
+    while not lifo.est_pile_vide(copie):
+        copie = lifo.depiler(copie)
+        n += 1
+    return n
+def max_pile(pile: blsc.Liste_Simplement_Chainee, i: int):
+    """Trouve le maximum parmi les i premiers éléments de la pile."""
+    total = hauteur_pile(pile)
+    #assert i > total (f"Taille insuffisante : attendu au moins {i} éléments")
+    meilleur = lifo.sommet(pile)  # Premier élément comme point de départ
+    temporaire = pile
+
+    for _ in range(i):
+        courant = lifo.sommet(temporaire)
+        temporaire = lifo.depiler(temporaire)
+
+        if courant > meilleur:
+            meilleur = courant
+
+    return meilleur
+def retourner(pile, j):
+    """Inverse les j derniers éléments de la pile."""
+    pile_aux = lifo.creer_pile_vide()
+    
+    # Depile les éléments dans une pile temporaire:
+    for _ in range(j):
+        pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile))
+        pile = lifo.depiler(pile)
+
+    # Remets les éléments inversés dans la pile principale:
+    while not lifo.est_pile_vide(pile_aux):
+        pile = lifo.empiler(pile, lifo.sommet(pile_aux))
+        pile_aux = lifo.depiler(pile_aux)
+
+    return pile
+
+def tri_crepes_recursif(pile, n=None):
+    """Trie la pile en utilisant le tri des crêpes de manière récursive."""
+    if n is None:
+        n = hauteur_pile(pile)
+    # pas besoin de tri en si len(pile) == 1
+    if n <= 1:
+        return pile
+
+    pos_max = max_pile(pile, n)
+
+    if pos_max != 1:
+        pile = retourner(pile, pos_max)
+
+    pile = retourner(pile, n)
+    return tri_crepes_recursif(pile, n - 1)
+
+if __name__ == "__main__":
+    # Initialisation d'une pile avec des valeurs aléatoires
+    # Tri des crêpes récursif
+    ma_liste = [_ for _ in range(10)]
+    shuffle(ma_liste)
+
+    print("Liste de départ : ", ma_liste)
+
+    ma_pile = lifo.creer_pile_vide()
+
+    print("\nEMPILEMENT\n")
+
+    for element in ma_liste:
+        ma_pile = lifo.empiler(ma_pile, element)
+        afficher(ma_pile)
+
+    print("\nDEPILEMENT\n")
+
+    while not(lifo.est_pile_vide(ma_pile)):
+        print(f"Sommet : {lifo.sommet(ma_pile)}")
+        ma_pile = lifo.depiler(ma_pile)
+        afficher(ma_pile)
+    print(max_pile(ma_pile,1))

TP6/test.py.patch

@@ -0,0 +1,34 @@
+# Patch generated by Pyment v0.3.3
+
+--- a/test.py
++++ b/test.py
+@@ -3,6 +3,14 @@
+ 
+ 
+ def afficher(pile):
++    """
++
++    Args:
++      pile: 
++
++    Returns:
++
++    """
+     print("|----\n|")
+     while not (lifo.est_vide(pile)):
+         print("| {}\n|".format(lifo.sommet(pile)))
+@@ -12,6 +20,14 @@
+ 
+ 
+ def hauteur_pile(P):
++    """
++
++    Args:
++      P: 
++
++    Returns:
++
++    """
+     n = 0
+     while not (lifo.est_vide(P)):
+         n += 1

TP6/test_2.py/Pile_List.rst

@@ -0,0 +1,7 @@
+Pile\_List module
+=================
+
+.. automodule:: Pile_List
+   :members:
+   :undoc-members:
+   :show-inheritance:

TP6/test_2.py/Pile_Tuple.rst

@@ -0,0 +1,7 @@
+Pile\_Tuple module
+==================
+
+.. automodule:: Pile_Tuple
+   :members:
+   :undoc-members:
+   :show-inheritance:

TP6/test_2.py/modules.rst

@@ -0,0 +1,9 @@
+TP6
+===
+
+.. toctree::
+   :maxdepth: 4
+
+   Pile_List
+   Pile_Tuple
+   test

TP6/test_2.py/test.rst

@@ -0,0 +1,7 @@
+test module
+===========
+
+.. automodule:: test
+   :members:
+   :undoc-members:
+   :show-inheritance: