first commit

tp_listes_chaines/execute.py

@@ -0,0 +1,278 @@
+# Création du fichier complet TP5_1.py avec toutes les fonctions demandées
+contenu_tp5 = """
+import re
+from Sommets import Sommet
+from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue
+
+# 1. Fonction extraire_altitude
+def extraire_altitude(chaine):
+    \"\"\"
+    Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'.
+
+    Paramètres :
+    chaine (str) : La chaîne contenant l'altitude et l'unité.
+
+    Retourne :
+    int : La valeur numérique de l'altitude.
+    \"\"\"
+    return int(re.sub(r'\\D', '', chaine))
+
+# 2. Fonction csv2liste
+def csv2liste(fichier_csv):
+    \"\"\"
+    Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
+    
+    Paramètres :
+    fichier_csv (str) : Le chemin vers le fichier CSV à lire.
+
+    Retourne :
+    Une liste simplement chaînée contenant les sommets.
+    \"\"\"
+    liste_sommets = creer_liste_vide()
+    with open(fichier_csv, 'r') as fichier:
+        for ligne in fichier:
+            nom, altitude = ligne.strip().split(',')
+            altitude = extraire_altitude(altitude)  # Extraction de la valeur numérique
+            sommet = Sommet(nom, altitude, 'Chartreuse')  # Le massif est 'Chartreuse'
+            liste_sommets = ajouter_en_tete(liste_sommets, sommet)
+    return liste_sommets
+
+# 3. Fonction copier_liste
+def copier_liste(liste):
+    \"\"\"
+    Copie une liste simplement chaînée.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+
+    Retourne :
+    Une copie de la liste.
+    \"\"\"
+    if est_vide(liste):
+        return creer_liste_vide()
+    else:
+        return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
+
+# 4. Fonction rechercher
+def rechercher(liste, nom):
+    \"\"\"
+    Recherche un sommet dans la liste par son nom.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à rechercher.
+
+    Retourne :
+    bool : True si le sommet est trouvé, False sinon.
+    \"\"\"
+    reste = liste
+    while not est_vide(reste):
+        sommet = tete(reste)
+        if sommet.nom == nom:
+            return True
+        reste = queue(reste)
+    return False
+
+# 5. Fonction modifier_altitude
+def modifier_altitude(liste, nom, nouvelle_altitude):
+    \"\"\"
+    Modifie l'altitude d'un sommet dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à modifier.
+    nouvelle_altitude (int) : La nouvelle altitude du sommet.
+    \"\"\"
+    reste = liste
+    while not est_vide(reste):
+        sommet = tete(reste)
+        if sommet.nom == nom:
+            sommet.altitude = nouvelle_altitude
+            break
+        reste = queue(reste)
+
+# 6. Fonction supprimer_sommet
+def supprimer_sommet(liste, nom):
+    \"\"\"
+    Supprime la première occurrence du sommet de nom donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec la première occurrence du sommet supprimée.
+    \"\"\"
+    if est_vide(liste):
+        return liste
+    elif tete(liste).nom == nom:
+        return queue(liste)
+    else:
+        return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste))
+
+# 7. Fonction supprimer_sommets
+def supprimer_sommets(liste, nom):
+    \"\"\"
+    Supprime toutes les occurrences du sommet de nom donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec toutes les occurrences du sommet supprimées.
+    \"\"\"
+    if est_vide(liste):
+        return liste
+    elif tete(liste).nom == nom:
+        return supprimer_sommets(queue(liste), nom)
+    else:
+        return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste))
+
+# 8. Fonction longueur
+def longueur(liste):
+    \"\"\"
+    Renvoie le nombre d'éléments de la liste simplement chaînée.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+
+    Retourne :
+    int : Le nombre d'éléments dans la liste.
+    \"\"\"
+    if est_vide(liste):
+        return 0
+    else:
+        return 1 + longueur(queue(liste))
+
+# 9. Fonction inserer
+def inserer(liste, element, rang):
+    \"\"\"
+    Insère un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    element : L'élément à insérer.
+    rang (int) : Le rang auquel insérer l'élément.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément inséré.
+    \"\"\"
+    if rang == 0:
+        return ajouter_en_tete(liste, element)
+    else:
+        return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste))
+
+# 10. Fonction supprimer
+def supprimer(liste, rang):
+    \"\"\"
+    Supprime un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément supprimé.
+    \"\"\"
+    if rang == 0:
+        return queue(liste)
+    else:
+        return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste))
+
+# 11. Fonction modifier
+def modifier(liste, rang, element):
+    \"\"\"
+    Modifie un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à modifier.
+    element : Le nouvel élément à insérer à ce rang.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément modifié.
+    \"\"\"
+    if rang == 0:
+        return ajouter_en_tete(queue(liste), element)
+    else:
+        return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste))
+
+# 12. Fonction rechercher_par_rang
+def rechercher_par_rang(liste, element):
+    \"\"\"
+    Recherche l'élément dans la liste et retourne son rang.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    element : L'élément à rechercher.
+
+    Retourne :
+    int : Le rang de l'élément ou -1 s'il n'est pas trouvé.
+    \"\"\"
+    reste = liste
+    rang = 0
+    while not est_vide(reste):
+        if tete(reste) == element:
+            return rang
+        reste = queue(reste)
+        rang += 1
+    return -1
+
+# 13. Fonction lire
+def lire(liste, rang):
+    \"\"\"
+    Renvoie l'élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à lire.
+
+    Retourne :
+    L'élément à ce rang.
+    \"\"\"
+    if rang == 0:
+        return tete(liste)
+    else:
+        return lire(queue(liste), rang - 1)
+
+# 14. Fonction trier
+def trier(liste, ordre=lambda x, y: x < y):
+    \"\"\"
+    Trie la liste dans un ordre donné.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    ordre : Une fonction de comparaison, par défaut x < y.
+
+    Retourne :
+    Une liste simplement chaînée triée.
+    \"\"\"
+    if est_vide(liste):
+        return liste
+    else:
+        pivot = tete(liste)
+        sous_liste = queue(liste)
+
+        # Séparer en deux listes
+        inferieurs = creer_liste_vide()
+        superieurs = creer_liste_vide()
+        while not est_vide(sous_liste):
+            elt = tete(sous_liste)
+            if ordre(elt, pivot):
+                inferieurs = ajouter_en_tete(inferieurs, elt)
+            else:
+                superieurs = ajouter_en_tete(superieurs, elt)
+            sous_liste = queue(sous_liste)
+
+        # Trier les sous-listes
+        inferieurs = trier(inferieurs, ordre)
+        superieurs = trier(superieurs, ordre)
+
+        # Ajouter le pivot au résultat
+        return ajouter_en_tete(superieurs, pivot)
+"""
+
+# Sauvegarder le fichier
+path = "/home/spectre/Python/tp_listes_chaines/TP5.py"
+

