corrigés du mastermind hors publication, liens vers les fichiers utiles

Projets/README.md

@@ -23,7 +23,7 @@ Chaque projet est découpé en phases dans son fichier `JALONS.md`, sur une **pr
 | [Le Jeu de la Vie](jeu_de_la_vie/) | L'automate cellulaire de Conway : quatre règles, et des structures qui émergent | Grilles 2D, fonctions pures, POO | non |
 | [Labyrinthe](labyrinthe/) | Générer un labyrinthe parfait, puis le résoudre automatiquement | Graphes, arbres couvrants, DFS et BFS, récursivité | oui, `src/maze.py` |
 | [Wa-Tor](wator/) | Simuler un monde torique où des requins chassent des thons | Grilles 2D, simulation, POO | non |
-| [Mastermind et algorithmes génétiques](mastermind/) | Faire évoluer une population de combinaisons jusqu'à trouver le code secret | POO, paradigme fonctionnel, optimisation | oui, `src/algo_gen.py` et `src/combinaison.py` |
+| [Mastermind et algorithmes génétiques](mastermind/) | Faire évoluer une population de combinaisons jusqu'à trouver le code secret | POO, paradigme fonctionnel, optimisation | oui, les deux classes abstraites de `src/` |
 
 Le Jeu de la Vie et le Labyrinthe sont les deux plus accessibles pour démarrer. Le Labyrinthe est celui qui recoupe le plus directement le programme de Terminale, entre le chapitre Graphes et le chapitre Récursivité.
 

Projets/mastermind/README.md

