refactor: improve code comments and app menu

app/src/main/java/sudoku/Bloc.java

@@ -18,23 +18,10 @@ public class Bloc {
         cases.add(c);
     }
 
-    public boolean contains(Symbole s) {
-        for (Case c : cases) {
-            if (c.getSymbole().equals(s)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     public String getCouleur() {
         return couleur;
     }
 
-    public int getCouleurIndex() {
-        return couleurIndex;
-    }
-
     public List<Case> getCases() {
         return cases;
     }

app/src/main/java/sudoku/ContrainteCasePartagee.java

@@ -1,31 +0,0 @@
-package sudoku;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-public class ContrainteCasePartagee implements Contrainte {
-    private Set<Case> casesLiees;
-
-    public ContrainteCasePartagee(Collection<Case> cases) {
-        this.casesLiees = new HashSet<>(cases);
-    }
-
-    @Override
-    public boolean estRespectee(Grille grille, Case caseActuelle) {
-        if (!casesLiees.contains(caseActuelle))
-            return true;
-
-        Symbole reference = null;
-        for (Case c : casesLiees) {
-            if (c.getSymbole() == null)
-                continue;
-            if (reference == null) {
-                reference = c.getSymbole();
-            } else if (!c.getSymbole().equals(reference)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}

app/src/main/java/sudoku/Grille.java

@@ -13,7 +13,7 @@ public class Grille {
     private final Case[][] cases;
     private final ArrayList<Bloc> blocs;
     private ArrayList<Symbole> symbolesPossibles;
-    private final Sudoku sudoku;
+    private final Sudoku sudoku; // Référence à Sudoku
     private Multidoku multidoku; // Référence à Multidoku
     private List<String> generatedColors;
 
@@ -23,8 +23,6 @@ public class Grille {
         this.blocs = new ArrayList<>();
         this.symbolesPossibles = new ArrayList<>();
         this.sudoku = sudoku;
-        // Pour un sudoku classique, on attend "taille" blocs, donc on génère "taille"
-        // couleurs.
         initColors();
 
         // Initialiser les cases
@@ -45,8 +43,8 @@ public class Grille {
      * on génère donc 'taille' couleurs.
      */
     private void initColors() {
-        int numberOfColors = taille; // nombre de couleurs = nombre de blocs (pour sudoku classique)
-        List<ColorGenerator.Color> colors = ColorGenerator.greatScheme(numberOfColors);
+        // nombre de couleurs = nombre de blocs (pour sudoku classique)
+        List<ColorGenerator.Color> colors = ColorGenerator.greatScheme(taille);
         generatedColors = new ArrayList<>();
         for (ColorGenerator.Color color : colors) {
             generatedColors.add(convertToAnsi(color));
@@ -70,7 +68,6 @@ public class Grille {
             Symbole ancienSymbole = currentCase.getSymbole();
             currentCase.setSymbole(symbole);
 
-            // Verify constraints including shared cases
             if (!sudoku.verifierToutesContraintes() ||
                     (multidoku != null && !multidoku.verifierContraintesPartagees())) {
                 currentCase.setSymbole(ancienSymbole);
@@ -82,17 +79,6 @@ public class Grille {
         }
     }
 
-    // public void setCaseAvecPropagation(int ligne, int colonne, Symbole symbole) {
-    // // Affecte la valeur dans la grille courante
-    // setCase(ligne, colonne, symbole);
-
-    // // Si cette case est partagée et qu'il y a un multidoku, on propage
-    // // immédiatement la valeur
-    // if (multidoku != null && multidoku.isSharedCase(getCase(ligne, colonne))) {
-    // multidoku.propagateSharedCase(getCase(ligne, colonne), symbole);
-    // }
-    // }
-
     public Case getCase(int ligne, int colonne) {
         return cases[ligne][colonne];
     }
@@ -124,56 +110,49 @@ public class Grille {
             }
 
             // Choisir la couleur suivante en fonction du nombre de blocs déjà créés
-            int couleurIndex = blocs.size() % generatedColors.size();
-            Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
-
-            for (int[] pos : positions) {
-                bloc.ajouterCase(cases[pos[0]][pos[1]]);
-            }
-            blocs.add(bloc);
+            setCouleurBloc(positions);
 
         } catch (IllegalArgumentException e) {
             Console.errorln(e.getMessage());
         }
     }
 
+    private void setCouleurBloc(List<int[]> positions) {
+        int couleurIndex = blocs.size() % generatedColors.size();
+        Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
+
+        for (int[] pos : positions) {
+            bloc.ajouterCase(cases[pos[0]][pos[1]]);
+        }
+        blocs.add(bloc);
+    }
+
     /**
      * Crée des blocs carrés (par exemple pour un sudoku classique).
      */
     public void creerBlocCarre() {
-        try {
-            int blocSize = (int) Math.sqrt(taille);
-            if (blocSize * blocSize != taille) {
-                throw new IllegalArgumentException("La taille de la grille doit être un carré parfait.");
-            }
+        int blocSize = (int) Math.sqrt(taille);
+        if (blocSize * blocSize != taille) {
+            throw new IllegalArgumentException("La taille de la grille doit être un carré parfait.");
+        }
 
-            // Création des blocs en motif (par exemple 3x3 pour un sudoku 9x9)
-            for (int blocRow = 0; blocRow < blocSize; blocRow++) {
-                for (int blocCol = 0; blocCol < blocSize; blocCol++) {
-                    List<int[]> positions = new ArrayList<>();
+        // Création des blocs en motif (par exemple 3x3 pour un sudoku 9x9)
+        for (int blocRow = 0; blocRow < blocSize; blocRow++) {
+            for (int blocCol = 0; blocCol < blocSize; blocCol++) {
+                List<int[]> positions = new ArrayList<>();
 
-                    // Ajouter toutes les positions pour le bloc courant
-                    for (int i = 0; i < blocSize; i++) {
-                        for (int j = 0; j < blocSize; j++) {
-                            positions.add(new int[] {
-                                    blocRow * blocSize + i,
-                                    blocCol * blocSize + j
-                            });
-                        }
+                // Ajouter toutes les positions pour le bloc courant
+                for (int i = 0; i < blocSize; i++) {
+                    for (int j = 0; j < blocSize; j++) {
+                        positions.add(new int[] {
+                                blocRow * blocSize + i,
+                                blocCol * blocSize + j
+                        });
                     }
-
-                    // Affectation cyclique d'une couleur issue de la palette générée
-                    int couleurIndex = blocs.size() % generatedColors.size();
-                    Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
-
-                    for (int[] pos : positions) {
-                        bloc.ajouterCase(cases[pos[0]][pos[1]]);
-                    }
-                    blocs.add(bloc);
                 }
+
+                setCouleurBloc(positions);
             }
-        } catch (IllegalArgumentException e) {
-            Console.errorln(e.getMessage());
         }
     }
 
@@ -183,41 +162,31 @@ public class Grille {
      * Ne fonctionne pas pour les grilles dont la taille est un carré parfait.
      */
     public void creerBlocRectangulaire(int blocHeight, int blocWidth) {
-        try {
-            if (taille % blocHeight != 0 || taille % blocWidth != 0) {
-                throw new IllegalArgumentException(
-                        "La taille de la grille doit être divisible par les dimensions des blocs.");
-            }
+        if (taille % blocHeight != 0 || taille % blocWidth != 0) {
+            throw new IllegalArgumentException(
+                    "La taille de la grille doit être divisible par les dimensions des blocs.");
+        }
 
-            int blocsParLigne = taille / blocWidth;
-            int blocsParColonne = taille / blocHeight;
+        int blocsParLigne = taille / blocWidth;
+        int blocsParColonne = taille / blocHeight;
 
-            // Création des blocs en motif rectangulaire
-            for (int blocRow = 0; blocRow < blocsParColonne; blocRow++) {
-                for (int blocCol = 0; blocCol < blocsParLigne; blocCol++) {
-                    List<int[]> positions = new ArrayList<>();
+        // Création des blocs en motif rectangulaire
+        for (int blocRow = 0; blocRow < blocsParColonne; blocRow++) {
+            for (int blocCol = 0; blocCol < blocsParLigne; blocCol++) {
+                List<int[]> positions = new ArrayList<>();
 
-                    // Ajouter toutes les positions pour le bloc courant
-                    for (int i = 0; i < blocHeight; i++) {
-                        for (int j = 0; j < blocWidth; j++) {
-                            positions.add(new int[] {
-                                    blocRow * blocHeight + i,
-                                    blocCol * blocWidth + j
-                            });
-                        }
+                // Ajouter toutes les positions pour le bloc courant
+                for (int i = 0; i < blocHeight; i++) {
+                    for (int j = 0; j < blocWidth; j++) {
+                        positions.add(new int[] {
+                                blocRow * blocHeight + i,
+                                blocCol * blocWidth + j
+                        });
                     }
-
-                    int couleurIndex = blocs.size() % generatedColors.size();
-                    Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
-
-                    for (int[] pos : positions) {
-                        bloc.ajouterCase(cases[pos[0]][pos[1]]);
-                    }
-                    blocs.add(bloc);
                 }
+
+                setCouleurBloc(positions);
             }
-        } catch (IllegalArgumentException e) {
-            Console.errorln(e.getMessage());
         }
     }
 
@@ -271,7 +240,7 @@ public class Grille {
                         break;
 
                     case 2: // Lettres
-                        if (input.length() == 1 && Character.isLetter(input.charAt(0))) {
+                        if (input.length() == 1 && Symbole.of(input.charAt(0)).isLetter()) {
                             Symbole charTemp = Symbole.of(input.charAt(0));
                             if (symbolesPossibles.contains(charTemp)) {
                                 Console.errorln("Ce symbole existe déjà, veuillez entrer un autre symbole");
@@ -321,7 +290,7 @@ public class Grille {
         for (Symbole symbole : symbolesPossibles) {
             sb.append(symbole.toString()).append(" ");
         }
-        System.out.println(sb.toString());
+        System.out.println(sb);
     }
 
     public int getTaille() {
@@ -365,17 +334,6 @@ public class Grille {
         return true;
     }
 
-    public Case getCaseLibre() {
-        for (int i = 0; i < taille; i++) {
-            for (int j = 0; j < taille; j++) {
-                if (cases[i][j].getSymbole() == null) {
-                    return cases[i][j];
-                }
-            }
-        }
-        return null;
-    }
-
     public int getLongueurSymboleLePlusLong() {
         int max = 0;
         for (Symbole symbole : symbolesPossibles) {
@@ -397,23 +355,23 @@ public class Grille {
                 String cellStr = currentCase.toString();
                 // Calculer le nombre d'espaces à ajouter pour atteindre maxLen
                 int pad = maxLen - cellStr.length();
-                String padding = " ".repeat(pad); // nécessite Java 11 ou ultérieur
+                String padding = " ".repeat(pad);
 
                 Bloc bloc = findBlocForCase(currentCase);
 
                 if (bloc != null) {
                     sb.append(bloc.getCouleur()) // couleur du bloc
-                            .append(cellStr)
-                            .append(padding)
+                            .append(cellStr) // symbole
+                            .append(padding) // padding pour aligner les symboles
                             .append("\u001B[0m ") // réinitialiser la couleur
                             .append(" ");
-                } else {
+                } else { // pas de bloc, afficher normalement
                     sb.append(cellStr)
                             .append(padding)
                             .append(" ");
                 }
             }
-            sb.append("\n");
+            sb.append("\n"); // nouvelle ligne
         }
         return sb.toString();
     }

app/src/main/java/sudoku/Multidoku.java

@@ -3,8 +3,8 @@ package sudoku;
 import java.util.*;
 
 public class Multidoku {
-    private List<SudokuPlacement> placements = new ArrayList<>();
-    private List<ContrainteCasePartagee> contraintesPartagees;
+    private final List<SudokuPlacement> placements = new ArrayList<>();
+    private final List<ContrainteCasePartagee> contraintesPartagees;
 
     public Multidoku() {
         this.contraintesPartagees = new ArrayList<>();
@@ -12,10 +12,9 @@ public class Multidoku {
 
     public void ajouterSudoku(Sudoku sudoku, int offsetLigne, int offsetColonne) {
         placements.add(new SudokuPlacement(sudoku, offsetLigne, offsetColonne));
-        sudoku.getGrille().setMultidoku(this); // Passer la référence de Multidoku à Grille
+        sudoku.getGrille().setMultidoku(this);
     }
 
-    // Dans la classe Multidoku, modifier la méthode ajouterCasesPartagees :
     public void ajouterCasesPartagees(List<Case> cases) {
         ContrainteCasePartagee contrainte = new ContrainteCasePartagee(cases, this);
         contraintesPartagees.add(contrainte);
@@ -34,7 +33,7 @@ public class Multidoku {
 
     private List<GlobalCell> collecterCellulesVides() {
         List<GlobalCell> cells = new ArrayList<>();
-        // Ajouter d'abord les cases partagées
+        // Ajout d'abord des cases partagées
         for (ContrainteCasePartagee contrainte : contraintesPartagees) {
             for (Case c : contrainte.getCasesLiees()) {
                 if (c.getSymbole() == null) {
@@ -43,7 +42,7 @@ public class Multidoku {
                 }
             }
         }
-        // Ajouter ensuite les cases non partagées
+        // Ajout ensuite des cases non partagées
         for (SudokuPlacement sp : placements) {
             Sudoku s = sp.getSudoku();
             Grille g = s.getGrille();
@@ -83,7 +82,8 @@ public class Multidoku {
             }
 
             boolean ok;
-            if (isSharedCase(c)) {
+            if (isSharedCase(c)) { // Si la case est partagée, on doit propager la valeur dans les cases
+                                   // correspondantes des autres sudokus concernés
                 ok = setCaseAvecPropagation(gc.ligne, gc.colonne, symbole, s);
             } else {
                 c.setSymbole(symbole);
@@ -132,7 +132,7 @@ public class Multidoku {
             return false;
         }
 
-        // Propagation à la case correspondante uniquement
+        // Propagation à la case correspondante dans les autres sudokus concernés
         for (ContrainteCasePartagee contrainte : contraintesPartagees) {
             if (contrainte.getCasesLiees().contains(c)) {
                 Case caseCorrespondante = contrainte.getCaseCorrespondante(c);
@@ -141,7 +141,7 @@ public class Multidoku {
                     caseCorrespondante.setSymbole(symbole);
 
                     Sudoku autreSudoku = trouverSudokuPourCase(caseCorrespondante);
-                    if (!autreSudoku.estValide(caseCorrespondante)) {
+                    if (autreSudoku != null && !autreSudoku.estValide(caseCorrespondante)) {
                         restaurerCases(sauvegarde);
                         return false;
                     }
@@ -188,7 +188,7 @@ public class Multidoku {
 
     public boolean verifierContraintesPartagees() {
         return contraintesPartagees.stream()
-                .allMatch(c -> c.estRespectee(null, null)); // Adaptation nécessaire selon votre logique
+                .allMatch(c -> c.estRespectee(null, null));
     }
 
     public boolean isSharedCase(Case c) {
@@ -214,16 +214,16 @@ public class Multidoku {
     }
 
     // Classe interne pour la contrainte de cases partagées
-    public class ContrainteCasePartagee implements Contrainte {
-        private Map<Case, Case> casesLiees; // Map associant chaque case à sa correspondante
-        private Set<Sudoku> sudokusLies;
+    public static class ContrainteCasePartagee implements Contrainte {
+        private final Map<Case, Case> casesLiees; // Map associant chaque case à sa correspondante
+        private final Set<Sudoku> sudokusLies;
 
         public ContrainteCasePartagee(List<Case> cases, Multidoku multidoku) {
             this.casesLiees = new HashMap<>();
             this.sudokusLies = new HashSet<>();
 
             // Les cases sont données dans l'ordre : d'abord celles du premier sudoku,
-            // puis celles du second dans le même ordre
+            // puis celles du second dans le même ordre.
             int size = cases.size() / 2;
             for (int i = 0; i < size; i++) {
                 Case c1 = cases.get(i);

app/src/main/java/sudoku/Sudoku.java

@@ -30,10 +30,6 @@ public class Sudoku {
         contraintes.add(contrainte);
     }
 
-    // public void creerBloc(List<int[]> positions, int blocHeight, int blocWidth) {
-    // grille.creerBloc(positions, blocHeight, blocWidth);
-    // }
-
     public boolean estValide(Case c) {
         for (Contrainte contrainte : contraintes) {
             if (!contrainte.estRespectee(grille, c)) {
@@ -63,11 +59,11 @@ public class Sudoku {
         return grille;
     }
 
-    public static Sudoku menuGrille() {
+    public static void menuGrille() {
         Scanner scanner = new Scanner(System.in);
         // ETAPE 1 : TAILLE GRILLE
         System.out.println("ETAPE 1 : Choisir la taille de la grille");
-        int tailleGrille = setTailleGrille(scanner); // récpère la taille de la grille
+        int tailleGrille = setTailleGrille(scanner); // récupère la taille de la grille
         Sudoku sudoku = new Sudoku(tailleGrille);
         // ETAPE 2 : SYMBOLE POSSIBLE
         System.out.println("ETAPE 2 : Choisir les symboles possibles");
@@ -84,8 +80,6 @@ public class Sudoku {
         // ETAPE 5 : RESOLUTION
         System.out.println("ETAPE 5 : Résolution du sudoku");
         choixResolution(sudoku, scanner);
-
-        return sudoku;
     }
 
     private static void choixContraintes(Sudoku sudoku, Scanner scanner) {
@@ -146,8 +140,6 @@ public class Sudoku {
         System.out.println("Voulez-vous résoudre le sudoku ? (O/N)");
         String choix = scanner.nextLine();
         if (choix.equalsIgnoreCase("O")) {
-            System.out.println("Résolution du sudoku.");
-            // resolutionSudoku(sudoku);
             System.out.println("Voulez-vous afficher les étapes de la résolution ? (O/N)");
             String choixAffichageEtapes = scanner.nextLine();
 
@@ -181,48 +173,49 @@ public class Sudoku {
         return tailleGrille;
     }
 
-    private static Sudoku setValeursGrille(Sudoku sudoku, Scanner scanner, int tailleGrille, int typeSymbole) {
-        // Etude de la taille de la grille pour choisir le type de génération
-        if (carreParfait(tailleGrille)) {
-            System.out.println(tailleGrille + " est un carré parfait.");
-            sudoku.getGrille().creerBlocCarre();
-        } else {
-            while (true) {
+    private static void setValeursGrille(Sudoku sudoku, Scanner scanner, int tailleGrille, int typeSymbole) {
+        while (true) {
+            try {
                 System.out.println("Veuillez faire votre choix");
                 System.out.println("1 : Entrer les blocs manuellement");
                 System.out.println("2 : Entrer les blocs à l'aide de la longueur et de la largeur");
+                System.out.println("3 : Générer des blocs carrés");
 
                 int choixGenerationBloc = Integer.parseInt(scanner.nextLine());
 
                 switch (choixGenerationBloc) {
                     case 1:
-                        // Entrer les blocs manuellement
                         System.out.println("Entrez les blocs manuellement.");
-                        creationBlocMannuel(sudoku, scanner, tailleGrille);
+                        creationBlocManuel(sudoku, scanner, tailleGrille);
                         break;
                     case 2:
-                        // Entrer les blocs à l'aide de la longueur et de la largeur
-                        boolean validDimensions = false;
-                        while (!validDimensions) {
-                            try {
-                                System.out.println("Entrez les blocs à l'aide de la longueur et de la largeur.");
-                                System.out.println("Entrez la longueur du bloc : ");
-                                int longueurBloc = Integer.parseInt(scanner.nextLine());
-                                System.out.println("Entrez la largeur du bloc :");
-                                int largeurBloc = Integer.parseInt(scanner.nextLine());
-                                sudoku.getGrille().creerBlocRectangulaire(longueurBloc, largeurBloc);
-                                validDimensions = true; // Sortir de la boucle si aucune exception n'est lancée
-                            } catch (IllegalArgumentException e) {
-                                Console.errorln("Erreur : " + e.getMessage());
-                                Console.errorln("Veuillez entrer des dimensions valides.");
-                            }
+                        try {
+                            System.out.println("Entrez les blocs à l'aide de la longueur et de la largeur.");
+                            System.out.println("Entrez la longueur du bloc : ");
+                            int longueurBloc = Integer.parseInt(scanner.nextLine());
+                            System.out.println("Entrez la largeur du bloc :");
+                            int largeurBloc = Integer.parseInt(scanner.nextLine());
+                            sudoku.getGrille().creerBlocRectangulaire(longueurBloc, largeurBloc);
+                            break;
+                        } catch (IllegalArgumentException e) {
+                            Console.errorln("Erreur : " + e.getMessage());
+                            continue;
+                        }
+                    case 3:
+                        try {
+                            sudoku.getGrille().creerBlocCarre();
+                            break;
+                        } catch (IllegalArgumentException e) {
+                            Console.errorln("Erreur : " + e.getMessage());
+                            continue;
                         }
-                        break;
                     default:
                         Console.errorln("Choix invalide.");
                         continue;
                 }
-                break;
+                break; // Sort de la boucle si la création des blocs a réussi
+            } catch (NumberFormatException e) {
+                Console.errorln("Erreur : Veuillez entrer un nombre valide.");
             }
         }
 
@@ -256,7 +249,7 @@ public class Sudoku {
             }
 
             // Demander et vérifier la colonne
-            int colonne = -1;
+            int colonne;
             while (true) {
                 System.out.println("Entrez le numéro de colonne :");
                 input = scanner.nextLine(); // Lire la colonne
@@ -273,7 +266,7 @@ public class Sudoku {
             }
 
             // Demander et vérifier le symbole
-            String symbole = "";
+            String symbole;
             while (true) {
                 System.out.println("Entrez le symbole :");
                 symbole = scanner.nextLine(); // Lire le symbole
@@ -282,22 +275,22 @@ public class Sudoku {
                     continue; // Recommencer la saisie du symbole si l'entrée est vide
                 }
                 try {
-                    Symbole s = null;
+                    Symbole s;
                     switch (typeSymbole) {
-                        case 1:
-                            // Entiers
+                        case 1: // Entiers
+                            if (!Symbole.of(symbole).isInt()) {
+                                throw new IllegalArgumentException("Veuillez entrer un nombre valide.");
+                            }
                             s = Symbole.of(Integer.parseInt(symbole));
                             break;
-                        case 2:
-                            // Lettres
-                            if (symbole.length() == 1 && Character.isLetter(symbole.charAt(0))) {
-                                s = Symbole.of(symbole.charAt(0));
-                            } else {
+                        case 2: // Lettres
+                            Symbole tempSymbole = Symbole.of(symbole);
+                            if (!tempSymbole.isLetter()) {
                                 throw new IllegalArgumentException("Veuillez entrer une seule lettre.");
                             }
+                            s = tempSymbole;
                             break;
-                        case 3:
-                            // Chaînes de caractères
+                        case 3: // Chaînes de caractères
                             s = Symbole.of(symbole);
                             break;
                         default:
@@ -312,18 +305,9 @@ public class Sudoku {
                 }
             }
         }
-        return sudoku;
     }
 
-    private static boolean carreParfait(int nombre) {
-        if (nombre < 0) {
-            return false;
-        }
-        int racine = (int) Math.sqrt(nombre);
-        return racine * racine == nombre;
-    }
-
-    private static Sudoku creationBlocMannuel(Sudoku sudoku, Scanner scanner, int tailleGrille) {
+    private static void creationBlocManuel(Sudoku sudoku, Scanner scanner, int tailleGrille) {
         int nombreBloc = tailleGrille; // Nombre de blocs dans la grille
 
         Set<String> toutesLesCoordonnees = new HashSet<>(); // Stocke toutes les coordonnées utilisées
@@ -361,7 +345,6 @@ public class Sudoku {
                         System.out.println(
                                 "Erreur : Ces coordonnées sont déjà utilisées dans un autre bloc ! Veuillez en entrer une nouvelle.");
                         coordonneesValides = false;
-                        continue;
                     }
 
                 } while (!coordonneesValides); // Tant que la saisie est invalide, on redemande
@@ -383,6 +366,5 @@ public class Sudoku {
 
             nombreBloc--; // Passer au bloc suivant
         }
-        return sudoku;
     }
 }

app/src/main/java/sudoku/SudokuPlacement.java

@@ -1,9 +1,9 @@
 package sudoku;
 
 public class SudokuPlacement {
-    private Sudoku sudoku;
-    private int offsetLigne;
-    private int offsetColonne;
+    private final Sudoku sudoku;
+    private final int offsetLigne;
+    private final int offsetColonne;
 
     public SudokuPlacement(Sudoku sudoku, int offsetLigne, int offsetColonne) {
         this.sudoku = sudoku;

app/src/main/java/sudoku/Symbole.java

@@ -48,8 +48,4 @@ public class Symbole {
         Symbole symbole = (Symbole) obj;
         return valeur.equals(symbole.valeur);
     }
-
-    public int getHashCode() {
-        return valeur.hashCode();
-    }
 }

app/src/main/java/sudoku/TestSudokuEmojis.java

@@ -1,5 +0,0 @@
-package sudoku;
-
-public class TestSudokuEmojis {
-
-}

app/src/test/java/sudoku/TestBlocRectangle.java

@@ -45,9 +45,6 @@ public class TestBlocRectangle {
         System.out.println("Symboles possibles :");
         sudoku.getGrille().printSymbolesPossibles();
 
-        // blocRectangle.resoudre(sudoku, true);
-        // System.out.println("Sudoku resolu :");
-        // System.out.println(sudoku.getGrille().toString());
         System.out.println("FIN TEST BLOC RECTANGLE");
     }
 }

app/src/test/java/sudoku/TestSudokuEmojis.java

@@ -13,10 +13,18 @@ public class TestSudokuEmojis {
         // Create a new Sudoku
         Sudoku sudoku = new Sudoku(9);
 
+        List<Symbole> symboles = new ArrayList<>();
+        symboles.add(Symbole.of("😎"));
+        symboles.add(Symbole.of("😂"));
+        symboles.add(Symbole.of("😍"));
+        symboles.add(Symbole.of("😜"));
+        symboles.add(Symbole.of("😇"));
+        symboles.add(Symbole.of("😘"));
+        symboles.add(Symbole.of("😋"));
+        symboles.add(Symbole.of("😊"));
+        symboles.add(Symbole.of("😉"));
         sudoku.getGrille()
-                .setSymbolesPossibles(new ArrayList<>(List.of(Symbole.of("😎"), Symbole.of("😂"), Symbole.of("😍"),
-                        Symbole.of("😜"), Symbole.of("😇"), Symbole.of("😘"), Symbole.of("😋"), Symbole.of("😊"),
-                        Symbole.of("😉"))));
+                .setSymbolesPossibles(new ArrayList<>(symboles));
 
         sudoku.ajouterContrainte(new ContrainteLigne());
         sudoku.ajouterContrainte(new ContrainteColonne());

app/src/test/java/sudoku/TestSudokuLettres.java

@@ -13,10 +13,18 @@ public class TestSudokuLettres {
         // Create a new Sudoku
         Sudoku sudoku = new Sudoku(9);
 
+        List<Symbole> symboles = new ArrayList<>();
+        symboles.add(Symbole.of("L"));
+        symboles.add(Symbole.of("E"));
+        symboles.add(Symbole.of("T"));
+        symboles.add(Symbole.of("T"));
+        symboles.add(Symbole.of("R"));
+        symboles.add(Symbole.of("E"));
+        symboles.add(Symbole.of("S"));
+        symboles.add(Symbole.of("O"));
+        symboles.add(Symbole.of("H"));
         sudoku.getGrille()
-                .setSymbolesPossibles(new ArrayList<>(List.of(Symbole.of("L"), Symbole.of("E"), Symbole.of("T"),
-                        Symbole.of("T"), Symbole.of("R"), Symbole.of("E"), Symbole.of("S"), Symbole.of("O"),
-                        Symbole.of("H"))));
+                .setSymbolesPossibles(new ArrayList<>(symboles));
 
         sudoku.ajouterContrainte(new ContrainteLigne());
         sudoku.ajouterContrainte(new ContrainteColonne());

app/src/test/java/sudoku/TestSudokusString.java

@@ -13,11 +13,19 @@ public class TestSudokusString {
         // Create a new Sudoku
         Sudoku sudoku = new Sudoku(9);
 
+        List<Symbole> symboles = new ArrayList<>();
+        symboles.add(Symbole.of("Sudoku"));
+        symboles.add(Symbole.of("🗿"));
+        symboles.add(Symbole.of("Test"));
+        symboles.add(Symbole.of("😂"));
+        symboles.add(Symbole.of("1"));
+        symboles.add(Symbole.of("woW"));
+        symboles.add(Symbole.of("😎"));
+        symboles.add(Symbole.of("42"));
+        symboles.add(Symbole.of("π"));
         sudoku.getGrille()
                 .setSymbolesPossibles(
-                        new ArrayList<>(List.of(Symbole.of("Sudoku"), Symbole.of("🗿"), Symbole.of("Test"),
-                                Symbole.of("😂"), Symbole.of("1"), Symbole.of("woW"), Symbole.of("😎"),
-                                Symbole.of("42"), Symbole.of("π"))));
+                        new ArrayList<>(symboles));
 
         sudoku.ajouterContrainte(new ContrainteLigne());
         sudoku.ajouterContrainte(new ContrainteColonne());