ajout TP3

TP1&TP2/MIniMax_versionprofondeur.java

@@ -0,0 +1,42 @@
+public class MIniMax_versionprofondeur {
+
+    private static int ExploreMax(int nbr_allumettes, int profondeur){
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        if (profondeur == 0){
+            return 0;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup, profondeur - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int profondeur){
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        if (profondeur == 0){
+            return 0;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup, profondeur - coup);
+            if (res < pire){
+                pire = res;
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 5;
+        int profondeur = 6;
+        System.out.println(ExploreMax(nbr_allumettes, profondeur));
+    }
+}

TP1&TP2/MiniMax_versionBase.java

@@ -0,0 +1,35 @@
+public class MiniMax_versionBase {
+
+    private static int ExploreMax(int nbr_allumettes){
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes){
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup);
+            if (res < pire){
+                pire = res;
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 5;
+        System.out.println(ExploreMax(nbr_allumettes));
+    }
+}

TP1&TP2/MiniMax_versionMemoisation.java

@@ -0,0 +1,59 @@
+import java.util.ArrayList;
+public class MiniMax_versionMemoisation{
+
+    private static ArrayList<Integer> max = new ArrayList<Integer>();
+    private static ArrayList<Integer> min = new ArrayList<Integer>();
+    private static int Allumete;
+
+    public MiniMax_versionMemoisation(int n){
+        Allumete = n;
+        for(int i=0;i<n;i++){
+            max.add(-2);
+            min.add(-2);
+        }
+    }
+
+    
+    public static int explorMax(int nbAllumete){
+            if (nbAllumete <=0){
+            return +1; 
+        } 
+        if (max.get(nbAllumete)!=-2){
+            return max.get(nbAllumete);
+        }
+        int meilleurRes = -2;
+        for (int coup =1;coup <=3;coup ++){
+            int res = explorMin(nbAllumete-coup);
+            if (meilleurRes < res){
+                meilleurRes =res;
+            }
+        }
+        max.set(nbAllumete,meilleurRes);
+        return meilleurRes;        
+    }
+
+
+    public static int explorMin(int nbAllumete){
+         if (nbAllumete <=0){
+            return -1; 
+        }
+          if (min.get(nbAllumete)!=-2){
+            return min.get(nbAllumete);
+        }
+            
+        int mepireRes = 2;
+        for (int coup =1;coup <=3;coup ++){   
+            int res = explorMax(nbAllumete-coup);    
+            if ( res <  mepireRes){
+                mepireRes = res;
+            }
+        }
+        min.set(nbAllumete,mepireRes);
+        return mepireRes;        
+    }
+
+    public static void main(String[]arg){
+        MiniMax_versionMemoisation newCLass = new MiniMax_versionMemoisation(1904);
+        System.out.println(explorMax(1903));
+    } 
+}

TP1&TP2/MiniMax_version_AlphaBeta.java

@@ -0,0 +1,41 @@
+public class MiniMax_version_AlphaBeta {
+
+    private static int ExploreMax(int nbr_allumettes, int alpha, int beta){
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int localAlpha = alpha;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup, localAlpha, beta);
+            if (res > localAlpha){
+                localAlpha = res;
+                if (localAlpha >= beta){
+                    return localAlpha;
+                }
+            }
+        }
+        return localAlpha;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int alpha, int beta){
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int localBeta = beta;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup, alpha, localBeta);
+            if (res < localBeta){
+                localBeta = res;
+                if (localBeta <= alpha){
+                    return localBeta;
+                }
+            }
+        }
+        return localBeta;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 5;
+        System.out.println(ExploreMax(nbr_allumettes, Integer.MIN_VALUE, Integer.MAX_VALUE));
+    }
+}

TP1&TP2/MiniMax_versionarret.java

@@ -0,0 +1,41 @@
+public class MiniMax_versionarret {
+
+    private static int ExploreMax(int nbr_allumettes){
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+                if (meilleurres == 1){
+                    break;
+                }
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes){
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup);
+            if (res < pire){
+                pire = res;
+                if (pire == -1){
+                    break;
+                }
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 4;
+        System.out.println(ExploreMax(nbr_allumettes));
+    }
+}

