v2

Enter.java

@@ -1,120 +0,0 @@
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.*;
-
-public class Enter extends JPanel {
-    private static final int GRID_SIZE = 3;
-    private static final int REGION_SIZE = 3;
-    private static final int CELL_SIZE = 50;
-    private int[][] grid;
-    private int[][] initialGrid; // Pour stocker la grille initiale
-    private int selectedRow = -1;
-    private int selectedCol = -1;
-
-    public Enter(int[][] grid) {
-        this.grid = grid;
-        // Copie de la grille initiale
-        this.initialGrid = new int[grid.length][grid[0].length];
-        for (int i = 0; i < grid.length; i++) {
-            for (int j = 0; j < grid[i].length; j++) {
-                this.initialGrid[i][j] = grid[i][j];
-            }
-        }
-        setPreferredSize(new Dimension(GRID_SIZE * REGION_SIZE * CELL_SIZE, GRID_SIZE * REGION_SIZE * CELL_SIZE));
-        setFocusable(true); // Permet au JPanel de recevoir les événements de souris
-
-        addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                int x = e.getX() / CELL_SIZE;
-                int y = e.getY() / CELL_SIZE;
-                if (x >= 0 && x < GRID_SIZE * REGION_SIZE && y >= 0 && y < GRID_SIZE * REGION_SIZE) {
-                    selectedRow = y;
-                    selectedCol = x;
-                    System.out.println("Case sélectionnée : (" + selectedRow + ", " + selectedCol + ")");
-                    if (initialGrid[selectedRow][selectedCol] == 0) { // Ne permet la modification que pour les cellules vides
-                        String valueStr = JOptionPane.showInputDialog(null, "Enter value for the selected cell:");
-                        try {
-                            int value = Integer.parseInt(valueStr);
-                            if (isValidValue(value, selectedRow, selectedCol)) {
-                                grid[selectedRow][selectedCol] = value;
-                                repaint();
-                            } else {
-                                JOptionPane.showMessageDialog(null, "Not possible.");
-                            }
-                        } catch (NumberFormatException ex) {
-                            JOptionPane.showMessageDialog(null, "Invalid input. Please enter a number.");
-                        }
-                    } else {
-                        JOptionPane.showMessageDialog(null, "You can't edit the default value.");
-                    }
-                }
-            }
-        });
-    }
-
-    public int[][] getInitialGrid() {
-        return initialGrid;
-    }
-
-    private boolean isValidValue(int value, int row, int col) {
-        // Vérifier la ligne
-        for (int i = 0; i < grid[row].length; i++) {
-            if (grid[row][i] == value && i != col) {
-                return false;
-            }
-        }
-
-        // Vérifier la colonne
-        for (int i = 0; i < grid.length; i++) {
-            if (grid[i][col] == value && i != row) {
-                return false;
-            }
-        }
-
-        // Vérifier la région
-        int regionRow = row / REGION_SIZE * REGION_SIZE;
-        int regionCol = col / REGION_SIZE * REGION_SIZE;
-        for (int i = regionRow; i < regionRow + REGION_SIZE; i++) {
-            for (int j = regionCol; j < regionCol + REGION_SIZE; j++) {
-                if (grid[i][j] == value && (i != row || j != col)) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        // Dessiner les contours de la grille (en gras)
-        Graphics2D g2d = (Graphics2D) g;
-        Stroke oldStroke = g2d.getStroke(); // Sauvegarder le style de ligne précédent
-        g2d.setStroke(new BasicStroke(4)); // Épaisseur de ligne de 4 pixels
-
-        for (int i = 0; i <= GRID_SIZE * REGION_SIZE; i++) {
-            if (i % REGION_SIZE == 0) {
-                g2d.drawLine(0, i * CELL_SIZE, GRID_SIZE * REGION_SIZE * CELL_SIZE, i * CELL_SIZE);
-                g2d.drawLine(i * CELL_SIZE, 0, i * CELL_SIZE, GRID_SIZE * REGION_SIZE * CELL_SIZE);
-            }
-        }
-
-        // Rétablir le style de ligne précédent
-        g2d.setStroke(oldStroke);
-
-        // Dessiner les cases de la grille
-        for (int i = 0; i < GRID_SIZE * REGION_SIZE; i++) {
-            for (int j = 0; j < GRID_SIZE * REGION_SIZE; j++) {
-                g.setColor(Color.BLACK);
-                g.drawRect(j * CELL_SIZE, i * CELL_SIZE, CELL_SIZE, CELL_SIZE);
-                int value = grid[i][j];
-                if (value != 0) {
-                    g.drawString(String.valueOf(value), j * CELL_SIZE + CELL_SIZE / 2, i * CELL_SIZE + CELL_SIZE / 2);
-                }
-            }
-        }
-    }
-}

GenerateurSudoku.java

@@ -0,0 +1,20 @@
+import javax.swing.*;
+
+public class GenerateurSudoku {
+    public static int[][] genererGrille() {
+        // grille par défaut
+        int[][] grille = {
+            {0, 0, 0, 0, 9, 5, 0, 0, 4},
+            {5, 3, 0, 4, 0, 8, 7, 0, 2},
+            {0, 0, 0, 7, 0, 0, 6, 0, 3},
+            {9, 0, 0, 0, 3, 4, 0, 8, 0},
+            {0, 4, 0, 0, 1, 0, 0, 7, 0},
+            {0, 2, 0, 5, 7, 0, 0, 0, 6},
+            {4, 0, 9, 0, 0, 2, 0, 0, 0},
+            {6, 0, 7, 9, 0, 3, 0, 2, 1},
+            {2, 0, 0, 6, 5, 0, 0, 0, 0}
+        };
+
+        return grille;
+    }
+}

GrilleSudokuDessin.java

@@ -0,0 +1,46 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class GrilleSudokuDessin extends JPanel {
+    private static final int TAILLE_GRILLE = 3;
+    private static final int TAILLE_REGION = 3;
+    private static final int TAILLE_CELLULE = 50;
+
+    private int[][] grille;
+
+    public GrilleSudokuDessin(int[][] grille) {
+        this.grille = grille;
+        setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE));
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+
+        Graphics2D g2d = (Graphics2D) g;
+        // Définir l'épaisseur de la ligne
+        g2d.setStroke(new BasicStroke(20)); // Épaisseur de ligne de 4 pixels
+
+        // Dessiner les lignes de la grille (en gras pour les contours)
+        for (int i = 0; i <= TAILLE_GRILLE * TAILLE_REGION; i++) {
+            if (i % TAILLE_REGION == 0) {
+                g2d.drawRect(0, i * TAILLE_CELLULE - 2, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, 4);
+                g2d.drawRect(i * TAILLE_CELLULE - 2, 0, 4, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE);
+            } else {
+                g2d.drawRect(0, i * TAILLE_CELLULE - 1, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, 2);
+                g2d.drawRect(i * TAILLE_CELLULE - 1, 0, 2, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE);
+            }
+        }
+
+        // Dessiner les valeurs de la grille
+        g.setColor(Color.BLACK);
+        for (int i = 0; i < grille.length; i++) {
+            for (int j = 0; j < grille[i].length; j++) {
+                int valeur = grille[i][j];
+                if (valeur != 0) {
+                    g.drawString(String.valueOf(valeur), j * TAILLE_CELLULE + TAILLE_CELLULE / 2, i * TAILLE_CELLULE + TAILLE_CELLULE / 2);
+                }
+            }
+        }
+    }
+}

