spectre/cours
1
0
Fork 0
mirror of https://github.com/Fare-spec/cours.git synced 2025-12-07 10:50:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto urgent commit.

Browse Source
This commit is contained in:
Spectre
2025-02-11 14:02:27 +01:00
parent 5a6bdf1e14
commit 57dfc1e18f
36 changed files with 0 additions and 3057 deletions
Download Patch File Download Diff File Expand all files Collapse all files

260
tp6_enirely/TP6/LSC.py
View File

@@ -1,260 +0,0 @@
"""
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
# ############################################################################

17
tp6_enirely/TP6/Pile_LSC.py
View File

@@ -1,17 +0,0 @@
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)

21
tp6_enirely/TP6/Pile_List.py
View File

@@ -1,21 +0,0 @@
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]

18
tp6_enirely/TP6/Pile_Tuple.py
View File

@@ -1,18 +0,0 @@
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]

BIN
tp6_enirely/TP6/TP_Piles.pdf
View File

Binary file not shown.

90
tp6_enirely/TP6/test.py
View File

@@ -1,90 +0,0 @@
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))

34
tp6_enirely/TP6/test.py.patch
View File

@@ -1,34 +0,0 @@
# 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

7
tp6_enirely/TP6/test_2.py/Pile_List.rst
View File

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

7
tp6_enirely/TP6/test_2.py/Pile_Tuple.rst
View File

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

9
tp6_enirely/TP6/test_2.py/modules.rst
View File

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

7
tp6_enirely/TP6/test_2.py/test.rst
View File

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

260
tp6_enirely/tp6/LSC.py
View File

@@ -1,260 +0,0 @@
"""
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
# ############################################################################

63
tp6_enirely/tp6/Pile_LSC.py
View File

@@ -1,63 +0,0 @@
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)

62
tp6_enirely/tp6/Pile_List.py
View File

@@ -1,62 +0,0 @@
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]

60
tp6_enirely/tp6/Pile_Tuple.py
View File

@@ -1,60 +0,0 @@
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]

69
tp6_enirely/tp6/README.md
View File

@@ -1,69 +0,0 @@
# 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

BIN
tp6_enirely/tp6/TP_Piles.pdf
View File

Binary file not shown.

46
tp6_enirely/tp6/npi.py
View File

@@ -1,46 +0,0 @@
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}")

125
tp6_enirely/tp6/test.py
View File

@@ -1,125 +0,0 @@
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)

260
tp6_enirely/tp6_self/LSC.py
View File

@@ -1,260 +0,0 @@
"""
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
# ############################################################################

55
tp6_enirely/tp6_self/Pile_LSC.py
View File

@@ -1,55 +0,0 @@
import LSC as lsc
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide():
"""Creer une pile vide.
Returns:
lsc.Liste_Simplement_Chainee: La liste vide
"""
return lsc.creer_liste_vide()
def est_pile_vide(pile: lsc.Liste_Simplement_Chainee):
"""Retourne True si la pile est vide, False sinon.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile à tester
Returns:
bool: True si la pile est vide
"""
return lsc.est_vide(pile)
def sommet(pile: lsc.Liste_Simplement_Chainee):
"""Retourne le sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
any: Le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.tete(pile)
def empiler(pile: lsc.Liste_Simplement_Chainee,elt: any):
"""Ajoute un element en tete de la pile
Args:
pile lsc.Liste_Simplement_Chainee: La pile à modifier
elt any: l'element a ajouter
Returns:
lsc.Liste_Simplement_Chainee : La pile avec l'element ajouté
"""
return lsc.ajouter_en_tete(pile, elt)
def depiler(pile: lsc.Liste_Simplement_Chainee):
"""Retire le sommet de la pile
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
lsc.Liste_Simplement_Chainee: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.queue(pile)

54
tp6_enirely/tp6_self/Pile_List.py
View File

@@ -1,54 +0,0 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide()->list:
"""Créer une pile vide.
Returns:
list: La pile vide
"""
return []
def est_pile_vide(pile: list) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (list): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: list)->int:
"""Retourne le sommet de la pile.
Args:
pile (list): La pile avec le sommet
Returns:
any: le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[-1]
def empiler(pile: list, elt: any)-> list:
"""rajoute elt au sommet de la pile
Args:
pile (list): La pile à modifier
elt (any): l'élement à ajouter
Returns:
list: la pile modifiée
"""
return pile + [elt]
def depiler(pile: list)-> any:
"""retourne la pile sans le sommet
Args:
pile (list): la pile avec le sommet
Returns:
any: la pile sans le sommet
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

54
tp6_enirely/tp6_self/Pile_Tuple.py
View File

@@ -1,54 +0,0 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide() -> tuple:
"""Créer une pile vide.
Returns:
Tuple: La pile vide
"""
return ()
def est_pile_vide(pile: tuple) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (tuple): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: tuple) -> any:
"""Renvoie le sommet de la pile.
Args:
pile (tuple): La pile contenant le sommet
Returns:
any: Le sommet de la pile
"""
return pile[-1]
def empiler(pile: tuple, elt: any)-> tuple:
"""ajoute elt au sommet de la pile
Args:
pile (tuple): la pile a modifier
elt (any): l'élement à ajouter
Returns:
tuple: la pile avec l'élement ajouté
"""
return pile + (elt,)
def depiler(pile: tuple) -> tuple:
"""Retire le sommet de la pile
Args:
pile (tuple): La pile avec le sommet
Returns:
tuple: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

