Aller au contenu

Aide pour le TP Mastermind : Ce que vous aviez dans le cours

Ce document montre que toutes les notions nécessaires au TP ont été vues en cours. Pour chaque étape du TP, vous trouverez la référence exacte au cours correspondant.

Rappel des consignes du TP

Créer une fonction mastermind(combinaison, proposition) qui : 1. Génère une combinaison secrète de 4 couleurs 2. Demande au joueur de deviner 3. Compare la proposition avec la combinaison 4. Renvoie une liste d'indices (X = bien placé, O = mal placé)

Étape 1 : Créer une liste pour la combinaison secrète

Ce qu'il faut faire

combinaison_secrete = ['R', 'B', 'V', 'J']

Où c'était dans le cours

Cours sur les listes (README.md - Section "Créer une liste") :

"On peut les créer par extension (comprendre une liste déclaré littéralement) comme ceci :" 

liste = [3, 8, 5, 4]

Vous savez donc créer une liste contenant 4 éléments. Ici, au lieu de nombres, on met des lettres (chaînes de caractères) : 'R', 'B', 'V', 'J'.

Étape 2 : Accéder aux éléments d'une liste par leur indice

Ce qu'il faut faire

Pour comparer la combinaison et la proposition élément par élément, il faut accéder à chaque position : 

combinaison[0]  # Premier élément
combinaison[1]  # Deuxième élément
# etc.

Où c'était dans le cours

Cours sur les listes (README.md - Section "Accéder aux éléments d'une liste") :

"Le premier élément d'une liste a pour indice 0." 

l_1 = [2,4,6,8]
len(l_1)  # Renvoie 4

Donc si combinaison = ['R', 'B', 'V', 'J'] : - combinaison[0] vaut 'R' - combinaison[1] vaut 'B' - combinaison[2] vaut 'V' - combinaison[3] vaut 'J'

Étape 3 : Parcourir une liste avec une boucle for

Ce qu'il faut faire

Parcourir les 4 positions de la combinaison pour les comparer une par une.

Où c'était dans le cours

Cours sur les listes (README.md - Section "Parcours d'une séquence") :

"On peut également utiliser une boucle en itérant l'indice i des éléments :" 

for i in range(len(liste_2)):
    print(liste_2[i], end='')
"Ici, pour i compris entre 0 et longueur de liste_2, on va afficher l'élément correspondant à l'indice valant i."

Cours sur les boucles (programmation/chapitre_3 - Section 2.2) :

"La fonction range permet de générer un intervalle sous la forme d'une liste d'entiers. Par exemple, l'appel range(n) génère n entiers : 0, 1, 2, ..., n-1."

Pour parcourir une liste de 4 éléments : 

for i in range(4):
    # i prend les valeurs 0, 1, 2, 3
    print(combinaison[i])

