Florian/TermNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ajout dossier Pile et File

Browse Source
This commit is contained in:
Florian Mathieu
2024-10-11 16:14:21 +02:00
parent f4a97f08e6
commit 9fd0bd2b2e
13 changed files with 771 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
Pile_File/TP/Bataille_correction.py Normal file
View File

@@ -0,0 +1,155 @@
from File import *
import random
VAL_CARTE = ['1','2','3','4','5','6','7','8','9','10','V','D','R','AS']
COL_CARTE = ['P','T','C','H']
def in_file(x,f):
"""
Fonction qui revoie True si x est dans la file f
param x (): element present ou non dans f
param f (File1/File2) : File contenant ou non x
return (bool) : Renvoie True si x est dans f, False sinon
"""
if type(f) == File1 :
if x in f.file :
return True
else :
return False
elif type(f) == File2 :
if f.tete == x :
return True
elif f.queue != None :
return in_file(x,f.queue)
else :
return False
else :
return False
def comp(c1,c2) :
"""
Fonction de comparaison entre deux cartes
param c1 : (tuple) Carte 1
param c2 : (tuple) Carte 2
return : Renvoie
-1 si => c1 < c2
1 si => c1 > <2
0 si => c1 == c2
"""
if VAL_CARTE.index(c1[0]) < VAL_CARTE.index(c2[0]) :
return -1
elif VAL_CARTE.index(c1[0]) > VAL_CARTE.index(c2[0]) :
return 1
else :
return 0
def creer_jeu():
"""
Fonction qui crée un jeu aléatoire
return a,b (File) Deux files contenant 26 cartes chacunes
"""
i = 0
val_carte = ['1','2','3','4','5','6','7','8','9','10','V','D','R','AS']
col_carte = ['P','T','C','H']
f1 = File1()
f2 = File1()
while i < 52 :
val = random.randint(0,len(val_carte)-1)
col = random.randint(0,len(col_carte)-1)
carte = (val_carte[val],col_carte[col])
if in_file(carte,f1) == False or in_file(carte,f2) == False :
if i%2 == 0 :
f1.enfile(carte)
else :
f2.enfile(carte)
i+=1
return f1,f2
def tour(f1,f2) :
"""
Foncton qui simule un tour de bataille
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
i = f1.defile()
j = f2.defile()
res = comp(i,j)
if res == -1 :
f2.enfile(i)
f2.enfile(j)
print('f2')
elif res == 1 :
f1.enfile(i)
f1.enfile(j)
print('f1')
else :
print('bataille')
if f1.taille()>=3 and f2.taille()>=3 :
bataille(i,j,f1,f2)
else :
# Si un des deux paquet ne peut pas faire la bataille alors on le vide pour faire gagner l'autre joueur
if f1.taille() < 3 :
while not f1.est_vide() :
f1.defile()
else :
while not f2.est_vide() :
f2.defile()
def bataille(c1,c2,f1,f2) :
"""
Fonction simulant un tour de bataille
param c1 : (tuple) Carte n°1 égale a c2
param c2 : (tuple) Carte n°1 égale a c1
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
bataille_tab= []
while comp(c1,c2) == 0:
bataille_tab.append(c1)
bataille_tab.append(c2)
bataille_tab.append(f1.defile())
bataille_tab.append(f2.defile())
c1 = f1.defile()
c2 = f2.defile()
if comp(c1,c2) == 1 :
for carte in bataille_tab :
f1.enfile(carte)
f1.enfile(c1)
f1.enfile(c2)
if comp(c1,c2) == -1 :
for carte in bataille_tab :
f2.enfile(carte)
f2.enfile(c1)
f2.enfile(c2)
def est_fini(f1,f2):
"""
Fonction qui détermine si le jeu est fini
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
return (bool): renvoie True si le jeu est fini, False sinon.
"""
if f1.taille() == 0 :
print("JOUEUR 2 A GAGNE")
return True
elif f2.taille() ==0:
print("JOUEUR 1 A GAGNE")
return True
else :
return False
def game(f1,f2):
"""
Fonction simulant le jeu de la bataille
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
while not est_fini(f1,f2) :
tour(f1,f2)
a,b = creer_jeu()

139
Pile_File/TP/File.py Normal file
View File

@@ -0,0 +1,139 @@
#PARTIE
class File1 :
def __init__(self,liste = []) :
"""
Méthode d'initialisation
param liste : (List) Liste d'élément à enfiler dès l'initialisation
"""
self.file = liste
def enfile(self,x) :
"""
Méthode qui enfile un élément x
param x : () Elément x à enfiler
"""
self.file = [x] + self.file
def defile(self) :
"""
Méthode qui defile un élément de la file
return : (bool/ ) False si impossible de retirer l'élément / Elément sinon
"""
if not self.est_vide() :
return self.file.pop()
else :
return False
def est_vide(self):
"""
Méthode testant la longueur de la file
return : (bool) True si la file est vide, False sinon
"""
return len(self.file) == 0
def taille(self):
"""
Méthode retournant la taille de la file
return : (int) taille de la file
"""
return len(self.file)
def get_file(self):
"""
Méthode retournant la file sous forme de liste pour en avoir un aperçu
return : (list) file sous forme de list
"""
return self.file
# EXERCICE 2
def ajout_element(self,element):
"""
Fonction qui ajoute un élément, si la taille le permet.
return (bool): Renvoie True si l'ajout de l'élément a eu lieu, False sinon
"""
if file.taille() < 5 :
file.enfile(fichier)
return True
else :
return False
def vide_file(self):
"""
Fonction qui vide une file et affiche ces éléments
"""
while file.est_vide() == False :
e = file.defile()
print(e)
# PARTIE 3 :
class File2 :
def __init__(self,tete = None,queue = None):
"""
Méthode d'initialisation
param tete : () Element a mettre en tete de file
param queue : (File) queue de la file (élements suivants)
"""
self.tete = tete
self.queue = queue
def enfile(self,x) :
"""
Méthode qui enfile un élément x
param x : () Elément x à enfiler
"""
self.queue = File2(self.tete,self.queue)
self.tete = x
def defile(self) :
"""
Méthode qui defile un élément de la file
return : (bool/ ) False si impossible de retirer l'élément / Elément sinon
"""
if self.est_vide() :
return False
if self.queue == None :
val = self.tete
self.tete = None
return val
elif self.queue.queue == None :
val = self.queue.tete
self.queue = None
return val
else :
return self.queue.defile()
def est_vide(self) :
"""
Méthode testant la longueur de la file
return : (bool) True si la file est vide, False sinon
"""
return self.queue == None and self.tete == None
def taille(self):
"""
Méthode retournant la taille de la file
return : (int) taille de la file
"""
if self.queue == None :
return 1
else :
return 1 + self.queue.taille()
def get_file(self):
"""
Méthode retournant la file sous forme de liste pour en avoir un aperçu
return : (list) file sous forme de list
"""
if self.queue != None :
return [self.tete] + self.queue.get_file()
else :
return [self.tete]

72
Pile_File/TP/TP_File.md Normal file
View File

@@ -0,0 +1,72 @@
# TP File
------
## 1. Première implémentation
Pour cette implémentation, le constructeur de la classe utilisera un tableau pour stocker les données.
1. Créez cette classe File contenant les méthodes suivantes :
* **enfile( )**
* **defile( )**
* **top( )**
* **est_vide( )**
* **taille( )**
## 2. File à taille fixe :
Supposons que notre file à une taille fixe, disons 7 éléments maximum.
1. Ecrire une méthode ajout_element( ) qui ajoute un élément dans la file seulement si il n'y a pas trop d'éléments dans la file.
2. Ecrire une méthode vide_file( ) qui enlève tous les éléments de la file.
## 3. Deuxième implémentation
Ici nous allons implémenter la file de manière récursive. Elle possèdera deux attributs, le premier sera un élément de la pile nommé tête, le second sera une autre File. Cette seconde file possèdera elle aura un élément et une autre file en attribut. Ainsi de suite.
1. Programmez cette classe nommée File2 avec les méthodes suivantes
* **enfile( )**
* **defile( )**
* **top( )**
* **est_vide( )**
* **taille( )**
## 4. Implémentation d'un jeu de bataille :
La bataille : règles du jeu
Chacun tire la carte du dessus de son paquet et la pose sur la table. Celui qui a la carte la plus forte ramasse les autres cartes. L'as est la plus forte carte, puis roi, dame, valet, 10, etc. Lorsque deux joueurs posent en même temps deux cartes de même valeur il y a "bataille".
Lorsqu'il y a "bataille" les joueurs tirent la carte suivante et la posent, face cachée, sur la carte précédente. Puis ils tirent une deuxième carte qu'ils posent cette fois-ci face découverte et c'est cette dernière qui départagera les joueurs.
Lorsqu'il y a bataille et qu'un des deux joueur à moins de 3 cartes alors il a perdu
Le gagnant est celui qui remporte toutes les cartes.
Le jeu de la bataille peut être facilement coder avec des Files.
Un fichier carte.py contient la classe carte et les fonctions suivantes :
- comp
- game
- creer_jeu
1. Pour ce travail vous allez devoir compléter les fonctions :
- tour
- bataille
- jeu_fini
​ Ces fonctions se trouvent dans un fichier nommé carte_eleve.py
## Pour aller plus loin :
Ecrire une nouvelle implémentation d'une file, cette fois-ci il faut manipuler la file avec deux piles.

100
Pile_File/TP/TP_Pile.md Normal file
View File

@@ -0,0 +1,100 @@
# TP Pile
------
## 1. Implémentation de la pile :
Afin d'implémenter la pile il nous faut utiliser une structure de données permettant de stocker des informations.
1. Trouver une structure de données adéquate permettant de réaliser les méthodes liées à la Pile
2. Implémenter la Pile (Constructeur et méthodes associées)
3. Implémenter la méthode *\_\_repr\_\_( )* permettant d'afficher la Pile crée
​ *Exemple :*
```python
>>> p = Pile()
>>> p
[ ]
>>> p.empile(7)
>>> p.empile(9)
>>> p
9
7
```
## 2. Exercices :
### 2. 1. Bon parenthésage
1. Ecrire une fonction *bien_parenthese*( ) vérifiant si une chaîne de caractère est bien parenthésée ou non. La valeur de retour sera un booléen. On vérifie les parenthèses '( )' ainsi que les crochets '[ ]'
```python
>>> bien_parenthese("(oui)")
True
>>> bien_parenthese("(ou(i)")
False
>>> bien_parenthese("(o[u]i)")
True
>>> bien_parenthese("(ou][i)")
False
```
## 2. 2. Calculatrice polonaise inverse
La calculatrice polonaise inverse permet de faire des calculs simple mais pose l'opérateur après les deux opérandes.
<u>Par exemple :</u>
5 + 8 + 9 => 5 8 + 9 +
7 * 8 + 9 * 2 => 7 8 * 9 2 * +
1. Ecrire une fonction calculatrice( ) prenant une chaîne de caractère en paramètre qui sera un calcul en polonais inverse et le résout.
```python
>>> calculatrice("5 8 + 9 + ")
22
>>> calculatrice("7 8 * 9 2 * + ")
74
>>> calculatrice("11 4 +")
15
```
> Ici il y a plusieurs points important.
> Il faut pouvoir découper la chaîne de caractères en plusieurs données. (split())
>
> Les éléments traités sont des chaînes de caractères => '11' '+' '4' ne veut rien dire
> De la même manière => '11' + '4' => '114'
## 2. 3. Tri d'une pile
Le but ici est de trier une pile. Pour cela nous utiliserons une autre pile temporaire permettant de stocker les éléments.
1. Ecrire une fonction tri_pile( ) prennant en paramètre une pile et renvoyant la pile triée.
> L'idée ici est d'utiliser seulement deux piles. Afin de comprendre le fonctionnement il faut faire quelques essais à la main.
```python
>>> >>> p = Pile()
>>> p
>>> p.empile(7)
>>> p.empile(1)
>>> p.empile(3)
>>> p.empile(9)
>>> p
9
3
1
7
>>> tri_pile(p)
1
3
7
9
```

64
Pile_File/TP/TP_Pile_correction.py Normal file
View File

@@ -0,0 +1,64 @@
class Pile :
def __init__(self) :
"""
Méthode constructeur
"""
self.pile = []
def empile(self,x) :
"""
Méthode qui enpile un élément
param x : () Elément x à enpiler
"""
self.pile.append(x)
def depile(self) :
"""
Méthode qui defile un élément de la pile
return : (bool/ ) False si impossible de retirer l'élément / Elément sinon
"""
if self.est_vide() :
return False
else :
return self.pile.pop()
def est_vide(self):
"""Méthode calculant la longueur de la pile"""
return self.pile == []
def top(self):
"""Méthode renvoyant l'élément au dessus de la pile"""
return self.pile[-1]
def __repr__(self):
long = len(self.pile)-1
s = ''
while long >= 0 :
s+=str(self.pile[long])+'\n'
long-=1
return s
def taille(self):
"""Méthode permettant de connaître la taille de la pile"""
return len(self.pile)
def sort_stack(self):
"""Méthode qui renvoie la pile trié"""
pile_tmp = Pile()
while not self.est_vide() :
val_tmp = self.depile()
while pile_tmp.taille() != 0 and pile_tmp.top() < val_tmp:
self.empile(pile_tmp.depile())
pile_tmp.empile(val_tmp)
p.pile = pile_tmp.pile
return p
p = Pile()
p.empile(7)
p.empile(1)
p.empile(3)
p.empile(9)