tp_listes_chaines/fichiers/Chartreuse.csv

@@ -0,0 +1,29 @@
+Grande Sure (La), 1 920 m
+Rocher de Lorzier (Le), 1 838 m
+Rochers de Chalves (Les), 1 845 m
+Rocher de l'Église (Le), 1 300 m
+Pointe de la Gorgeat (La), 1 486 m
+Mont Joigny (Le), 1 556 m
+Mont Outheran (Le), 1 673 m
+Cochette (La), 1 618 m
+Roc de Gleisin (Le), 1 434 m
+Roche Veyrand (La), 1 429 m
+Dent de l'Ours (La), 1 820 m
+Petit Som (Le), 1 772 m
+Grand Som (Le), 2 026 m
+Charmant Som (Le), 1 867 m
+Pinéa (La), 1 771 m
+Néron (Le), 1 299 m
+Mont Granier (Le), 1 933 m
+Sommet du Pinet (Le) ou le Truc, 1 867 m
+Grand Manti (Le), 1 818 m
+Scia (La), 1 791 m
+Lances de Malissard (Les), 2 045 m
+Dôme de Bellefont (Le), 1 975 m
+Dent de Crolles (La), 2 062 m
+Piton de Bellefont (Le), 1 958 m
+Chamechaude, 2 082 m
+Grands Crêts (Les), 1 489 m
+Mont Saint-Eynard (Le), 1 379 m
+Écoutoux (L'), 1 406 m
+Rachais (Le), 1 050 m

tp_listes_chaines/fichiers/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
+
+
+# ############################################################################

tp_listes_chaines/fichiers/Sommets.py

@@ -0,0 +1,191 @@
+#! /usr/bin/python3
+# coding=utf-8
+
+"""
+Ce fichier contient la définition des objets Sommets.
+
+Un sommet dispose 
+
+- des attributs
+  + nom
+  + altitude
+  + massif
+- des méthodes 
+  + __lt__ : inférieur
+  + __le__ : inférieur ou égal
+  + __eq__ : égal
+  + __ge__ : supérieur ou égal
+  + __gt__ : supérieur
+  + __repr__ : représentation (affichage)
+"""
+
+
+# ############################################################################
+
+class Sommet(object):
+    """
+    Classe des Sommets montagneux.
+
+    Attributs
+        - nom : STR, nom du sommet
+        - altitude : INT, altitude en mètres
+        - massif : STR, nom du massif d'appartenance
+
+    Méthodes
+        - comparaison
+        - représentation
+
+    """
+
+    def __init__(self, nom, altitude, massif):
+        """
+        Construire une instance de la classe Sommet.
+
+        Parameters
+        ----------
+        nom : str
+            nom du sommet.
+        altitude : int
+            altitude en m.
+        massif : str
+            massif d'appartenance.
+
+        Returns
+        -------
+        None.
+
+        """
+        self.nom = nom
+        self.altitude = altitude
+        self.massif = massif
+        return None
+
+    def __repr__(self):
+        """
+        Construire l'affichage d'une instance de Sommet.
+
+        Returns
+        -------
+        str
+            chaine formattée d'affichage.
+
+        """
+        if self.altitude < 1000:
+            altitude = str(self.altitude)
+        else:
+            altitude = str(self.altitude)
+            altitude = altitude[:-3]+' '+altitude[-3:]
+        return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude)
+
+    def __str__(self):
+        """
+        Construire la chaîne de caractères résumant
+        une instance de Sommet.
+
+        Returns
+        -------
+        str
+            chaine formattée d'affichage.
+
+        """
+        if self.altitude < 1000:
+            altitude = str(self.altitude)
+        else:
+            altitude = str(self.altitude)
+            altitude = altitude[:-3]+' '+altitude[-3:]
+        return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude)
+
+
+    def __gt__(self, other):
+        """
+        Strictement plus grand.
+
+        Parameters
+        ----------
+        other : Sommet
+            Sommet à comparer.
+
+        Returns
+        -------
+        boolean
+            Resultat du test.
+
+        """
+        return (self.altitude > other.altitude)\
+            or ((self.altitude == other.altitude) and (self.nom > other.nom))
+
+    def __lt__(self, other):
+        """
+        Strictement plus petit.
+
+        Parameters
+        ----------
+        other : Sommet
+            Sommet à comparer.
+
+        Returns
+        -------
+        boolean
+            Resultat du test.
+
+        """
+        return (self.altitude < other.altitude)\
+            or ((self.altitude == other.altitude) and (self.nom < other.nom))
+
+    def __eq__(self, other):
+        """
+        Est égal à.
+
+        Parameters
+        ----------
+        other : Sommet
+            Sommet à comparer.
+
+        Returns
+        -------
+        boolean
+            Resultat du test.
+
+        """
+        return (self.altitude == other.altitude)
+
+    def __ge__(self, other):
+        """
+        Plus grand ou égal.
+
+        Parameters
+        ----------
+        other : Sommet
+            Sommet à comparer.
+
+        Returns
+        -------
+        boolean
+            Resultat du test.
+
+        """
+        return (self > other) or (self == other)
+
+    def __le__(self, other):
+        """
+        Plus petit ou égal.
+
+        Parameters
+        ----------
+        other : Sommet
+            Sommet à comparer.
+
+        Returns
+        -------
+        boolean
+            Resultat du test.
+
+        """
+        return (self < other) or (self == other)
+
+
+# ############################################################################
+
+if __name__ == '__main__':
+    s = Sommet('Chamechaude', 2062, 'Chartreuse')
+    print(s)