TP1&TP2/Readme.md

@@ -0,0 +1,97 @@
+Ce fichier repertorie et explique les code qui se trouve dans ce fichier.
+
+## MiniMax_versionBase
+
+Ce code est la version de base vu en cours du jeu de Nim.
+Il fonctionne et donne bien -1 en resultat.
+
+# Tableau d'états visité
+
+| n (allumettes) | Nombre de nœuds explorés |
+|----------------|--------------------------|
+| 5              | 46                       |
+| 7              | 157                      |
+| 13             | 6 094                    |
+| 19             | 235 957                  |
+| 31             | 353 693 521              |
+
+
+
+## MiniMax_versionprofondeur
+
+Ce code est une version optimisé de la version vu en cours du jeu de Nim.
+Celui-ci a un autre paramètre qui est profoncdeur qui limite les calcul et donne une approximation.
+Il fonctionne et donne bien 0 en resultat si la profonceur est inférieur à 6 et si elle est de 6 ou plus elle donne bien -1 car 6 est la profondeur maximal de l'abre du jeu de Nim.
+
+# Tableau d'états visité
+
+| Nombre d’allumettes | Profondeur max | Nombre de nœuds (états) |
+|---------------------|----------------|-------------------------|
+| 5                   | 6              | 46                      |
+| 7                   | 8              | 157                     |
+| 13                  | 14             | 6 094                   |
+| 19                  | 20             | 235 957                 |
+| 31                  | 32             | 353 693 521             |
+
+
+
+## MiniMax_versionarret
+
+Ce code est une version optimisé de la version vu en cours du jeu de Nim.
+Celui-ci a une autre condition d'arret qui limite les calcul qui est donné par un chemin où il y a une victiore ou une défaite.
+Il fonctionne et donne bien -1 en resultat si le nombre d'allumettes est de 5 et si elle est de 4, elle donne bien 1.
+
+# Tableau d'états visité
+
+| Nombre d’allumettes | Nœuds visités |
+|---------------------:|-------------:|
+| 5                    | 36           |
+| 7                    | 74           |
+| 13                   | 1 828        |
+| 19                   | 25 610       |
+| 31                   | 8 784 458    |
+
+
+## MiniMax_versionMemoisation
+Ce code est une version optimisé de la version vu en cours du jeu de Nim.
+Celui-ci garde en mémoire avec un tableau pour le min et le max pour éviter de recalculer des sous-arbres déjà vu précédemment.
+Il fonctionne avec les tests effectué.
+
+# Tableau d'états visité
+
+| Nombre d’allumettes | Nœuds distincts (états) visités |
+|---------------------:|-------------------------------:|
+| 5                    | 25                             |
+| 7                    | 37                             |
+| 13                   | 73                             |
+| 19                   | 109                            |
+| 31                   | 181                            |
+
+
+## MiniMax_version_AlphaBeta
+Ce code est une version optimisé de la version vu en cours du jeu de Nim.
+Celui-ci permet de coupé des partie de l'arbre de jeux, donc de visité moins de noeuds.
+Il fonctionne avec les tests effectué.
+
+# Tableau d'états visité
+
+| Nombre d’allumettes | Nœuds visités |
+|--------------------:|--------------:|
+| 5                   | 41            |
+| 7                   | 107           |
+| 13                  | 2 244         |
+| 19                  | 31 898        |
+| 31                  | 9 523 124     |
+
+## Différence de noeud visité entre MiniMax_version_AlphaBeta et MiniMax_versionBase
+La différence entre le nombre de noeuds visité car alpha_beta ne regarde pas tous les sous-arbres, contrairement à la version de base, cela se voit surtout avec une grande longueur de l'arbre de jeux.
+
+## Nombre d'états visités dans chaque version
+
+| Version                        | Paramètres initiaux               | États explorés |
+|--------------------------------|-----------------------------------|----------------|
+| MiniMax_versionBase            | `nbr_allumettes = 5`              | 46             |
+| MiniMax_versionarret           | `nbr_allumettes = 5`              | 36             |
+| MiniMax_versionprofondeur      | `nbr_allumettes = 5, profondeur=6`| 46             |
+| MiniMax_versionMemoisation     | `nbr_allumettes = 5`              | 25             |
+| MiniMax_version_AlphaBeta      | `nbr_allumettes = 5`              | 41             |

