dick/SAE21_2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

v2

Browse Source
This commit is contained in:
Adrien DICK 2024-04-06 20:23:50 +02:00
parent 44ebaefb19
commit c818eec943
24 changed files with 237 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Enter$1.class
View File

Binary file not shown.

BIN
Enter.class
View File

Binary file not shown.

120
Enter.java
View File

@ -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);
}
}
}
}
}

BIN
GenerateurSudoku.class Normal file
View File

Binary file not shown.

20
GenerateurSudoku.java Normal file
View File

@ -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;
}
}

BIN
GrilleSudokuDessin.class Normal file
View File

Binary file not shown.

46
GrilleSudokuDessin.java Normal file
View File

@ -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);
}
}
}
}
}

BIN
Main$1.class
View File

Binary file not shown.

BIN
Main$2.class Normal file
View File

Binary file not shown.

BIN
Main.class
View File

Binary file not shown.

80
Main.java
View File

@ -1,52 +1,58 @@
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.*;
import java.awt.event.*;
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
System.out.println("Grille Sudoku générée à partir du fichier avec succès.");
int[][] grille = GenerateurSudoku.genererGrille(); // Obtenir la grille par défaut
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
JButton solveButton = new JButton("Solve");
JButton resetButton = new JButton("Reset");
JPanel buttonPanel = new JPanel();
buttonPanel.add(solveButton);
buttonPanel.add(resetButton);
// Panneau pour contenir les boutons
JPanel boutonsPanel = new JPanel();
boutonsPanel.setLayout(new FlowLayout());
// Bouton "Résoudre"
JButton resoudreButton = new JButton("Résoudre");
resoudreButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
long startTime = System.nanoTime(); // Temps avant la résolution
if (Resolveur.resoudreSudoku(grille)) {
long endTime = System.nanoTime(); // Temps après la résolution
long duration = (endTime - startTime) / 1000000; // Durée en millisecondes
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(enterPanel, BorderLayout.CENTER);
frame.add(buttonPanel, BorderLayout.SOUTH);
// 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)) {
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
JOptionPane.showMessageDialog(frame, "Grille résolue avec succès en " + duration + " millisecondes !");
} else {
JOptionPane.showMessageDialog(frame, "Impossible de résoudre la grille.");
}
}
});
frame.add(saisieGrille, BorderLayout.CENTER);
frame.add(boutonsPanel, BorderLayout.SOUTH);
frame.pack();
frame.setLocationRelativeTo(null); // Centrer la fenêtre sur l'écran

BIN
Reinitialiser.class Normal file
View File

Binary file not shown.

22
Reinitialiser.java Normal file
View File

@ -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();
}
}

BIN
Reset.class
View File

Binary file not shown.

22
Reset.java
View File

@ -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();
}
}

BIN
Resolve.class → Resolveur.class
View File

Binary file not shown.

38
Resolve.java → Resolveur.java
View File

@ -1,40 +1,40 @@
public class Resolve {
public static boolean solveSudoku(int[][] grid) {
public class Resolveur {
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 j = 0; j < grid[i].length; j++) {
if (grid[i][j] == 0) {
for (int i = 0; i < grille.length; i++) {
for (int j = 0; j < grille[i].length; j++) {
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
if (isEmpty) {
// Si la grille est pleine, le Sudoku est résolu
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)) {
grid[row][col] = num;
// Résoudre récursivement le sudoku
if (solveSudoku(grid)) {
if (estCoupValide(grille, row, col, num)) {
grille[row][col] = num;
// Résoudre récursivement le Sudoku
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;
}
}

BIN
SaisieGrille$1.class Normal file
View File

Binary file not shown.

BIN
SaisieGrille.class Normal file
View File

Binary file not shown.

87
SaisieGrille.java Normal file
View File

@ -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);
}
}
}
}
}

BIN
SudokuDraw.class
View File

Binary file not shown.

46
SudokuDraw.java
View File

@ -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);
}
}
}
}
}

BIN
SudokuGenerator.class
View File

Binary file not shown.

114
SudokuGenerator.java
View File

@ -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
}
}