From f940c8df195aa986d3008e6b22c6418016cb475b Mon Sep 17 00:00:00 2001 From: "corentin.bollet" Date: Wed, 13 Dec 2023 11:58:31 +0100 Subject: [PATCH] main fonctionne un peu mieux mais pas totalement --- Pile.py | 91 +++++++++++++++++++++++++++++++++++++ Projetbataille0.py | 37 +++++++++------ listeChaine.py | 111 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 224 insertions(+), 15 deletions(-) create mode 100644 Pile.py create mode 100644 listeChaine.py diff --git a/Pile.py b/Pile.py new file mode 100644 index 0000000..3f198b5 --- /dev/null +++ b/Pile.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +from listeChaine import ListeChaine + +class Pile_lst: + """Implémentation d'une pile par une liste.""" + def __init__(self): + """Crée une pile vide.""" + self.__pile = [] + + def est_vide(self): + """Indique si la pile est vide.""" + return self.__pile == [] + + def empiler(self, valeur): + """Empile la valeur.""" + self.__pile.append(valeur) + + def depiler(self): + """Dépile le sommet de la pile et le renvoie.""" + return self.__pile.pop() + + def taille(self): + """Renvoie la taille de la pile.""" + return len(self.__pile) + + def sommet(self): + """Renvoie le sommet de la pile (sans le dépiler).""" + return self.__pile[-1] + + def __str__(self): + s = "|" + for val in self.__pile: + s = str(val) + "->" + s + return s + + +class Pile_chaine: + """Implémentation d'une pile par une liste chaînée.""" + def __init__(self): + """Crée une pile vide.""" + self.__pile = ListeChaine() + self.__taille = 0 + + def est_vide(self): + """Indique si la pile est vide.""" + return self.__taille == 0 + + def empiler(self, valeur): + """Empile la valeur.""" + self.__pile.ajoute(valeur) + self.__taille += 1 + + def depiler(self): + """Dépile le sommet de la pile et le renvoie.""" + if self.est_vide(): + raise IndexError("Impossible de dépiler une pile vide.") + valeur = self.__pile.tete() + self.__pile = self.__pile.queue() + self.__taille -= 1 + return valeur + + def taille(self): + """Renvoie la taille de la pile.""" + return self.__taille + + def sommet(self): + """Renvoie le sommet de la pile (sans le dépiler).""" + if self.est_vide(): + raise IndexError("Une pile vide n'a pas de sommet.") + return self.__pile.tete() + + def __str__(self): + return str(self.__pile) + "->|" + + +if __name__ == "__main__": + p = Pile_lst() + print(p.est_vide()) + p.empiler('A') + p.empiler('B') + p.empiler('C') + print(p.est_vide()) + print(p.sommet()) + print(p) + print(p.taille()) + print(p.depiler()) + print(p.depiler()) + print(p.depiler()) + print(p.est_vide()) diff --git a/Projetbataille0.py b/Projetbataille0.py index fa8c0c3..63a5743 100644 --- a/Projetbataille0.py +++ b/Projetbataille0.py @@ -70,29 +70,36 @@ class Jeux: nb_cartes = 42 #52 partie = Jeux(32) +def vider_dans(mise_1, mise_2,paquet_joueur): + """ajoute les cartes des mises dans le paquet du joueur (et supprime les mises)""" + while not mise_1.est_vide(): + paquet_joueur.enfiler(mise_1.depiler()) + while not mise_2.est_vide(): + paquet_joueur.enfiler(mise_2.depiler()) + + def main(): + """fonction principale""" jeu = Jeux(32) (paquet_joueur1, paquet_joueur2) = jeu.distribue() - paquet_tmp_joueur1 = Pile() - paquet_tmp_joueur2 = Pile() + mise_joueur1 = Pile() + mise_joueur2 = Pile() + + while not paquet_joueur1.est_vide() and not paquet_joueur2.est_vide(): - if paquet_joueur1.tete().compare(paquet_joueur2.tete()) == 1: - paquet_joueur1.enfiler(paquet_joueur1.defiler()) - paquet_joueur1.enfiler(paquet_joueur2.defiler()) + if mise_joueur1.est_vide() or mise_joueur1.est_vide(): + mise_joueur1.empiler(paquet_joueur1.defiler()) + mise_joueur2.empiler(paquet_joueur2.defiler()) + + if mise_joueur1.sommet().compare(mise_joueur1.sommet()) == 1: + vider_dans(mise_joueur1, mise_joueur2, paquet_joueur1) if paquet_joueur1.tete().compare(paquet_joueur2.tete()) == -1: - paquet_joueur2.enfiler(paquet_joueur1.defiler()) - paquet_joueur2.enfiler(paquet_joueur2.defiler()) + vider_dans(mise_joueur1, mise_joueur2, paquet_joueur2) else: for i in range(2): - paquet_tmp_joueur1.empiler(paquet_joueur1.defiler()) - paquet_tmp_joueur2.empiler(paquet_joueur2.defiler()) - if paquet_tmp_joueur1.sommet().compare(paquet_tmp_joueur2.sommet()) == 1: - paquet_joueur1.enfiler(paquet_tmp_joueur1.depiler()) - paquet_joueur1.enfiler(paquet_tmp_joueur2.depiler()) - if paquet_tmp_joueur1.sommet().compare(paquet_tmp_joueur2.sommet()) == -1: - paquet_joueur2.enfiler(paquet_tmp_joueur1.depiler()) - paquet_joueur2.enfiler(paquet_tmp_joueur2.depiler()) + mise_joueur1.empiler(paquet_joueur1.defiler()) + mise_joueur2.empiler(paquet_joueur2.defiler()) print("joueur1",paquet_joueur1) print("joueur2",paquet_joueur2) diff --git a/listeChaine.py b/listeChaine.py new file mode 100644 index 0000000..5c491ef --- /dev/null +++ b/listeChaine.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Tue Sep 22 20:44:35 2020 + +@author: manu +""" + + +class Maillon: + """Un maillon d'une liste chaînée.""" + def __init__(self, valeur, suivant): + self.valeur = valeur + self.suivant = suivant + + def __str__(self): + """Renvoie une chane de caractères représentant le maillon.""" + return str(self.valeur) + + +class ListeChaine: + """Une liste chaînée.""" + def __init__(self, tete=None): + """Crée une liste vide, ou une liste dont la tete (un maillon) + est donnée.""" + self.__tete = tete + + def est_vide(self): + """Indique si la liste est vide.""" + return self.__tete is None + + def tete(self): + """Renvoie la valeur du premier élément de la liste.""" + if self.est_vide(): + raise IndexError("La liste vide n'a pas de tête") + return self.__tete.valeur + + def queue(self): + """Renvoie la queue de la liste.""" + if self.est_vide(): + raise IndexError("La liste vide n'a pas de queue") + return ListeChaine(self.__tete.suivant) + + def ajoute(self, valeur): + """ajoute `valeur` en tête de la liste.""" + self.__tete = Maillon(valeur, self.__tete) + + def __str__(self): + """Renvoie une chaîne de caractères représentant la liste.""" + maillon = self.__tete + s = '' + while maillon is not None: + s = s + str(maillon.valeur) + maillon = maillon.suivant + if maillon is not None: + s += '->' + return s + + def __len__(self): + """Renvoie la longueur de la liste.""" + maillon = self.__tete + long = 0 + while maillon is not None: + long = long + 1 + maillon = maillon.suivant + return long + + def __getitem__(self, n): + """Renvoie l'élément d'indice n de la liste.""" + maillon = self.__tete + i = 0 + while i < n and maillon is not None: + i = i + 1 + maillon = maillon.suivant + if maillon is None or n < 0: + raise IndexError("Indice non valide") + return maillon.valeur + + def __add__(self, other): + """Renvoie la liste correspondant à la concaténation des 2 listes.""" + if self.est_vide(): + return other + v = self.tete() + q = self.queue() + return ListeChaine(Maillon(v, (q + other).__tete)) + + def reverse(self): + """Renvoie une liste correspondant à la liste renversée.""" + res = ListeChaine() + maillon = self.__tete + while maillon is not None: + res.ajoute(maillon.valeur) + maillon = maillon.suivant + return res + + +if __name__ == "__main__": + lst = ListeChaine() + print(lst.est_vide()) + lst.ajoute(306) + lst.ajoute(42) + lst.ajoute(205) + print(lst) + print(lst.est_vide()) + print(lst[0]) + print(lst[1]) + print(len(lst)) + lst2 = ListeChaine() + lst2.ajoute(18) + lst2.ajoute(45) + print(lst + lst2)