Main.java

@@ -1,52 +1,58 @@
 import javax.swing.*;
-import java.awt.BorderLayout;
+import java.awt.*;
-import java.awt.event.ActionListener;
+import java.awt.event.*;
-import java.awt.event.ActionEvent;
-
-
 
 public class Main {
     public static void main(String[] args) {
         System.out.println("Le programme Main a démarré.");
 
-        int[][] grid = SudokuGenerator.readGridFromFile(); // Demander à l'utilisateur de sélectionner un fichier de grille
+        int[][] grille = GenerateurSudoku.genererGrille(); // Obtenir la grille par défaut
-        System.out.println("Grille Sudoku générée à partir du fichier avec succès.");
+        System.out.println("Grille Sudoku générée avec succès.");
 
         JFrame frame = new JFrame("Sudoku");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-        Enter enterPanel = new Enter(grid); // Utilisation de la classe Enter pour permettre la saisie des valeurs
+        SaisieGrille saisieGrille = new SaisieGrille(grille); // Utilisation de la classe SaisieGrille pour permettre la saisie des valeurs
 
-        // Ajout de deux boutons
+        // Panneau pour contenir les boutons
-        JButton solveButton = new JButton("Solve");
+        JPanel boutonsPanel = new JPanel();
-        JButton resetButton = new JButton("Reset");
+        boutonsPanel.setLayout(new FlowLayout());
-        JPanel buttonPanel = new JPanel();
-        buttonPanel.add(solveButton);
-        buttonPanel.add(resetButton);
 
-        // Ajout des composants au frame
+        // Bouton "Résoudre"
-        frame.add(enterPanel, BorderLayout.CENTER);
+        JButton resoudreButton = new JButton("Résoudre");
-        frame.add(buttonPanel, BorderLayout.SOUTH);
+        resoudreButton.addActionListener(new ActionListener() {
-
-        // Ajout de l'écouteur d'événements au bouton "Reset"
-        resetButton.addActionListener(new Reset(grid, enterPanel));
-
-        // Ajout de l'écouteur d'événements au bouton "Solve"
-        solveButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 long startTime = System.nanoTime(); // Temps avant la résolution
 
-        if (Resolve.solveSudoku(grid)) {
+                if (Resolveur.resoudreSudoku(grille)) {
                     long endTime = System.nanoTime(); // Temps après la résolution
                     long duration = (endTime - startTime) / 1000000; // Durée en millisecondes
 
-            enterPanel.repaint(); // Redessiner la grille après la résolution
+                    saisieGrille.repaint(); // Redessiner la grille après la résolution
                     JOptionPane.showMessageDialog(frame, "Grille résolue avec succès en " + duration + " millisecondes !");
                 } else {
                     JOptionPane.showMessageDialog(frame, "Impossible de résoudre la grille.");
                 }
             }
-});
+        });
+
+        // Bouton "Réinitialiser"
+        JButton reinitialiserButton = new JButton("Réinitialiser");
+        reinitialiserButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                Reinitialiser reinitialiser = new Reinitialiser(grille, saisieGrille);
+                reinitialiser.actionPerformed(e);
+            }
+        });
+
+        // Ajout des boutons au panneau
+        boutonsPanel.add(resoudreButton);
+        boutonsPanel.add(reinitialiserButton);
+
+        // Ajout des composants au frame
+        frame.add(saisieGrille, BorderLayout.CENTER);
+        frame.add(boutonsPanel, BorderLayout.SOUTH);
 
         frame.pack();
         frame.setLocationRelativeTo(null); // Centrer la fenêtre sur l'écran

