Projets : structure par projet (jeu_de_la_vie, labyrinthe, mastermind, wator)

Projets/mastermind/JALONS.md

@@ -0,0 +1,80 @@
+# Jalons — Mastermind & Algorithmes Génétiques
+
+> Progression suggérée sur ~10 séances (septembre → février)
+
+---
+
+## Phase 1 — Comprendre les algorithmes génétiques (Séances 1-2)
+
+**Objectif :** Saisir l'analogie entre évolution biologique et optimisation.
+
+- Lire la fiche `../src/src_mastermind_fiche.md` du début jusqu'à la section "Les individus"
+- Répondre aux questions : qu'est-ce qu'un individu ? une population ? le fitness ? la sélection ?
+- Schématiser à la main le cycle d'un algorithme génétique :
+  ```
+  Génèse → Évaluation → Sélection → Croisement → Mutation → [retour Évaluation]
+  ```
+- Expliquer en une phrase comment cet algorithme peut résoudre le Mastermind
+
+---
+
+## Phase 2 — L'individu : la classe Combinaison (Séances 3-4)
+
+**Objectif :** Implémenter la brique de base.
+
+- Implémenter `init_value(self)` → génère une combinaison aléatoire de couleurs
+- Implémenter `cross_with(self, other)` → croisement en 1 point (renvoie 2 enfants)
+- Implémenter `mutate_gene(self, gene)` → remplace un gène par une autre couleur aléatoire
+- Tester chaque méthode indépendamment avant de passer à la suite
+
+**Point clé :** le croisement en 1 point prend un indice aléatoire et échange les parties.
+
+---
+
+## Phase 3 — Le problème : la classe Mastermind (Séances 5-6)
+
+**Objectif :** Définir comment évaluer une combinaison.
+
+- Implémenter `create_individual(self)` → crée un individu aléatoire du bon type
+- Implémenter `evaluate_fitness(self, individual)` → compte les gènes bien placés
+- Implémenter `best_individual(self, population)` → renvoie le meilleur de la population
+- Implémenter `tournament(self, first, second)` → compare deux individus, garde le meilleur
+- Tester avec une combinaison cible connue et vérifier que le score est correct
+
+---
+
+## Phase 4 — L'algorithme : la classe AlgoGen (Séances 7-8)
+
+**Objectif :** Assembler toutes les briques.
+
+- Implémenter `genesis(self)` → crée la population initiale
+- Implémenter `evaluate_population(self, population)` → évalue tous les individus
+- Implémenter `next_generation_tournament(self, population)` → sélection par tournoi
+- Implémenter `crossover(self, population)` → croisements entre les meilleurs
+- Implémenter `mutate(self, individuals)` → applique les mutations
+- Implémenter `solve(self, nb_generations)` → boucle principale
+
+---
+
+## Phase 5 — Tests, ajustement et documentation (Séances 9-10)
+
+**Objectif :** Valider et optimiser.
+
+- Tester avec la combinaison exemple : `Mastermind(["bleu", "blanc", "blanc", "rouge"])`
+- Faire varier les paramètres : taille de population, probabilité de mutation, taux de croisement
+- Observer : combien de générations faut-il en moyenne pour trouver la solution ?
+- Tracer la courbe de convergence (fitness max par génération)
+- Compléter le `SUIVI.md` et préparer les questions pour le Grand Oral
+
+---
+
+## Idées d'extension avancée
+
+- **Nouveau problème** : adapter le framework à un autre problème (labyrinthe, sac à dos, TSP...)
+- **Roulette vs tournoi** : implémenter une sélection par roulette et comparer les performances
+- **Mastermind jouable** : ajouter une interface où un humain joue contre l'IA
+- **Parallélisation** : tester plusieurs populations en parallèle et garder la meilleure
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/mastermind/README.md

