BDD

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 int getTile(int x,int y){
@@ -31,7 +38,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) {
@@ -40,10 +47,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;
             }
         }
@@ -54,8 +61,8 @@ public class Chessboard {
         return queensPosition.size();
     }
     public void printChessboard() {
-        for (int i = 0; i < SIZE; i++) {
-            for (int j = 0; j < SIZE; j++) {
+        for (int i = 0; i < currentSize; i++) {
+            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 {
     public Chessboard chessboard = new Chessboard();
 
+    public Chessboard chessboard(){
+        return chessboard;
+    }
+
     public EightQueensSolver() {
         
     }
-
-    
-
-    public static void main(String[] args){
-        EightQueensSolver solver = new EightQueensSolver();
-        
-        long startTimeSimSim = System.currentTimeMillis();
-        System.out.println("Début SimSim");
-        System.out.println(solver.SolverSim(0));
-        System.out.println("Fin SimSim");
-        long endTimeSimSim = System.currentTimeMillis();
-        System.out.println("Temps d'exécution SimSim: " + (endTimeSimSim - startTimeSimSim) + " ms");
-        solver.chessboard.printChessboard();
-
-
-        solver.chessboard = new Chessboard(); 
-        
-
-        long startTimeVictor = System.currentTimeMillis();
-        System.out.println("Début Victor");
-        System.out.println(solver.SolverVic(0));
-        System.out.println("Fin Victor");
-        long endTimeVictor = System.currentTimeMillis();
-        System.out.println("Temps d'exécution Victor: " + (endTimeVictor - startTimeVictor) + " ms");
-        solver.chessboard.printChessboard();
-        
+    public void setChessboard(Chessboard theChessboard) {
+        this.chessboard = theChessboard;
     }
 
+    
+
+     public static void main(String[] args){
+        EightQueensSolver solver = new EightQueensSolver();
+        System.out.println("Taille de l'echiquier : " + Chessboard.currentSize);  
+        
+        //Chronometrage de la méthode à Victor
+        long time = 0;
+        for (int i = 0; i < 10; i++) {
+            solver.chessboard = new Chessboard();
+            long startTime = System.currentTimeMillis();
+            solver.SolverVic(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");
+        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");
+        System.out.println("Temps moyen d'exécution SimSim: " + (time) + " ms");
+        solver.chessboard.printChessboard();
+
+
+        //Spoiler : c'est simsim qu'a la meilleure méthode :)
+    }
+    
+
+    // Méthode de résolution de victor
     public Boolean SolverVic(int level) {
-        if (chessboard.getNumberOfQueen() == Chessboard.SIZE) {
+        if (chessboard.getNumberOfQueen() == Chessboard.currentSize) {
             return true;
         }
-        for (int i = level*Chessboard.SIZE; i < Chessboard.SIZE * Chessboard.SIZE; i++) {
-            int x = i % Chessboard.SIZE;
-            int y = i / Chessboard.SIZE;
+        for (int i = level*Chessboard.currentSize; i < Chessboard.currentSize * Chessboard.currentSize; i++) {
+            int x = i % Chessboard.currentSize;
+            int y = i / Chessboard.currentSize;
             if (chessboard.VerifAccessible(x, y)) {
                 chessboard.placeQueen(x, y);
                 if (!SolverVic(y)) {
@@ -53,18 +76,19 @@ public class EightQueensSolver {
         return false;
     }
 
-    public boolean SolverSim(int line){
-        if(chessboard.getNumberOfQueen() == Chessboard.SIZE){
+    // Méthode de résolution de Simon
+    public boolean SolverSim(int yPos){
+        if(chessboard.getNumberOfQueen() == Chessboard.currentSize){
             return true;
         }
-        for(int collumn = 0 ; collumn < Chessboard.SIZE ; collumn++){
-            if(chessboard.VerifAccessible(collumn, line)){
-                chessboard.placeQueen(collumn, line);
-                if(SolverSim(line+1)){
+        for(int xPos = 0 ; xPos < Chessboard.currentSize ; xPos++){
+            if(chessboard.VerifAccessible(xPos, yPos)){
+                chessboard.placeQueen(xPos, yPos);
+                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
+        }
+    }
+
+}

src/test/java/fr/iut_fbleau/but3/dev6_2/ChessboardTest.java

@@ -41,8 +41,8 @@ class ChessboardTest {
         assertEquals(3, this.chessboard.getNumberOfQueen());
         int cpt=0;
         //double test to assure getNumberOfQueen works
-        for(int i = 0; i< Chessboard.SIZE ;i++){
-            for(int j = 0; j< Chessboard.SIZE ;j++){
+        for(int i = 0; i< Chessboard.currentSize ;i++){
+            for(int j = 0; j< Chessboard.currentSize ;j++){
                 if(this.chessboard.getTile(i, j) == 1){
                     cpt += 1;
 ;               }

src/test/java/fr/iut_fbleau/but3/dev6_2/steps/EightQueensSolverSteps.java

@@ -1,6 +1,6 @@
 package fr.iut_fbleau.but3.dev6_2.steps;
 
-import fr.iut_fbleau.but3.dev6_2.EightQueensSolver;
+import fr.iut_fbleau.but3.dev6_2.*;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;

src/test/resources/features/placeAQueen.feature

@@ -2,6 +2,26 @@ Feature: Placer une reine
   Placer une reine sur l'échiquier
 
   Scenario: Placer une reine en 0, 0
-    Given un echiquier
+    Given un echiquier vide
     When placer une reine en 0, 0
     Then 1 reine sur l'échiquier
+  
+  Scenario: Placer une reine sur une case libre
+    Given un echiquier avec une reine sur la ligne 0
+    When placer une reine sur la ligne 1
+    Then la reine est posée sur une case libre
+    And 2 reines sur l'échiquier
+
+Feature: Résoudre le problème
+
+  Scenario: Résoudre le problème à l'aide du solveur SolverVic
+    Given un echiquier vide
+    When le solveur termine de résoudre le problème
+    Then la solution doit être valide
+    And le nombre de reines doit être égal à 8
+
+  Scenario: Résoudre le problème à l'aide du solveur SolverSim
+    Given un echiquier vide
+    When le solveur termine de résoudre le problème
+    Then la solution doit être valide
+    And le nombre de reines doit être égal à 8