ajout dossier Pile et File

Pile_File/Cours/Cours_Pile_File.md

@@ -0,0 +1,81 @@
+# Structure de données : Pile et File
+
+------
+
+## 1. Rappel :
+
+<u>**Structure de données**</u> : Collection d'information dans laquelle il est possible de stocker, traiter, organiser, extraire des données.
+
+Les structures de données connues à ce jour sont : Les tableaux, les dictionnaires, les chaînes de caractères, les n-uplets. Chacune de ces structures possèdent des caractéristiques propres qui créent des avantages et des inconvénients selon la situation.
+
+De plus, ces types sont natifs à python, et aux autres langages selon les cas. Nous n'avons donc ici aucune idée de comment le type *dict* ou *tuple* est crée par exemple.
+
+Les structures de données Pile et File ne sont pas natives à python et nous aurons donc besoin de les implémenter.
+
+## 2. Interface et implémentation : 
+
+Ces deux termes sont particulier et très important pour ce chapitre. Alors un petit rappel n'est pas de trop.
+
+<u>**Interface :**</u> L'interface d'un type est définie par les méthodes qui lui sont associées. 
+
+**<u>Implémentation :</u>** L'implémentation d'un type est la manière dont on va le coder.
+
+Il faut bien faire la distinction entre les deux termes.
+
+## 3. Pile
+
+### 3. 1. Définition
+
+Une pile est une structure de données dans la quelle les derniers éléments entrant dans la structure seront les premiers à en sortir, nous appelons ce principe **LIFO (Last In First Out)**. Afin d'imager cette structure nous pouvons penser à un pile d'assiettes par exemple.
+
+![image-20220729234146926](../Images/Pile.png)
+
+Ici seul le premier élément est accessible.  
+
+### 3. 2. Interface
+
+Méthodes associées à la pile :
+
+- Empile : Méthode permettant d'empiler un élément.
+  - L'élément sera positionné au haut de la pile
+- Depile : Méthode permettant d'enlever un élément.
+  - L'élément enlever sera celui en haut de la pile.
+
+- Est_vide : Permet de savoir si la pile est vide ou non
+
+On peut ajouter d'autres méthodes :
+
+- Taille : Permet de savoir le nombre d'élément de la pile
+- Top : Permet de connaître l'élément au dessus de la pile.
+
+## 3. File
+
+### 3. 1. Définition
+
+Une file est une structure de données dans la quelle les derniers éléments entrant dans la structure seront les dernier à en sortir, nous appelons ce principe **FIFO (First In First Out)**. Afin d'imager cette structure nous pouvons penser à un file de voiture sur une route par exemple.
+
+![File](../Images/File.png)
+
+Ici seul le premier élément peut sortir de la structure.    
+
+### 3. 2. Interface
+
+Méthodes associées à la pile :
+
+- Enfile: Méthode permettant d'enfile un élément.
+  - L'élément sera positionné au haut de la file
+- Defile: Méthode permettant d'enlever un élément.
+  - L'élément enlever sera celui en bas de la file.
+
+- Est_vide : Permet de savoir si la file est vide ou non
+
+On peut ajouter d'autres méthodes :
+
+- Taille : Permet de savoir le nombre d'élément de la file
+- Top : Permet de connaître l'élément au dessus de la file.
+
+## 4. Conclusion
+
+Les deux structures ont une interface très semblable. Seul le principe FIFO / LIFO peut les différencier. 
+
+La suite du chapitre se concentrera sur l'utilisation de ses structures et leurs implémentations.

Pile_File/TD/TD_Pile_File.md

@@ -0,0 +1,31 @@
+# TD Pile et File
+
+------
+
+Le but du TD est de manipuler des piles et des files sans avoir d'implémentation.
+
+## 1 Application de cours
+
+### 1. 1. Pile
+
+<u>Voici une pile :</u>
+
+![Pile_td](../Images/Pile_td.png)
+
+1. Quel sera l'état de la pile après l'utilisation des méthodes suivantes :
+   - Depile(), Depile(), Empile(7), Empile(8),Depile()
+   - Que renvoie la méthode top() ?
+2. Reprenons la pile de l'image, que faut t'il faire comme méthode pour que Est_vide() soit vrai ? 
+3. En partant de 0 écrire les méthodes permettant de créer une pile contenant les numéros dans cette ordre 19982018. (1 est en bas de pile)
+
+### 1. 2. File
+
+<u>Voici une file :</u>
+
+![image-20220730000106940](../Images/File_td.png)
+
+1. Quel sera l'état de la file après l'utilisation des méthodes suivantes :
+   - Defile(), Defile(), Enfile(7), Enfile(8),Defile()
+   - Que renvoie la méthode top() ?
+2. Reprenons la file de l'image, que faut t'il faire comme méthode pour que Est_vide() soit vrai ? 
+3. En partant de 0 écrire les méthodes permettant de créer une file contenant les numéros dans cette ordre 19982018. (1 est en haut de pile)

Pile_File/TP/Bataille_correction.py

@@ -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()

Pile_File/TP/File.py

@@ -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]
+        
+
+    
+    
+    

Pile_File/TP/TP_File.md

@@ -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.

Pile_File/TP/TP_Pile.md

@@ -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
+```
+

Pile_File/TP/TP_Pile_correction.py

@@ -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)
+    

Pile_File/TP/carte_eleve.py

@@ -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)