Reinitialiser.java

@@ -0,0 +1,22 @@
+import javax.swing.*;
+import java.awt.event.*;
+
+public class Reinitialiser implements ActionListener {
+    private int[][] grille;
+    private SaisieGrille panneauSaisie;
+
+    public Reinitialiser(int[][] grille, SaisieGrille panneauSaisie) {
+        this.grille = grille;
+        this.panneauSaisie = panneauSaisie;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        // Réinitialiser la grille en copiant la grille initiale
+        for (int i = 0; i < grille.length; i++) {
+            System.arraycopy(panneauSaisie.getGrilleInitiale()[i], 0, grille[i], 0, grille[i].length);
+        }
+        // Redessiner le panneau
+        panneauSaisie.repaint();
+    }
+}

Reset.java

@@ -1,22 +0,0 @@
-import javax.swing.*;
-import java.awt.event.*;
-
-public class Reset implements ActionListener {
-    private int[][] grid;
-    private Enter enterPanel;
-
-    public Reset(int[][] grid, Enter enterPanel) {
-        this.grid = grid;
-        this.enterPanel = enterPanel;
-    }
-
-    @Override
-    public void actionPerformed(ActionEvent e) {
-        // Réinitialiser la grille en copiant la grille initiale
-        for (int i = 0; i < grid.length; i++) {
-            System.arraycopy(enterPanel.getInitialGrid()[i], 0, grid[i], 0, grid[i].length);
-        }
-        // Redessiner le panneau
-        enterPanel.repaint();
-    }
-}

Resolveur.java

