Exercice 2 OK

TP1/Exercice2.py

+import random
+
+class Prisonnier:
+    """
+    Classe représentant un prisonnier avec une stratégie basée sur une probabilité d'avouer.
+    """
+    def __init__(self, proba_avouer=0.5):
+        """
+        Constructeur de la classe Prisonnier.
+        
+        Args:
+            proba_avouer: probabilité d'avouer (par défaut 0.5 pour un joueur aléatoire uniforme)
+        """
+        self.proba_avouer = proba_avouer
+        self.historique_adversaire = []
+    
+    def jouer(self):
+        """
+        Méthode qui détermine l'action du joueur en fonction de sa probabilité d'avouer.
+        
+        Returns:
+            'avoue' ou 'nie' selon la probabilité
+        """
+        if random.random() < self.proba_avouer:
+            return "avoue"
+        else:
+            return "nie"
+    
+    def maj(self, coup):
+        """
+        Méthode qui met à jour l'historique des coups joués par l'adversaire.
+        
+        Args:
+            coup: le coup joué par l'adversaire ('avoue' ou 'nie')
+        """
+        self.historique_adversaire.append(coup)
+
+
+class TitForTat(Prisonnier):
+    """
+    Stratégie Tit for Tat (oeil pour oeil) : commence par coopérer (nier),
+    puis imite le dernier coup de l'adversaire.
+    """
+    def __init__(self):
+        """
+        Constructeur de la classe TitForTat.
+        """
+        super().__init__()  # Appel du constructeur de la classe parente
+    
+    def jouer(self):
+        """
+        Méthode qui détermine l'action du joueur selon la stratégie Tit for Tat.
+        
+        Returns:
+            'avoue' ou 'nie' selon la stratégie
+        """
+        # Si c'est le premier coup, on coopère (nie)
+        if not self.historique_adversaire:
+            return "nie"
+        # Sinon, on imite le dernier coup de l'adversaire
+        else:
+            return self.historique_adversaire[-1]
+
+
+class Dummy(Prisonnier):
+    """
+    Stratégie Dummy : toujours coopérer ou toujours trahir selon un paramètre.
+    """
+    def __init__(self, coopere=True):
+        """
+        Constructeur de la classe Dummy.
+        
+        Args:
+            coopere: si True, toujours coopérer (nier), sinon toujours trahir (avouer)
+        """
+        super().__init__()  # Appel du constructeur de la classe parente
+        self.coopere = coopere
+    
+    def jouer(self):
+        """
+        Méthode qui détermine l'action du joueur selon la stratégie Dummy.
+        
+        Returns:
+            'avoue' ou 'nie' selon la stratégie
+        """
+        if self.coopere:
+            return "nie"  # Coopérer = nier
+        else:
+            return "avoue"  # Trahir = avouer
+
+
+def jouer_partie(joueur1, joueur2, matrice_pertes, nb_tours=10):
+    """
+    Fonction qui simule une partie entre deux joueurs.
+    
+    Args:
+        joueur1: premier joueur
+        joueur2: deuxième joueur
+        matrice_pertes: dictionnaire des pertes
+        nb_tours: nombre de tours à jouer
+        
+    Returns:
+        tuple des scores totaux (score_joueur1, score_joueur2)
+    """
+    score_joueur1 = 0
+    score_joueur2 = 0
+    
+    for tour in range(nb_tours):
+        # Les joueurs choisissent leur action
+        action_joueur1 = joueur1.jouer()
+        action_joueur2 = joueur2.jouer()
+        
+        # On calcule les pertes pour ce tour
+        perte_joueur1, perte_joueur2 = matrice_pertes[(action_joueur1, action_joueur2)]
+        
+        # On met à jour les scores (négatif des pertes)
+        score_joueur1 -= perte_joueur1
+        score_joueur2 -= perte_joueur2
+        
+        # On met à jour l'historique des joueurs
+        joueur1.maj(action_joueur2)
+        joueur2.maj(action_joueur1)
+        
+        # Affichage du tour
+        print(f"Tour {tour+1}: Joueur 1 joue {action_joueur1}, Joueur 2 joue {action_joueur2}")
+        print(f"Pertes: Joueur 1 = {perte_joueur1}, Joueur 2 = {perte_joueur2}")
+        print(f"Scores cumulés: Joueur 1 = {score_joueur1}, Joueur 2 = {score_joueur2}\n")
+    
+    return score_joueur1, score_joueur2
+
+
+# Main pour tester le code
+if __name__ == "__main__":
+    # Définition des actions possibles
+    actions = ["avoue", "nie"]
+    
+    # Représentation des pertes (peines) par un dictionnaire
+    pertes = {
+        ("avoue", "avoue"): (3, 3),
+        ("avoue", "nie"): (0, 10),
+        ("nie", "avoue"): (10, 0),
+        ("nie", "nie"): (1, 1)
+    }
+    
+    print("Exercice 2: Stratégies et dilemme itéré")
+    print("======================================")
+    
+    print("\nTest des classes de stratégies")
+    print("-----------------------------")
+    
+    # Création des joueurs
+    p_random = Prisonnier()
+    p_tit_for_tat = TitForTat()
+    p_dummy_coopere = Dummy(coopere=True)
+    p_dummy_trahit = Dummy(coopere=False)
+    
+    print("Joueur aléatoire (Prisonnier) :")
+    for i in range(3):
+        print(f"Coup {i+1}: {p_random.jouer()}")
+    
+    print("\nJoueur TitForTat :")
+    print(f"Premier coup (sans historique): {p_tit_for_tat.jouer()}")
+    
+    # Simulons quelques coups de l'adversaire
+    adversaire_coups = ["avoue", "nie", "avoue"]
+    for i, coup in enumerate(adversaire_coups):
+        p_tit_for_tat.maj(coup)
+        print(f"Après que l'adversaire a joué {coup}, TitForTat joue: {p_tit_for_tat.jouer()}")
+    
+    print("\nJoueur Dummy (coopère) :")
+    for i in range(3):
+        print(f"Coup {i+1}: {p_dummy_coopere.jouer()}")
+    
+    print("\nJoueur Dummy (trahit) :")
+    for i in range(3):
+        print(f"Coup {i+1}: {p_dummy_trahit.jouer()}")
+    
+    print("\nSimulation d'une partie")
+    print("---------------------")
+    
+    # Réinitialisation des joueurs pour la partie
+    joueur1 = TitForTat()
+    joueur2 = Dummy(coopere=False)
+    
+    print(f"Joueur 1: TitForTat")
+    print(f"Joueur 2: Dummy (trahit)")
+    
+    # Jouer une partie de 5 tours
+    score_joueur1, score_joueur2 = jouer_partie(joueur1, joueur2, pertes, nb_tours=5)
+    
+    print("Résultat final:")
+    print(f"Score Joueur 1 (TitForTat): {score_joueur1}")
+    print(f"Score Joueur 2 (Dummy trahit): {score_joueur2}")
+    
+    if score_joueur1 > score_joueur2:
+        print("Le Joueur 1 (TitForTat) gagne!")
+    elif score_joueur2 > score_joueur1:
+        print("Le Joueur 2 (Dummy trahit) gagne!")
+    else:
+        print("Match nul!")
\ No newline at end of file