# 📘 README – Minimax pour le jeu de Nim

## 🎯 Objectif
Ce TP a pour but d’implémenter l’algorithme **Minimax** dans le jeu de **Nim** (variante à 1 tas où l’on peut retirer 1, 2 ou 3 objets).  
On développe plusieurs versions de l’algorithme pour comprendre ses optimisations possibles.

---

## 📂 Fichiers
Le projet contient **4 fichiers Java**, correspondant chacun à une variante de Minimax :

1. **`MinimaxSimple.java`**  
   - Version de base.  
   - Explore toutes les possibilités jusqu’à la fin de la partie.  
   - Pas d’optimisation → explore parfois plus que nécessaire.

2. **`MinimaxEarlyStop.java`**  
   - Optimisation par **arrêt anticipé** .  
   - Si un coup gagnant (pour Max) ou perdant (pour Min) est trouvé, la recherche s’arrête immédiatement.  
   - Même résultat que la version simple, mais plus rapide.
```bash
boutaric@MacBook-James TP1 % time java MinimaxSimple 
Résultat pour n=8 → -1
java MinimaxSimple  0,03s user 0,03s system 49% cpu 0,136 total
```
```bash
boutaric@MacBook-James TP1 % time java MinimaxStop 
Résultat  pour n=7 → 1
java MinimaxStop  0,04s user 0,02s system 93% cpu 0,062 total
```


3. **`MinimaxProfondeur.java`**  
   - Variante avec **profondeur maximale fixée**.  
   - Quand la profondeur limite est atteinte, on utilise une **fonction d’évaluation heuristique**.  
   - Heuristique utilisée : une position est perdante si `n % 4 == 0`, sinon gagnante.

4. **`MinimaxMemo.java`**  
   - Optimisation par **mémoïsation**.  
   - Utilise deux tableaux (`memoMax` et `memoMin`) pour stocker les résultats déjà calculés.  
   - Évite les recalculs et accélère l’algorithme pour des valeurs de `n` plus grandes.

---

## ▶️ Exécution
Compiler et lancer chaque fichier séparément :  

```bash
javac MinimaxSimple.java
java MinimaxSimple
```

```bash
javac MinimaxEarlyStop.java
java MinimaxEarlyStop
```

```bash
javac MinimaxProfondeur.java
java MinimaxProfondeur
```

```bash
javac MinimaxMemo.java
java MinimaxMemo
```

Chaque programme affiche le résultat pour une valeur donnée de `n` (taille initiale du tas).  
- `+1` → Position gagnante pour Max (le joueur qui commence).  
- `-1` → Position perdante pour Max.  

---

## 📊 Exemple de résultats
Pour les premières positions de Nim (1 tas) :  

| n  | Résultat | Commentaire |
|----|----------|-------------|
| 1  | +1       | Max peut tout prendre et gagne |
| 2  | +1       | Max peut tout prendre et gagne |
| 3  | +1       | Max peut tout prendre et gagne |
| 4  | -1       | Position perdante (Min gagne) |
| 5  | +1       | Max enlève 1 → reste 4 (perdant pour Min) |
| 6  | +1       | Max enlève 2 → reste 4 |
| 7  | +1       | Max enlève 3 → reste 4 |
| 8  | -1       | Position perdante |
| ...| ...      | ... |

---

## 🧠 Conclusion
- Le **Minimax simple** permet de comprendre la logique de base.  
- Le **Minimax stop** améliore la performance sans changer le résultat.  
- La **profondeur fixe + heuristique** est utile si l’arbre est trop grand.  
- La **mémoïsation** accélère énormément le calcul pour des valeurs de `n` élevées.