@@ -0,0 +1,53 @@
+# Projet — Mastermind & Algorithmes Génétiques
+
+> Darwin rencontre la programmation : faire évoluer une population de combinaisons pour qu'elle converge vers la solution cachée du Mastermind — sans jamais la connaître à l'avance.
+
+## Contexte
+
+Le **Mastermind** est un jeu de déduction : un joueur choisit une combinaison secrète de 4 couleurs parmi 8, l'autre doit la deviner en un minimum d'essais.
+
+Plutôt que de coder une IA par force brute, ce projet applique un **algorithme génétique** : on fait évoluer une population de combinaisons candidates en s'inspirant de la sélection naturelle (tournoi, croisement, mutation) jusqu'à trouver la solution.
+
+Une base de code complète est disponible dans `../src/` :
+- `algo_gen.py` — framework de l'algorithme génétique
+- `combinaison.py` — représentation d'un individu (une combinaison)
+- `src_mastermind_fiche.md` — fiche TP détaillée avec toutes les consignes
+
+## Compétences mobilisées
+
+| Notion | Chapitre du cours |
+|--------|-------------------|
+| Classes, héritage, encapsulation | POO |
+| Paradigme fonctionnel (fonctions pures) | Paradigmes |
+| Algorithmes d'optimisation | Algorithmique |
+| Listes, compréhensions de listes | Programmation |
+| Probabilités appliquées | — |
+
+## Cahier des charges
+
+### Fonctionnalités minimales
+
+- [ ] Implémenter la classe `Combinaison` (individu) : création aléatoire, croisement, mutation
+- [ ] Implémenter la classe `Mastermind` (problème) : évaluation du fitness, tournoi
+- [ ] Implémenter la classe `AlgoGen` : génèse, sélection, croisement, mutation, solve
+- [ ] Résoudre une combinaison cible en un nombre raisonnable de générations
+- [ ] Afficher l'évolution du meilleur individu à chaque génération
+
+### Extensions possibles
+
+- [ ] Adapter le framework à un autre problème (labyrinthe, sac à dos...)
+- [ ] Comparer plusieurs stratégies de sélection (tournoi vs roulette)
+- [ ] Tracer la courbe de convergence (fitness max par génération)
+- [ ] Implémenter un Mastermind jouable par un humain vs l'IA
+
+## Ressources
+
+- `../src/src_mastermind_fiche.md` — fiche TP complète avec toutes les consignes
+- `../src/algo_gen.py` — squelette du framework générique
+- `../src/combinaison.py` — classe individu à compléter
+- [Algorithme génétique — Wikipedia](https://fr.wikipedia.org/wiki/Algorithme_génétique)
+- [Mastermind — Wikipedia](https://fr.wikipedia.org/wiki/Mastermind)
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/mastermind/SUIVI.md

@@ -0,0 +1,72 @@
+# Suivi de projet — [Nom du projet]
+
+**Élève(s) :**
+**Classe :**
+**Projet :**
+**Date de début :**
+
+---
+
+## Journal de bord
+
+*Compléter après chaque séance.*
+
+### Séance 1 — [Date]
+
+**Objectif de la séance :**
+
+**Ce que j'ai fait :**
+
+**Difficultés rencontrées :**
+
+**Décisions prises et pourquoi :**
+
+**Ce qu'il reste à faire :**
+
+---
+
+### Séance 2 — [Date]
+
+**Objectif de la séance :**
+
+**Ce que j'ai fait :**
+
+**Difficultés rencontrées :**
+
+**Décisions prises et pourquoi :**
+
+**Ce qu'il reste à faire :**
+
+---
+
+*(Dupliquer le bloc ci-dessus pour chaque séance)*
+
+---
+
+## Bilan du projet
+
+### Ce qui fonctionne
+
+### Ce qui ne fonctionne pas encore (et pourquoi)
+
+### Choix techniques importants
+
+*Quelles décisions as-tu prises ? Pourquoi ce choix plutôt qu'un autre ?*
+
+### Ce que j'ai appris
+
+---
+
+## Préparation au Grand Oral
+
+*Le Grand Oral dure 20 minutes. Tu dois pouvoir présenter ton projet et répondre à des questions. Prépare-toi en répondant à ces questions :*
+
+**1. En quoi consiste ton projet ? Explique-le en 2 minutes à quelqu'un qui ne connaît pas l'informatique.**
+
+**2. Quelles notions du cours as-tu utilisées ? Donne un exemple concret dans ton code.**
+
+**3. Quelle a été la difficulté principale ? Comment l'as-tu résolue ?**
+
+**4. Qu'aurais-tu fait différemment si tu recommençais ?**
+
+**5. Quelle extension aimerais-tu implémenter si tu avais plus de temps ?**