Premier commit

File.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+class File_lst:
+    """Implémentation d'une file par une liste."""
+    def __init__(self):
+        """Crée une file vide."""
+        self.__file = []
+
+    def est_vide(self):
+        """Indique si la file est vide."""
+        return self.__file == []
+
+    def enfiler(self, valeur):
+        """Enfile l'élément valeur."""
+        self.__file.append(valeur)
+
+    def defiler(self):
+        """Défile la tête de la file et la renvoie."""
+        return self.__file.pop(0)
+
+    def taille(self):
+        """Renvoie la taille de la file."""
+        return len(self.__file)
+
+    def tete(self):
+        """Renvoie la tête de la file (sans la défiler)."""
+        return self.__file[0]
+
+    def __str__(self):
+        s = "tete->"
+        for val in self.__file:
+            s += str(val) + "->"
+        return s + "queue"
+
+
+class Maillon:
+    """Un maillon d'une liste doublement chaînée."""
+    def __init__(self, precedent, valeur, suivant):
+        self.valeur = valeur
+        self.precedent = precedent
+        self.suivant = suivant
+
+    def __str__(self):
+        return str(self.valeur)
+
+
+class File_chaine:
+    """Implémentation d'une file par une liste doublement chaînée."""
+    def __init__(self):
+        """Crée une file vide."""
+        self.__debut = self.__fin = None
+        self.__taille = 0
+
+    def est_vide(self):
+        """Indique si la file est vide."""
+        return self.__taille == 0
+
+    def enfiler(self, valeur):
+        """Enfile l'élément valeur."""
+        maillon = Maillon(self.__fin, valeur, None)
+        if self.est_vide():
+            self.__debut = self.__fin = maillon
+        else:
+            self.__fin.suivant = maillon
+            self.__fin = maillon
+        self.__taille += 1
+
+    def defiler(self):
+        """Défile la tête de la file et la renvoie."""
+        if self.est_vide():
+            raise IndexError("Impossible de défiler une file vide.")
+        valeur = self.__debut.valeur
+        self.__taille -= 1
+        if self.est_vide():
+            self.__debut = self.__fin = None
+        else:
+            self.__debut = self.__debut.suivant
+            self.__debut.precedent = None
+        return valeur
+
+    def taille(self):
+        """Renvoie la taille de la file."""
+        return self.__taille
+
+    def tete(self):
+        """Renvoie la tête de la file (sans la défiler)."""
+        if self.est_vide():
+            raise IndexError("Une file vide n'a pas de tête.")
+        return self.__debut.valeur
+
+    def __str__(self):
+        s = "tete->"
+        maillon = self.__debut
+        while maillon is not None:
+            s += str(maillon) + "->"
+            maillon = maillon.suivant
+        return s + "queue"
+
+
+if __name__ == "__main__":
+    f = File_lst()
+    print(f.est_vide())
+    f.enfiler('A')
+    f.enfiler('B')
+    f.enfiler('C')
+    print(f.est_vide())
+    print(f.tete())
+    print(f)
+    print(f.taille())
+    print(f.defiler())
+    print(f.defiler())
+    print(f.defiler())
+    print(f.est_vide())

README.txt

@@ -0,0 +1,24 @@
+Votre mission, si vous l’acceptez (et même si vous ne l’acceptez pas), est de réaliser un jeu de bataille en
+utilisant une structure de donnée adaptée, et avec une interface graphique. Vous aurez pour cela 6 heures
+(les trois séances jusqu’aux vacances de Noël).
+Plus précisément, on attend au minimum :
+• Une classe Carte ayant
+– deux attributs valeur et couleur
+– une méthode compare qui prend en paramètre une autre carte other, et qui renvoie
+1 si la valeur de self est supérieure à la valeur de other ;
+−1 si la valeur de other est supérieure à la valeur de self ;
+0 si les deux valeurs sont les mêmes.
+• Une classe Jeux ayant
+– Un attribut paquet contenant toutes les cartes du jeux. Le nombre de cartes (32 ou 54) sera un paramètre
+du constructeur. Ce paquet sera créé puis mélangé dans le constructeur.
+– Une méthode distribue qui renvoie deux Files contenant la moitié des cartes du paquet chacune. On
+utilisera la classe File du cours (disponible sur Moodle).
+À chaque tour de jeu, chaque joueur joue la carte supérieure de son paquet. Le joueur ayant la carte de plus
+grande valeur récupère les deux cartes et les remets sous son paquet.
+En cas d’égalité, chaque joueur ajoute une carte à l’envers, puis une autre carte à l’endroit, et on compare à
+nouveau les valeurs. En cas de nouvelle égalité, on réitère le processus. Le gagnant remporte l’ensemble des
+cartes jouées.
+Si un joueur ne peut plus jouer car il n’a plus de carte, il a perdu la partie.
+Concernant l’interface graphique, elle sera réalisée en Tkinter, et permettra de faire une partie contre l’or-
+dinateur. Il n’est pas nécessaire d’afficher les cartes à un format graphique (même si ce n’est bien sûr pas
+interdit) : on pourra se contenter de textes de la forme « 3 de carreau » ou « roi de pique ».