diff --git a/Partie2/Eleve/._livres.sql b/Partie2/Eleve/._livres.sql new file mode 100644 index 0000000..133f450 Binary files /dev/null and b/Partie2/Eleve/._livres.sql differ diff --git a/Partie2/Eleve/._p_app_web_python_sqlite.pdf b/Partie2/Eleve/._p_app_web_python_sqlite.pdf new file mode 100644 index 0000000..e0971d1 Binary files /dev/null and b/Partie2/Eleve/._p_app_web_python_sqlite.pdf differ diff --git a/Partie2/Eleve/Projet/__init__.py b/Partie2/Eleve/Projet/__init__.py new file mode 100644 index 0000000..5562095 --- /dev/null +++ b/Partie2/Eleve/Projet/__init__.py @@ -0,0 +1 @@ +from .control import app diff --git a/Partie2/Eleve/Projet/control.py b/Partie2/Eleve/Projet/control.py new file mode 100644 index 0000000..c150743 --- /dev/null +++ b/Partie2/Eleve/Projet/control.py @@ -0,0 +1,7 @@ +from flask import Flask, render_template + +app = Flask(__name__) + +@app.route('/') +def index(): + return render_template('index.html') diff --git a/Partie2/Eleve/Projet/index.html b/Partie2/Eleve/Projet/index.html new file mode 100644 index 0000000..2ce3f82 --- /dev/null +++ b/Partie2/Eleve/Projet/index.html @@ -0,0 +1,13 @@ + + + + + + + + + +

Bonjour

+ + + diff --git a/Partie2/Eleve/Projet/templates/index.html b/Partie2/Eleve/Projet/templates/index.html new file mode 100644 index 0000000..2ce3f82 --- /dev/null +++ b/Partie2/Eleve/Projet/templates/index.html @@ -0,0 +1,13 @@ + + + + + + + + + +

Bonjour