tp_listes_chaines/fichiers/TP5.py

@@ -0,0 +1,276 @@
+import re
+from Sommets import Sommet
+from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue
+
+# 1. Fonction extraire_altitude (inchangée, non récursive)
+def extraire_altitude(chaine):
+    """
+    Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'.
+
+    Paramètres :
+    chaine (str) : La chaîne contenant l'altitude et l'unité.
+
+    Retourne :
+    int : La valeur numérique de l'altitude.
+    """
+    return int(re.sub(r'\D', '', chaine))
+
+# 2. Fonction csv2liste (récursive)
+def csv2liste(fichier_csv):
+    """
+    Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
+
+    Paramètres :
+    fichier_csv (str) : Le chemin vers le fichier CSV à lire.
+
+    Retourne :
+    Une liste simplement chaînée contenant les sommets.
+    """
+    with open(fichier_csv, 'r') as fichier:
+        lignes = fichier.readlines()
+
+    # Fonction récursive interne pour construire la liste
+    def construire_liste(lignes):
+        if not lignes:
+            return creer_liste_vide()
+        else:
+            nom, altitude = lignes[0].strip().split(',')
+            altitude = extraire_altitude(altitude)
+            sommet = Sommet(nom, altitude, 'Chartreuse')
+            return ajouter_en_tete(construire_liste(lignes[1:]), sommet)
+
+    return construire_liste(lignes)
+
+# 3. Fonction copier_liste (récursive)
+def copier_liste(liste):
+    """
+    Copie une liste simplement chaînée.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+
+    Retourne :
+    Une copie de la liste.
+    """
+    if est_vide(liste):
+        return creer_liste_vide()
+    else:
+        return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
+
+# 4. Fonction rechercher (récursive)
+def rechercher(liste, nom):
+    """
+    Recherche un sommet dans la liste par son nom.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à rechercher.
+
+    Retourne :
+    bool : True si le sommet est trouvé, False sinon.
+    """
+    if est_vide(liste):
+        return False
+    elif tete(liste).nom == nom:
+        return True
+    else:
+        return rechercher(queue(liste), nom)
+
+# 5. Fonction modifier_altitude (récursive)
+def modifier_altitude(liste, nom, nouvelle_altitude):
+    """
+    Modifie l'altitude d'un sommet dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à modifier.
+    nouvelle_altitude (int) : La nouvelle altitude du sommet.
+    """
+    if not est_vide(liste):
+        sommet = tete(liste)
+        if sommet.nom == nom:
+            sommet.altitude = nouvelle_altitude
+        modifier_altitude(queue(liste), nom, nouvelle_altitude)
+
+# 6. Fonction supprimer_sommet (récursive)
+def supprimer_sommet(liste, nom):
+    """
+    Supprime la première occurrence du sommet de nom donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec la première occurrence du sommet supprimée.
+    """
+    if est_vide(liste):
+        return liste
+    elif tete(liste).nom == nom:
+        return queue(liste)
+    else:
+        return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste))
+
+# 7. Fonction supprimer_sommets (récursive)
+def supprimer_sommets(liste, nom):
+    """
+    Supprime toutes les occurrences du sommet de nom donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec toutes les occurrences du sommet supprimées.
+    """
+    if est_vide(liste):
+        return liste
+    elif tete(liste).nom == nom:
+        return supprimer_sommets(queue(liste), nom)
+    else:
+        return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste))
+
+# 8. Fonction longueur (récursive)
+def longueur(liste):
+    """
+    Renvoie le nombre d'éléments de la liste simplement chaînée.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+
+    Retourne :
+    int : Le nombre d'éléments dans la liste.
+    """
+    if est_vide(liste):
+        return 0
+    else:
+        return 1 + longueur(queue(liste))
+
+# 9. Fonction inserer (récursive)
+def inserer(liste, element, rang):
+    """
+    Insère un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    element : L'élément à insérer.
+    rang (int) : Le rang auquel insérer l'élément.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément inséré.
+    """
+    if rang == 0:
+        return ajouter_en_tete(liste, element)
+    else:
+        return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste))
+
+# 10. Fonction supprimer (récursive)
+def supprimer(liste, rang):
+    """
+    Supprime un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à supprimer.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément supprimé.
+    """
+    if rang == 0:
+        return queue(liste)
+    else:
+        return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste))
+
+# 11. Fonction modifier (récursive)
+def modifier(liste, rang, element):
+    """
+    Modifie un élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à modifier.
+    element : Le nouvel élément à insérer à ce rang.
+
+    Retourne :
+    Une liste simplement chaînée avec l'élément modifié.
+    """
+    if rang == 0:
+        return ajouter_en_tete(queue(liste), element)
+    else:
+        return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste))
+
+# 12. Fonction rechercher_par_rang (récursive)
+def rechercher_par_rang(liste, element):
+    """
+    Recherche l'élément dans la liste et retourne son rang.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    element : L'élément à rechercher.
+
+    Retourne :
+    int : Le rang de l'élément ou -1 s'il n'est pas trouvé.
+    """
+    def rechercher_recursif(liste, element, rang):
+        if est_vide(liste):
+            return -1
+        elif tete(liste) == element:
+            return rang
+        else:
+            return rechercher_recursif(queue(liste), element, rang + 1)
+    
+    return rechercher_recursif(liste, element, 0)
+
+# 13. Fonction lire (récursive)
+def lire(liste, rang):
+    """
+    Renvoie l'élément à un rang donné dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    rang (int) : Le rang de l'élément à lire.
+
+    Retourne :
+    L'élément à ce rang.
+    """
+    if rang == 0:
+        return tete(liste)
+    else:
+        return lire(queue(liste), rang - 1)
+
+# 14. Fonction trier (récursive)
+def trier(liste, ordre=lambda x, y: x < y):
+    """
+    Trie la liste dans un ordre donné.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    ordre : Une fonction de comparaison, par défaut x < y.
+
+    Retourne :
+    Une liste simplement chaînée triée.
+    """
+    if est_vide(liste):
+        return liste
+    else:
+        pivot = tete(liste)
+        sous_liste = queue(liste)
+
+        # Séparer en deux listes
+        inferieurs = creer_liste_vide()
+        superieurs = creer_liste_vide()
+        while not est_vide(sous_liste):
+            elt = tete(sous_liste)
+            if ordre(elt, pivot):
+                inferieurs = ajouter_en_tete(inferieurs, elt)
+            else:
+                superieurs = ajouter_en_tete(superieurs, elt)
+            sous_liste = queue(sous_liste)
+
+        # Trier les sous-listes
+        inferieurs = trier(inferieurs, ordre)
+        superieurs = trier(superieurs, ordre)
+
+        # Ajouter le pivot au résultat
+        return ajouter_en_tete(superieurs, pivot)
+