133
tp6_enirely/tp6_self/README.md
View File

@@ -1,133 +0,0 @@
# **README - DM Piles et NPI**
## **Comment exécuter le programme :**
1. Verfier que tous les fichiers sont dans le même répertoire :
- `test.py`
- `Pile_Tuple.py`
- `Pile_LSC.py`
- `Pile_Liste.py`
- `npi.py`
2. Ouvrez un terminal dans ce répertoire.
3. Exécutez le programme avec la commande suivante :
```bash
python3 test.py
```
ou executer pour la notation polonaise inverse:
```bash
python3 npi.py
```
---
## **Fonctions disponibles et leur utilisation :**
### 1. **`creer_pile_vide()`**
- **Description** : Crée et renvoie une pile vide.
- **Utilisation** :
```python
pile = creer_pile_vide()
```
---
### 2. **`est_pile_vide(pile)`**
- **Description** : Vérifie si une pile est vide.
- **Paramètre** :
- `pile` : La pile à vérifier.
- **Retour** : Renvoie `True` si la pile est vide, sinon `False`.
- **Utilisation** :
```python
if est_pile_vide(pile):
print("La pile est vide.")
```
---
### 3. **`sommet(pile)`**
- **Description** : Retourne l’élément au sommet de la pile sans le retirer.
- **Paramètre** :
- `pile` : La pile à consulter.
- **Retour** : L’élément au sommet de la pile.
- **Utilisation** :
```python
print(sommet(pile))
```
---
### 4. **`empiler(pile, elt)`**
- **Description** : Ajoute un élément au sommet de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `elt` : L’élément à empiler.
- **Retour** : La nouvelle pile avec l’élément ajouté.
- **Utilisation** :
```python
pile = empiler(pile, 5)
```
---
### 5. **`depiler(pile)`**
- **Description** : Retire l’élément au sommet de la pile.
- **Paramètre** :
- `pile` : La pile à modifier.
- **Retour** : La pile sans l’élément au sommet.
- **Utilisation** :
```python
pile = depiler(pile)
```
---
### 6. **`hauteur_pile(pile)`**
- **Description** : Renvoie le nombre d'éléments présents dans la pile sans la modifier.
- **Paramètre** :
- `pile` : La pile à analyser.
- **Retour** : La hauteur de la pile (nombre d'éléments).
- **Utilisation** :
```python
print(hauteur_pile(pile))
```
---
### 7. **`max_pile(pile, i)`**
- **Description** : Trouve le maximum parmi les `i` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à analyser.
- `i` : Le nombre d'éléments à prendre en compte depuis le sommet.
- **Retour** : Le maximum trouvé parmi les `i` éléments.
- **Utilisation** :
```python
print(max_pile(pile, 3))
```
---
### 8. **`retourner(pile, j)`**
- **Description** : Inverse l’ordre des `j` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `j` : Le nombre d'éléments à inverser.
- **Retour** : La pile modifiée.
- **Utilisation** :
```python
pile = retourner(pile, 2)
```
---
### 9. **`tri_crepes_recursif(pile)`**
- **Description** : Trie une pile en suivant le tri des crêpes.
- **Paramètre** :
- `pile` : La pile à trier.
- **Retour** : La pile triée.
- **Utilisation** :
```python
pile = tri_crepes_recursif(pile)
```
<hr>
Cela conclut la documentation des fonctions. Pour toute question, consultez le fichier **test.py** pour des exemples plus détaillés.
pour toutes questions: elouan.fare@protonmail.ch

44
tp6_enirely/tp6_self/npi.py
View File

@@ -1,44 +0,0 @@
def npi(exp: str) -> float:
"""Calcule une expression arithmétique en NPI (notation polonaise inverse).
Args:
exp (str): L'expression arithmétique à calculer.
Returns:
float: Le résultat de l'expression.
"""
assert exp, "L'expression est vide."
pile = []
for token in exp.split():
if token in "+-*/":
if len(pile) < 2:
print("Erreure : Pas assez d'opérandes.")
return None
b, a = pile.pop(), pile.pop()
match token:
case '+': pile.append(a + b)
case '-': pile.append(a - b)
case '*': pile.append(a * b)
case '/':
if b == 0:
print("Erreur : Division par zéro.")
return None
pile.append(a / b)
elif token.replace('.', '', 1).isdigit(): # isdigit verifie si 'token' est un nombre ou un chiffre
pile.append(float(token))
else:
print(f"erreur : '{token}' n'est pas un opérande valide.")
return None
if len(pile) != 1:
print("erreur : Expression mal formée.")
return None
return pile[0] # On aurait pu mettre pile[-1]
if __name__ == "__main__":
# Test
exp = "3 4 + 5 * 2 /" # correspond a (3+4)(5/2) soit 7 * 2.5 = 17.5
print(npi(exp))

160
tp6_enirely/tp6_self/test.py
View File

@@ -1,160 +0,0 @@
#!/usr/bin/python3
import LSC as lsc
import Pile_List as lifo
from random import shuffle
from typing import List, Tuple, Union, TypeVar, Any
T = TypeVar('T')
PileType = Union[List[T], Tuple[T,...], lsc.Liste_Simplement_Chainee]
#----------------------------------------------------------------
# Aucun effet de bord sur les fonctions ajoutés car je n'y suis pas arrivé
#----------------------------------------------------------------
def afficher(pile):
print("|----\n|")
while not(lifo.est_pile_vide(pile)):
print(f"| {lifo.sommet(pile)}\n|")
pile = lifo.depiler(pile)
print("|----")
return None
def hauteur_pile(pile: PileType) -> int:
"""Retourne la taille/ hauteur de la pile
Args:
pile (list/tuple/lsc.Liste_Simplement_Chainee): la pile a mesurer
Returns:
int: la taille de la pile
"""
n = 0
while not(lifo.est_pile_vide(pile)):
n += 1
pile = lifo.depiler(pile)
return n
def copie(pile: PileType) -> PileType:
"""creer une copie de la pile
Args:
pile (PileType): pile a copier
Returns:
PileType: une copie de la pile
"""
pile_copie = lifo.creer_pile_vide()
while not(lifo.est_pile_vide(pile)):
pile_copie = lifo.empiler(pile_copie, lifo.sommet(pile))
pile = lifo.depiler(pile)
return pile_copie
def max_pile(pile: PileType,start: int)-> int:
"""Retourne l'element le plus grand de la pile
Args:
start: int: la position de départ de la recherche
pile: PileType: la pile a analyser
Returns:
int: l'indice de l'element le plus grand de la pile
"""
assert start >=0, "Position de départ invalide"
assert hauteur_pile(pile) >= start, "Position de départ dépasse la taille de la pile"
assert not(lifo.est_pile_vide(pile)), "La pile est vide"
pile2 = copie(copie(pile)) # <--- pas très propre c'est pour renverser la copie qui a été renversé
# J'itère jusqu' a start:
max_n = lifo.sommet(pile)
for _ in range(start):
sommet = lifo.sommet(pile2)
pile2 = lifo.depiler(pile2)
if sommet > max_n:
max_n = sommet
pile2 = copie(copie(pile))
# je cherche l'index du max dans pile2
for i in range(start):
i+=1
if lifo.sommet(pile2) == max_n:
return i
else:
pile2 = lifo.depiler(pile2)
def retourner(pile: PileType, j: int) -> PileType:
"""retourne la pile avec les j premiers éléments renversés.
Args:
pile (PileType): la pile
j (int): l'index a renverser
Returns:
PileType: la pile renversée
"""
pile1 = copie(copie(pile))
pile2 = lifo.creer_pile_vide()
# je déplace les j premiers éléments de pile1 dans pile2
for _ in range(j):
sommet = lifo.sommet(pile1)
pile1 = lifo.depiler(pile1)
pile2 = lifo.empiler(pile2, sommet)
# renverse Pile 2
pile2 = copie(pile2)
#ajoute pile2 a pile1
while not(lifo.est_pile_vide(pile2)):
sommet = lifo.sommet(pile2)
pile1 = lifo.empiler(pile1,sommet)
pile2 = lifo.depiler(pile2)
pile = lifo.creer_pile_vide()
# remplace Pile par Pile1
while not(lifo.est_pile_vide(pile1)):
sommet = lifo.sommet(pile1)
pile = lifo.empiler(pile, sommet)
pile1 = lifo.depiler(pile1)
return copie(pile)
def tri_crepes(pile: PileType) -> PileType:
"""tri la pile en utilisant 'pancakes sort'
Args:
pile (PileType): la pile a trier
Returns:
PileType: la pile triée
"""
n = hauteur_pile(pile)
while n > 1:
index_max = max_pile(pile, n)
pile = retourner(pile,index_max)
pile = retourner(pile,n)
n-=1
return (pile)
if __name__ == "__main__":
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)
j = 4
print("\nTaille de la pile : ", hauteur_pile(ma_pile))
print(f"Element le plus grand de la pile à partir de l'index {j}: {max_pile(ma_pile,4)}")
pile = retourner(ma_pile, j)
hauteur_pile(ma_pile)
afficher(pile)
print("\nDEPILEMENT\n")
pile_triee = tri_crepes(ma_pile)
afficher(pile_triee)
while not(lifo.est_pile_vide(ma_pile)):
print(f"Sommet : {lifo.sommet(ma_pile)}")
ma_pile = lifo.depiler(ma_pile)
afficher(ma_pile)

