From de9293ce69c3c583d46bbb9c35b29fea7cc04b19 Mon Sep 17 00:00:00 2001 From: Florian Mathieu Date: Fri, 16 Jan 2026 13:56:49 +0100 Subject: [PATCH] fichier lien entre tp et cours mastermind --- .../chapitre_1/tp/AIDE_MASTERMIND.md | 318 ++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100644 representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md diff --git a/representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md b/representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md new file mode 100644 index 0000000..7a27516 --- /dev/null +++ b/representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md @@ -0,0 +1,318 @@ +# 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 +```python +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 :"* +> ```python +> 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 : +```python +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**."* +> ```python +> 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 :"* +> ```python +> 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 : +```python +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 : +```python +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"* +> ```python +> if condition: +> instruction1 +> elif condition2: +> instruction2 +> else: +> instruction3 +> ``` + +Exemple pour le Mastermind : +```python +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 : +```python +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** :"* +> ```python +> 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 : +```python +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` :"* +> ```python +> 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 : +```python +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."* + +```python +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 :"* +> ```python +> while condition: +> bloc_instructions +> ``` +> *"Tant que `condition` vaut True les instructions du bloc sont répétées"* + +```python +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) : + +```python +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 !*