Étape 4 : Comparer deux éléments (test d'égalité)

Ce qu'il faut faire

Vérifier si la couleur proposée est la même que la couleur secrète à la même position.

Où c'était dans le cours

Cours sur les conditionnelles (programmation/chapitre_2 - Section 2) :

"Les opérateurs de comparaisons sont :" - == : est égal à - != : est différents de

"⚠ ATTENTION : le test d'égalité entre deux variables se fait avec un double égal =="

Donc pour comparer : 

if combinaison[i] == proposition[i]:
    # Les couleurs sont identiques à la même position

Étape 5 : Utiliser des structures conditionnelles (if/elif/else)

Ce qu'il faut faire

  • Si la couleur est bien placée → ajouter 'X'
  • Sinon, si la couleur existe ailleurs → ajouter 'O'
  • Sinon → ne rien ajouter (ou ajouter un espace)

Où c'était dans le cours

Cours sur les conditionnelles (programmation/chapitre_2 - Sections 3, 4, 5) :

"Si une ou plusieurs conditions sont réalisées Alors on exécute une ou plusieurs instructions" 

if condition:
    instruction1
elif condition2:
    instruction2
else:
    instruction3

Exemple pour le Mastermind : 

if combinaison[i] == proposition[i]:
    indices.append('X')  # Bien placé
elif proposition[i] in combinaison:
    indices.append('O')  # Mal placé

Étape 6 : Vérifier si un élément est dans une liste (opérateur in)

Ce qu'il faut faire

Vérifier si une couleur proposée existe quelque part dans la combinaison secrète.

Où c'était dans le cours

Cours sur les listes (README.md - Section "À retenir") :

Opération Résultat
x in t Renvoie True si un élément de t est égal à x
x not in t Renvoie True si aucun élément de t n'est égal à x

Donc : 

if 'R' in combinaison:
    print("Le rouge est dans la combinaison")

Étape 7 : Ajouter un élément à une liste (append)

Ce qu'il faut faire

Construire la liste des indices en ajoutant 'X' ou 'O' au fur et à mesure.

Où c'était dans le cours

Cours sur les listes (README.md - Section "Propriétés") :

"On peut ajouter un élément avec le mot clé append :" 

liste = [1,2,3,4,5]
liste.append(6)
print(liste)
[1,2,3,4,5,6]
"L'élément ajouté se positionne donc à la fin de la liste"

Pour construire la liste d'indices : 

indices = []  # Liste vide au départ
indices.append('X')  # Ajoute 'X' à la fin
indices.append('O')  # Ajoute 'O' à la fin
# indices vaut maintenant ['X', 'O']

Étape 8 : Créer une fonction

Ce qu'il faut faire

Encapsuler le code dans une fonction mastermind(combinaison, proposition).

Où c'était dans le cours

Cours sur les fonctions (programmation/chapitre_4 - Section 2) :

"En Python, on définit une fonction en utilisant l'instruction def :" 

def nom_de_la_fonction(parametre1, parametre2):
    corps_de_la_fonction
    return valeur

"Le corps de la fonction doit nécessairement être indenté."

Structure de la fonction Mastermind : 

def mastermind(combinaison, proposition):
    indices = []
    # ... code de comparaison ...
    return indices

Étape 9 : Renvoyer une valeur avec return

Ce qu'il faut faire

La fonction doit renvoyer la liste des indices.

Où c'était dans le cours

Cours sur les fonctions (programmation/chapitre_4 - Section 2) :

"Très souvent, le corps de la fonction se terminera par l'instruction return suivie de la ou des valeurs que la fonction doit renvoyer."

def mastermind(combinaison, proposition):
    indices = []
    # ... votre code ...
    return indices  # Renvoie la liste créée

Étape 10 (bonus) : Boucle while pour les tentatives

Ce qu'il faut faire

Répéter le jeu tant que le joueur n'a pas trouvé (max 10 tentatives).

Où c'était dans le cours

Cours sur les boucles (programmation/chapitre_3 - Section 5.2) :

"En Python, les boucles 'Tant que' se codent en utilisant l'instruction while :" 

while condition:
    bloc_instructions
"Tant que condition vaut True les instructions du bloc sont répétées"

tentatives = 0
while tentatives < 10 and not gagne:
    # Demander une proposition
    # Vérifier avec la fonction mastermind
    tentatives = tentatives + 1

Récapitulatif : correspondance TP ↔ Cours

Étape du TP Notion Cours
Créer la combinaison secrète Créer une liste Listes - "Créer une liste"
Accéder à un élément Indice liste[i] Listes - "Accéder aux éléments"
Parcourir les 4 positions Boucle for i in range(4) Listes + Boucles chapitre 3
Comparer deux couleurs Opérateur == Conditionnelles chapitre 2
Tester bien/mal placé if/elif/else Conditionnelles chapitre 2
Couleur présente ? Opérateur in Listes - "À retenir"
Construire la liste indices append() Listes - "Propriétés"
Créer la fonction def ... return Fonctions chapitre 4
10 tentatives max Boucle while Boucles chapitre 3

Squelette de la solution

Voici la structure générale (à compléter) :

def mastermind(combinaison, proposition):
    """
    Compare la proposition avec la combinaison secrète.
    :param combinaison: liste de 4 couleurs (la combinaison secrète)
    :param proposition: liste de 4 couleurs (la proposition du joueur)
    :return: liste d'indices ('X' = bien placé, 'O' = mal placé)
    """
    indices = []  # Liste vide pour stocker les indices

    for i in range(4):  # Parcourir les 4 positions
        if combinaison[i] == proposition[i]:
            # La couleur est bien placée
            indices.append('X')
        elif proposition[i] in combinaison:
            # La couleur existe mais est mal placée
            indices.append('O')
        # Sinon on n'ajoute rien (ou on peut ajouter un espace)

    return indices

Attention : Ce squelette est simplifié. Il y a un piège ! Si une couleur apparaît plusieurs fois, le comportement peut être incorrect. Réfléchissez à comment gérer ce cas.

Vous aviez tout ce qu'il fallait dans vos cours. Relisez-les et lancez-vous !