@@ -8,10 +8,9 @@ Le **Mastermind** est un jeu de déduction : un joueur choisit une combinaison s
 
 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/` :
+Vous ne partez pas de rien : deux classes abstraites vous sont fournies, `Individual_Interface`
-- `algo_gen.py` - framework de l'algorithme génétique
+et `Problem_Interface`. Vous en héritez, et vous écrivez les méthodes qu'elles laissent vides.
-- `combinaison.py` - représentation d'un individu (une combinaison)
+La fiche de TP et l'activité guidée vous mènent pas à pas.
-- `src_mastermind_fiche.md` - fiche TP détaillée avec toutes les consignes
 
 ## Compétences mobilisées
 
@@ -42,9 +41,10 @@ Une base de code complète est disponible dans `../src/` :
 
 ## Ressources
 
-- `../src/src_mastermind_fiche.md` - fiche TP complète avec toutes les consignes
+- [Fiche de TP](https://florianmathieu.prof/hub-docs/nsi/terminale/Projets/src/src_mastermind_fiche/) - toutes les consignes, dans l'ordre
-- `../src/algo_gen.py` - squelette du framework générique
+- [Activité guidée](https://florianmathieu.prof/hub-docs/nsi/terminale/Projets/src/Activit%C3%A9/) - le pas à pas complet, avec les explications
-- `../src/combinaison.py` - classe individu à compléter
+- [`individual_interface.py`](https://florianmathieu.prof/hub-docs/nsi/terminale/Projets/src/individual_interface/individual_interface.py) - classe abstraite d'un individu, à hériter
+- [`problem_interface.py`](https://florianmathieu.prof/hub-docs/nsi/terminale/Projets/src/problem_interface/problem_interface.py) - classe abstraite d'un problème, à hériter
 - [Algorithme génétique - Wikipedia](https://fr.wikipedia.org/wiki/Algorithme_génétique)
 - [Mastermind - Wikipedia](https://fr.wikipedia.org/wiki/Mastermind)
 

Projets/src/_algo_gen.py

@@ -1,4 +1,4 @@
-from problem_sup import *
+from _problem_sup import *
 
 BEST_KEPT = 5
 

Projets/src/_problem_sup.py

@@ -1,84 +1,84 @@
-from problem_interface import *
+from problem_interface import *
-from combinaison import *
+from _combinaison import *
-
+
-class Problem_5(Problem_Interface) :
+class Problem_5(Problem_Interface) :
-    """
+    """
-    classe probleme n°5 : Combinaison Coffre-Fort
+    classe probleme n°5 : Combinaison Coffre-Fort
-    """
+    """
-    
+    
-    def __init__(self, calcul):
+    def __init__(self, calcul):
-        self.__size = len(calcul)
+        self.__size = len(calcul)
-        self.__combinaison = calcul
+        self.__combinaison = calcul
-        
+        
-
+
-        
+        
-    def create_individual(self):
+    def create_individual(self):
-        '''
+        '''
-        create a randomly generated indidivual for this problem
+        create a randomly generated indidivual for this problem
-
+
-        :return: a randomly generated individual gfor this problem
+        :return: a randomly generated individual gfor this problem
-        :rtype: an Individual object
+        :rtype: an Individual object
-        '''
+        '''
-        return Combinaison(self.__size)
+        return Combinaison(self.__size)
-
+
-    def evaluate_fitness(self, individual):
+    def evaluate_fitness(self, individual):
-        '''
+        '''
-        compute the fitness of individual for this problem
+        compute the fitness of individual for this problem
-
+
-        :param individual: the individual to consider
+        :param individual: the individual to consider
-        :type individual: an Individual object
+        :type individual: an Individual object
-        :return: the fitness of individual for this problem
+        :return: the fitness of individual for this problem
-        :rtype: an Individual object
+        :rtype: an Individual object
-        '''
+        '''
-
+
-        return sum([1 if calcul[chiffre]==self.__combinaison[chiffre] else 0 for chiffre in range(len(calcul))])
+        return sum([1 if calcul[chiffre]==self.__combinaison[chiffre] else 0 for chiffre in range(len(calcul))])
-    
+    
-
+
-    def sort_population(self, population):
+    def sort_population(self, population):
-        '''
+        '''
-        sort population from best fitted to worst fitted individuals.
+        sort population from best fitted to worst fitted individuals.
-        Depending on the problem, it can correspond to ascending or descending order with respect to the fitness function.
+        Depending on the problem, it can correspond to ascending or descending order with respect to the fitness function.
-
+
-        side effect : population is modified by this method
+        side effect : population is modified by this method
-
+
-        :param population: the list of individuals to sort
+        :param population: the list of individuals to sort
-        :type population: list(Individual)        
+        :type population: list(Individual)        
-        '''
+        '''
-        population.sort(key = lambda x: x.get_score())
+        population.sort(key = lambda x: x.get_score())
-
+
-    def best_individual(self, population):
+    def best_individual(self, population):
-        '''
+        '''
-        return the best fitted individual from population.
+        return the best fitted individual from population.
-        Depending on the problem, it can correspond to the individual with the highest or the lowest fitness value.
+        Depending on the problem, it can correspond to the individual with the highest or the lowest fitness value.
-
+
-
+
-        :param population: the list of individuals to sort
+        :param population: the list of individuals to sort
-        :type population: list(Individual)
+        :type population: list(Individual)
-        :return: the best fitted individual of population
+        :return: the best fitted individual of population
-        :rtype: an Individual object
+        :rtype: an Individual object
-        '''
+        '''
-        self.sort_population(population)
+        self.sort_population(population)
-        return population[len(population) -1 ]
+        return population[len(population) -1 ]
-
+
-    def tournament(self, first, second):
+    def tournament(self, first, second):
-        '''
+        '''
-        perform a rounament between two individuals, the winner is the most fitted one, it is returned
+        perform a rounament between two individuals, the winner is the most fitted one, it is returned
-
+
-
+
-        :param first: an individual
+        :param first: an individual
-        :type first: an Individual object
+        :type first: an Individual object
-        :param second: an individual
+        :param second: an individual
-        :type second: an Individual object
+        :type second: an Individual object
-        :return: the winner of the tournament
+        :return: the winner of the tournament
-        :rtype: Individual object
+        :rtype: Individual object
-        '''
+        '''
-        if first.get_score() < second.get_score():
+        if first.get_score() < second.get_score():
-            res = first
+            res = first
-        else:
+        else:
-            res = second
+            res = second
-        return res
+        return res
-        
+        
-
+
-
+
-
+
-
+

Projets/src/test.py

@@ -1,16 +1,16 @@
-from algo_gen import *
+from _algo_gen import *
-from problem_4 import *
+from _problem_4 import *
-
+
-if __name__=="__main__":
+if __name__=="__main__":
-    p = Problem_4([
+    p = Problem_4([
-                    ['Lille', 15, 15], 
+                    ['Lille', 15, 15], 
-                    ['Tourcoing', 10, 20],
+                    ['Tourcoing', 10, 20],
-                    ['Paris', 5, 20],
+                    ['Paris', 5, 20],
-                    ['Alsace', 5, 30],
+                    ['Alsace', 5, 30],
-                    ['Londre', 30, 15],
+                    ['Londre', 30, 15],
-                    ['Strasburg', 30, 30],
+                    ['Strasburg', 30, 30],
-                    ['Moskou', 5, 5],
+                    ['Moskou', 5, 5],
-                    ['San Francisco', 10, 15]
+                    ['San Francisco', 10, 15]
-                    ])
+                    ])
-    a = AlgoGen(p, 1000, 0, 0.1)
+    a = AlgoGen(p, 1000, 0, 0.1)
     a.solve(20)