129
Pile_File/TP/carte_eleve.py Normal file
View File

@@ -0,0 +1,129 @@
import File
import random
VAL_CARTE = ['1','2','3','4','5','6','7','8','9','10','V','D','R','AS']
COL_CARTE = ['P','T','C','H']
def in_file(x,f):
"""
Fonction qui revoie True si x est dans la file f
param x (): element present ou non dans f
param f (File1/File2) : File contenant ou non x
return (bool) : Renvoie True si x est dans f, False sinon
"""
if type(f) == File1 :
if x in f.file :
return True
else :
return False
elif type(f) == File2 :
if f.tete == x :
return True
elif f.queue != None :
return in_file(x,f.queue)
else :
return False
else :
return False
def comp(c1,c2) :
"""
Fonction de comparaison entre deux cartes
param c1 : (tuple) Carte 1
param c2 : (tuple) Carte 2
return : Renvoie
-1 si => c1 < c2
1 si => c1 > <2
0 si => c1 == c2
"""
if VAL_CARTE.index(c1[0]) < VAL_CARTE.index(c2[0]) :
return -1
elif VAL_CARTE.index(c1[0]) > VAL_CARTE.index(c2[0]) :
return 1
else :
return 0
def creer_jeu():
"""
Fonction qui crée un jeu aléatoire
return a,b (File) Deux files contenant 26 cartes chacunes
"""
i = 0
val_carte = ['1','2','3','4','5','6','7','8','9','10','V','D','R','AS']
col_carte = ['P','T','C','H']
f1 = File1()
f2 = File1()
while i < 52 :
val = random.randint(0,len(val_carte)-1)
col = random.randint(0,len(col_carte)-1)
carte = (val_carte[val],col_carte[col])
if in_file(carte,f1) == False or in_file(carte,f2) == False :
if i%2 == 0 :
f1.enfile(carte)
else :
f2.enfile(carte)
i+=1
return f1,f2
def tour(f1,f2) :
"""
Foncton qui simule un tour de bataille
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
i = f1.defile()
j = f2.defile()
res = comp(i,j)
if # A compléter
elif # A compléter
else :
print('bataille')
if # A compléter :
bataille(i,j,f1,f2)
else :
# Si un des deux paquet ne peut pas faire la bataille alors on le vide pour faire gagner l'autre joueur
if # A compléter :
# A compléter
else :
# A compléter
def bataille(c1,c2,f1,f2) :
"""
Fonction simulant un tour de bataille
param c1 : (tuple) Carte n°1 égale a c2
param c2 : (tuple) Carte n°1 égale a c1
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
bataille_tab= []
while comp(c1,c2) == 0:
# A compléter
if comp(c1,c2) == 1 :
# A compléter
if comp(c1,c2) == -1 :
# A compléter
def est_fini(f1,f2):
"""
Fonction qui détermine si le jeu est fini
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
return (bool): renvoie True si le jeu est fini, False sinon.
"""
if # A compléter
elif # A compléter
else :
# A compléter
def game(f1,f2):
"""
Fonction simulant le jeu de la bataille
param f1: (File) File contenant le jeu n°1
param f2: (File) File contenant le jeu n°2
"""
while not est_fini(f1,f2) :
tour(f1,f2)