Java > Programme de résolution de sudoku 9*9

public class SudokuFinal
{
        public static boolean estDansLigne(int i, int nombre) //fonction qui regarde si la valeur "nombre" est déjà dans la ligne.
        {
                boolean test=false;
                int j=0;
                while((j<=8)&&(test==false))
                {
                        if(t[i][j]==nombre)
                       
                                test=true; //si le nombre est trouvé, alors on renvoie vrai.
                       
                        else
                       
                                test=false; //si le nombre est trouvé, alors on renvoie faux.
                       
                        j=j+1;
                }
       
                return test;
        }
       
        public static boolean estDansColonne(int j, int nombre)// fonction qui regarde si la valeur "nombre" se trouve déjà dans la colonne.
        {
                boolean test=false;
                int i=0;
                while((i<=8)&&(test==false))
                {
                       
                        if(t[i][j]==nombre)
                       
                                test=true; // si le nombre est trouvé, alors on renvoie vrai.
                       
                        else
                       
                                test=false; //si le nombre est trouvé, alors on renvoie faux.
                       
                        i=i+1;
                }      
                return test;
        }
       
       
        public static boolean estDansCarre(int i, int j, int nombe) //fonction qui regarde si la valeur "nombre" se situe déjà dans le carré 3x3 où se trouve la case/
        {
                int c=0;
                boolean test=false;
                int carreligne, carrecolonne, debutcarreligne, debutcarrecolonne ;
                carreligne=i/3;
                carrecolonne=j/3;
                debutcarreligne=carreligne*3;
                debutcarrecolonne=carrecolonne*3;
                while((c<=8)&&(test==false))
                {
                        if(t[debutcarreligne][debutcarrecolonne]==nombre)
                       
                                test=true; // renvoie vrai si "nombre" dans le carré
                       
                        else
                       
                                test=false; //renvoie faux si "nombre" n'est pas dans le carré.
                       
                        debutcarrecolonne=debutcarrecolonne+1;
                        if(debutcarrecolonne%3==0)
                        {
                                debutcarrecolonne=debutcarrecolonne-3;
                                debutcarreligne=debutcarreligne+1;
                        }
                        c=c+1;
                }      
                return test;   
        }
       
        static boolean solution; //booléen qui regarde si le programme est déjà fini
        static boolean sens; // booléen qui indique si le programme doit aller en avant ou si il doit retourner en arrière.
        static boolean grilleTerminee; //la grille est remplie correctement ou non
        static boolean validNombre; // le nombre peut être situé dans la cas voulue ou non
        static int nombre, ancienNombre, i, j;
       
        public static void main(String args[])
                {
                        i=0;
                        j=0;
                        solution=false;
                        sens=true;
                        new AffichageSudoku(t, grille, 100);
                        while(solution==false) //le programme se fait tant que solution est faux.
                        {
                                if(grille[i][j]==0)//si il n'y a aucune valeur pré-rentrée dans la case
                                {
                                        if(t[i][j]!=0) // si le programme n'a pas encore rentré de valeur
                                       
                                                ancienNombre=t[i][j]+1;
                                       
                                        else
                                       
                                                ancienNombre=1;
                                       
                                        nombre=ancienNombre;
                                        validNombre=false;
                                        while(nombre<10&&validNombre==false)// "nombre" reste inférieur à 10
                                        {
                                                if((estDansLigne(i, nombre)==false)&&(estDansColonne(j, nombre)==false)&&(estDansCarre(i, j, nombre)==false))// si les fonctions retournent faux alors on peut attacher "nombre" à la case voulue
                                                {      
                                                        t[i][j]=nombre;
                                                        validNombre=true;
                                                }
                                                nombre=nombre+1;
                                        }
                                        if(i==8&&j==8&&validNombre==true)//on arrive à la dernière case et la valeur de celle-ci est bonne.
                                        {      
                                                solution=true;
                                                grilleTerminee=true;
                                               
                                        }
                                       
                                        else
                                        {
                                                if(i==0&&j==0&&validNombre==false)// on arrive à la première case et il n'y a plus de possibilités.
                                                {
                                                        solution=true;
                                                        grilleTerminee=false;
                                                       
                                                }
                                                else
                                                {
                                                        sens=validNombre;
                                                        if(sens==false) // on revient en arrière :"backtracking"
                                                        {
                                                                t[i][j]=grille[i][j];
                                                                do{
                                                                        if(j!=0) // on recule sans être en début de ligne.
                                                                       
                                                                                j=j-1;
                                                                       
                                                                        else //on recule en étant en début de ligne
                                                                        {
                                                                                i=i-1;
                                                                                j=8;
                                                                        }
                                                                }while(grille[i][j]!=0&&i>=0&&j>=0);
                                                        }
                                                        else
                                                        {
                                                                if(j==8) //on avance en fin de ligne
                                                                {
                                                                        j=0;
                                                                        i=i+1;
                                                                }
                                                                else // on avance à partir d'une autre case que la dernière
                                                               
                                                                        j=j+1;
                                                               
                                                        }
                                                }
                                        }
                                }
                                else
                                {
                                        if(sens==false)//on revient en arrière
                                        {
                                                t[i][j]=grille[i][j];
                                                if(j!=0) //on recule sans être en début de ligne.
                                               
                                                        j=j-1;
                                               
                                                else //on recule en étant en début de ligne
                                                {
                                                        i=i-1;
                                                        j=8;
                                                }
                                        }
                                        else
                                        {
                                                if(j==8)//on avance en fin de ligne
                                                {
                                                        j=0;
                                                        i=i+1;
                                                }
                                                else  // on avance à partir d'une autre case que la dernière
                                               
                                                        j=j+1;
                                               
                                        }
                                }
                        }
                }
        static int t[][] =  
        {
                {0,0,0,0,0,6,0,0,0},
                {0,5,0,0,0,0,6,0,0},
                {0,0,1,0,0,0,5,0,8},
                {4,0,0,0,0,9,0,0,7},
                {0,6,0,0,0,0,0,9,0},
                {0,3,0,1,0,0,4,2,0},
                {3,1,0,9,0,7,0,0,0},
                {0,9,8,0,2,1,0,0,3},
                {0,2,0,3,0,0,9,0,0}
        };

        static int grille[][] =
        {
                {0,0,0,0,0,6,0,0,0},
                {0,5,0,0,0,0,6,0,0},
                {0,0,1,0,0,0,5,0,8},
                {4,0,0,0,0,9,0,0,7},
                {0,6,0,0,0,0,0,9,0},
                {0,3,0,1,0,0,4,2,0},
                {3,1,0,9,0,7,0,0,0},
                {0,9,8,0,2,1,0,0,3},
                {0,2,0,3,0,0,9,0,0}
        };
}