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

Auto commit

Browse Source
This commit is contained in:
Spectre
2025-02-09 12:17:21 +01:00
parent 3a1f6a8d4c
commit 55cfb57800
19 changed files with 38 additions and 1862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

287
README.html
View File

@@ -1,287 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Source file</title>
<link rel="stylesheet" type="text/css" href="highlight.css">
</head>
<body class="hl">
<pre class="hl">.
├── algo2.md
├── elouan_fare
│   └── tp6
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   ├── test.py
│   └── TP_Piles.pdf
├── elouan_fare.tar.gz
├── elouan_fare_v2
│   └── tp6_self
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   └── test.py
├── elouan_fare_v2.tar.gz
├── ensembles_dynamiques
│   └── TP
│   ├── _collection_list.py
│   ├── _collection.py
│   ├── data
│   │   └── Chartreuse.csv
│   ├── main.py
│   ├── __pycache__
│   │   ├── _collection.cpython-312.pyc
│   │   ├── _collection_list.cpython-312.pyc
│   │   ├── _sommets.cpython-312.pyc
│   │   └── _sommets_dict.cpython-312.pyc
│   ├── _sommets_dict.py
│   └── _sommets.py
├── fibonacci
│   ├── code1.py
│   ├── complex.py
│   └── fibobo
│   ├── Cargo.lock
│   ├── Cargo.toml
│   ├── src
│   │   └── main.rs
│   └── target
│   ├── CACHEDIR.TAG
│   ├── debug
│   │   ├── build
│   │   ├── deps
│   │   │   ├── fibobo-810e1cb07c397525.d
│   │   │   ├── fibobo-a1cd0427fbdbb954.d
│   │   │   ├── libfibobo-810e1cb07c397525.rmeta
│   │   │   └── libfibobo-a1cd0427fbdbb954.rmeta
│   │   ├── examples
│   │   └── incremental
│   │   ├── fibobo-2flkpqcyr8r2k
│   │   │   ├── s-h2tyx70fiv-0np3ven-cetzdomvijq2fq7eb3ig9iiiy
│   │   │   │   ├── dep-graph.bin
│   │   │   │   ├── query-cache.bin
│   │   │   │   └── work-products.bin
│   │   │   └── s-h2tyx70fiv-0np3ven.lock
│   │   └── fibobo-2tiuzkggvknqa
│   │   ├── s-h2tyx70her-05l7no3-ag0f5y72t7jx6dzosg88sgd73
│   │   │   ├── dep-graph.bin
│   │   │   ├── query-cache.bin
│   │   │   └── work-products.bin
│   │   └── s-h2tyx70her-05l7no3.lock
│   └── release
│   ├── build
│   ├── deps
│   │   ├── fibobo-2f995dd7ce38f150
│   │   └── fibobo-2f995dd7ce38f150.d
│   ├── examples
│   ├── fibobo
│   ├── fibobo.d
│   └── incremental
├── fichier.md
├── file
│   ├── file_LSC.py
│   ├── file.py
│   ├── file_tuple.py
│   └── LSC.py
├── fn_test_tri_bynome
├── fonctions_tri
│   └── partitionement.py
├── graphes
│   ├── DS_possible
│   │   ├── elouan_fare.tar
│   │   ├── main.py
│   │   └── v
│   ├── ht
│   ├── leaudibidon
│   │   ├── correction.py
│   │   ├── main.py
│   │   └── Water_jug.py
│   └── why
├── highlight.css
├── learning_pygame
│   ├── bouncing_ball
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── constantes.py
│   │   ├── f
│   │   ├── __pycache__
│   │   │   ├── balle.cpython-313.pyc
│   │   │   ├── constantes.cpython-313.pyc
│   │   │   └── raquette.cpython-313.pyc
│   │   └── raquette.py
│   ├── bouncing_ball_project
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── bouncing_ball_game.py
│   │   ├── constantes.py
│   │   ├── __pycache__
│   │   │   ├── balle.cpython-313.pyc
│   │   │   ├── constantes.cpython-313.pyc
│   │   │   └── raquette.cpython-313.pyc
│   │   └── raquette.py
│   └── bouncing_ball_project.zip
├── LICENSE
├── magic_square
│   ├── magic_square.py
│   ├── __pycache__
│   │   └── td_carre_magique.cpython-312.pyc
│   ├── td_carre_magique.py
│   └── TDliste2liste
│   ├── exercice1.py
│   ├── exercice2.py
│   ├── exercice3.py
│   ├── exercice4.py
│   ├── exercice5.py
│   ├── exercice6.py
│   └── __pycache__
│   └── exercice6.cpython-312.pyc
├── Partie2
│   └── Eleve
│   ├── livres.db
│   ├── livres.db-journal
│   ├── livres.sql
│   ├── p_app_web_python_sqlite.pdf
│   ├── Projet
│   │   ├── control.py
│   │   ├── index.html
│   │   ├── __init__.py
│   │   ├── __pycache__
│   │   │   ├── control.cpython-313.pyc
│   │   │   └── __init__.cpython-313.pyc
│   │   └── templates
│   │   └── index.html
│   └── run.py
├── partition_fusion
│   ├── code2.py
│   └── code.py
├── prblm.txt
├── preuve.md
├── readme_creator.txt
├── README.html
├── README.md
├── recurivite
│   └── exercice_MJoannic
│   └── dichotomie
│   └── recursif
│   └── myself
│   └── idx
│   └── __pycache__
│   ├── main.cpython-313.pyc
│   └── sort_list.cpython-313.pyc
├── recursivite
│   ├── exercice_MJoannic
│   │   ├── dichotomie
│   │   │   ├── iteratif
│   │   │   │   ├── main.py
│   │   │   │   ├── sort_list.py
│   │   │   │   └── tester.py
│   │   │   └── recursif
│   │   │   ├── correction
│   │   │   │   └── V1.py
│   │   │   └── myself
│   │   │   ├── idx
│   │   │   │   ├── main.py
│   │   │   │   ├── sort_list.py
│   │   │   │   └── tester.py
│   │   │   ├── main.py
│   │   │   ├── sort_list.py
│   │   │   └── tester.py
│   │   ├── palindrom.py
│   │   └── sqrt
│   │   ├── correction
│   │   │   └── main.py
│   │   └── main.py
│   └── TD1.py
├── sqlite
│   ├── test
│   └── test-journal
├── TDliste2liste
│   ├── exercice1.py
│   ├── exercice2.py
│   ├── exercice3.py
│   ├── exercice4.py
│   ├── exercice5.py
│   └── exercice6.py
├── threading
├── tp6
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   ├── test.py
│   └── TP_Piles.pdf
├── TP6
│   ├── LSC.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── test_2.py
│   │   ├── modules.rst
│   │   ├── Pile_List.rst
│   │   ├── Pile_Tuple.rst
│   │   └── test.rst
│   ├── test.py
│   ├── test.py.patch
│   └── TP_Piles.pdf
├── tp6_self
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   └── test.py
└── tp_listes_chaines
├── execute.py
├── fichiers
│   ├── Chartreuse.csv
│   ├── factorial.py
│   ├── LSC.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   └── Sommets.cpython-312.pyc
│   ├── Sommets.py
│   ├── test.py
│   ├── TP5_1.py
│   └── TP5.py
├── TP 5 Listes Chaînées-20240925.zip
└── TP5_Listes_Chainees.pdf
80 directories, 193 files
</pre>
</body>
</html>
<!--HTML generated by highlight 4.13, http://andre-simon.de/-->