@@ -1,40 +1,40 @@
-public class Resolve {
+public class Resolveur {
-    public static boolean solveSudoku(int[][] grid) {
+    public static boolean resoudreSudoku(int[][] grille) {
         int row = -1;
         int col = -1;
-        boolean isEmpty = true;
+        boolean estVide = true;
 
         // Recherche d'une cellule vide dans la grille
-        for (int i = 0; i < grid.length; i++) {
+        for (int i = 0; i < grille.length; i++) {
-            for (int j = 0; j < grid[i].length; j++) {
+            for (int j = 0; j < grille[i].length; j++) {
-                if (grid[i][j] == 0) {
+                if (grille[i][j] == 0) {
                     row = i;
                     col = j;
                     // Cellule vide trouvée
-                    isEmpty = false;
+                    estVide = false;
                     break;
                 }
             }
-            if (!isEmpty) {
+            if (!estVide) {
                 break;
             }
         }
 
-        // Si la grille est pleine, le sudoku est résolu
+        // Si la grille est pleine, le Sudoku est résolu
-        if (isEmpty) {
+        if (estVide) {
             return true;
         }
 
         // Essayer de placer les chiffres de 1 à 9 dans la cellule vide
         for (int num = 1; num <= 9; num++) {
-            if (isValidMove(grid, row, col, num)) {
+            if (estCoupValide(grille, row, col, num)) {
-                grid[row][col] = num;
+                grille[row][col] = num;
-                // Résoudre récursivement le sudoku
+                // Résoudre récursivement le Sudoku
-                if (solveSudoku(grid)) {
+                if (resoudreSudoku(grille)) {
                     return true;
                 }
                 // Annuler la valeur si la solution n'est pas possible
-                grid[row][col] = 0;
+                grille[row][col] = 0;
             }
         }
         // Aucune solution n'est possible pour cette cellule
@@ -42,17 +42,17 @@ public class Resolve {
     }
 
     // Vérifie si un nombre peut être placé dans une cellule spécifique
-    private static boolean isValidMove(int[][] grid, int row, int col, int num) {
+    private static boolean estCoupValide(int[][] grille, int row, int col, int num) {
         // Vérifie la ligne
         for (int x = 0; x < 9; x++) {
-            if (grid[row][x] == num) {
+            if (grille[row][x] == num) {
                 return false;
             }
         }
 
         // Vérifie la colonne
         for (int y = 0; y < 9; y++) {
-            if (grid[y][col] == num) {
+            if (grille[y][col] == num) {
                 return false;
             }
         }
@@ -62,7 +62,7 @@ public class Resolve {
         int regionColStart = col - col % 3;
         for (int i = 0; i < 3; i++) {
             for (int j = 0; j < 3; j++) {
-                if (grid[i + regionRowStart][j + regionColStart] == num) {
+                if (grille[i + regionRowStart][j + regionColStart] == num) {
                     return false;
                 }
             }

SaisieGrille.java

@@ -0,0 +1,87 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class SaisieGrille extends JPanel {
+    private static final int TAILLE_GRILLE = 3;
+    private static final int TAILLE_REGION = 3;
+    private static final int TAILLE_CELLULE = 50;
+    private int[][] grille;
+    private int[][] grilleInitiale; // Pour stocker la grille initiale
+    private int ligneSelectionnee = -1;
+    private int colonneSelectionnee = -1;
+
+    public SaisieGrille(int[][] grille) {
+        this.grille = grille;
+        // Copie de la grille initiale
+        this.grilleInitiale = new int[grille.length][grille[0].length];
+        for (int i = 0; i < grille.length; i++) {
+            for (int j = 0; j < grille[i].length; j++) {
+                this.grilleInitiale[i][j] = grille[i][j];
+            }
+        }
+        setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE));
+        setFocusable(true); // Permet au JPanel de recevoir les événements de souris
+
+        addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                int x = e.getX() / TAILLE_CELLULE;
+                int y = e.getY() / TAILLE_CELLULE;
+                if (x >= 0 && x < TAILLE_GRILLE * TAILLE_REGION && y >= 0 && y < TAILLE_GRILLE * TAILLE_REGION) {
+                    ligneSelectionnee = y;
+                    colonneSelectionnee = x;
+                    System.out.println("Case sélectionnée : (" + ligneSelectionnee + ", " + colonneSelectionnee + ")");
+                    if (grilleInitiale[ligneSelectionnee][colonneSelectionnee] == 0) { // Ne permet la modification que pour les cellules vides
+                        String valeurStr = JOptionPane.showInputDialog(null, "Entrez la valeur pour la cellule sélectionnée :");
+                        try {
+                            int valeur = Integer.parseInt(valeurStr);
+                            grille[ligneSelectionnee][colonneSelectionnee] = valeur;
+                            repaint();
+                        } catch (NumberFormatException ex) {
+                            JOptionPane.showMessageDialog(null, "Saisie invalide. Veuillez entrer un nombre.");
+                        }
+                    } else {
+                        JOptionPane.showMessageDialog(null, "Vous ne pouvez pas modifier la valeur par défaut.");
+                    }
+                }
+            }
+        });
+    }
+
+    public int[][] getGrilleInitiale() {
+        return grilleInitiale;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+
+        // Dessiner les contours de la grille (en gras)
+        Graphics2D g2d = (Graphics2D) g;
+        Stroke ancienStroke = g2d.getStroke(); // Sauvegarder le style de ligne précédent
+        g2d.setStroke(new BasicStroke(4)); // Épaisseur de ligne de 4 pixels
+
+        for (int i = 0; i <= TAILLE_GRILLE * TAILLE_REGION; i++) {
+            if (i % TAILLE_REGION == 0) {
+                g2d.drawLine(0, i * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, i * TAILLE_CELLULE);
+                g2d.drawLine(i * TAILLE_CELLULE, 0, i * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE);
+            }
+        }
+
+        // Rétablir le style de ligne précédent
+        g2d.setStroke(ancienStroke);
+
+        // Dessiner les cellules de la grille
+        for (int i = 0; i < TAILLE_GRILLE * TAILLE_REGION; i++) {
+            for (int j = 0; j < TAILLE_GRILLE * TAILLE_REGION; j++) {
+                g.setColor(Color.BLACK);
+                g.drawRect(j * TAILLE_CELLULE, i * TAILLE_CELLULE, TAILLE_CELLULE, TAILLE_CELLULE);
+                int valeur = grille[i][j];
+                if (valeur != 0) {
+                    g.drawString(String.valueOf(valeur), j * TAILLE_CELLULE + TAILLE_CELLULE / 2, i * TAILLE_CELLULE + TAILLE_CELLULE / 2);
+                }
+            }
+        }
+    }
+}

SudokuDraw.java

@@ -1,46 +0,0 @@
-import javax.swing.*;
-import java.awt.*;
-
-public class SudokuDraw extends JPanel {
-    private static final int GRID_SIZE = 3;
-    private static final int REGION_SIZE = 3;
-    private static final int CELL_SIZE = 50;
-
-    private int[][] grid;
-
-    public SudokuDraw(int[][] grid) {
-        this.grid = grid;
-        setPreferredSize(new Dimension(GRID_SIZE * REGION_SIZE * CELL_SIZE, GRID_SIZE * REGION_SIZE * CELL_SIZE));
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        Graphics2D g2d = (Graphics2D) g;
-        // Définir l'épaisseur de la ligne
-        g2d.setStroke(new BasicStroke(20)); // Épaisseur de ligne de 4 pixels
-
-        // Dessiner les lignes de la grille (en gras pour les contours)
-        for (int i = 0; i <= GRID_SIZE * REGION_SIZE; i++) {
-            if (i % REGION_SIZE == 0) {
-                g2d.drawRect(0, i * CELL_SIZE - 2, GRID_SIZE * REGION_SIZE * CELL_SIZE, 4);
-                g2d.drawRect(i * CELL_SIZE - 2, 0, 4, GRID_SIZE * REGION_SIZE * CELL_SIZE);
-            } else {
-                g2d.drawRect(0, i * CELL_SIZE - 1, GRID_SIZE * REGION_SIZE * CELL_SIZE, 2);
-                g2d.drawRect(i * CELL_SIZE - 1, 0, 2, GRID_SIZE * REGION_SIZE * CELL_SIZE);
-            }
-        }
-
-        // Dessiner les valeurs de la grille
-        g.setColor(Color.BLACK);
-        for (int i = 0; i < grid.length; i++) {
-            for (int j = 0; j < grid[i].length; j++) {
-                int value = grid[i][j];
-                if (value != 0) {
-                    g.drawString(String.valueOf(value), j * CELL_SIZE + CELL_SIZE / 2, i * CELL_SIZE + CELL_SIZE / 2);
-                }
-            }
-        }
-    }
-}

SudokuGenerator.java

@@ -1,114 +0,0 @@
-import javax.swing.*;
-import java.io.*;
-
-public class SudokuGenerator {
-    public static int[][] generateGrid() {
-        // grille par défaut
-        int[][] grid = {
-            {0, 0, 0, 9, 0, 5, 0, 0, 4},
-            {5, 0, 3, 0, 0, 4, 0, 8, 7},
-            {0, 0, 0, 7, 0, 0, 6, 0, 3},
-            {9, 0, 0, 0, 3, 4, 0, 8, 0},
-            {0, 4, 0, 0, 1, 0, 0, 7, 0},
-            {0, 2, 0, 5, 7, 0, 0, 0, 6},
-            {4, 0, 9, 0, 0, 2, 0, 0, 0},
-            {6, 0, 7, 9, 0, 3, 0, 2, 1},
-            {2, 0, 0, 6, 5, 0, 0, 0, 0}
-        };
-
-        return grid;
-    }
-
-    public static int[][] readGridFromFile() {
-        int[][] grid = new int[9][9];
-        JFileChooser fileChooser = new JFileChooser();
-        int result = fileChooser.showOpenDialog(null);
-        if (result == JFileChooser.APPROVE_OPTION) {
-            File selectedFile = fileChooser.getSelectedFile();
-            try (BufferedReader reader = new BufferedReader(new FileReader(selectedFile))) {
-                for (int i = 0; i < 9; i++) {
-                    String line = reader.readLine();
-                    // Vérifier la longueur de la ligne lue
-                    if (line.length() != 9) {
-                        JOptionPane.showMessageDialog(null, "Invalid file format. Please select a file with correct Sudoku grid format.");
-                        return generateGrid(); // Charger la grille par défaut en cas d'erreur
-                    }
-                    for (int j = 0; j < 9; j++) {
-                        char ch = line.charAt(j);
-                        if (ch >= '1' && ch <= '9') {
-                            grid[i][j] = Character.getNumericValue(ch);
-                        } else {
-                            grid[i][j] = 0;
-                        }
-                    }
-                }
-                if (!isGridValid(grid)) {
-                    JOptionPane.showMessageDialog(null, "Invalid Sudoku grid. Loading default grid.");
-                    return generateGrid(); // Charger la grille par défaut en cas de grille invalide
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-        return grid;
-    }
-
-    // Méthode pour vérifier si la grille est valide
-    private static boolean isGridValid(int[][] grid) {
-        for (int i = 0; i < 9; i++) {
-            if (!isRowValid(grid, i) || !isColumnValid(grid, i) || !isRegionValid(grid, i)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    // Méthode pour vérifier s'il n'y a pas de chiffres en double sur une ligne donnée
-    private static boolean isRowValid(int[][] grid, int row) {
-        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
-        for (int i = 0; i < 9; i++) {
-            int num = grid[row][i];
-            if (num != 0) {
-                if (seen[num]) {
-                    return false; // Le chiffre est déjà apparu sur cette ligne
-                }
-                seen[num] = true;
-            }
-        }
-        return true; // Aucun chiffre en double sur la ligne
-    }
-
-    // Méthode pour vérifier s'il n'y a pas de chiffres en double sur une colonne donnée
-    private static boolean isColumnValid(int[][] grid, int col) {
-        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
-        for (int i = 0; i < 9; i++) {
-            int num = grid[i][col];
-            if (num != 0) {
-                if (seen[num]) {
-                    return false; // Le chiffre est déjà apparu sur cette colonne
-                }
-                seen[num] = true;
-            }
-        }
-        return true; // Aucun chiffre en double sur la colonne
-    }
-
-    // Méthode pour vérifier s'il n'y a pas de chiffres en double dans une région donnée
-    private static boolean isRegionValid(int[][] grid, int region) {
-        int rowOffset = (region / 3) * 3;
-        int colOffset = (region % 3) * 3;
-        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
-        for (int i = rowOffset; i < rowOffset + 3; i++) {
-            for (int j = colOffset; j < colOffset + 3; j++) {
-                int num = grid[i][j];
-                if (num != 0) {
-                    if (seen[num]) {
-                        return false; // Le chiffre est déjà apparu dans cette région
-                    }
-                    seen[num] = true;
-                }
-            }
-        }
-        return true; // Aucun chiffre en double dans la région
-    }
-}