fichier lien entre tp et cours mastermind
This commit is contained in:
318
representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md
Normal file
318
representation_construits/chapitre_1/tp/AIDE_MASTERMIND.md
Normal file
@@ -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 !*
|
||||
Reference in New Issue
Block a user