168
README.md
View File

@@ -8,37 +8,8 @@
<body class="hl"> <body class="hl">
<pre class="hl">. <pre class="hl">.
├── algo2.md ├── algo2.md
├── elouan_fare ├── casse-brique
│   └── tp6 │   └── main.py
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   ├── test.py
│   └── TP_Piles.pdf
├── elouan_fare.tar.gz
├── elouan_fare_v2
│   └── tp6_self
│   ├── LSC.py
│   ├── npi.py
│   ├── Pile_List.py
│   ├── Pile_LSC.py
│   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md
│   └── test.py
├── elouan_fare_v2.tar.gz
├── ensembles_dynamiques ├── ensembles_dynamiques
│   └── TP │   └── TP
│   ├── _collection_list.py │   ├── _collection_list.py
@@ -46,11 +17,6 @@
│   ├── data │   ├── data
│   │   └── Chartreuse.csv │   │   └── Chartreuse.csv
│   ├── main.py │   ├── main.py
│   ├── __pycache__
│   │   ├── _collection.cpython-312.pyc
│   │   ├── _collection_list.cpython-312.pyc
│   │   ├── _sommets.cpython-312.pyc
│   │   └── _sommets_dict.cpython-312.pyc
│   ├── _sommets_dict.py │   ├── _sommets_dict.py
│   └── _sommets.py │   └── _sommets.py
├── fibonacci ├── fibonacci
@@ -59,47 +25,14 @@
│   └── fibobo │   └── fibobo
│   ├── Cargo.lock │   ├── Cargo.lock
│   ├── Cargo.toml │   ├── Cargo.toml
│   ├── src │   └── src
│   │   └── main.rs │   └── main.rs
│   └── target
│   ├── CACHEDIR.TAG
│   ├── debug
│   │   ├── build
│   │   ├── deps
│   │   │   ├── fibobo-810e1cb07c397525.d
│   │   │   ├── fibobo-a1cd0427fbdbb954.d
│   │   │   ├── libfibobo-810e1cb07c397525.rmeta
│   │   │   └── libfibobo-a1cd0427fbdbb954.rmeta
│   │   ├── examples
│   │   └── incremental
│   │   ├── fibobo-2flkpqcyr8r2k
│   │   │   ├── s-h2tyx70fiv-0np3ven-cetzdomvijq2fq7eb3ig9iiiy
│   │   │   │   ├── dep-graph.bin
│   │   │   │   ├── query-cache.bin
│   │   │   │   └── work-products.bin
│   │   │   └── s-h2tyx70fiv-0np3ven.lock
│   │   └── fibobo-2tiuzkggvknqa
│   │   ├── s-h2tyx70her-05l7no3-ag0f5y72t7jx6dzosg88sgd73
│   │   │   ├── dep-graph.bin
│   │   │   ├── query-cache.bin
│   │   │   └── work-products.bin
│   │   └── s-h2tyx70her-05l7no3.lock
│   └── release
│   ├── build
│   ├── deps
│   │   ├── fibobo-2f995dd7ce38f150
│   │   └── fibobo-2f995dd7ce38f150.d
│   ├── examples
│   ├── fibobo
│   ├── fibobo.d
│   └── incremental
├── fichier.md ├── fichier.md
├── file ├── file
│   ├── file_LSC.py │   ├── file_LSC.py
│   ├── file.py │   ├── file.py
│   ├── file_tuple.py │   ├── file_tuple.py
│   └── LSC.py │   └── LSC.py
├── fn_test_tri_bynome
├── fonctions_tri ├── fonctions_tri
│   └── partitionement.py │   └── partitionement.py
├── graphes ├── graphes
@@ -107,40 +40,25 @@
│   │   ├── elouan_fare.tar │   │   ├── elouan_fare.tar
│   │   ├── main.py │   │   ├── main.py
│   │   └── v │   │   └── v
│   ├── homework_wednesday.py
│   ├── ht │   ├── ht
│   ├── leaudibidon │   ├── leaudibidon
│   │   ├── correction.py │   │   ├── correction.py
│   │   ├── main.py │   │   ├── main.py
│   │   ├── Water_jug(en_xz).tar
│   │   └── Water_jug.py │   │   └── Water_jug.py
│   ├── maze
│   │   ├── fifo.py
│   │   ├── lifo.py
│   │   ├── main.py
│   │   ├── maze_creator.py
│   │   └── test.py
│   ├── monday_homework.py
│   └── why │   └── why
├── highlight.css ├── highlight.css
├── learning_pygame
│   ├── bouncing_ball
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── constantes.py
│   │   ├── f
│   │   ├── __pycache__
│   │   │   ├── balle.cpython-313.pyc
│   │   │   ├── constantes.cpython-313.pyc
│   │   │   └── raquette.cpython-313.pyc
│   │   └── raquette.py
│   ├── bouncing_ball_project
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── bouncing_ball_game.py
│   │   ├── constantes.py
│   │   ├── __pycache__
│   │   │   ├── balle.cpython-313.pyc
│   │   │   ├── constantes.cpython-313.pyc
│   │   │   └── raquette.cpython-313.pyc
│   │   └── raquette.py
│   └── bouncing_ball_project.zip
├── LICENSE ├── LICENSE
├── magic_square ├── magic_square
│   ├── magic_square.py │   ├── magic_square.py
│   ├── __pycache__
│   │   └── td_carre_magique.cpython-312.pyc
│   ├── td_carre_magique.py │   ├── td_carre_magique.py
│   └── TDliste2liste │   └── TDliste2liste
│   ├── exercice1.py │   ├── exercice1.py
@@ -148,9 +66,7 @@
│   ├── exercice3.py │   ├── exercice3.py
│   ├── exercice4.py │   ├── exercice4.py
│   ├── exercice5.py │   ├── exercice5.py
│   ├── exercice6.py │   └── exercice6.py
│   └── __pycache__
│   └── exercice6.cpython-312.pyc
├── Partie2 ├── Partie2
│   └── Eleve │   └── Eleve
│   ├── livres.db │   ├── livres.db
@@ -161,9 +77,6 @@
│   │   ├── control.py │   │   ├── control.py
│   │   ├── index.html │   │   ├── index.html
│   │   ├── __init__.py │   │   ├── __init__.py
│   │   ├── __pycache__
│   │   │   ├── control.cpython-313.pyc
│   │   │   └── __init__.cpython-313.pyc
│   │   └── templates │   │   └── templates
│   │   └── index.html │   │   └── index.html
│   └── run.py │   └── run.py
@@ -172,18 +85,32 @@
│   └── code.py │   └── code.py
├── prblm.txt ├── prblm.txt
├── preuve.md ├── preuve.md
├── pygame
│   ├── bouncing_ball
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── constantes.py
│   │   ├── f
│   │   └── raquette.py
│   ├── bouncing_ball_project
│   │   ├── balle.py
│   │   ├── ball.py
│   │   ├── bouncing_ball_game.py
│   │   ├── constantes.py
│   │   └── raquette.py
│   ├── bouncing_ball_project.zip
│   ├── lab_py
│   │   └── main.py
│   └── V2
│   └── balle
│   ├── balle.py
│   ├── balle_rebondissante.py
│   ├── casse_brique.py
│   ├── constantes.py
│   └── raquette.py
├── readme_creator.txt ├── readme_creator.txt
├── README.html ├── README.html
├── README.md ├── README.md
├── recurivite
│   └── exercice_MJoannic
│   └── dichotomie
│   └── recursif
│   └── myself
│   └── idx
│   └── __pycache__
│   ├── main.cpython-313.pyc
│   └── sort_list.cpython-313.pyc
├── recursivite ├── recursivite
│   ├── exercice_MJoannic │   ├── exercice_MJoannic
│   │   ├── dichotomie │   │   ├── dichotomie
@@ -218,18 +145,12 @@
│   ├── exercice4.py │   ├── exercice4.py
│   ├── exercice5.py │   ├── exercice5.py
│   └── exercice6.py │   └── exercice6.py
├── threading
├── tp6 ├── tp6
│   ├── LSC.py │   ├── LSC.py
│   ├── npi.py │   ├── npi.py
│   ├── Pile_List.py │   ├── Pile_List.py
│   ├── Pile_LSC.py │   ├── Pile_LSC.py
│   ├── Pile_Tuple.py │   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md │   ├── README.md
│   ├── test.py │   ├── test.py
│   └── TP_Piles.pdf │   └── TP_Piles.pdf
@@ -238,11 +159,6 @@
│   ├── Pile_List.py │   ├── Pile_List.py
│   ├── Pile_LSC.py │   ├── Pile_LSC.py
│   ├── Pile_Tuple.py │   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── test_2.py │   ├── test_2.py
│   │   ├── modules.rst │   │   ├── modules.rst
│   │   ├── Pile_List.rst │   │   ├── Pile_List.rst
@@ -257,11 +173,6 @@
│   ├── Pile_List.py │   ├── Pile_List.py
│   ├── Pile_LSC.py │   ├── Pile_LSC.py
│   ├── Pile_Tuple.py │   ├── Pile_Tuple.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   ├── Pile_List.cpython-312.pyc
│   │   ├── Pile_LSC.cpython-312.pyc
│   │   └── Pile_Tuple.cpython-312.pyc
│   ├── README.md │   ├── README.md
│   └── test.py │   └── test.py
└── tp_listes_chaines └── tp_listes_chaines
@@ -270,9 +181,6 @@
│   ├── Chartreuse.csv │   ├── Chartreuse.csv
│   ├── factorial.py │   ├── factorial.py
│   ├── LSC.py │   ├── LSC.py
│   ├── __pycache__
│   │   ├── LSC.cpython-312.pyc
│   │   └── Sommets.cpython-312.pyc
│   ├── Sommets.py │   ├── Sommets.py
│   ├── test.py │   ├── test.py
│   ├── TP5_1.py │   ├── TP5_1.py
@@ -280,7 +188,7 @@
├── TP 5 Listes Chaînées-20240925.zip ├── TP 5 Listes Chaînées-20240925.zip
└── TP5_Listes_Chainees.pdf └── TP5_Listes_Chainees.pdf
80 directories, 193 files 45 directories, 136 files
</pre> </pre>
</body> </body>
</html> </html>

BIN
elouan_fare.tar.gz
View File

Binary file not shown.

260
elouan_fare/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
elouan_fare/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
elouan_fare/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
elouan_fare/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
elouan_fare/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
elouan_fare/tp6/TP_Piles.pdf
View File

Binary file not shown.

46
elouan_fare/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
elouan_fare/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)

BIN
elouan_fare_v2.tar.gz
View File

Binary file not shown.

260
elouan_fare_v2/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
elouan_fare_v2/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
elouan_fare_v2/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
elouan_fare_v2/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
elouan_fare_v2/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
elouan_fare_v2/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
elouan_fare_v2/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)