TP1&TP2/compteur/MIniMax_versionprofondeur_compteur.java

@@ -0,0 +1,47 @@
+public class MIniMax_versionprofondeur_compteur {
+
+    public static int compteur_noeud = 0;
+
+    private static int ExploreMax(int nbr_allumettes, int profondeur){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        if (profondeur == 0){
+            return 0;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup, profondeur - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int profondeur){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        if (profondeur == 0){
+            return 0;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup, profondeur - coup);
+            if (res < pire){
+                pire = res;
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 5;
+        int profondeur = 6;
+        System.out.println(ExploreMax(nbr_allumettes, profondeur));
+        System.out.println(compteur_noeud);
+    }
+}

TP1&TP2/compteur/MiniMax_versionBase_compteur.java

@@ -0,0 +1,40 @@
+public class MiniMax_versionBase_compteur {
+
+    public static int compteur_noeud = 0;
+
+    private static int ExploreMax(int nbr_allumettes){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup);
+            if (res < pire){
+                pire = res;
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 19;
+        System.out.println(ExploreMax(nbr_allumettes));
+        System.out.println(compteur_noeud);
+    }
+}

TP1&TP2/compteur/MiniMax_versionMemoisation_compteur.java

@@ -0,0 +1,63 @@
+import java.util.ArrayList;
+public class MiniMax_versionMemoisation_compteur{
+
+    private static ArrayList<Integer> max = new ArrayList<Integer>();
+    private static ArrayList<Integer> min = new ArrayList<Integer>();
+    private static int Allumete;
+    public static int compteur_noeud = 0;
+
+    public MiniMax_versionMemoisation_compteur(int n){
+        Allumete = n;
+        for(int i=0;i<n;i++){
+            max.add(-2);
+            min.add(-2);
+        }
+    }
+
+    
+    public static int explorMax(int nbAllumete){
+        compteur_noeud++;
+        if (nbAllumete <=0){
+            return +1; 
+        } 
+        if (max.get(nbAllumete)!=-2){
+            return max.get(nbAllumete);
+        }
+        int meilleurRes = -2;
+        for (int coup =1;coup <=3;coup ++){
+            int res = explorMin(nbAllumete-coup);
+            if (meilleurRes < res){
+                meilleurRes =res;
+            }
+        }
+        max.set(nbAllumete,meilleurRes);
+        return meilleurRes;        
+    }
+
+
+    public static int explorMin(int nbAllumete){
+        compteur_noeud++;
+         if (nbAllumete <=0){
+            return -1; 
+        }
+          if (min.get(nbAllumete)!=-2){
+            return min.get(nbAllumete);
+        }
+            
+        int mepireRes = 2;
+        for (int coup =1;coup <=3;coup ++){   
+            int res = explorMax(nbAllumete-coup);    
+            if ( res <  mepireRes){
+                mepireRes = res;
+            }
+        }
+        min.set(nbAllumete,mepireRes);
+        return mepireRes;        
+    }
+
+    public static void main(String[]arg){
+        MiniMax_versionMemoisation_compteur newCLass = new MiniMax_versionMemoisation_compteur(32);
+        System.out.println(explorMax(31));
+        System.out.println(compteur_noeud);
+    } 
+}

TP1&TP2/compteur/MiniMax_version_AlphaBeta_compteur.java

@@ -0,0 +1,46 @@
+public class MiniMax_version_AlphaBeta_compteur {
+
+    public static int compteur_noeud = 0;
+
+    private static int ExploreMax(int nbr_allumettes, int alpha, int beta){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int localAlpha = alpha;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup, localAlpha, beta);
+            if (res > localAlpha){
+                localAlpha = res;
+                if (localAlpha >= beta){
+                    return localAlpha;
+                }
+            }
+        }
+        return localAlpha;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int alpha, int beta){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int localBeta = beta;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup, alpha, localBeta);
+            if (res < localBeta){
+                localBeta = res;
+                if (localBeta <= alpha){
+                    return localBeta;
+                }
+            }
+        }
+        return localBeta;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 31;
+        System.out.println(ExploreMax(nbr_allumettes, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        System.out.println(compteur_noeud);
+    }
+}

