# 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 !*