tp_listes_chaines/fichiers/TP5_1.py

@@ -0,0 +1,86 @@
+from Sommets import Sommet
+from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste
+
+def csv2liste(fichier_csv):
+    """
+    Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
+    
+    Paramètres :
+    fichier_csv (str) : Le chemin vers le fichier CSV à lire.
+
+    Retourne :
+    Une liste simplement chaînée contenant les sommets.
+    """
+    liste_sommets = creer_liste_vide()
+    with open(fichier_csv, 'r') as fichier:
+        for ligne in fichier:
+            nom, altitude = ligne.strip().split(',')
+            sommet = Sommet(nom, int(altitude), 'Chartreuse')  # Modifier selon le massif si nécessaire
+            liste_sommets = ajouter_en_tete(liste_sommets, sommet)
+    return liste_sommets
+
+# Test
+liste_sommets = csv2liste('Chartreuse.csv')
+afficher_liste(liste_sommets)
+from LSC import est_vide, tete, queue, ajouter_en_tete
+
+def copier_liste(liste):
+    """
+    Copie une liste simplement chaînée.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+
+    Retourne :
+    Une copie de la liste.
+    """
+    if est_vide(liste):
+        return creer_liste_vide()
+    else:
+        return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
+
+# Test
+copie = copier_liste(liste_sommets)
+afficher_liste(copie)
+def rechercher(liste, nom):
+    """
+    Recherche un sommet dans la liste par son nom.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à rechercher.
+
+    Retourne :
+    bool : True si le sommet est trouvé, False sinon.
+    """
+    reste = liste
+    while not est_vide(reste):
+        sommet = tete(reste)
+        if sommet.nom == nom:
+            return True
+        reste = queue(reste)
+    return False
+
+# Test
+print(rechercher(liste_sommets, "Chamechaude"))
+def modifier_altitude(liste, nom, nouvelle_altitude):
+    """
+    Modifie l'altitude d'un sommet dans la liste.
+
+    Paramètres :
+    liste : Une liste simplement chaînée.
+    nom (str) : Le nom du sommet à modifier.
+    nouvelle_altitude (int) : La nouvelle altitude du sommet.
+    """
+    reste = liste
+    while not est_vide(reste):
+        sommet = tete(reste)
+        if sommet.nom == nom:
+            sommet.altitude = nouvelle_altitude
+            break
+        reste = queue(reste)
+
+# Test
+modifier_altitude(liste_sommets, "Chamechaude", 2082)
+afficher_liste(liste_sommets)
+

tp_listes_chaines/fichiers/test.py

@@ -0,0 +1,22 @@
+import LSC as lc
+import csv
+import Sommets as sm
+liste = lc.creer_liste_vide()
+with open("Chartreuse.csv", mode="r",encoding='utf-8') as f:
+    lecteur_csv = csv.reader(f)
+    for ligne in lecteur_csv:
+        nom = ligne[0].strip()
+        altitude_str = ligne[1].strip()
+        altitude = int(altitude_str.replace('m', '').replace(' ', ''))
+        sommet = sm.Sommet(nom, altitude, "Chartreuse")
+        liste = lc.ajouter_en_tete(liste, sommet)
+    lecteur_csv = csv.reader(f)
+    for ligne in lecteur_csv:
+        nom = ligne[0].strip()
+        altitude_str = ligne[1].strip()
+        altitude = int(altitude_str.replace('m', '').replace(' ', ''))
+        sommet = sm.Sommet(nom, altitude, "Chartreuse")
+        liste = lc.ajouter_en_tete(liste, sommet)
+lc.afficher_liste(liste.queue())
+liste1 = liste.tete()
+print(liste1[0])