TP1&TP2/compteur/MiniMax_versionarret_compteur.java

@@ -0,0 +1,46 @@
+public class MiniMax_versionarret_compteur {
+
+    public static int compteur_noeud = 0;
+
+    private static int ExploreMax(int nbr_allumettes){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int meilleurres = -2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMin(nbr_allumettes - coup);
+            if (res > meilleurres){
+                meilleurres = res;
+                if (meilleurres == 1){
+                    break;
+                }
+            }
+        }
+        return meilleurres;
+    }
+
+    private static int ExploreMin(int nbr_allumettes){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int pire = 2;
+        for (int coup = 1; coup <= 3; coup++){
+            int res = ExploreMax(nbr_allumettes - coup);
+            if (res < pire){
+                pire = res;
+                if (pire == -1){
+                    break;
+                }
+            }
+        }
+        return pire;
+    }
+
+    public static void main(String[] args) {
+        int nbr_allumettes = 19;
+        System.out.println(ExploreMax(nbr_allumettes));
+        System.out.println(compteur_noeud);
+    }
+}

TP1&TP2/version_liste_melange/MiniMax_version_AlphaBeta_melange.java

@@ -0,0 +1,50 @@
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class MiniMax_version_AlphaBeta_melange {
+    private static ArrayList<Integer> list = new ArrayList<Integer>();
+
+    private static int ExploreMax(int nbr_allumettes, int alpha, int beta){
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int localAlpha = alpha;
+        for (Integer coup : list){
+            int res = ExploreMin(nbr_allumettes - coup, localAlpha, beta);
+            if (res > localAlpha){
+                localAlpha = res;
+                if (localAlpha >= beta){
+                    return localAlpha;
+                }
+            }
+        }
+        return localAlpha;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int alpha, int beta){
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int localBeta = beta;
+        for (Integer coup : list){
+            int res = ExploreMax(nbr_allumettes - coup, alpha, localBeta);
+            if (res < localBeta){
+                localBeta = res;
+                if (localBeta <= alpha){
+                    return localBeta;
+                }
+            }
+        }
+        return localBeta;
+    }
+
+    public static void main(String[] args) {
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        Collections.shuffle(list);
+        int nbr_allumettes = 5;
+        System.out.println(list);
+        System.out.println(ExploreMax(nbr_allumettes, Integer.MIN_VALUE, Integer.MAX_VALUE));
+    }
+}

TP1&TP2/version_liste_melange/MiniMax_version_AlphaBeta_melange_compteur.java

@@ -0,0 +1,54 @@
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class MiniMax_version_AlphaBeta_melange_compteur {
+    private static ArrayList<Integer> list = new ArrayList<Integer>();
+    public static int compteur_noeud = 0;
+
+    private static int ExploreMax(int nbr_allumettes, int alpha, int beta){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return 1;
+        }
+        int localAlpha = alpha;
+        for (Integer coup : list){
+            int res = ExploreMin(nbr_allumettes - coup, localAlpha, beta);
+            if (res > localAlpha){
+                localAlpha = res;
+                if (localAlpha >= beta){
+                    return localAlpha;
+                }
+            }
+        }
+        return localAlpha;
+    }
+
+    private static int ExploreMin(int nbr_allumettes, int alpha, int beta){
+        compteur_noeud++;
+        if (nbr_allumettes <= 0){
+            return -1;
+        }
+        int localBeta = beta;
+        for (Integer coup : list){
+            int res = ExploreMax(nbr_allumettes - coup, alpha, localBeta);
+            if (res < localBeta){
+                localBeta = res;
+                if (localBeta <= alpha){
+                    return localBeta;
+                }
+            }
+        }
+        return localBeta;
+    }
+
+    public static void main(String[] args) {
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        Collections.shuffle(list);
+        int nbr_allumettes = 5;
+        System.out.println(list);
+        System.out.println(ExploreMax(nbr_allumettes, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        System.out.println(compteur_noeud);
+    }
+}