+ + + diff --git a/Partie2/Eleve/livres.db b/Partie2/Eleve/livres.db new file mode 100644 index 0000000..988613f Binary files /dev/null and b/Partie2/Eleve/livres.db differ diff --git a/Partie2/Eleve/livres.db-journal b/Partie2/Eleve/livres.db-journal new file mode 100644 index 0000000..3b2b8e0 Binary files /dev/null and b/Partie2/Eleve/livres.db-journal differ diff --git a/Partie2/Eleve/livres.sql b/Partie2/Eleve/livres.sql new file mode 100644 index 0000000..15b7b33 --- /dev/null +++ b/Partie2/Eleve/livres.sql @@ -0,0 +1,480 @@ +BEGIN TRANSACTION; +DROP TABLE IF EXISTS "usagers"; +CREATE TABLE IF NOT EXISTS "usagers" ( + "nom" VARCHAR(90), + "prenom" VARCHAR(90), + "adresse" VARCHAR(90), + "cp" VARCHAR(90), + "ville" VARCHAR(90), + "email" VARCHAR(90), + "code_barre" CHAR(10), + CONSTRAINT "PK_usagers" PRIMARY KEY("code_barre") +); +DROP TABLE IF EXISTS "livre"; +CREATE TABLE IF NOT EXISTS "livre" ( + "titre" VARCHAR(300) NOT NULL, + "editeur" VARCHAR(90) NOT NULL, + "annee" INT NOT NULL, + "isbn" CHAR(14), + PRIMARY KEY("isbn") +); +DROP TABLE IF EXISTS "auteur"; +CREATE TABLE IF NOT EXISTS "auteur" ( + "a_id" INT, + "nom" VARCHAR(90) NOT NULL, + "prenom" VARCHAR(90) NOT NULL, + PRIMARY KEY("a_id") +); +DROP TABLE IF EXISTS "auteur_de"; +CREATE TABLE IF NOT EXISTS "auteur_de" ( + "a_id" INT, + "isbn" CHAR(14), + FOREIGN KEY("a_id") REFERENCES "Auteur"("a_id"), + FOREIGN KEY("isbn") REFERENCES "livre"("isbn"), + PRIMARY KEY("a_id","isbn") +); +DROP TABLE IF EXISTS "emprunts"; +CREATE TABLE IF NOT EXISTS "emprunts" ( + "code_barre" CHAR(10), + "isbn" VARCHAR(15), + "date_retour" DATE, + CONSTRAINT "FK_emprunts_usagers" FOREIGN KEY("code_barre") REFERENCES "usagers"("code_barre"), + CONSTRAINT "FK_emprunts_livre" FOREIGN KEY("isbn") REFERENCES "livre"("isbn"), + CONSTRAINT "PK_emprunts" PRIMARY KEY("code_barre","isbn","date_retour") +); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('MICHEL','VALÉRIE','104, Rue du Stade','75013','Paris','vmichel5@monmail.com','199614051174633'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('DURAND','JULIEN','183, Rue de la Gare','75019','Paris','jdurand9@email.fr','782124241492509'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('MOREAU','ALAIN','48, Rue du Château','75005','Paris','amoreau1@abc.de','421921003090881'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('DUBOIS','PHILIPPE','35, Rue du Moulin','75014','Paris','pdubois5@chezmoi.net','137332830764072'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('ROBERT','PASCAL','95, Rue de la Gare','75005','Paris','probert9@monmail.com','533299198788609'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('FOURNIER','DAVID','157, Rue de la Fontaine','75007','Paris','dfournier4@abc.de','612978231522917'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('LAURENT','FRANÇOISE','90, Rue Principale','75005','Paris','flaurent3@monmail.com','917547585216771'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('SIMON','SANDRINE','45, Rue du Château','75020','Paris','ssimon2@abc.de','654834075188732'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('PETIT','SÉBASTIEN','5, Rue du Stade','75012','Paris','spetit4@email.fr','934701281931582'); +INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('BERNARD','STÉPHANE','131, Place de la Mairie','75015','Paris','sbernard2@chezmoi.net','035184062854281'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Aventures de Huckleberry Finn','Flammarion',2020,'978-2081509511'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fondation et Empire','Editions Denoël',1999,'978-2207249123'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Akira','Glénat',2000,'978-2723428262'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Robots','Editions Milan',2017,'978-2745989857'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Pictes','Editions Albert René',2013,'978-2864972662'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Monades urbaines','Robert Laffont',2016,'978-2221197691'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Voyages de Gulliver','Primento',2015,'978-2335008586'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Lolita','Penguin UK',2012,'978-0141391601'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Nuit des temps','Presses de la Cité',2014,'978-2258116429'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ravage','Editions Gallimard',2014,'978-2072534911'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Lauriers de César','Educa Books',2008,'978-2012101500'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Niourk','French Pulp éditions',2018,'979-1025100639'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Meilleur des mondes','Plon',2013,'978-2259221702'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Berlin Alexanderplatz','Editions Gallimard',1933,'978-2070219292'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fahrenheit 451','Simon and Schuster',2011,'978-1439142677'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Mort d''Ivan Ilitch','Flammarion',2015,'978-2081364509'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Croisière sans escale','Editions Denoël',1990,'978-2207500293'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Vieil Homme et la Mer','Editions Gallimard',2018,'978-2072762093'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mrs Dalloway','Flammarion',2015,'978-2081358881'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Idiot','Les Editions de Londres',2019,'978-1911572909'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Carnet d''or','Le Livre de poche',1980,'978-2253025320'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Grandes Espérances','BoD - Books on Demand',2019,'978-2322185801'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et Cléopâtre','Dargaud',1999,'978-2012100060'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Madame Bovary','UPblisher',2016,'978-2759902293'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Frères Karamazov','Les éditions Pulsio',2016,'978-2371131118'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Moby Dick','Campfire Graphic Novels',2010,'978-8190732673'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Demain les chiens','J''ai Lu',2015,'978-2290112168'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Tour de Gaule d''Astérix','Educa Books',2007,'978-2012101685'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('1984','Houghton Mifflin Harcourt',1983,'978-0547249643'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Don Quichotte','Les éditions Pulsio',2016,'978-2371130418'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Château de Lord Valentin','Robert Laffont',2017,'978-2221216361'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Père Goriot','Primento',2012,'978-2806231697'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Procès','Flammarion',2014,'978-2081351981'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme qui rétrécit','Editions Gallimard',2017,'978-2072457340'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Chroniques martiennes','Editions Gallimard',2016,'978-2072455162'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Roi Lear','Éditions Actes Sud',2015,'978-2330052768'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Cadeau de César','Educa Books',2005,'978-2012101531'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Planète des singes','Julliard',2011,'978-2260019183'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Orgueil et Préjugés','Fleurus',2015,'978-2215130475'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Une maison de poupée','Éditions Actes Sud',2016,'978-2330068349'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Vermilion Sands','Carroll & Graf Pub',1988,'978-0881844221'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Grande Traversée','Seuil Jeunesse',2014,'979-1023500448'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Étranger','Editions Gallimard',2012,'978-2072376429'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Île des morts','POL Editeur',2010,'978-2846825573'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Par-delà le mur du sommeil','République des Lettres',2018,'978-2824904269'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Papyrus de César','Editions Albert René',2015,'978-2864972716'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Main de Zeï','Bragelonne Classic',2016,'978-2820511034'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Beloved','Christian Bourgois',2015,'978-2267028133'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Conscience de Zeno','République des Lettres',2015,'978-2824902371'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Delirium Circus','Bragelonne',2013,'978-2820508935'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Médée','Hatier',2013,'978-2218972324'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Nostromo','Oxford University Press',2009,'978-0199555918'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Au carrefour des étoiles','J''ai Lu',1997,'978-2277118473'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Vagabond','BnF collection ebooks',2016,'978-2346014453'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Buddenbrook','LGF/Le Livre de Poche',1993,'978-2253063193'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Métamorphoses','Le Livre de Poche',2011,'978-2253158677'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Jack Barron et l''Éternité','J''ai Lu',2016,'978-2290105504'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Hacker''s Delight','Addison-Wesley Professional',2003,'978-0201914658'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et les Normands','Dargaud',2005,'978-2012101418'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Temps incertain','Robert Laffont',2011,'978-2221119709'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix en Corse','Dargaud',2005,'978-2012101524'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Fils de la Médina','Arles [France] : Actes sud',2003,'978-2742744824'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Grand secret','Presses de la Cité',2014,'978-2258116405'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Devin','Educa Books',2010,'978-2012101517'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Noir Dessein','Livre de poche',1998,'978-2253062820'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix légionnaire','Educa Books',2011,'978-2012101784'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Romancero gitano','Greenbooks editore',2020,'978-8832957402'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('The Practice of Programming','Addison-Wesley Professional',1999,'978-0201615869'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Crime et Châtiment','Editions Humanis',2012,'979-1021900486'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Promenade au phare','LGF/Le Livre de Poche',1983,'978-2253031536'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme sans qualités','Contemporary French Fiction',2011,'978-2757803691'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Bruit et la Fureur','Gallimard Education',1972,'978-2070361625'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Plus qu''humains','adsaa',1999,'000-0000000162'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Main gauche de la nuit','Robert Laffont',2012,'978-2221128121'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mémoires d''Hadrien','Gallimard Education',1974,'978-2070369218'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Contes de l''absurde','Presses Pocket',1978,'978-2266006095'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et la Transitalique','Editions Albert René',2017,'978-2864973270'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Odyssée d''Astérix','Educa Books',2008,'978-2864972051'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Singes du temps','Robert Laffont',2011,'978-2221119693'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Contes de Canterbury','Gallimard Education',2000,'978-2070406340'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Sécheresse','La Cheminante',2014,'978-2371270060'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('The Art of Computer Programming','Addison-Wesley Professional',1997,'978-0321635747'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Aveuglement','Contemporary French Fiction',2000,'978-2020403436'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Berceau du chat','Contemporary French Fiction',2010,'978-2757820919'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Anna Karénine','Bibliothèque russe et slave',2018,'978-2371240087'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Montagne magique','Fayard',2016,'978-2213703848'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Domaine des dieux','French & European Publications',1992,'978-0785909903'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Cent ans de solitude','Contemporary French Fiction',1995,'978-2020238113'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Gargantua et Pantagruel','Livre de Poche Jeunesse',2009,'978-2013230827'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Contes','J''ai Lu',2015,'978-2290117965'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Guerre et Paix','Archipoche',2016,'978-2352879183'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Énéide','Belles Lettres',1993,'978-2251013039'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Seconde Fondation','adsaa',1979,'000-0000000097'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Jeux de l''esprit','FeniXX',1971,'978-2402281775'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Middlemarch','Wordsworth Editions',1994,'978-1853262371'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Œdipe roi','J''ai Lu',2013,'978-2290080207'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Amour aux temps du choléra','Grasset',2009,'978-2246819554'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fictions','Gallimard Education',1974,'978-2070366149'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Bretons','Dargaud',2002,'978-2012100084'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Château','Points',2011,'978-2757827413'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Voyageur imprudent','Editions Gallimard',2014,'978-2072535031'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Je suis une légende','Editions Gallimard',2013,'978-2072457388'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Maître du Haut Château','J''ai Lu',2017,'978-2290157268'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Âmes mortes','Bibliothèque russe et slave',2018,'978-2371240001'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Tambour','Contemporary French Fiction',1997,'978-2020314305'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Polymath','iMinds Pty Ltd',2014,'978-1921746864'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Seigneur de lumière','Editions Gallimard',2014,'978-2072487958'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ulysse','Nathan',2012,'978-2092532195'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Pedro Páramo','New York : Grove Press',1959,'000-0000000069'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ubik','Houghton Mifflin Harcourt',2012,'978-0547728247'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Algorithms','Addison-Wesley Professional',2011,'978-0132762564'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fifi Brindacier','Hachette Romans',2013,'978-2011179043'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le monde s''effondre','Editions Présence Africaine',1972,'978-2708701915'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Naissance des dieux','Glénat BD',2017,'978-2331035531'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Hamlet','Primento',2012,'978-2806240187'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Enfants de minuit','Gallimard Education',2010,'978-2070402632'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Dune','Penguin',2003,'978-1101658055'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Couleur tombée du ciel','Tiers Livre Éditeur',2014,'978-2814510012'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Éducation sentimentale','FeniXX',1990,'978-2402282697'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Obélix et Compagnie','Educa Books',2008,'978-2012101555'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Journal d''un fou','Bibebook',2013,'978-2824709420'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Hauts de Hurlevent','Le Livre de Poche',2012,'978-2253174561'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Plaie','FeniXX',1967,'978-2402255462'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Belges','Dargaud',1979,'978-2012101562'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Rouge et le Noir','Les Éditions de l''Ebook malin',1971,'978-2367881171'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('À la recherche du temps perdu','Books LLC, Wiki Series',2010,'978-1153611725'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La storia','Editions Gallimard',2004,'978-2070315017'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme total','Presses Universitaires de France - PUF',2011,'978-2130592150'); +INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mon livre','Buisson',2022,'0-2022'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (0,'Twain','Mark'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (1,'Asimov','Isaac'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (2,'Ōtomo','Katsuhiro'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (3,'Martelle','Myriam'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (4,'Touache','Sébastien'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (5,'Goscinny','René'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (6,'Ferri','Jean-Yves'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (7,'Uderzo','Albert'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (8,'Conrad','Didier'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (9,'SILVERBERG','Robert'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (10,'Swift','Jonathan'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (11,'Ligaran,',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (12,'Nabokov','Vladimir'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (13,'BARJAVEL','René'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (14,'Barjavel','René'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (15,'Wul','Stefan'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (16,'HUXLEY','Aldous'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (17,'Döblin','Alfred'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (18,'Bradbury','Ray'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (19,'Tolstoï','Léon'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (20,'Aldiss','Brian Wilson'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (21,'Hemingway','Ernest'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (22,'Woolf','Virginia'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (23,'Fiodor','Dostoïevski'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (24,'Lessing','Doris'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (25,'Dickens','Charles'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (26,'Flaubert','Gustave'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (27,'Dostoïevski','Fiodor'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (28,'Melville','Herman'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (29,'Simak','Clifford D.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (30,'Orwell','George'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (31,'Cervantes','Miguel de'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (32,'Balzac','Honoré de'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (33,'Kafka','Franz'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (34,'Matheson','Richard'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (35,'Py','Olivier'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (36,'Shakespeare','William'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (37,'BOULLE','Pierre'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (38,'Austen','Jane'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (39,'Ibsen','Henrik'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (40,'Ballard','J. G.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (41,'Demois','Agathe'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (42,'Godeau','Vincent'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (43,'Camus','Albert'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (44,'Frémon','Jean'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (45,'Lovecraft','H. P.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (46,'Camp','Lyon Sprague de'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (47,'Morrison','Toni'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (48,'Svevo','Italo'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (49,'Pelot','Pierre'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (50,'Corneille',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (51,'Faerber','Johan'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (52,'Conrad','Joseph'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (53,'Deutsch','Michel'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (54,'Maupassant','Guy de'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (55,'Mann','Thomas'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (56,'Ovide',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (57,'Spinrad','Norman'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (58,'Warren','Henry S.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (59,'JEURY','Michel'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (60,'Goscinny',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (61,'Maḥfūẓ','Naǧīb'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (62,'Farmer','Philip José'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (63,'Lorca','Federico Garcia'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (64,'Kernighan','Brian W.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (65,'Pike','Rob'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (66,'Dostoïevski','Fédor Mikhaïlovitch'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (67,'Musil','Robert'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (68,'Faulkner','William'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (69,'Fransa','France'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (70,'GUIN','Ursula LE'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (71,'Yourcenar','Marguerite'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (72,'Boulle','Pierre'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (73,'Gascony','Rene'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (74,'Chaucer','Geoffrey'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (75,'Chenet','Gérard'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (76,'Knuth','Donald E.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (77,'Saramago','José'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (78,'Vonnegut','Kurt'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (79,'Goscinny','Rene'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (80,'Márquez','Gabriel García'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (81,'Rabelais','François'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (82,'Laporte','Michel'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (83,'Nadel','Olivier-Marc'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (84,'Grimm','Jacob'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (85,'Grimm','Wilhelm'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (86,'Vergilius','Publius Maro'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (87,'Virgile',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (88,'Eliot','George'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (89,'Sophocle',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (90,'Márquez','Gabriel Garcia'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (91,'Borges','Jorge Luis'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (92,'Dick','Philip K.'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (93,'Gogol','Nikolaï'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (94,'Grass','Günter'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (95,'iMinds',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (96,'Zelazny','Roger'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (97,'Montardre','Hélène'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (98,'Rulfo','Juan'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (99,'Sedgewick','Robert'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (100,'Wayne','Kevin'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (101,'Lindgren','Astrid'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (102,'Achebe','Chinua'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (103,'Bruneau','Clotilde'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (104,'D.','Dim'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (105,'Santagati','Federico'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (106,'Ferry','Luc'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (107,'Poli','Didier'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (108,'Rushdie','Salman'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (109,'Herbert','Frank'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (110,'Lovecraft','Howard Phillips'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (111,'Rincé','Dominique'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (112,'Gogol','Nikolai'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (113,'Brontë','Emily'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (114,'Fall','Malick'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (115,'Stendhal',''); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (116,'Wikipedia','Source'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (117,'Morante','Elsa'); +INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (118,'Karsenti','Bruno'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (0,'978-2081509511'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (1,'978-2207249123'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (2,'978-2723428262'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (3,'978-2745989857'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (4,'978-2745989857'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2864972662'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864972662'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2864972662'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (8,'978-2864972662'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (9,'978-2221197691'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (10,'978-2335008586'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (11,'978-2335008586'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (12,'978-0141391601'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (13,'978-2258116429'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (14,'978-2072534911'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101500'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101500'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (15,'979-1025100639'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (16,'978-2259221702'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (17,'978-2070219292'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (18,'978-1439142677'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2081364509'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (20,'978-2207500293'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (21,'978-2072762093'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (22,'978-2081358881'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (23,'978-1911572909'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (24,'978-2253025320'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (25,'978-2322185801'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012100060'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012100060'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (26,'978-2759902293'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (27,'978-2371131118'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (28,'978-8190732673'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (29,'978-2290112168'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101685'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101685'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (30,'978-0547249643'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (31,'978-2371130418'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (9,'978-2221216361'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (32,'978-2806231697'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (33,'978-2081351981'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (34,'978-2072457340'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (18,'978-2072455162'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (35,'978-2330052768'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (36,'978-2330052768'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (37,'978-2260019183'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (38,'978-2215130475'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (39,'978-2330068349'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (40,'978-0881844221'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (41,'979-1023500448'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (42,'979-1023500448'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (43,'978-2072376429'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (44,'978-2846825573'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (45,'978-2824904269'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864972716'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (46,'978-2820511034'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (47,'978-2267028133'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (48,'978-2824902371'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (49,'978-2820508935'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (50,'978-2218972324'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (51,'978-2218972324'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (52,'978-0199555918'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (29,'978-2277118473'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (53,'978-2277118473'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (54,'978-2346014453'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (55,'978-2253063193'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (56,'978-2253158677'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (57,'978-2290105504'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (58,'978-0201914658'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101418'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101418'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (59,'978-2221119709'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (60,'978-2012101524'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101524'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (61,'978-2742744824'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (13,'978-2258116405'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101517'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101517'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (62,'978-2253062820'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101784'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101784'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (63,'978-8832957402'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (64,'978-0201615869'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (65,'978-0201615869'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (66,'979-1021900486'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (22,'978-2253031536'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (67,'978-2757803691'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (68,'978-2070361625'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (69,'000-0000000162'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (70,'978-2221128121'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (71,'978-2070369218'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (72,'978-2266006095'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864973270'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (73,'978-2864972051'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2864972051'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (59,'978-2221119693'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (74,'978-2070406340'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (75,'978-2371270060'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (76,'978-0321635747'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (77,'978-2020403436'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (78,'978-2757820919'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2371240087'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (55,'978-2213703848'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (79,'978-0785909903'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-0785909903'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (80,'978-2020238113'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (81,'978-2013230827'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (82,'978-2013230827'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (83,'978-2013230827'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (84,'978-2290117965'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (85,'978-2290117965'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2352879183'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (86,'978-2251013039'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (87,'978-2251013039'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (1,'000-0000000097'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (72,'978-2402281775'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (88,'978-1853262371'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (89,'978-2290080207'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (90,'978-2246819554'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (91,'978-2070366149'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012100084'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012100084'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (33,'978-2757827413'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (14,'978-2072535031'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (34,'978-2072457388'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (92,'978-2290157268'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (93,'978-2371240001'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (94,'978-2020314305'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (95,'978-1921746864'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (96,'978-2072487958'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (97,'978-2092532195'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (98,'000-0000000069'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (92,'978-0547728247'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (99,'978-0132762564'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (100,'978-0132762564'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (101,'978-2011179043'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (102,'978-2708701915'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (103,'978-2331035531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (104,'978-2331035531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (105,'978-2331035531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (106,'978-2331035531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (107,'978-2331035531'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (36,'978-2806240187'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (108,'978-2070402632'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (109,'978-1101658055'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (110,'978-2814510012'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (111,'978-2402282697'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101555'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101555'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (112,'978-2824709420'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (113,'978-2253174561'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (114,'978-2402255462'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101562'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101562'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (115,'978-2367881171'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (116,'978-1153611725'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (117,'978-2070315017'); +INSERT INTO "auteur_de" ("a_id","isbn") VALUES (118,'978-2130592150'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2081358881','2020-04-28'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2207249123','2020-04-28'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2824709420','2020-04-28'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2352879183','2020-02-20'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2335008586','2020-02-20'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2013230827','2020-02-20'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('533299198788609','978-2253174561','2020-02-28'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('533299198788609','978-2251013039','2020-02-28'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('917547585216771','978-2290105504','2020-04-07'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2864973270','2020-02-17'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2070406340','2020-02-17'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2806231697','2020-02-17'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('934701281931582','978-2260019183','2020-01-01'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('934701281931582','978-2371240087','2020-01-01'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2745989857','2020-02-18'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2072762093','2020-02-18'); +INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2742744824','2020-02-18'); +COMMIT; diff --git a/Partie2/Eleve/p_app_web_python_sqlite.pdf b/Partie2/Eleve/p_app_web_python_sqlite.pdf new file mode 100644 index 0000000..7262a18 Binary files /dev/null and b/Partie2/Eleve/p_app_web_python_sqlite.pdf differ diff --git a/Partie2/Eleve/run.py b/Partie2/Eleve/run.py new file mode 100644 index 0000000..40a2c3a --- /dev/null +++ b/Partie2/Eleve/run.py @@ -0,0 +1,5 @@ +from Projet import app + + +if __name__ == "__main__": + app.run() diff --git a/TDliste2liste/exercice1.py b/TDliste2liste/exercice1.py new file mode 100644 index 0000000..f0a9683 --- /dev/null +++ b/TDliste2liste/exercice1.py @@ -0,0 +1,11 @@ +def appartient(elt,tableau): + for i in tableau: + if i == elt: + return True + else: + continue + return False + +if __name__ == "__main__": + print(appartient(5,[1,2,3,4,5,6,7,8,9,10])) + print(appartient(5,[1,2,3,4,6,7,8,9,10])) diff --git a/TDliste2liste/exercice2.py b/TDliste2liste/exercice2.py new file mode 100644 index 0000000..2f7708e --- /dev/null +++ b/TDliste2liste/exercice2.py @@ -0,0 +1,21 @@ +def max_local(tableau): + maximum = tableau[0] + for i in tableau: + if i > maximum: + maximum = i + else: + continue + return maximum + +def indice_max(tableau): + maximum = max_local(tableau) + for i in range(len(tableau)): + if tableau[i] == maximum: + return i + else: + continue + +if __name__ == "__main__": + l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1] + print(max_local(l1)) + print(indice_max(l1)) diff --git a/TDliste2liste/exercice3.py b/TDliste2liste/exercice3.py new file mode 100644 index 0000000..7566bd1 --- /dev/null +++ b/TDliste2liste/exercice3.py @@ -0,0 +1,8 @@ +def cree_tableau_n_m(n,m): + return [[0 for _ in range(m)] for _ in range(n)] + +def cree_tableau_carre_n(n): + return [[0 for _ in range(n)] for _ in range(n)] +if __name__ == "__main__": + print(cree_tableau_n_m(3,5)) + print(cree_tableau_carre_n(5)) diff --git a/TDliste2liste/exercice4.py b/TDliste2liste/exercice4.py new file mode 100644 index 0000000..814150f --- /dev/null +++ b/TDliste2liste/exercice4.py @@ -0,0 +1,12 @@ +def cree_carre_entier_1_n_carre(n): + carre = [] + compteur = 1 + for i in range(n): + ligne = [] + for j in range(n): + ligne.append(compteur) + compteur += 1 + carre.append(ligne) + return carre +print(cree_carre_entier_1_n_carre(8)) + diff --git a/TDliste2liste/exercice5.py b/TDliste2liste/exercice5.py new file mode 100644 index 0000000..6471d60 --- /dev/null +++ b/TDliste2liste/exercice5.py @@ -0,0 +1,9 @@ +def transpose(carre): + n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée) + return [[carre[j][i] for j in range(n)] for i in range(n)] + +def transpose_en_place(carre): + n = len(carre) # Nombre de lignes (ou colonnes) + for i in range(n): + for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés + carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments diff --git a/TDliste2liste/exercice6.py b/TDliste2liste/exercice6.py new file mode 100644 index 0000000..7881f21 --- /dev/null +++ b/TDliste2liste/exercice6.py @@ -0,0 +1,9 @@ +def diag_1(carre): + return [carre[i][i] for i in range(len(carre))] + +def diag_2(carre): + n = len(carre) + return [carre[i][n - 1 - i] for i in range(n)] + +def colonne(j, carre): + return [carre[i][j] for i in range(len(carre))] diff --git a/TP6/LSC.py b/TP6/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/TP6/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/TP6/Pile_LSC.py b/TP6/Pile_LSC.py new file mode 100644 index 0000000..589706c --- /dev/null +++ b/TP6/Pile_LSC.py @@ -0,0 +1,17 @@ +import LSC as lsc +from typing import Any + +def creer_pile_vide() -> lsc.Liste_Simplement_Chainee: + return lsc.creer_liste_vide() + +def est_pile_vide(liste: lsc.Liste_Simplement_Chainee) -> bool: + return lsc.est_vide(liste) + +def sommet(liste: lsc.Liste_Simplement_Chainee) -> Any: + return lsc.tete(liste) + +def empiler(liste: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee: + return lsc.ajouter_en_tete(liste,element) + +def depiler(liste: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee: + return lsc.queue(liste) diff --git a/TP6/Pile_List.py b/TP6/Pile_List.py new file mode 100644 index 0000000..042a4f5 --- /dev/null +++ b/TP6/Pile_List.py @@ -0,0 +1,21 @@ +from typing import Any + + +def creer_pile_vide(): + return [] + + +def est_pile_vide(pile: list): + return len(pile) == 0 + + +def sommet(pile: list): + return pile[-1] + + +def empiler(pile: list, element: Any): + return pile + [element] + + +def depiler(pile: list): + return pile[:-1] diff --git a/TP6/Pile_Tuple.py b/TP6/Pile_Tuple.py new file mode 100644 index 0000000..120f904 --- /dev/null +++ b/TP6/Pile_Tuple.py @@ -0,0 +1,18 @@ +def creer_pile_vide(): + return () + + +def est_pile_vide(pile): + return pile == () + + +def sommet(pile): + return pile[-1] + + +def empiler(pile, elt): + return pile + [elt] + + +def depiler(pile): + return pile[:-1] diff --git a/TP6/TP_Piles.pdf b/TP6/TP_Piles.pdf new file mode 100644 index 0000000..6a5c849 Binary files /dev/null and b/TP6/TP_Piles.pdf differ diff --git a/TP6/test.py b/TP6/test.py new file mode 100644 index 0000000..6139a8f --- /dev/null +++ b/TP6/test.py @@ -0,0 +1,90 @@ +import Pile_LSC as lifo +import LSC as blsc +from random import shuffle + +def afficher(pile): + """Affiche les éléments d'une pile du sommet à la base.""" + print("|----") + while not lifo.est_pile_vide(pile): + print(f"| {lifo.sommet(pile)}") + pile = lifo.depiler(pile) + print("|----\n") + +def hauteur_pile(pile): + """Renvoie la hauteur de la pile sans la modifier.""" + copie = pile + n = 0 + while not lifo.est_pile_vide(copie): + copie = lifo.depiler(copie) + n += 1 + return n +def max_pile(pile: blsc.Liste_Simplement_Chainee, i: int): + """Trouve le maximum parmi les i premiers éléments de la pile.""" + total = hauteur_pile(pile) + #assert i > total (f"Taille insuffisante : attendu au moins {i} éléments") + meilleur = lifo.sommet(pile) # Premier élément comme point de départ + temporaire = pile + + for _ in range(i): + courant = lifo.sommet(temporaire) + temporaire = lifo.depiler(temporaire) + + if courant > meilleur: + meilleur = courant + + return meilleur +def retourner(pile, j): + """Inverse les j derniers éléments de la pile.""" + pile_aux = lifo.creer_pile_vide() + + # Depile les éléments dans une pile temporaire: + for _ in range(j): + pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile)) + pile = lifo.depiler(pile) + + # Remets les éléments inversés dans la pile principale: + while not lifo.est_pile_vide(pile_aux): + pile = lifo.empiler(pile, lifo.sommet(pile_aux)) + pile_aux = lifo.depiler(pile_aux) + + return pile + +def tri_crepes_recursif(pile, n=None): + """Trie la pile en utilisant le tri des crêpes de manière récursive.""" + if n is None: + n = hauteur_pile(pile) + # pas besoin de tri en si len(pile) == 1 + if n <= 1: + return pile + + pos_max = max_pile(pile, n) + + if pos_max != 1: + pile = retourner(pile, pos_max) + + pile = retourner(pile, n) + return tri_crepes_recursif(pile, n - 1) + +if __name__ == "__main__": + # Initialisation d'une pile avec des valeurs aléatoires + # Tri des crêpes récursif + ma_liste = [_ for _ in range(10)] + shuffle(ma_liste) + + print("Liste de départ : ", ma_liste) + + ma_pile = lifo.creer_pile_vide() + + print("\nEMPILEMENT\n") + + for element in ma_liste: + ma_pile = lifo.empiler(ma_pile, element) + afficher(ma_pile) + + print("\nDEPILEMENT\n") + + while not(lifo.est_pile_vide(ma_pile)): + print(f"Sommet : {lifo.sommet(ma_pile)}") + ma_pile = lifo.depiler(ma_pile) + afficher(ma_pile) + print(max_pile(ma_pile,1)) diff --git a/TP6/test.py.patch b/TP6/test.py.patch new file mode 100644 index 0000000..1f31b39 --- /dev/null +++ b/TP6/test.py.patch @@ -0,0 +1,34 @@ +# Patch generated by Pyment v0.3.3 + +--- a/test.py ++++ b/test.py +@@ -3,6 +3,14 @@ + + + def afficher(pile): ++ """ ++ ++ Args: ++ pile: ++ ++ Returns: ++ ++ """ + print("|----\n|") + while not (lifo.est_vide(pile)): + print("| {}\n|".format(lifo.sommet(pile))) +@@ -12,6 +20,14 @@ + + + def hauteur_pile(P): ++ """ ++ ++ Args: ++ P: ++ ++ Returns: ++ ++ """ + n = 0 + while not (lifo.est_vide(P)): + n += 1 diff --git a/TP6/test_2.py/Pile_List.rst b/TP6/test_2.py/Pile_List.rst new file mode 100644 index 0000000..f395726 --- /dev/null +++ b/TP6/test_2.py/Pile_List.rst @@ -0,0 +1,7 @@ +Pile\_List module +================= + +.. automodule:: Pile_List + :members: + :undoc-members: + :show-inheritance: diff --git a/TP6/test_2.py/Pile_Tuple.rst b/TP6/test_2.py/Pile_Tuple.rst new file mode 100644 index 0000000..de01687 --- /dev/null +++ b/TP6/test_2.py/Pile_Tuple.rst @@ -0,0 +1,7 @@ +Pile\_Tuple module +================== + +.. automodule:: Pile_Tuple + :members: + :undoc-members: + :show-inheritance: diff --git a/TP6/test_2.py/modules.rst b/TP6/test_2.py/modules.rst new file mode 100644 index 0000000..af68937 --- /dev/null +++ b/TP6/test_2.py/modules.rst @@ -0,0 +1,9 @@ +TP6 +=== + +.. toctree:: + :maxdepth: 4 + + Pile_List + Pile_Tuple + test diff --git a/TP6/test_2.py/test.rst b/TP6/test_2.py/test.rst new file mode 100644 index 0000000..206500f --- /dev/null +++ b/TP6/test_2.py/test.rst @@ -0,0 +1,7 @@ +test module +=========== + +.. automodule:: test + :members: + :undoc-members: + :show-inheritance: diff --git a/elouan_fare.tar.gz b/elouan_fare.tar.gz new file mode 100644 index 0000000..6a831ed Binary files /dev/null and b/elouan_fare.tar.gz differ diff --git a/elouan_fare/tp6/LSC.py b/elouan_fare/tp6/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/elouan_fare/tp6/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/elouan_fare/tp6/Pile_LSC.py b/elouan_fare/tp6/Pile_LSC.py new file mode 100644 index 0000000..5603678 --- /dev/null +++ b/elouan_fare/tp6/Pile_LSC.py @@ -0,0 +1,63 @@ +import LSC as lsc +from typing import Any + +def creer_pile_vide() -> lsc.Liste_Simplement_Chainee: + """Crée une pile vide sous forme de liste simplement chaînée. + + Returns: + lsc.Liste_Simplement_Chainee: Une pile vide représentée par une liste simplement chaînée. + """ + return lsc.creer_liste_vide() + +def est_pile_vide(pile: lsc.Liste_Simplement_Chainee) -> bool: + """Vérifie si la pile est vide. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return lsc.est_vide(pile) + +def sommet(pile: lsc.Liste_Simplement_Chainee) -> Any: + """Renvoie l'élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile dont on veut connaître le sommet. + + Returns: + Any: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide." + return lsc.tete(pile) + +def empiler(pile: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee: + """Ajoute un élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile actuelle. + element (Any): L'élément à ajouter au sommet de la pile. + + Returns: + lsc.Liste_Simplement_Chainee: La nouvelle pile avec l'élément ajouté. + """ + return lsc.ajouter_en_tete(pile, element) + +def depiler(pile: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee: + """Retire l'élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile dont on veut retirer le sommet. + + Returns: + lsc.Liste_Simplement_Chainee: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return lsc.queue(pile) diff --git a/elouan_fare/tp6/Pile_List.py b/elouan_fare/tp6/Pile_List.py new file mode 100644 index 0000000..21a1ab6 --- /dev/null +++ b/elouan_fare/tp6/Pile_List.py @@ -0,0 +1,62 @@ +from typing import Any + +def creer_pile_vide() -> list: + """Crée une pile vide sous forme de liste. + + Returns: + list: Une pile vide représentée par une liste. + """ + return [] + +def est_pile_vide(pile: list) -> bool: + """Vérifie si la pile est vide. + + Args: + pile (list): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return len(pile) == 0 + +def sommet(pile: list) -> Any: + """Renvoie l'élément au sommet de la pile. + + Args: + pile (list): La pile dont on veut connaître le sommet. + + Returns: + Any: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[-1] + +def empiler(pile: list, element: Any) -> list: + """Ajoute un élément au sommet de la pile. + + Args: + pile (list): La pile actuelle. + element (Any): L'élément à ajouter au sommet de la pile. + + Returns: + list: La nouvelle pile avec l'élément ajouté. + """ + return pile + [element] + +def depiler(pile: list) -> list: + """Retire l'élément au sommet de la pile. + + Args: + pile (list): La pile dont on veut retirer le sommet. + + Returns: + list: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[:-1] diff --git a/elouan_fare/tp6/Pile_Tuple.py b/elouan_fare/tp6/Pile_Tuple.py new file mode 100644 index 0000000..5781a66 --- /dev/null +++ b/elouan_fare/tp6/Pile_Tuple.py @@ -0,0 +1,60 @@ +def creer_pile_vide(): + """Crée une pile vide sous forme de tuple. + + Returns: + tuple: Une pile vide représentée par un tuple vide. + """ + return () + +def est_pile_vide(pile): + """Vérifie si la pile est vide. + + Args: + pile (tuple): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return pile == () + +def sommet(pile): + """Renvoie l'élément au sommet de la pile. + + Args: + pile (tuple): La pile dont on veut connaître le sommet. + + Returns: + _type_: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[-1] + +def empiler(pile, elt): + """Ajoute un élément au sommet de la pile. + + Args: + pile (tuple): La pile actuelle. + elt (_type_): L'élément à ajouter au sommet de la pile. + + Returns: + tuple: La nouvelle pile avec l'élément ajouté. + """ + return pile + (elt,) + +def depiler(pile): + """Retire l'élément au sommet de la pile. + + Args: + pile (tuple): La pile dont on veut retirer le sommet. + + Returns: + tuple: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[:-1] diff --git a/elouan_fare/tp6/README.md b/elouan_fare/tp6/README.md new file mode 100644 index 0000000..2192cf2 --- /dev/null +++ b/elouan_fare/tp6/README.md @@ -0,0 +1,69 @@ +# Devoir Maison : Gestion de Piles et Notation Polonaise Inverse + +Ce devoir présente des fonctions pour manipuler des piles et évaluer des expressions en notation polonaise inverse (NPI). + +## Prérequis + +Pour exécuter ce devoir, vous aurez besoin de : + +- [Python 3.x](https://www.python.org/downloads/) installé sur votre machine. + +### Installation de Python + +1. **Téléchargez Python** : Allez sur le [site officiel de Python](https://www.python.org/downloads/) et téléchargez la dernière version stable pour votre système d'exploitation. + +2. **Installez Python** : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add Python to PATH" lors de l'installation sur Windows. + +3. **Vérifiez l'installation** : Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante : + ```bash + python --version + ``` + Cela devrait afficher la version de Python installée. + +## Utilisation des Modules + +### Modules Fournis + +Le devoir contient les modules suivants : + +- `LSC` : Implémentation d'une liste simplement chaînée. +- `Pile_LSC` : Implémentation d'une pile utilisant une liste simplement chaînée. +- `Tuple` : Implémentation d'une pile utilisant un tuple. +- `Liste` : Implémentation d'une pile utilisant une liste. + +#### Primitives du Module `LSC` + +- `creer_liste_vide()`: Crée une liste vide. +- `est_vide(liste)`: Vérifie si la liste est vide. +- `ajouter_en_tete(liste, element)`: Ajoute un élément au début de la liste. +- `queue(liste)`: Retire le premier élément de la liste. +- `tete(liste)`: Renvoie le premier élément de la liste. + +#### Primitives du Module `Pile_LSC` + +- `creer_pile_vide()`: Crée une pile vide sous forme de liste simplement chaînée. +- `est_pile_vide(pile)`: Vérifie si la pile est vide. +- `sommet(pile)`: Renvoie l'élément au sommet de la pile. +- `empiler(pile, element)`: Ajoute un élément au sommet de la pile. +- `depiler(pile)`: Retire l'élément au sommet de la pile. + +## Fichier `test.py` + +Le fichier `test.py` contient des exemples d'utilisation des fonctionnalités de gestion de piles et d'évaluation en notation polonaise inverse. + +### Fonctions dans `test.py` + +- **Afficher une pile** : Affiche les éléments d'une pile du sommet à la base. +- **Copier une pile** : Crée une copie d'une pile donnée. +- **Hauteur de la pile** : Renvoie la hauteur de la pile. +- **Inverser des éléments** : Inverse les `j` derniers éléments de la pile. +- **Trouver le maximum** : Renvoie la position du maximum parmi les `i` derniers éléments de la pile. +- **Tri des crêpes** : Trie les éléments de la pile en utilisant la méthode des crêpes. +- **Évaluation NPI** : Évalue une expression arithmétique en notation polonaise inverse. + +### Exécution de `test.py` + +Pour exécuter le script, ouvrez votre terminal, naviguez vers le dossier contenant le fichier `test.py`, puis exécutez la commande suivante : + +```bash +python test.py diff --git a/elouan_fare/tp6/TP_Piles.pdf b/elouan_fare/tp6/TP_Piles.pdf new file mode 100644 index 0000000..6a5c849 Binary files /dev/null and b/elouan_fare/tp6/TP_Piles.pdf differ diff --git a/elouan_fare/tp6/npi.py b/elouan_fare/tp6/npi.py new file mode 100644 index 0000000..9b4edd0 --- /dev/null +++ b/elouan_fare/tp6/npi.py @@ -0,0 +1,46 @@ +def evaluer_npi(expression): + """fais la notation polonaise inversée (NPI) d'une expression arithmétique + Args: + expression (_type_): String contenant l'expression arithmétique + + Returns: + _type_: Integer contenant le resultat. + """ + + pile = [] + + + elements = expression.split() + + for element in elements: + if element.isdigit(): + pile.append(int(element)) + else: + + droite = pile.pop() + gauche = pile.pop() + + if element == '+': + resultat = gauche + droite + elif element == '-': + resultat = gauche - droite + elif element == '*': + resultat = gauche * droite + elif element == '/': + resultat = gauche / droite + else: + raise ValueError(f"Opérateur inconnu: {element}") + + + pile.append(resultat) + + + if len(pile) != 1: + raise ValueError("L'expression est mal formée.") + + return pile.pop() + + +expression = "100 60 / 60 + 90 *" +resultat = evaluer_npi(expression) +print(f"Le résultat de l'expression '{expression}' est: {resultat}") diff --git a/elouan_fare/tp6/test.py b/elouan_fare/tp6/test.py new file mode 100644 index 0000000..a2b1b36 --- /dev/null +++ b/elouan_fare/tp6/test.py @@ -0,0 +1,125 @@ +import Pile_LSC as lifo +from random import shuffle + +def afficher(pile): + """Affiche les éléments d'une pile du sommet à la base.""" + print("|----") + temp = pile + while not lifo.est_pile_vide(temp): + print(f"| {lifo.sommet(temp)}") + temp = lifo.depiler(temp) + print("|----\n") + +def copier_pile(pile): + """Copie une pile représentée par une liste simplement chaînée.""" + copie = lifo.creer_pile_vide() + pile_temp = lifo.creer_pile_vide() + + while not lifo.est_pile_vide(pile): + sommet = lifo.sommet(pile) + pile_temp = lifo.empiler(pile_temp, sommet) + pile = lifo.depiler(pile) + + while not lifo.est_pile_vide(pile_temp): + sommet = lifo.sommet(pile_temp) + pile = lifo.empiler(pile, sommet) + copie = lifo.empiler(copie, sommet) + pile_temp = lifo.depiler(pile_temp) + + return copie + +def hauteur_pile(pile): + """ + Renvoie hauteur de la pile. + PARAMETRES : pile - pile à analyser. + RETURN : hauteur. + EFFET DE BORD : Aucune. + """ + n = 0 + while not lifo.est_pile_vide(pile): + n += 1 + pile = lifo.depiler(pile) + return n + +def retourner(pile, j): + """ + Inverse j derniers éléments de la pile. + PARAMETRES : pile - pile à modifier, j - nombre d'éléments à inverser. + RETURN : Aucune. + EFFET DE BORD : Modifie la pile. + """ + pile_aux = lifo.creer_pile_vide() + + for _ in range(j): + if lifo.est_pile_vide(pile): + break + pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile)) + pile = lifo.depiler(pile) + + while not lifo.est_pile_vide(pile_aux): + pile = lifo.empiler(pile, lifo.sommet(pile_aux)) + pile_aux = lifo.depiler(pile_aux) + +def max_pile(pile, i): + """ + Renvoie position du maximum parmi i derniers éléments. + PARAMETRES : pile - pile à analyser, i - nombre d'éléments. + RETURN : position du maximum. + EFFET DE BORD : Aucune. + """ + + copy = copier_pile(pile) + max_value = lifo.sommet(copy) + ind = 1 + ind_n = 1 + + for _ in range(i): + if lifo.est_pile_vide(copy): + break + current = lifo.sommet(copy) + if current > max_value: + max_value = current + ind = ind_n + copy = lifo.depiler(copy) + ind_n += 1 + + return ind + + +def tri_crepes_iteratif(pile): #ne fonctionne pas + """ + Tri des crêpes en cours. + PARAMETRES : pile - pile à trier. + RETURN : pile triée. + EFFET DE BORD : Modifie la pile. + """ + + n = hauteur_pile(pile) + for i in range(n): + max_position = max_pile(pile, n - i) + if max_position!= n - i: + retourner(pile, n - max_position) + retourner(pile, i + 1) + + return pile + + +if __name__ == "__main__": + from random import shuffle + + ma_liste = [i for i in range(10)] + shuffle(ma_liste) + + print("Liste de départ :", ma_liste) + + ma_pile = lifo.creer_pile_vide() + for element in ma_liste: + ma_pile = lifo.empiler(ma_pile, element) + + print("\nPile initiale :") + afficher(ma_pile) + print(max_pile(ma_pile,10)) + print("Tri des crêpes en cours...") + ma_pile = tri_crepes_iteratif(ma_pile) + print("Pile après tri :") + afficher(ma_pile) \ No newline at end of file diff --git a/elouan_fare_v1.1.tar.gz b/elouan_fare_v1.1.tar.gz new file mode 100644 index 0000000..f5e0585 Binary files /dev/null and b/elouan_fare_v1.1.tar.gz differ diff --git a/elouan_fare_v1.1.tart.gz b/elouan_fare_v1.1.tart.gz new file mode 100644 index 0000000..f5e0585 Binary files /dev/null and b/elouan_fare_v1.1.tart.gz differ diff --git a/elouan_fare_v2.tar.gz b/elouan_fare_v2.tar.gz new file mode 100644 index 0000000..f5e0585 Binary files /dev/null and b/elouan_fare_v2.tar.gz differ diff --git a/elouan_fare_v2/tp6_self/LSC.py b/elouan_fare_v2/tp6_self/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/elouan_fare_v2/tp6_self/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/elouan_fare_v2/tp6_self/Pile_LSC.py b/elouan_fare_v2/tp6_self/Pile_LSC.py new file mode 100644 index 0000000..90b814f --- /dev/null +++ b/elouan_fare_v2/tp6_self/Pile_LSC.py @@ -0,0 +1,55 @@ +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) diff --git a/elouan_fare_v2/tp6_self/Pile_List.py b/elouan_fare_v2/tp6_self/Pile_List.py new file mode 100644 index 0000000..1edac49 --- /dev/null +++ b/elouan_fare_v2/tp6_self/Pile_List.py @@ -0,0 +1,54 @@ +# 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] \ No newline at end of file diff --git a/elouan_fare_v2/tp6_self/Pile_Tuple.py b/elouan_fare_v2/tp6_self/Pile_Tuple.py new file mode 100644 index 0000000..447dd07 --- /dev/null +++ b/elouan_fare_v2/tp6_self/Pile_Tuple.py @@ -0,0 +1,54 @@ +# 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] \ No newline at end of file diff --git a/elouan_fare_v2/tp6_self/README.md b/elouan_fare_v2/tp6_self/README.md new file mode 100644 index 0000000..86868a7 --- /dev/null +++ b/elouan_fare_v2/tp6_self/README.md @@ -0,0 +1,133 @@ + +# **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) + ``` +
+ +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 \ No newline at end of file diff --git a/elouan_fare_v2/tp6_self/npi.py b/elouan_fare_v2/tp6_self/npi.py new file mode 100644 index 0000000..0005927 --- /dev/null +++ b/elouan_fare_v2/tp6_self/npi.py @@ -0,0 +1,44 @@ +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)) diff --git a/elouan_fare_v2/tp6_self/test.py b/elouan_fare_v2/tp6_self/test.py new file mode 100644 index 0000000..86158cc --- /dev/null +++ b/elouan_fare_v2/tp6_self/test.py @@ -0,0 +1,160 @@ +#!/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) diff --git a/ensembles_dynamiques/TP/_collection.py b/ensembles_dynamiques/TP/_collection.py new file mode 100644 index 0000000..772e807 --- /dev/null +++ b/ensembles_dynamiques/TP/_collection.py @@ -0,0 +1,185 @@ +#!/usr/bin/python3 +# -*- coding: utf8 -*- + +################################# +# +# _COLLECTION.PY +# -------------- +# +# Module du type ensemble +# +################################# + +# Un ensemble est une collection d'éléments, d'occurence unique. +# Les fonctions sont implémentées dans le paradigme fonctionnel. + +def initialiser_ensemble(): + """ + Construit un ensemble vide. + + Paramètre : + - aucun + + Résultat : + - ENSEMBLE vide + + Pré-condition : + - aucune + + Effet de bord + - aucune + """ + return set() + +def est_ensemble_vide(ensemble): + """ + Teste si l'ensemble est vide. + + Paramètre : + - ensemble : ENSEMBLE, l'ensemble à tester + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return len(ensemble) == 0 + +def copier_ensemble(ensemble): + """ + Construit la copie d'un ensemble. + + Paramètre : + - ensemble : ENSEMBLE, la source + + Résultat : + - ENSEMBLE : une copie de la source + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + resultat = initialiser_ensemble() + for _ in ensemble: + resultat.add(_) + return resultat + +def ajouter(ensemble, element): + """ + Ajoute un element à la copie d'un ensemble + + Paramètres : + - ensemble : ENSEMBLE, l'ensemble à abonder + - element : ANY, l'élément à ajouter + + Résultat : + - ENSEMBLE, l'ensemble abondé + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + resultat = copier_ensemble(ensemble) + resultat.add(element) + return resultat + +def supprimer(ensemble, element): + """ + Construire une copie de l'ensemble privé d'un élément. + Si l'élément à supprimer n'est pas dans l'ensemble initial, + alors une copie intégrale est renvoyée. + + Paramètres : + - ensemble ; ENSEMBLE, la collection à amender + - element : ANY, l'élément à supprimer + + Résultat : + - ENSEMBLE, la copie amendée de l'ensemble + """ + resultat = initialiser_ensemble() + for _ in ensemble: + if not(_ == element): + resultat = ajouter(resultat, _) + return resultat + +def rechercher(ensemble, cle, critere = lambda x, y: x==y): + """ + Construit la sous-collection constituée des éléments d'un ensemble + dont la clé satisfait un critère donné. + + Paramètres : + - ensemble : ENSEMBLE, la collection à explorer + - cle : ANY, la clé à rechercher + - critere : FUNCTION ou LAMBDA, test utilisé pour la recherche + + Résultat : + - ENSEMBLE, la collection extraite des éléments satisfaisant le test + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + resultat = initialiser_ensemble() + for _ in ensemble: + if critere(_, cle): + resultat = ajouter(resultat, _) + return resultat + +def supprimer_critere(ensemble, cle, critere): + """ + Construit la collection des éléments d'un ensemble, + dont la clé satisfait le critère donné. + + Paramètres : + - ensemble : ENSEMBLE, la collection source + - cle : ANY, la clé à employer pour la suppression + - critere : FUNCTION ou LAMBDA, critère de sélection + + Résultat : + - ENSEMBLE : la copie de l'ensemble amendée + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + resultat = copier_ensemble(ensemble) + elements = rechercher(ensemble, cle, critere) + for _ in elements: + resultat = supprimer(resultat, _) + return resultat + +def lister(ensemble, affichage=print): + """ + Afficher le contenu d'un ensemble, + en formattant chaque élément selon la fonction d'affichage fournie. + + Paramètres : + - ensemble : ENSEMBLE, la collection à énumérer + - affichage : FUNCTION, la fonction à appliquer à chaque élément. + + Résultat : + - None : NONETYPE + + Pré-condition : + - aucune + + Effet de bord : + - Affichage sur la sortie standard + """ + for element in ensemble: + affichage(element) + return None + + + +if __name__ == "__main__": + pass diff --git a/ensembles_dynamiques/TP/_collection_list.py b/ensembles_dynamiques/TP/_collection_list.py new file mode 100644 index 0000000..a14dffc --- /dev/null +++ b/ensembles_dynamiques/TP/_collection_list.py @@ -0,0 +1,167 @@ +#!/usr/bin/python3 +# -*- coding: utf8 -*- + +################################# +# +# _COLLECTION_LIST.PY +# ------------------- +# +# Module du type ensemble +# implémenté sur les listes +################################# + +# Un ensemble est une collection d'éléments, d'occurence unique. +# Les fonctions sont implémentées dans le paradigme fonctionnel. + +def initialiser_ensemble(): + """ + Construit un ensemble vide. + + Paramètre : + - aucun + + Résultat : + - ENSEMBLE vide + + Pré-condition : + - aucune + + Effet de bord : + - aucune + """ + return list() + +def est_ensemble_vide(ensemble): + """ + Teste si l'ensemble est vide. + + Paramètre : + - ensemble : LIST, l'ensemble à tester + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return len(ensemble) == 0 + +def copier_ensemble(ensemble): + """ + Construit la copie d'un ensemble. + + Paramètre : + - ensemble : LIST, la source + + Résultat : + - LIST : une copie de la source + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return ensemble[:] + +def ajouter(ensemble, element): + """ + Ajoute un element à la copie d'un ensemble + + Paramètres : + - ensemble : LIST, l'ensemble à abonder + - element : ANY, l'élément à ajouter + + Résultat : + - LIST, l'ensemble abondé + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + copie = ensemble.copy() + copie.append(element) + return copie + +def supprimer(ensemble, element): + """ + Construire une copie de l'ensemble privé d'un élément. + Si l'élément à supprimer n'est pas dans l'ensemble initial, + alors une copie intégrale est renvoyée. + + Paramètres : + - ensemble ; LIST, la collection à amender + - element : ANY, l'élément à supprimer + + Résultat : + - LIST, la copie amendée de l'ensemble + """ + resultat = ensemble[:] + return resultat.remove(element) + +def rechercher(ensemble, cle, critere = lambda x, y: x==y): + """ + Construit la sous-collection constituée des éléments d'un ensemble + dont la clé satisfait un critère donné. + + Paramètres : + - ensemble : LIST, la collection à explorer + - cle : ANY, la clé à rechercher + - critere : FUNCTION ou LAMBDA, test utilisé pour la recherche + + Résultat : + - LIST, la collection extraite des éléments satisfaisant le test + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return [element for element in ensemble if critere(element, cle)] + +def supprimer_critere(ensemble, cle, critere): + """ + Construit la collection des éléments d'un ensemble, + dont la clé satisfait le critère donné. + + Paramètres : + - ensemble : LIST, la collection source + - cle : ANY, la clé à employer pour la suppression + - critere : FUNCTION ou LAMBDA, critère de sélection + + Résultat : + - LIST : la copie de l'ensemble amendée + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return [element for element in ensemble if not critere(element,cle)] + +def lister(ensemble, affichage=print): + """ + Afficher le contenu d'un ensemble, + en formattant chaque élément selon la fonction d'affichage fournie. + + Paramètres : + - ensemble : LIST, la collection à énumérer + - affichage : FUNCTION, la fonction à appliquer à chaque élément. + + Résultat : + - None : NONETYPE + + Pré-condition : + - aucune + + Effet de bord : + - Affichage sur la sortie standard + """ + for item in ensemble: + affichage(item) +if __name__ == "__main__": + pass diff --git a/ensembles_dynamiques/TP/_sommets.py b/ensembles_dynamiques/TP/_sommets.py new file mode 100644 index 0000000..5ab3cee --- /dev/null +++ b/ensembles_dynamiques/TP/_sommets.py @@ -0,0 +1,175 @@ +#!/usr/bin/python3 +# -*- coding: utf8 -*- + +################################### +# +# _SOMMETS.PY +# ----------- +# +# Module de traitement des Sommets +# +################################### + +# Un sommet est un tuple (nom, altitude, massif) +# - nom : STR +# - altitude : INT, altitude en m +# - massif : STR + +def creer_sommet(nom, altitude, massif): + """ + Construit le tuple sommet. + + Paramètres : + - nom : STR, le nom du sommet + - altitude : INT, l'altitude en m + - massif : STR, le massif contenant le sommet + + Résultat : + - TUPLE, le sommet + + Pré-condition : + - aucune (programmation défensive à envisager) + + Effet de bord : + - aucun + """ + return (nom, altitude, massif) + +def altitude_en_m(altitude): + """ + Conversion de l'altitude en entier ("2 062 m" -> 2062) + + Paramètre : + - altitude : STR, chaîne du type "2 062 m", avec espaces et 'm' + + Résultat : + - INT, l'altitude en m + + Pré-condition : + - aucune (prog def à envisager) + + Effet de bord : + - aucun + """ + tmp = '' + for symbole in altitude: + if not(symbole in ' m'): + tmp += symbole + return int(tmp) + +def creer_sommet_csv(ligne, massif): + """ + Construit un sommet à partir d'une ligne du fichier csv. + + Paramètres : + - ligne : STR, ligne du fichier csv + - massif : STR, basename du fichier contenant la ligne + + Résultat : + - TUPLE, le sommet correspondant + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + nom, alt = ligne.rstrip().split(',') + return creer_sommet(nom, altitude_en_m(alt), massif) + +def afficher(sommet): + """ + Affichage formatté du sommet. + + Paramètres : + - sommet : TUPLE, le sommet à afficher + + Résultat : + - NONETYPE, None + + Pré-condition : + - aucune + + Effet de bord : + - Affichage sur la sortie standard + """ + nom, altitude, massif = sommet + print(f'{nom:35s}\t[{massif}]\n\taltitude : {altitude} m') + return None + +def nom(sommet): + """ + Consulte le nom d'un sommet + + Paramètre : + - sommet : TUPLE + + Résultat : + - STR, le nom du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet[0] + +def altitude(sommet): + """ + Consulte l'altitude d'un sommet + + Paramètre : + - sommet : TUPLE + + Résultat : + - INT : l'altitude du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet[1] + +def massif(sommet): + """ + Consulte le massif d'un sommet + + Paramètre : + - sommet : TUPLE + + Résultat : + - STR, le massif du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet[2] + +def coincide_nom(sommet, motif): + """ + Compare le nom du sommet au motif + + Paramètres : + - sommet : TUPLE, le sommet à tester + - motif : STR, le motif à identifier + + Résultat : + - BOOL : Vrai ssi le nom du sommet correspond au motif + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + nom_sommet = nom(sommet) + return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif) + +if __name__ == '__main__': + pass diff --git a/ensembles_dynamiques/TP/_sommets_dict.py b/ensembles_dynamiques/TP/_sommets_dict.py new file mode 100644 index 0000000..5c27225 --- /dev/null +++ b/ensembles_dynamiques/TP/_sommets_dict.py @@ -0,0 +1,180 @@ +#!/usr/bin/python3 +# -*- coding: utf8 -*- + +############################ +# +# _SOMMETS_DICT.PY +# ---------------- +# +# Module des sommets +# implémentés par des dict +############################ + +# Un sommet est un dictionnaire +# dont les clés sont 'nom', 'altitude' et 'massif' +# - nom : STR +# - altitude : INT, altitude en m +# - massif : STR + +def creer_sommet(nom, altitude, massif): + """ + Construit le dico sommet. + + Paramètres : + - nom : STR, le nom du sommet + - altitude : INT, l'altitude en m + - massif : STR, le massif contenant le sommet + + Résultat : + - DICT, le sommet + + Pré-condition : + - aucune (programmation défensive à envisager) + + Effet de bord : + - aucun + """ + sommet = { + "Nom": nom, + "Altitude": altitude, + "Massif": massif + } + + return sommet + +def altitude_en_m(altitude): + """ + Conversion de l'altitude en entier ("2 062 m" -> 2062) + + Paramètre : + - altitude : STR, chaîne du type "2 062 m", avec espaces et 'm' + + Résultat : + - INT, l'altitude en m + + Pré-condition : + - aucune (prog def à envisager) + + Effet de bord : + - aucun + """ + tmp = '' + for symbole in altitude: + if not(symbole in ' m'): + tmp += symbole + return int(tmp) + +def creer_sommet_csv(ligne, massif): + """ + Construit un sommet à partir d'une ligne du fichier csv. + + Paramètres : + - ligne : STR, ligne du fichier csv + - massif : STR, basename du fichier contenant la ligne + + Résultat : + - DICT, le sommet correspondant + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + nom, alt = ligne.rstrip().split(',') + return creer_sommet(nom, altitude_en_m(alt), massif) + +def afficher(sommet): + """ + Affichage formatté du sommet. + + Paramètres : + - sommet : TUPLE, le sommet à afficher + + Résultat : + - NONETYPE, None + + Pré-condition : + - aucune + + Effet de bord : + - Affichage sur la sortie standard + """ + + print(f"{sommet['Nom']:35s}\t[{sommet['Massif']}]\n\taltitude : {sommet['Altitude']} m") + + +def nom(sommet): + """ + Consulte le nom d'un sommet + + Paramètre : + - sommet : DICT + + Résultat : + - STR, le nom du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet["Nom"] +def altitude(sommet): + """ + Consulte l'altitude d'un sommet + + Paramètre : + - sommet : DICT + + Résultat : + - INT : l'altitude du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet['Altitude'] +def massif(sommet): + """ + Consulte le massif d'un sommet + + Paramètre : + - sommet : DICT + + Résultat : + - STR, le massif du sommet + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return sommet["Massif"] +def coincide_nom(sommet, motif): + """ + Compare le nom du sommet au motif + + Paramètres : + - sommet : TUPLE, le sommet à tester + - motif : STR, le motif à identifier + + Résultat : + - BOOL : Vrai ssi le nom du sommet correspond au motif + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + + nom_sommet = nom(sommet) + return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif) + +if __name__ == '__main__': + pass diff --git a/ensembles_dynamiques/TP/data/Chartreuse.csv b/ensembles_dynamiques/TP/data/Chartreuse.csv new file mode 100644 index 0000000..eb6f049 --- /dev/null +++ b/ensembles_dynamiques/TP/data/Chartreuse.csv @@ -0,0 +1,29 @@ +Grande Sure (La), 1 920 m +Rocher de Lorzier (Le), 1 838 m +Rochers de Chalves (Les), 1 845 m +Rocher de l'Église (Le), 1 300 m +Pointe de la Gorgeat (La), 1 486 m +Mont Joigny (Le), 1 556 m +Mont Outheran (Le), 1 673 m +Cochette (La), 1 618 m +Roc de Gleisin (Le), 1 434 m +Roche Veyrand (La), 1 429 m +Dent de l'Ours (La), 1 820 m +Petit Som (Le), 1 772 m +Grand Som (Le), 2 026 m +Charmant Som (Le), 1 867 m +Pinéa (La), 1 771 m +Néron (Le), 1 299 m +Mont Granier (Le), 1 933 m +Sommet du Pinet (Le) ou le Truc, 1 867 m +Grand Manti (Le), 1 818 m +Scia (La), 1 791 m +Lances de Malissard (Les), 2 045 m +Dôme de Bellefont (Le), 1 975 m +Dent de Crolles (La), 2 062 m +Piton de Bellefont (Le), 1 958 m +Chamechaude, 2 082 m +Grands Crêts (Les), 1 489 m +Mont Saint-Eynard (Le), 1 379 m +Écoutoux (L'), 1 406 m +Rachais (Le), 1 050 m diff --git a/ensembles_dynamiques/TP/main.py b/ensembles_dynamiques/TP/main.py new file mode 100644 index 0000000..b09b2b7 --- /dev/null +++ b/ensembles_dynamiques/TP/main.py @@ -0,0 +1,67 @@ +#!/usr/bin/python3 +# -*- coding: utf8 -*- + +####################################### +# +# MAIN.PY +# ------- +# +# Interface principale +# +####################################### + +import _collection_list as col +import _sommets as som + +# Le module _collection définit nos ENSEMBLES +# Le module _sommets définit nos SOMMETS + +def file_2_set(fichier='./data/Chartreuse.csv'): + """ + Lecture du fichier csv contenant les caractéristiques des sommets. + + Paramètres : + - fichier : STR, le nom complet du fichier csv à parcourir + + Résultat : + - resultat : ENSEMBLE, la collection des sommets + + Pré-conditions : + - aucune + + Effets de bord : + - aucun + """ + massif = fichier[7:-4] + resultat = col.initialiser_ensemble() + with open(fichier) as src: + ligne = src.readline() + while ligne: + resultat = col.ajouter(resultat, som.creer_sommet_csv(ligne, massif)) + ligne = src.readline() + return resultat + +def rechercher(ensemble, motif): + """ + Recherche les sommets de la collection dont le nom + correspond à un motif donné. + + Paramètres : + - ensemble : ENSEMBLE, la collection des somets + - motif : STR, la chaîne de caractères à identifier + + Résultat : + - ENSEMBLE, la sous-collection des sommets satisfaisant au critère + + Pré-condition : + - aucune + + Effet de bord : + - aucun + """ + return col.rechercher(ensemble, motif, som.coincide_nom) + + +if __name__ == '__main__': + col.lister(col.supprimer_critere(file_2_set(), 'Grand', som.coincide_nom), \ + som.afficher) diff --git a/file/LSC.py b/file/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/file/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/file/file.py b/file/file.py new file mode 100644 index 0000000..20e20b8 --- /dev/null +++ b/file/file.py @@ -0,0 +1,58 @@ +def creer_file_vide(): + """ + Crée une nouvelle file vide. + + Returns: + list: Une liste vide représentant la file. + """ + return [] + +def est_vide(file): + """ + Vérifie si une file est vide. + + Args: + file (list): La file à vérifier. + + Returns: + bool: `True` si la file est vide, `False` sinon. + """ + return len(file) == 0 + +def enfiler(file, elt): + """ + Ajoute un élément à la fin de la file. + + Args: + file (list): La file à laquelle ajouter l'élément. + elt: L'élément à ajouter. + + Returns: + None + """ + return file.append(elt) + +def defiler(file: list): + """ + Retire et renvoie le premier élément de la file. + + Args: + file (list): La file dont l'élément de tête doit être retiré. + + Returns: + list: La file sans le premier élément. + """ + return file[1:] + +def peak(file: list): + """ + Renvoie l'élément en tête de la file sans le retirer. + + Args: + file (list): La file dont on veut consulter le premier élément. + + Returns: + L'élément en tête de la file. + """ + return file[0] + diff --git a/file/file_LSC.py b/file/file_LSC.py new file mode 100644 index 0000000..a6d6869 --- /dev/null +++ b/file/file_LSC.py @@ -0,0 +1,4 @@ +import LSC as lifo + +def creer_liste_vide(): + return lifo.cr diff --git a/file/file_tuple.py b/file/file_tuple.py new file mode 100644 index 0000000..2420266 --- /dev/null +++ b/file/file_tuple.py @@ -0,0 +1,23 @@ +def creer_file_vide(): + return () + +def est_vide(file: tuple)-> bool: + return () == file + +def tete(file: tuple): + assert not(est_vide(file)), "file vide" + element, reste = file + + return element + +def queue(file): + element,reste = liste + return reste + +def inserer_tete(file,elt): + return (elt,file) + +def inserer_queue(file,elt): + if est_vide(file): + return inserer_tete(file,elt) + return inserer_tete(inserer_queu(queue(file),elt)tete(file)) diff --git a/magic_square/TDliste2liste/exercice1.py b/magic_square/TDliste2liste/exercice1.py new file mode 100644 index 0000000..f0a9683 --- /dev/null +++ b/magic_square/TDliste2liste/exercice1.py @@ -0,0 +1,11 @@ +def appartient(elt,tableau): + for i in tableau: + if i == elt: + return True + else: + continue + return False + +if __name__ == "__main__": + print(appartient(5,[1,2,3,4,5,6,7,8,9,10])) + print(appartient(5,[1,2,3,4,6,7,8,9,10])) diff --git a/magic_square/TDliste2liste/exercice2.py b/magic_square/TDliste2liste/exercice2.py new file mode 100644 index 0000000..2f7708e --- /dev/null +++ b/magic_square/TDliste2liste/exercice2.py @@ -0,0 +1,21 @@ +def max_local(tableau): + maximum = tableau[0] + for i in tableau: + if i > maximum: + maximum = i + else: + continue + return maximum + +def indice_max(tableau): + maximum = max_local(tableau) + for i in range(len(tableau)): + if tableau[i] == maximum: + return i + else: + continue + +if __name__ == "__main__": + l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1] + print(max_local(l1)) + print(indice_max(l1)) diff --git a/magic_square/TDliste2liste/exercice3.py b/magic_square/TDliste2liste/exercice3.py new file mode 100644 index 0000000..7566bd1 --- /dev/null +++ b/magic_square/TDliste2liste/exercice3.py @@ -0,0 +1,8 @@ +def cree_tableau_n_m(n,m): + return [[0 for _ in range(m)] for _ in range(n)] + +def cree_tableau_carre_n(n): + return [[0 for _ in range(n)] for _ in range(n)] +if __name__ == "__main__": + print(cree_tableau_n_m(3,5)) + print(cree_tableau_carre_n(5)) diff --git a/magic_square/TDliste2liste/exercice4.py b/magic_square/TDliste2liste/exercice4.py new file mode 100644 index 0000000..814150f --- /dev/null +++ b/magic_square/TDliste2liste/exercice4.py @@ -0,0 +1,12 @@ +def cree_carre_entier_1_n_carre(n): + carre = [] + compteur = 1 + for i in range(n): + ligne = [] + for j in range(n): + ligne.append(compteur) + compteur += 1 + carre.append(ligne) + return carre +print(cree_carre_entier_1_n_carre(8)) + diff --git a/magic_square/TDliste2liste/exercice5.py b/magic_square/TDliste2liste/exercice5.py new file mode 100644 index 0000000..6471d60 --- /dev/null +++ b/magic_square/TDliste2liste/exercice5.py @@ -0,0 +1,9 @@ +def transpose(carre): + n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée) + return [[carre[j][i] for j in range(n)] for i in range(n)] + +def transpose_en_place(carre): + n = len(carre) # Nombre de lignes (ou colonnes) + for i in range(n): + for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés + carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments diff --git a/magic_square/TDliste2liste/exercice6.py b/magic_square/TDliste2liste/exercice6.py new file mode 100644 index 0000000..7881f21 --- /dev/null +++ b/magic_square/TDliste2liste/exercice6.py @@ -0,0 +1,9 @@ +def diag_1(carre): + return [carre[i][i] for i in range(len(carre))] + +def diag_2(carre): + n = len(carre) + return [carre[i][n - 1 - i] for i in range(n)] + +def colonne(j, carre): + return [carre[i][j] for i in range(len(carre))] diff --git a/magic_square/magic_square.py b/magic_square/magic_square.py new file mode 100644 index 0000000..cc1d8d4 --- /dev/null +++ b/magic_square/magic_square.py @@ -0,0 +1,48 @@ +from TDliste2liste.exercice6 import diag_1, diag_2, colonne +def check_diagonale(liste): + return diag1(liste), diag2(liste) +def check_colonne(liste): + somme = [] + for i in range(len(liste)): + somme.append(colonne(i,liste)) + return somme +def check_line(liste): + somme = [] + for i in range(len(liste)): + somme.append(sum(liste[i])) + return somme + +def check_all(carre): + diag1_values, diag2_values = check_diagonale(carre) + colonne_values = check_colonne(carre) + line_values = check_line(carre) + + # On récupère la première valeur de diag1 pour la comparaison + reference_value = diag1_values[0] if diag1_values else None + + # Vérification si toutes les valeurs sont les mêmes + all_same = True + + # Vérification des diagonales + if not all(value == reference_value for value in diag1_values): + all_same = False + + if not all(value == reference_value for value in diag2_values): + all_same = False + + # Vérification des colonnes + for col in colonne_values: + if not all(value == reference_value for value in col): + all_same = False + + # Vérification des lignes + for line in line_values: + if line != reference_value: + all_same = False + + return all_same + +carre1=[[4, 9, 2],\ + [3, 5, 7],\ + [8, 1, 6]] +print(check_all(carre1)) diff --git a/magic_square/td_carre_magique.py b/magic_square/td_carre_magique.py new file mode 100644 index 0000000..8ad17c7 --- /dev/null +++ b/magic_square/td_carre_magique.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + + + + + + + +if __name__ == '__main__': + carre1=[[4, 9, 2],\ + [3, 5, 7],\ + [8, 1, 6]] + carre2=[[16, 9, 14],\ + [11, 13, 15],\ + [12, 17, 10]] + carre3=[[1, 2, 3],\ + [4, 5, 6],\ + [7, 8, 9]] + carre4=[[16, 3, 2, 13],\ + [5, 10, 11, 8],\ + [9, 6, 7, 12],\ + [4, 15, 14, 1]] + carre5=[[1, 14, 14, 4],\ + [11, 7, 6, 9],\ + [8, 10, 10, 5],\ + [13, 2, 3, 15]] diff --git a/oracle/finder.py b/oracle/finder.py new file mode 100644 index 0000000..fec2ce6 --- /dev/null +++ b/oracle/finder.py @@ -0,0 +1,72 @@ +from tri import triii + + +def dichotomie_maximum(arr: list): + """cherche le maximum d'une liste triée de façon dichotomique + + Args: + arr (list): la liste contenant le maximum + + Returns: + int: le maximum + """ + arr = triii(arr) + if not arr: + return None + left, right = 0, len(arr) - 1 + while left < right: + mid = (left + right) // 2 + if arr[mid] > arr[mid + 1]: + right = mid + else: + left = mid + 1 + return arr[left] + +def dichotomie_minimum(arr: list)->int: + """cherche le minimum d'une liste de façon dichotometrique trier ! + + Args: + arr (list): la liste + + Returns: + int: le minimum + """ + arr = triii(arr) + if not arr: + return None + left, right = 0, len(arr) - 1 + while left < right: + mid = (left + right) // 2 + if arr[mid] < arr[mid + 1]: + right = mid + else: + left = mid + 1 + return arr[left] + +def trouver_indice_dichotomie(arr, x): + """cherche l'élement x dans une liste arr + + Args: + arr (list): la liste + x (int): l'élement + + Returns: + int: l'indice de l'element dans la liste ou -1 s'il est absent + """ + arr = sorted(arr) + left, right = 0, len(arr) - 1 + while left <= right: + mid = (left + right) // 2 + if arr[mid] == x: + return mid + elif arr[mid] < x: + left = mid + 1 + else: + right = mid - 1 + return None + + + +liste = [i for i in range(20000)] +print(trouver_indice_dichotomie(liste,5624)) + diff --git a/oracle/oracle.py b/oracle/oracle.py new file mode 100644 index 0000000..5ab1fde --- /dev/null +++ b/oracle/oracle.py @@ -0,0 +1,52 @@ + +from tri import triage, triii +total_tests = 0 +successes = 0 +failures = 0 + +def run_test(func, input_data, expected_output, test_name): + global total_tests, successes, failures + total_tests += 1 + + try: + result = func(input_data) + if result == expected_output: + print(f"[SUCCÈS] {test_name}") + successes += 1 + else: + print(f"[ÉCHEC] {test_name}: attendu {expected_output}, mais obtenu {result}") + failures += 1 + except Exception as e: + print(f"[ERREUR] {test_name}: exception {e}") + failures += 1 + +def test_triage(): + run_test(triage, [], [], "triage avec liste vide") + run_test(triage, [5], [5], "triage avec un seul élément") + run_test(triage, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], "triage avec liste déjà triée") + run_test(triage, [3, 1, 4, 2, 5], [1, 2, 3, 4, 5], "triage avec liste non triée") + run_test(triage, [9, 3, 7, 1, 5], [1, 3, 5, 7, 9], "triage avec liste non triée aléatoire") + +def test_triii(): + run_test(triii, [], [], "triii avec liste vide") + run_test(triii, [7], [7], "triii avec un seul élément") + run_test(triii, [1, 2, 3], [1, 2, 3], "triii avec liste déjà triée") + run_test(triii, [3, 2, 1, 4], [1, 2, 3, 4], "triii avec liste non triée") + run_test(triii, [6, 3, 9, 1, 2], [1, 2, 3, 6, 9], "triii avec liste non triée aléatoire") + +if __name__ == '__main__': + print("Tests pour la fonction triage:") + test_triage() + print("\nTests pour la fonction triii:") + test_triii() + + + print("\n--- Résumé des tests ---") + print(f"Total de tests exécutés : {total_tests}") + print(f"Tests réussis : {successes}") + print(f"Tests échoués : {failures}") + + if failures == 0: + print("Tous les tests ont réussi !") + else: + print(f"{failures} tests ont échoué.") \ No newline at end of file diff --git a/oracle/tri.py b/oracle/tri.py new file mode 100644 index 0000000..8b8c402 --- /dev/null +++ b/oracle/tri.py @@ -0,0 +1,18 @@ +def triage(liste:list) -> list: + if len(liste) < 2: + return list + for i in range(len(liste)-1): + if liste[i] > liste[i+1]: + liste[i], liste[i+1] = liste[i+1], liste[i] + return triage(liste) + return liste + +def triii(liste: list) -> list: + if liste == [] : + return [] + mini = 0 + for i in range(1, len(liste)): + if liste[i] < liste[mini]: + mini = i + liste[0], liste[mini] = liste[mini], liste[0] + return [liste[0]] + triii(liste[1:]) \ No newline at end of file diff --git a/partition_fusion/code.py b/partition_fusion/code.py new file mode 100644 index 0000000..9356ba9 --- /dev/null +++ b/partition_fusion/code.py @@ -0,0 +1,45 @@ +def partition(tab, debut, fin): + pivot = tab[fin] + i = debut - 1 + for j in range(debut, fin): + if tab[j] <= pivot: + i += 1 + tab[i], tab[j] = tab[j], tab[i] + tab[i + 1], tab[fin] = tab[fin], tab[i + 1] + return i + 1 + +def fusion(tab, debut, milieu, fin): + gauche = tab[debut:milieu + 1] + droite = tab[milieu + 1:fin + 1] + i, j, k = 0, 0, debut + + while i < len(gauche) and j < len(droite): + if gauche[i] <= droite[j]: + tab[k] = gauche[i] + i += 1 + else: + tab[k] = droite[j] + j += 1 + k += 1 + + while i < len(gauche): + tab[k] = gauche[i] + i += 1 + k += 1 + + while j < len(droite): + tab[k] = droite[j] + j += 1 + k += 1 + +def tri_fusion_partition(tab, debut, fin): + if debut < fin: + pivot_index = partition(tab, debut, fin) + tri_fusion_partition(tab, debut, pivot_index - 1) + tri_fusion_partition(tab, pivot_index + 1, fin) + fusion(tab, debut, pivot_index, fin) + +tableau = [34, 7, 23, 32, 5, 62, 32, 8, 9] +tri_fusion_partition(tableau, 0, len(tableau) - 1) +print("Tableau trié :", tableau) + diff --git a/recurivite/TD1.py b/recurivite/TD1.py new file mode 100644 index 0000000..efa8fb3 --- /dev/null +++ b/recurivite/TD1.py @@ -0,0 +1,28 @@ +def factorielle(number: int): + if number == 0: + return 1 + else: + return number * factorielle(number-1) + +def modulo(a, b): + if b-a < 0: + return b + elif b == 0: + return b + else: + return modulo(a,b-a) +def somme(n): + if n == 0: + return n + else: + return(n+somme(n-1)) +def init_quotient(a,b): + i = 0 + return (quotient(a,b,i)) +def quotient(a,b,i): + if b == 0 or b-a < 0: + return i + else: + return(quotient(a,b-a,i+1)) + +print(init_quotient(6,18)) diff --git a/recurivite/exercice_MJoannic/palindrom.py b/recurivite/exercice_MJoannic/palindrom.py new file mode 100644 index 0000000..7227bc0 --- /dev/null +++ b/recurivite/exercice_MJoannic/palindrom.py @@ -0,0 +1,12 @@ +def is_palindrom(word)->bool: + word = list(word) + if len(word) < 2: + return True + if word[0] == word[-1]: + word.pop(0) + word.pop(-1) + return is_palindrom(word) + else: + return False + +print(is_palindrom("do geese see god".replace(' ', ''))) diff --git a/referencement/search.py b/referencement/search.py new file mode 100644 index 0000000..4a3fe8a --- /dev/null +++ b/referencement/search.py @@ -0,0 +1,13 @@ +import requests +from bs4 import BeautifulSoup +def search(url): + r = requests.get(url) + return r.text + + +def search_urls_in_text(content): + soup = BeautifulSoup(content, 'html5lib') + hrefs = [a['href'] for a in soup.find_all('a', href=True)] + return hrefs + +print(search_urls_in_text(search("https://google.com"))) diff --git a/sqlite/test b/sqlite/test new file mode 100644 index 0000000..988613f Binary files /dev/null and b/sqlite/test differ diff --git a/sqlite/test-journal b/sqlite/test-journal new file mode 100644 index 0000000..34c2c39 Binary files /dev/null and b/sqlite/test-journal differ diff --git a/tp6/LSC.py b/tp6/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/tp6/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/tp6/Pile_LSC.py b/tp6/Pile_LSC.py new file mode 100644 index 0000000..5603678 --- /dev/null +++ b/tp6/Pile_LSC.py @@ -0,0 +1,63 @@ +import LSC as lsc +from typing import Any + +def creer_pile_vide() -> lsc.Liste_Simplement_Chainee: + """Crée une pile vide sous forme de liste simplement chaînée. + + Returns: + lsc.Liste_Simplement_Chainee: Une pile vide représentée par une liste simplement chaînée. + """ + return lsc.creer_liste_vide() + +def est_pile_vide(pile: lsc.Liste_Simplement_Chainee) -> bool: + """Vérifie si la pile est vide. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return lsc.est_vide(pile) + +def sommet(pile: lsc.Liste_Simplement_Chainee) -> Any: + """Renvoie l'élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile dont on veut connaître le sommet. + + Returns: + Any: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide." + return lsc.tete(pile) + +def empiler(pile: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee: + """Ajoute un élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile actuelle. + element (Any): L'élément à ajouter au sommet de la pile. + + Returns: + lsc.Liste_Simplement_Chainee: La nouvelle pile avec l'élément ajouté. + """ + return lsc.ajouter_en_tete(pile, element) + +def depiler(pile: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee: + """Retire l'élément au sommet de la pile. + + Args: + pile (lsc.Liste_Simplement_Chainee): La pile dont on veut retirer le sommet. + + Returns: + lsc.Liste_Simplement_Chainee: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return lsc.queue(pile) diff --git a/tp6/Pile_List.py b/tp6/Pile_List.py new file mode 100644 index 0000000..21a1ab6 --- /dev/null +++ b/tp6/Pile_List.py @@ -0,0 +1,62 @@ +from typing import Any + +def creer_pile_vide() -> list: + """Crée une pile vide sous forme de liste. + + Returns: + list: Une pile vide représentée par une liste. + """ + return [] + +def est_pile_vide(pile: list) -> bool: + """Vérifie si la pile est vide. + + Args: + pile (list): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return len(pile) == 0 + +def sommet(pile: list) -> Any: + """Renvoie l'élément au sommet de la pile. + + Args: + pile (list): La pile dont on veut connaître le sommet. + + Returns: + Any: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[-1] + +def empiler(pile: list, element: Any) -> list: + """Ajoute un élément au sommet de la pile. + + Args: + pile (list): La pile actuelle. + element (Any): L'élément à ajouter au sommet de la pile. + + Returns: + list: La nouvelle pile avec l'élément ajouté. + """ + return pile + [element] + +def depiler(pile: list) -> list: + """Retire l'élément au sommet de la pile. + + Args: + pile (list): La pile dont on veut retirer le sommet. + + Returns: + list: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[:-1] diff --git a/tp6/Pile_Tuple.py b/tp6/Pile_Tuple.py new file mode 100644 index 0000000..5781a66 --- /dev/null +++ b/tp6/Pile_Tuple.py @@ -0,0 +1,60 @@ +def creer_pile_vide(): + """Crée une pile vide sous forme de tuple. + + Returns: + tuple: Une pile vide représentée par un tuple vide. + """ + return () + +def est_pile_vide(pile): + """Vérifie si la pile est vide. + + Args: + pile (tuple): La pile à vérifier. + + Returns: + bool: True si la pile est vide, False sinon. + """ + return pile == () + +def sommet(pile): + """Renvoie l'élément au sommet de la pile. + + Args: + pile (tuple): La pile dont on veut connaître le sommet. + + Returns: + _type_: L'élément au sommet de la pile. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[-1] + +def empiler(pile, elt): + """Ajoute un élément au sommet de la pile. + + Args: + pile (tuple): La pile actuelle. + elt (_type_): L'élément à ajouter au sommet de la pile. + + Returns: + tuple: La nouvelle pile avec l'élément ajouté. + """ + return pile + (elt,) + +def depiler(pile): + """Retire l'élément au sommet de la pile. + + Args: + pile (tuple): La pile dont on veut retirer le sommet. + + Returns: + tuple: La nouvelle pile sans l'élément au sommet. + + Raises: + AssertionError: Si la pile est vide. + """ + assert not est_pile_vide(pile), "Pile vide!" + return pile[:-1] diff --git a/tp6/README.md b/tp6/README.md new file mode 100644 index 0000000..2192cf2 --- /dev/null +++ b/tp6/README.md @@ -0,0 +1,69 @@ +# Devoir Maison : Gestion de Piles et Notation Polonaise Inverse + +Ce devoir présente des fonctions pour manipuler des piles et évaluer des expressions en notation polonaise inverse (NPI). + +## Prérequis + +Pour exécuter ce devoir, vous aurez besoin de : + +- [Python 3.x](https://www.python.org/downloads/) installé sur votre machine. + +### Installation de Python + +1. **Téléchargez Python** : Allez sur le [site officiel de Python](https://www.python.org/downloads/) et téléchargez la dernière version stable pour votre système d'exploitation. + +2. **Installez Python** : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add Python to PATH" lors de l'installation sur Windows. + +3. **Vérifiez l'installation** : Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante : + ```bash + python --version + ``` + Cela devrait afficher la version de Python installée. + +## Utilisation des Modules + +### Modules Fournis + +Le devoir contient les modules suivants : + +- `LSC` : Implémentation d'une liste simplement chaînée. +- `Pile_LSC` : Implémentation d'une pile utilisant une liste simplement chaînée. +- `Tuple` : Implémentation d'une pile utilisant un tuple. +- `Liste` : Implémentation d'une pile utilisant une liste. + +#### Primitives du Module `LSC` + +- `creer_liste_vide()`: Crée une liste vide. +- `est_vide(liste)`: Vérifie si la liste est vide. +- `ajouter_en_tete(liste, element)`: Ajoute un élément au début de la liste. +- `queue(liste)`: Retire le premier élément de la liste. +- `tete(liste)`: Renvoie le premier élément de la liste. + +#### Primitives du Module `Pile_LSC` + +- `creer_pile_vide()`: Crée une pile vide sous forme de liste simplement chaînée. +- `est_pile_vide(pile)`: Vérifie si la pile est vide. +- `sommet(pile)`: Renvoie l'élément au sommet de la pile. +- `empiler(pile, element)`: Ajoute un élément au sommet de la pile. +- `depiler(pile)`: Retire l'élément au sommet de la pile. + +## Fichier `test.py` + +Le fichier `test.py` contient des exemples d'utilisation des fonctionnalités de gestion de piles et d'évaluation en notation polonaise inverse. + +### Fonctions dans `test.py` + +- **Afficher une pile** : Affiche les éléments d'une pile du sommet à la base. +- **Copier une pile** : Crée une copie d'une pile donnée. +- **Hauteur de la pile** : Renvoie la hauteur de la pile. +- **Inverser des éléments** : Inverse les `j` derniers éléments de la pile. +- **Trouver le maximum** : Renvoie la position du maximum parmi les `i` derniers éléments de la pile. +- **Tri des crêpes** : Trie les éléments de la pile en utilisant la méthode des crêpes. +- **Évaluation NPI** : Évalue une expression arithmétique en notation polonaise inverse. + +### Exécution de `test.py` + +Pour exécuter le script, ouvrez votre terminal, naviguez vers le dossier contenant le fichier `test.py`, puis exécutez la commande suivante : + +```bash +python test.py diff --git a/tp6/TP_Piles.pdf b/tp6/TP_Piles.pdf new file mode 100644 index 0000000..6a5c849 Binary files /dev/null and b/tp6/TP_Piles.pdf differ diff --git a/tp6/npi.py b/tp6/npi.py new file mode 100644 index 0000000..9b4edd0 --- /dev/null +++ b/tp6/npi.py @@ -0,0 +1,46 @@ +def evaluer_npi(expression): + """fais la notation polonaise inversée (NPI) d'une expression arithmétique + Args: + expression (_type_): String contenant l'expression arithmétique + + Returns: + _type_: Integer contenant le resultat. + """ + + pile = [] + + + elements = expression.split() + + for element in elements: + if element.isdigit(): + pile.append(int(element)) + else: + + droite = pile.pop() + gauche = pile.pop() + + if element == '+': + resultat = gauche + droite + elif element == '-': + resultat = gauche - droite + elif element == '*': + resultat = gauche * droite + elif element == '/': + resultat = gauche / droite + else: + raise ValueError(f"Opérateur inconnu: {element}") + + + pile.append(resultat) + + + if len(pile) != 1: + raise ValueError("L'expression est mal formée.") + + return pile.pop() + + +expression = "100 60 / 60 + 90 *" +resultat = evaluer_npi(expression) +print(f"Le résultat de l'expression '{expression}' est: {resultat}") diff --git a/tp6/test.py b/tp6/test.py new file mode 100644 index 0000000..a2b1b36 --- /dev/null +++ b/tp6/test.py @@ -0,0 +1,125 @@ +import Pile_LSC as lifo +from random import shuffle + +def afficher(pile): + """Affiche les éléments d'une pile du sommet à la base.""" + print("|----") + temp = pile + while not lifo.est_pile_vide(temp): + print(f"| {lifo.sommet(temp)}") + temp = lifo.depiler(temp) + print("|----\n") + +def copier_pile(pile): + """Copie une pile représentée par une liste simplement chaînée.""" + copie = lifo.creer_pile_vide() + pile_temp = lifo.creer_pile_vide() + + while not lifo.est_pile_vide(pile): + sommet = lifo.sommet(pile) + pile_temp = lifo.empiler(pile_temp, sommet) + pile = lifo.depiler(pile) + + while not lifo.est_pile_vide(pile_temp): + sommet = lifo.sommet(pile_temp) + pile = lifo.empiler(pile, sommet) + copie = lifo.empiler(copie, sommet) + pile_temp = lifo.depiler(pile_temp) + + return copie + +def hauteur_pile(pile): + """ + Renvoie hauteur de la pile. + PARAMETRES : pile - pile à analyser. + RETURN : hauteur. + EFFET DE BORD : Aucune. + """ + n = 0 + while not lifo.est_pile_vide(pile): + n += 1 + pile = lifo.depiler(pile) + return n + +def retourner(pile, j): + """ + Inverse j derniers éléments de la pile. + PARAMETRES : pile - pile à modifier, j - nombre d'éléments à inverser. + RETURN : Aucune. + EFFET DE BORD : Modifie la pile. + """ + pile_aux = lifo.creer_pile_vide() + + for _ in range(j): + if lifo.est_pile_vide(pile): + break + pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile)) + pile = lifo.depiler(pile) + + while not lifo.est_pile_vide(pile_aux): + pile = lifo.empiler(pile, lifo.sommet(pile_aux)) + pile_aux = lifo.depiler(pile_aux) + +def max_pile(pile, i): + """ + Renvoie position du maximum parmi i derniers éléments. + PARAMETRES : pile - pile à analyser, i - nombre d'éléments. + RETURN : position du maximum. + EFFET DE BORD : Aucune. + """ + + copy = copier_pile(pile) + max_value = lifo.sommet(copy) + ind = 1 + ind_n = 1 + + for _ in range(i): + if lifo.est_pile_vide(copy): + break + current = lifo.sommet(copy) + if current > max_value: + max_value = current + ind = ind_n + copy = lifo.depiler(copy) + ind_n += 1 + + return ind + + +def tri_crepes_iteratif(pile): #ne fonctionne pas + """ + Tri des crêpes en cours. + PARAMETRES : pile - pile à trier. + RETURN : pile triée. + EFFET DE BORD : Modifie la pile. + """ + + n = hauteur_pile(pile) + for i in range(n): + max_position = max_pile(pile, n - i) + if max_position!= n - i: + retourner(pile, n - max_position) + retourner(pile, i + 1) + + return pile + + +if __name__ == "__main__": + from random import shuffle + + ma_liste = [i for i in range(10)] + shuffle(ma_liste) + + print("Liste de départ :", ma_liste) + + ma_pile = lifo.creer_pile_vide() + for element in ma_liste: + ma_pile = lifo.empiler(ma_pile, element) + + print("\nPile initiale :") + afficher(ma_pile) + print(max_pile(ma_pile,10)) + print("Tri des crêpes en cours...") + ma_pile = tri_crepes_iteratif(ma_pile) + print("Pile après tri :") + afficher(ma_pile) \ No newline at end of file diff --git a/tp6_self/LSC.py b/tp6_self/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/tp6_self/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/tp6_self/Pile_LSC.py b/tp6_self/Pile_LSC.py new file mode 100644 index 0000000..90b814f --- /dev/null +++ b/tp6_self/Pile_LSC.py @@ -0,0 +1,55 @@ +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) diff --git a/tp6_self/Pile_List.py b/tp6_self/Pile_List.py new file mode 100644 index 0000000..1edac49 --- /dev/null +++ b/tp6_self/Pile_List.py @@ -0,0 +1,54 @@ +# 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] \ No newline at end of file diff --git a/tp6_self/Pile_Tuple.py b/tp6_self/Pile_Tuple.py new file mode 100644 index 0000000..447dd07 --- /dev/null +++ b/tp6_self/Pile_Tuple.py @@ -0,0 +1,54 @@ +# 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] \ No newline at end of file diff --git a/tp6_self/README.md b/tp6_self/README.md new file mode 100644 index 0000000..86868a7 --- /dev/null +++ b/tp6_self/README.md @@ -0,0 +1,133 @@ + +# **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) + ``` +
+ +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 \ No newline at end of file diff --git a/tp6_self/npi.py b/tp6_self/npi.py new file mode 100644 index 0000000..0005927 --- /dev/null +++ b/tp6_self/npi.py @@ -0,0 +1,44 @@ +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)) diff --git a/tp6_self/test.py b/tp6_self/test.py new file mode 100644 index 0000000..86158cc --- /dev/null +++ b/tp6_self/test.py @@ -0,0 +1,160 @@ +#!/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) diff --git a/tp_listes_chaines/TP 5 Listes Chaînées-20240925.zip b/tp_listes_chaines/TP 5 Listes Chaînées-20240925.zip new file mode 100644 index 0000000..bca1338 Binary files /dev/null and b/tp_listes_chaines/TP 5 Listes Chaînées-20240925.zip differ diff --git a/tp_listes_chaines/TP5_Listes_Chainees.pdf b/tp_listes_chaines/TP5_Listes_Chainees.pdf new file mode 100644 index 0000000..77accef Binary files /dev/null and b/tp_listes_chaines/TP5_Listes_Chainees.pdf differ diff --git a/tp_listes_chaines/execute.py b/tp_listes_chaines/execute.py new file mode 100755 index 0000000..b7a16ec --- /dev/null +++ b/tp_listes_chaines/execute.py @@ -0,0 +1,278 @@ +# Création du fichier complet TP5_1.py avec toutes les fonctions demandées +contenu_tp5 = """ +import re +from Sommets import Sommet +from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue + +# 1. Fonction extraire_altitude +def extraire_altitude(chaine): + \"\"\" + Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'. + + Paramètres : + chaine (str) : La chaîne contenant l'altitude et l'unité. + + Retourne : + int : La valeur numérique de l'altitude. + \"\"\" + return int(re.sub(r'\\D', '', chaine)) + +# 2. Fonction csv2liste +def csv2liste(fichier_csv): + \"\"\" + Lit un fichier CSV et retourne une liste simplement chaînée des sommets. + + Paramètres : + fichier_csv (str) : Le chemin vers le fichier CSV à lire. + + Retourne : + Une liste simplement chaînée contenant les sommets. + \"\"\" + liste_sommets = creer_liste_vide() + with open(fichier_csv, 'r') as fichier: + for ligne in fichier: + nom, altitude = ligne.strip().split(',') + altitude = extraire_altitude(altitude) # Extraction de la valeur numérique + sommet = Sommet(nom, altitude, 'Chartreuse') # Le massif est 'Chartreuse' + liste_sommets = ajouter_en_tete(liste_sommets, sommet) + return liste_sommets + +# 3. Fonction copier_liste +def copier_liste(liste): + \"\"\" + Copie une liste simplement chaînée. + + Paramètres : + liste : Une liste simplement chaînée. + + Retourne : + Une copie de la liste. + \"\"\" + if est_vide(liste): + return creer_liste_vide() + else: + return ajouter_en_tete(copier_liste(queue(liste)), tete(liste)) + +# 4. Fonction rechercher +def rechercher(liste, nom): + \"\"\" + Recherche un sommet dans la liste par son nom. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à rechercher. + + Retourne : + bool : True si le sommet est trouvé, False sinon. + \"\"\" + reste = liste + while not est_vide(reste): + sommet = tete(reste) + if sommet.nom == nom: + return True + reste = queue(reste) + return False + +# 5. Fonction modifier_altitude +def modifier_altitude(liste, nom, nouvelle_altitude): + \"\"\" + Modifie l'altitude d'un sommet dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à modifier. + nouvelle_altitude (int) : La nouvelle altitude du sommet. + \"\"\" + reste = liste + while not est_vide(reste): + sommet = tete(reste) + if sommet.nom == nom: + sommet.altitude = nouvelle_altitude + break + reste = queue(reste) + +# 6. Fonction supprimer_sommet +def supprimer_sommet(liste, nom): + \"\"\" + Supprime la première occurrence du sommet de nom donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à supprimer. + + Retourne : + Une liste simplement chaînée avec la première occurrence du sommet supprimée. + \"\"\" + if est_vide(liste): + return liste + elif tete(liste).nom == nom: + return queue(liste) + else: + return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste)) + +# 7. Fonction supprimer_sommets +def supprimer_sommets(liste, nom): + \"\"\" + Supprime toutes les occurrences du sommet de nom donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à supprimer. + + Retourne : + Une liste simplement chaînée avec toutes les occurrences du sommet supprimées. + \"\"\" + if est_vide(liste): + return liste + elif tete(liste).nom == nom: + return supprimer_sommets(queue(liste), nom) + else: + return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste)) + +# 8. Fonction longueur +def longueur(liste): + \"\"\" + Renvoie le nombre d'éléments de la liste simplement chaînée. + + Paramètres : + liste : Une liste simplement chaînée. + + Retourne : + int : Le nombre d'éléments dans la liste. + \"\"\" + if est_vide(liste): + return 0 + else: + return 1 + longueur(queue(liste)) + +# 9. Fonction inserer +def inserer(liste, element, rang): + \"\"\" + Insère un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + element : L'élément à insérer. + rang (int) : Le rang auquel insérer l'élément. + + Retourne : + Une liste simplement chaînée avec l'élément inséré. + \"\"\" + if rang == 0: + return ajouter_en_tete(liste, element) + else: + return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste)) + +# 10. Fonction supprimer +def supprimer(liste, rang): + \"\"\" + Supprime un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à supprimer. + + Retourne : + Une liste simplement chaînée avec l'élément supprimé. + \"\"\" + if rang == 0: + return queue(liste) + else: + return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste)) + +# 11. Fonction modifier +def modifier(liste, rang, element): + \"\"\" + Modifie un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à modifier. + element : Le nouvel élément à insérer à ce rang. + + Retourne : + Une liste simplement chaînée avec l'élément modifié. + \"\"\" + if rang == 0: + return ajouter_en_tete(queue(liste), element) + else: + return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste)) + +# 12. Fonction rechercher_par_rang +def rechercher_par_rang(liste, element): + \"\"\" + Recherche l'élément dans la liste et retourne son rang. + + Paramètres : + liste : Une liste simplement chaînée. + element : L'élément à rechercher. + + Retourne : + int : Le rang de l'élément ou -1 s'il n'est pas trouvé. + \"\"\" + reste = liste + rang = 0 + while not est_vide(reste): + if tete(reste) == element: + return rang + reste = queue(reste) + rang += 1 + return -1 + +# 13. Fonction lire +def lire(liste, rang): + \"\"\" + Renvoie l'élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à lire. + + Retourne : + L'élément à ce rang. + \"\"\" + if rang == 0: + return tete(liste) + else: + return lire(queue(liste), rang - 1) + +# 14. Fonction trier +def trier(liste, ordre=lambda x, y: x < y): + \"\"\" + Trie la liste dans un ordre donné. + + Paramètres : + liste : Une liste simplement chaînée. + ordre : Une fonction de comparaison, par défaut x < y. + + Retourne : + Une liste simplement chaînée triée. + \"\"\" + if est_vide(liste): + return liste + else: + pivot = tete(liste) + sous_liste = queue(liste) + + # Séparer en deux listes + inferieurs = creer_liste_vide() + superieurs = creer_liste_vide() + while not est_vide(sous_liste): + elt = tete(sous_liste) + if ordre(elt, pivot): + inferieurs = ajouter_en_tete(inferieurs, elt) + else: + superieurs = ajouter_en_tete(superieurs, elt) + sous_liste = queue(sous_liste) + + # Trier les sous-listes + inferieurs = trier(inferieurs, ordre) + superieurs = trier(superieurs, ordre) + + # Ajouter le pivot au résultat + return ajouter_en_tete(superieurs, pivot) +""" + +# Sauvegarder le fichier +path = "/home/spectre/Python/tp_listes_chaines/TP5.py" + diff --git a/tp_listes_chaines/fichiers/Chartreuse.csv b/tp_listes_chaines/fichiers/Chartreuse.csv new file mode 100644 index 0000000..eb6f049 --- /dev/null +++ b/tp_listes_chaines/fichiers/Chartreuse.csv @@ -0,0 +1,29 @@ +Grande Sure (La), 1 920 m +Rocher de Lorzier (Le), 1 838 m +Rochers de Chalves (Les), 1 845 m +Rocher de l'Église (Le), 1 300 m +Pointe de la Gorgeat (La), 1 486 m +Mont Joigny (Le), 1 556 m +Mont Outheran (Le), 1 673 m +Cochette (La), 1 618 m +Roc de Gleisin (Le), 1 434 m +Roche Veyrand (La), 1 429 m +Dent de l'Ours (La), 1 820 m +Petit Som (Le), 1 772 m +Grand Som (Le), 2 026 m +Charmant Som (Le), 1 867 m +Pinéa (La), 1 771 m +Néron (Le), 1 299 m +Mont Granier (Le), 1 933 m +Sommet du Pinet (Le) ou le Truc, 1 867 m +Grand Manti (Le), 1 818 m +Scia (La), 1 791 m +Lances de Malissard (Les), 2 045 m +Dôme de Bellefont (Le), 1 975 m +Dent de Crolles (La), 2 062 m +Piton de Bellefont (Le), 1 958 m +Chamechaude, 2 082 m +Grands Crêts (Les), 1 489 m +Mont Saint-Eynard (Le), 1 379 m +Écoutoux (L'), 1 406 m +Rachais (Le), 1 050 m diff --git a/tp_listes_chaines/fichiers/LSC.py b/tp_listes_chaines/fichiers/LSC.py new file mode 100644 index 0000000..a0cd9c8 --- /dev/null +++ b/tp_listes_chaines/fichiers/LSC.py @@ -0,0 +1,260 @@ +""" +Librairie des Listes Simplement Chaînées. + +Elle met à distribution cette structure de données et son interface. + +@author: L. JOANNIC +""" + + +# ############################################################################ + +class Liste_Simplement_Chainee(object): + """ + Classe des Listes Simplement Chainees. + + Attributs + - _tete : None si vide, Maillon sinon. + + Méthodes + - est_vide + - ajouter_en_tete + - tete + - queue + """ + + def __init__(self): + """ + Construire une instance de Liste Simplement Chainee. + + Returns + ------- + None. + + """ + self._tete = None + return None + + def est_vide(self): + """ + Tester si l'instance est vide. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + """ + return (self._tete is None) + + def ajouter_en_tete(self, element): + """ + Ajouter l'élément en tête de liste. + + Parameters + ---------- + element : type de donnee + Donnnée à ajouter à la liste. + + Returns + ------- + resultat : Liste_Simplement_Chainee + La liste à abonder. + + """ + resultat = Liste_Simplement_Chainee() + resultat._tete = Maillon(element, self) + return resultat + + def tete(self): + """ + Renvoyer la donnée stockée en tête de liste. + + Returns + ------- + type de donnee quelconque + donnee en tete. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.donnee + + def queue(self): + """ + Renvoyer la sous-liste suivant le maillon de tete. + + Returns + ------- + Liste_Simplement_Chainee + Queue de la liste. + + """ + assert not(self.est_vide()), "Liste Vide" + return self._tete.suite + + +# ############################################################################ + +def creer_liste_vide(): + """ + Créer une liste simplement chainee vide. + + Returns + ------- + Liste_Simplement_Chainee + Liste vide. + + Effets de bord + -------------- + Aucun + """ + return Liste_Simplement_Chainee() + + +def est_vide(liste): + """ + Tester si la liste simplement chainee est vide. + + Parameters + ---------- + liste : Liste Simplement Chainee + Liste à tester. + + Returns + ------- + bool + Vrai ssi la liste est vide. + + Effets de bord + -------------- + Aucun + """ + return liste.est_vide() + + +def ajouter_en_tete(liste, element): + """ + Inserer un element en tete de liste simplemeent chainee. + + Parameters + ---------- + liste : LSC + Liste à abonder. + element : type de donnee + Donnee à aouter. + + Returns + ------- + LSC, copie de liste à laquelle element a été ajouté en tete. + + Effets de bord + -------------- + Aucun + """ + return liste.ajouter_en_tete(element) + + +def tete(liste): + """ + Consulter la tete de liste. + + Parameters + ---------- + liste : LSC + Liste à consulter. + + Returns + ------- + type de donnée + valeur de la tete de liste. + + Effets de bord + -------------- + Aucun + """ + return liste.tete() + + +def queue(liste): + """ + Renvoyer la liste sans sa tete. + + Parameters + ---------- + liste : LSC + Liste à étêter. + + Returns + ------- + LSC + Liste sans son maillon de tête. + + Effets de bord + -------------- + Aucun + """ + return liste.queue() + + +def afficher_liste(liste, taille=-1): + """ + Afficher la liste en format de présentation. + + Parameters + ---------- + liste : LSC + Liste à énumérer. + + Returns + ------- + None. + + Effets de bord + -------------- + Affichage à l'écran. + + """ + reste = liste + compteur = 0 + print('+-----\n|') + while not(est_vide(reste)) and (taille == -1 or compteur < taille): + print('+- {}\n|'.format(str(tete(reste)))) + reste = queue(reste) + compteur += 1 + print('+-----') + return None + +# ############################################################################ + +class Maillon(object): + """ + Classe des Maillons d'une Liste Simplement Chainee. + + Attributs + - donnee : donnee stockee dans le maillon + - suite : liste simplemement chainee suivant le maillon + """ + + def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()): + """ + Construire une instance de la classe des Maillons. + + Parameters + ---------- + donnee : type de donnee, optional + Donnee initiale dans le Maillon. The default is None. + suite : LSC, optional + Sous-liste suivant le Maillon courant. + The default is Liste_Simplement_Chainee(). + + Returns + ------- + None. + + """ + self.donnee = donnee + self.suite = suite + return None + + +# ############################################################################ diff --git a/tp_listes_chaines/fichiers/Sommets.py b/tp_listes_chaines/fichiers/Sommets.py new file mode 100644 index 0000000..a8408f2 --- /dev/null +++ b/tp_listes_chaines/fichiers/Sommets.py @@ -0,0 +1,191 @@ +#! /usr/bin/python3 +# coding=utf-8 + +""" +Ce fichier contient la définition des objets Sommets. + +Un sommet dispose + +- des attributs + + nom + + altitude + + massif +- des méthodes + + __lt__ : inférieur + + __le__ : inférieur ou égal + + __eq__ : égal + + __ge__ : supérieur ou égal + + __gt__ : supérieur + + __repr__ : représentation (affichage) +""" + + +# ############################################################################ + +class Sommet(object): + """ + Classe des Sommets montagneux. + + Attributs + - nom : STR, nom du sommet + - altitude : INT, altitude en mètres + - massif : STR, nom du massif d'appartenance + + Méthodes + - comparaison + - représentation + + """ + + def __init__(self, nom, altitude, massif): + """ + Construire une instance de la classe Sommet. + + Parameters + ---------- + nom : str + nom du sommet. + altitude : int + altitude en m. + massif : str + massif d'appartenance. + + Returns + ------- + None. + + """ + self.nom = nom + self.altitude = altitude + self.massif = massif + return None + + def __repr__(self): + """ + Construire l'affichage d'une instance de Sommet. + + Returns + ------- + str + chaine formattée d'affichage. + + """ + if self.altitude < 1000: + altitude = str(self.altitude) + else: + altitude = str(self.altitude) + altitude = altitude[:-3]+' '+altitude[-3:] + return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude) + + def __str__(self): + """ + Construire la chaîne de caractères résumant + une instance de Sommet. + + Returns + ------- + str + chaine formattée d'affichage. + + """ + if self.altitude < 1000: + altitude = str(self.altitude) + else: + altitude = str(self.altitude) + altitude = altitude[:-3]+' '+altitude[-3:] + return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude) + + + def __gt__(self, other): + """ + Strictement plus grand. + + Parameters + ---------- + other : Sommet + Sommet à comparer. + + Returns + ------- + boolean + Resultat du test. + + """ + return (self.altitude > other.altitude)\ + or ((self.altitude == other.altitude) and (self.nom > other.nom)) + + def __lt__(self, other): + """ + Strictement plus petit. + + Parameters + ---------- + other : Sommet + Sommet à comparer. + + Returns + ------- + boolean + Resultat du test. + + """ + return (self.altitude < other.altitude)\ + or ((self.altitude == other.altitude) and (self.nom < other.nom)) + + def __eq__(self, other): + """ + Est égal à. + + Parameters + ---------- + other : Sommet + Sommet à comparer. + + Returns + ------- + boolean + Resultat du test. + + """ + return (self.altitude == other.altitude) + + def __ge__(self, other): + """ + Plus grand ou égal. + + Parameters + ---------- + other : Sommet + Sommet à comparer. + + Returns + ------- + boolean + Resultat du test. + + """ + return (self > other) or (self == other) + + def __le__(self, other): + """ + Plus petit ou égal. + + Parameters + ---------- + other : Sommet + Sommet à comparer. + + Returns + ------- + boolean + Resultat du test. + + """ + return (self < other) or (self == other) + + +# ############################################################################ + +if __name__ == '__main__': + s = Sommet('Chamechaude', 2062, 'Chartreuse') + print(s) diff --git a/tp_listes_chaines/fichiers/TP5.py b/tp_listes_chaines/fichiers/TP5.py new file mode 100644 index 0000000..a1e1738 --- /dev/null +++ b/tp_listes_chaines/fichiers/TP5.py @@ -0,0 +1,276 @@ +import re +from Sommets import Sommet +from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue + +# 1. Fonction extraire_altitude (inchangée, non récursive) +def extraire_altitude(chaine): + """ + Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'. + + Paramètres : + chaine (str) : La chaîne contenant l'altitude et l'unité. + + Retourne : + int : La valeur numérique de l'altitude. + """ + return int(re.sub(r'\D', '', chaine)) + +# 2. Fonction csv2liste (récursive) +def csv2liste(fichier_csv): + """ + Lit un fichier CSV et retourne une liste simplement chaînée des sommets. + + Paramètres : + fichier_csv (str) : Le chemin vers le fichier CSV à lire. + + Retourne : + Une liste simplement chaînée contenant les sommets. + """ + with open(fichier_csv, 'r') as fichier: + lignes = fichier.readlines() + + # Fonction récursive interne pour construire la liste + def construire_liste(lignes): + if not lignes: + return creer_liste_vide() + else: + nom, altitude = lignes[0].strip().split(',') + altitude = extraire_altitude(altitude) + sommet = Sommet(nom, altitude, 'Chartreuse') + return ajouter_en_tete(construire_liste(lignes[1:]), sommet) + + return construire_liste(lignes) + +# 3. Fonction copier_liste (récursive) +def copier_liste(liste): + """ + Copie une liste simplement chaînée. + + Paramètres : + liste : Une liste simplement chaînée. + + Retourne : + Une copie de la liste. + """ + if est_vide(liste): + return creer_liste_vide() + else: + return ajouter_en_tete(copier_liste(queue(liste)), tete(liste)) + +# 4. Fonction rechercher (récursive) +def rechercher(liste, nom): + """ + Recherche un sommet dans la liste par son nom. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à rechercher. + + Retourne : + bool : True si le sommet est trouvé, False sinon. + """ + if est_vide(liste): + return False + elif tete(liste).nom == nom: + return True + else: + return rechercher(queue(liste), nom) + +# 5. Fonction modifier_altitude (récursive) +def modifier_altitude(liste, nom, nouvelle_altitude): + """ + Modifie l'altitude d'un sommet dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à modifier. + nouvelle_altitude (int) : La nouvelle altitude du sommet. + """ + if not est_vide(liste): + sommet = tete(liste) + if sommet.nom == nom: + sommet.altitude = nouvelle_altitude + modifier_altitude(queue(liste), nom, nouvelle_altitude) + +# 6. Fonction supprimer_sommet (récursive) +def supprimer_sommet(liste, nom): + """ + Supprime la première occurrence du sommet de nom donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à supprimer. + + Retourne : + Une liste simplement chaînée avec la première occurrence du sommet supprimée. + """ + if est_vide(liste): + return liste + elif tete(liste).nom == nom: + return queue(liste) + else: + return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste)) + +# 7. Fonction supprimer_sommets (récursive) +def supprimer_sommets(liste, nom): + """ + Supprime toutes les occurrences du sommet de nom donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à supprimer. + + Retourne : + Une liste simplement chaînée avec toutes les occurrences du sommet supprimées. + """ + if est_vide(liste): + return liste + elif tete(liste).nom == nom: + return supprimer_sommets(queue(liste), nom) + else: + return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste)) + +# 8. Fonction longueur (récursive) +def longueur(liste): + """ + Renvoie le nombre d'éléments de la liste simplement chaînée. + + Paramètres : + liste : Une liste simplement chaînée. + + Retourne : + int : Le nombre d'éléments dans la liste. + """ + if est_vide(liste): + return 0 + else: + return 1 + longueur(queue(liste)) + +# 9. Fonction inserer (récursive) +def inserer(liste, element, rang): + """ + Insère un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + element : L'élément à insérer. + rang (int) : Le rang auquel insérer l'élément. + + Retourne : + Une liste simplement chaînée avec l'élément inséré. + """ + if rang == 0: + return ajouter_en_tete(liste, element) + else: + return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste)) + +# 10. Fonction supprimer (récursive) +def supprimer(liste, rang): + """ + Supprime un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à supprimer. + + Retourne : + Une liste simplement chaînée avec l'élément supprimé. + """ + if rang == 0: + return queue(liste) + else: + return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste)) + +# 11. Fonction modifier (récursive) +def modifier(liste, rang, element): + """ + Modifie un élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à modifier. + element : Le nouvel élément à insérer à ce rang. + + Retourne : + Une liste simplement chaînée avec l'élément modifié. + """ + if rang == 0: + return ajouter_en_tete(queue(liste), element) + else: + return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste)) + +# 12. Fonction rechercher_par_rang (récursive) +def rechercher_par_rang(liste, element): + """ + Recherche l'élément dans la liste et retourne son rang. + + Paramètres : + liste : Une liste simplement chaînée. + element : L'élément à rechercher. + + Retourne : + int : Le rang de l'élément ou -1 s'il n'est pas trouvé. + """ + def rechercher_recursif(liste, element, rang): + if est_vide(liste): + return -1 + elif tete(liste) == element: + return rang + else: + return rechercher_recursif(queue(liste), element, rang + 1) + + return rechercher_recursif(liste, element, 0) + +# 13. Fonction lire (récursive) +def lire(liste, rang): + """ + Renvoie l'élément à un rang donné dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + rang (int) : Le rang de l'élément à lire. + + Retourne : + L'élément à ce rang. + """ + if rang == 0: + return tete(liste) + else: + return lire(queue(liste), rang - 1) + +# 14. Fonction trier (récursive) +def trier(liste, ordre=lambda x, y: x < y): + """ + Trie la liste dans un ordre donné. + + Paramètres : + liste : Une liste simplement chaînée. + ordre : Une fonction de comparaison, par défaut x < y. + + Retourne : + Une liste simplement chaînée triée. + """ + if est_vide(liste): + return liste + else: + pivot = tete(liste) + sous_liste = queue(liste) + + # Séparer en deux listes + inferieurs = creer_liste_vide() + superieurs = creer_liste_vide() + while not est_vide(sous_liste): + elt = tete(sous_liste) + if ordre(elt, pivot): + inferieurs = ajouter_en_tete(inferieurs, elt) + else: + superieurs = ajouter_en_tete(superieurs, elt) + sous_liste = queue(sous_liste) + + # Trier les sous-listes + inferieurs = trier(inferieurs, ordre) + superieurs = trier(superieurs, ordre) + + # Ajouter le pivot au résultat + return ajouter_en_tete(superieurs, pivot) + diff --git a/tp_listes_chaines/fichiers/TP5_1.py b/tp_listes_chaines/fichiers/TP5_1.py new file mode 100644 index 0000000..3914832 --- /dev/null +++ b/tp_listes_chaines/fichiers/TP5_1.py @@ -0,0 +1,86 @@ +from Sommets import Sommet +from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste + +def csv2liste(fichier_csv): + """ + Lit un fichier CSV et retourne une liste simplement chaînée des sommets. + + Paramètres : + fichier_csv (str) : Le chemin vers le fichier CSV à lire. + + Retourne : + Une liste simplement chaînée contenant les sommets. + """ + liste_sommets = creer_liste_vide() + with open(fichier_csv, 'r') as fichier: + for ligne in fichier: + nom, altitude = ligne.strip().split(',') + sommet = Sommet(nom, int(altitude), 'Chartreuse') # Modifier selon le massif si nécessaire + liste_sommets = ajouter_en_tete(liste_sommets, sommet) + return liste_sommets + +# Test +liste_sommets = csv2liste('Chartreuse.csv') +afficher_liste(liste_sommets) +from LSC import est_vide, tete, queue, ajouter_en_tete + +def copier_liste(liste): + """ + Copie une liste simplement chaînée. + + Paramètres : + liste : Une liste simplement chaînée. + + Retourne : + Une copie de la liste. + """ + if est_vide(liste): + return creer_liste_vide() + else: + return ajouter_en_tete(copier_liste(queue(liste)), tete(liste)) + +# Test +copie = copier_liste(liste_sommets) +afficher_liste(copie) +def rechercher(liste, nom): + """ + Recherche un sommet dans la liste par son nom. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à rechercher. + + Retourne : + bool : True si le sommet est trouvé, False sinon. + """ + reste = liste + while not est_vide(reste): + sommet = tete(reste) + if sommet.nom == nom: + return True + reste = queue(reste) + return False + +# Test +print(rechercher(liste_sommets, "Chamechaude")) +def modifier_altitude(liste, nom, nouvelle_altitude): + """ + Modifie l'altitude d'un sommet dans la liste. + + Paramètres : + liste : Une liste simplement chaînée. + nom (str) : Le nom du sommet à modifier. + nouvelle_altitude (int) : La nouvelle altitude du sommet. + """ + reste = liste + while not est_vide(reste): + sommet = tete(reste) + if sommet.nom == nom: + sommet.altitude = nouvelle_altitude + break + reste = queue(reste) + +# Test +modifier_altitude(liste_sommets, "Chamechaude", 2082) +afficher_liste(liste_sommets) + diff --git a/tp_listes_chaines/fichiers/factorial.py b/tp_listes_chaines/fichiers/factorial.py new file mode 100644 index 0000000..e69de29 diff --git a/tp_listes_chaines/fichiers/test.py b/tp_listes_chaines/fichiers/test.py new file mode 100644 index 0000000..bfc7722 --- /dev/null +++ b/tp_listes_chaines/fichiers/test.py @@ -0,0 +1,22 @@ +import LSC as lc +import csv +import Sommets as sm +liste = lc.creer_liste_vide() +with open("Chartreuse.csv", mode="r",encoding='utf-8') as f: + lecteur_csv = csv.reader(f) + for ligne in lecteur_csv: + nom = ligne[0].strip() + altitude_str = ligne[1].strip() + altitude = int(altitude_str.replace('m', '').replace(' ', '')) + sommet = sm.Sommet(nom, altitude, "Chartreuse") + liste = lc.ajouter_en_tete(liste, sommet) + lecteur_csv = csv.reader(f) + for ligne in lecteur_csv: + nom = ligne[0].strip() + altitude_str = ligne[1].strip() + altitude = int(altitude_str.replace('m', '').replace(' ', '')) + sommet = sm.Sommet(nom, altitude, "Chartreuse") + liste = lc.ajouter_en_tete(liste, sommet) +lc.afficher_liste(liste.queue()) +liste1 = liste.tete() +print(liste1[0])