Ajout étude, modification du programme principal

src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java

@@ -5,13 +5,20 @@ import java.util.List;
 
 public class Chessboard {
     public static final int SIZE = 8;
-    private final int[][] gameBoard = new int[SIZE][SIZE];
+    public static int currentSize;
+    private final int[][] gameBoard;
     private final List<Position> queensPosition = new ArrayList<>();
     private static final String ANSI_RED = "\u001B[31m";
     private static final String ANSI_RESET = "\u001B[0m";
 
     public Chessboard() {
-        // Constructeur vide
+        this.gameBoard = new int[SIZE][SIZE];
+        currentSize = SIZE;
+    }
+
+    public Chessboard(int size) {
+        this.gameBoard = new int[size][size];
+        currentSize = size;
     }
 
     public void placeQueen(int x, int y) {
@@ -27,7 +34,7 @@ public class Chessboard {
     }
 
     public Boolean VerifAccessible(int x, int y) {
-        for (int i = 0; i < SIZE; i++) {
+        for (int i = 0; i < currentSize; i++) {
             int diagonaleAscendante = y - (x - i);
             int diagonaleDescendante = y + (x - i);
             if (gameBoard[i][y] != 0) {
@@ -36,10 +43,10 @@ public class Chessboard {
             if (gameBoard[x][i] != 0) {
                 return false;
             }
-            if (diagonaleAscendante >= 0 && diagonaleAscendante < SIZE && gameBoard[i][diagonaleAscendante] == 1) {
+            if (diagonaleAscendante >= 0 && diagonaleAscendante < currentSize && gameBoard[i][diagonaleAscendante] == 1) {
                 return false;
             }
-            if (diagonaleDescendante >= 0 && diagonaleDescendante < SIZE && gameBoard[i][diagonaleDescendante] == 1) {
+            if (diagonaleDescendante >= 0 && diagonaleDescendante < currentSize && gameBoard[i][diagonaleDescendante] == 1) {
                 return false;
             }
         }
@@ -50,8 +57,8 @@ public class Chessboard {
         return queensPosition.size();
     }
     public void printChessboard() {
-        for (int i = 0; i < SIZE; i++) {
+        for (int i = 0; i < currentSize; i++) {
-            for (int j = 0; j < SIZE; j++) {
+            for (int j = 0; j < currentSize; j++) {
                 if (gameBoard[j][i] == 1) {
                     System.out.print(ANSI_RED+"|♕|"+ANSI_RESET);
                 } else{

src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java

@@ -3,44 +3,67 @@ package fr.iut_fbleau.but3.dev6_2;
 public class EightQueensSolver {
     private Chessboard chessboard = new Chessboard();
 
+    public Chessboard chessboard(){
+        return chessboard;
+    }
+
     public EightQueensSolver() {
         
+    }
+    public void setChessboard(Chessboard theChessboard) {
+        this.chessboard = theChessboard;
     }
 
     
 
-    public void main(String[] args){
+     public static void main(String[] args){
+        EightQueensSolver solver = new EightQueensSolver();
+        System.out.println("Taille de l'echiquier : " + Chessboard.currentSize);  
         
-        // Début de la résolution par méthode simplifiée
+        //Chronometrage de la méthode à Victor
-        long startTimeSimSim = System.currentTimeMillis();
+        long time = 0;
+        for (int i = 0; i < 10; i++) {
+            solver.chessboard = new Chessboard();
+            long startTime = System.currentTimeMillis();
+            solver.Solver(0); 
+            long endTime = System.currentTimeMillis();
+            
+            time += endTime - startTime;
+        }
+        time /= 10;
+
+        System.out.println("Temps moyen d'exécution Victor: " + (time) + " ms");
+        solver.chessboard.printChessboard();
+        
+        // Chronometrage de la méthode à Simon
+        time = 0;
         System.out.println("Début SimSim");
-        System.out.println(SolverSim(0));
+        for (int i = 0; i < 10; i++) {
+            solver.chessboard = new Chessboard();
+            long startTime = System.currentTimeMillis();
+            solver.SolverSim(0); 
+            long endTime = System.currentTimeMillis();
+            
+            time += endTime - startTime;
+        }
+        time /= 10;
         System.out.println("Fin SimSim");
-        long endTimeSimSim = System.currentTimeMillis();
+        System.out.println("Temps moyen d'exécution SimSim: " + (time) + " ms");
-        System.out.println("Temps d'exécution SimSim: " + (endTimeSimSim - startTimeSimSim) + " ms");
+        solver.chessboard.printChessboard();
-        chessboard.printChessboard();
 
 
-        chessboard = new Chessboard(); // Réinitialisation du plateau
+        //Spoiler : c'est simsim qu'a la meilleure méthode :)
-        
-        // Début de la résolution par méthode classique
-        long startTimeVictor = System.currentTimeMillis();
-        System.out.println("Début Victor");
-        System.out.println(Solver(0));
-        System.out.println("Fin Victor");
-        long endTimeVictor = System.currentTimeMillis();
-        System.out.println("Temps d'exécution Victor: " + (endTimeVictor - startTimeVictor) + " ms");
-        chessboard.printChessboard();
-        
     }
+    
 
-    private Boolean Solver(int level) {
+    // Méthode de résolution de victor
-        if (chessboard.getNumberOfQueen() == Chessboard.SIZE) {
+    public Boolean Solver(int level) {
+        if (chessboard.getNumberOfQueen() == Chessboard.currentSize) {
             return true;
         }
-        for (int i = level*Chessboard.SIZE; i < Chessboard.SIZE * Chessboard.SIZE; i++) {
+        for (int i = level*Chessboard.currentSize; i < Chessboard.currentSize * Chessboard.currentSize; i++) {
-            int x = i % Chessboard.SIZE;
+            int x = i % Chessboard.currentSize;
-            int y = i / Chessboard.SIZE;
+            int y = i / Chessboard.currentSize;
             if (chessboard.VerifAccessible(x, y)) {
                 chessboard.placeQueen(x, y);
                 if (!Solver(y)) {
@@ -53,18 +76,19 @@ public class EightQueensSolver {
         return false;
     }
 
-    private boolean SolverSim(int line){
+    // Méthode de résolution de Simon
-        if(chessboard.getNumberOfQueen() == Chessboard.SIZE){
+    public boolean SolverSim(int yPos){
+        if(chessboard.getNumberOfQueen() == Chessboard.currentSize){
             return true;
         }
-        for(int collumn = 0 ; collumn < Chessboard.SIZE ; collumn++){
+        for(int xPos = 0 ; xPos < Chessboard.currentSize ; xPos++){
-            if(chessboard.VerifAccessible(collumn, line)){
+            if(chessboard.VerifAccessible(xPos, yPos)){
-                chessboard.placeQueen(collumn, line);
+                chessboard.placeQueen(xPos, yPos);
-                if(SolverSim(line+1)){
+                if(SolverSim(yPos+1)){
                     return true;
                 }
                 else{
-                    chessboard.removeQueen(collumn, line);
+                    chessboard.removeQueen(xPos, yPos);
                 }
             }
         }

src/main/java/fr/iut_fbleau/but3/dev6_2/Etude.java

@@ -0,0 +1,63 @@
+package fr.iut_fbleau.but3.dev6_2;
+
+public class Etude {
+    public static final int MAX_TIME = 1000;
+
+    private Chessboard chessboard;
+    private int currentSize;
+    private EightQueensSolver solver;
+    public Etude() {
+        this.currentSize = 5;
+        this.solver = new EightQueensSolver();
+
+    }
+
+    private void resetChessboard(){
+        this.chessboard = new Chessboard(currentSize);
+        this.solver.setChessboard(this.chessboard);
+    }
+
+    /**
+     * Etude de performance des différents solveurs sur des tailles croissantes de chessboards. 
+     * Chaque taille est testée 10 fois et la moyenne du temps passé dessus par chaque solveur est indiquée en ms.
+     * La boucle de l'étude s'arrête lorsque le temps de résolution moyen dépasse les 1000ms. 
+     *
+     *  Un seul solveur est testé à la fois. Il suffit de commenter et décommenter une ligne au milieu de la méthode main pour qu'un autre solveur soit testé. 
+     *  Il vous reviens de noter les résultats de chaque solveur, aucune comparaison n'est faite dans ce code. 
+     *
+     * Les chessboards de taille impaire sont bien plus rapides à résoudre que ceux de taille paire.
+     * Pour faire l'étude uniquement sur des tailles paires, une ligne est à décommenter à la fin de la méthode main.
+     */
+    public static void _main(String[] args){
+        Etude etude = new Etude();
+
+        int passedTime = 0;
+        while(passedTime < MAX_TIME){
+            passedTime = 0;
+            
+            System.out.println("Taille de l'echiquier : " + etude.currentSize);
+            System.out.println("Début solveur");
+            
+            for (int i = 0; i < 10; i++) {
+                long startTimeSimSim = System.currentTimeMillis();
+                etude.resetChessboard();
+                etude.solver.SolverSim(0);
+                //etude.solver.Solver(0);   // décommenter cette ligne et commenter celle du dessus pour étudier l'autre solveur
+                long endTimeSimSim = System.currentTimeMillis();
+
+                passedTime += endTimeSimSim - startTimeSimSim;
+            }
+            passedTime /= 10;
+            
+            System.out.println("Fin solveur");
+            System.out.println("Temps d'exécution moyen solveur: " + (passedTime) + " ms");
+            
+            etude.chessboard.printChessboard(); 
+            
+
+            etude.currentSize ++;
+            // etude.currentSize ++;   // décommenter cette ligne pour que seules les tailles de chessboard impaires soient testées
+        }
+    }
+
+}