BIN
tp6_enirely/tp_listes_chaines/TP 5 Listes Chaînées-20240925.zip
View File

Binary file not shown.

BIN
tp6_enirely/tp_listes_chaines/TP5_Listes_Chainees.pdf
View File

Binary file not shown.

278
tp6_enirely/tp_listes_chaines/execute.py
View File

@@ -1,278 +0,0 @@
# 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"

29
tp6_enirely/tp_listes_chaines/fichiers/Chartreuse.csv
View File

@@ -1,29 +0,0 @@
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
1 Grande Sure (La) 1 920 m
2 Rocher de Lorzier (Le) 1 838 m
3 Rochers de Chalves (Les) 1 845 m
4 Rocher de l'Église (Le) 1 300 m
5 Pointe de la Gorgeat (La) 1 486 m
6 Mont Joigny (Le) 1 556 m
7 Mont Outheran (Le) 1 673 m
8 Cochette (La) 1 618 m
9 Roc de Gleisin (Le) 1 434 m
10 Roche Veyrand (La) 1 429 m
11 Dent de l'Ours (La) 1 820 m
12 Petit Som (Le) 1 772 m
13 Grand Som (Le) 2 026 m
14 Charmant Som (Le) 1 867 m
15 Pinéa (La) 1 771 m
16 Néron (Le) 1 299 m
17 Mont Granier (Le) 1 933 m
18 Sommet du Pinet (Le) ou le Truc 1 867 m
19 Grand Manti (Le) 1 818 m
20 Scia (La) 1 791 m
21 Lances de Malissard (Les) 2 045 m
22 Dôme de Bellefont (Le) 1 975 m
23 Dent de Crolles (La) 2 062 m
24 Piton de Bellefont (Le) 1 958 m
25 Chamechaude 2 082 m
26 Grands Crêts (Les) 1 489 m
27 Mont Saint-Eynard (Le) 1 379 m
28 Écoutoux (L') 1 406 m
29 Rachais (Le) 1 050 m

260
tp6_enirely/tp_listes_chaines/fichiers/LSC.py
View File

@@ -1,260 +0,0 @@
"""
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
# ############################################################################

191
tp6_enirely/tp_listes_chaines/fichiers/Sommets.py
View File

@@ -1,191 +0,0 @@
#! /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)

276
tp6_enirely/tp_listes_chaines/fichiers/TP5.py
View File

@@ -1,276 +0,0 @@
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)

86
tp6_enirely/tp_listes_chaines/fichiers/TP5_1.py
View File

@@ -1,86 +0,0 @@
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)

0
tp6_enirely/tp_listes_chaines/fichiers/factorial.py
View File

22
tp6_enirely/tp_listes_chaines/fichiers/test.py
View File

@@ -1,22 +0,0 @@
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])