Java > Sudoku

public class Sudoku {
        static final int n = 3 ;                // taille des régions
        int [][] unPlateau = new int [n*n][n*n];
        /*
         * Terminologie
         *
         * m est un plateau (de sudoku) si
         *      - m est un int [][] ne contenant que des entiers compris entre 0 et 9
         *      - m.length = n^2
         *  - m[i].length = n^2 pour tous les i de 0 à n^2-1
         *  
         */

        static String enClair (int [][] m) {
                /*
                 * Prérequis : m est un plateau de sudoku
                 * Résultat : une chaîne dont l'affichage permet de visualiser m
                 *
                 */
                String r = "" ;        
                for (int i = 0; i < n*n ; i++) {
                        for (int j = 0; j < n*n ; j++) {
                                r = r + m[i][j] + " " ;
                                if (j%n == n-1) {r = r + "  ";}
                        }
                        if (i%n == n-1) {r = r + "\n";}
                        r = r + "\n";
                }              
                r = r + " " ;          
                return r ;
        } // enClair
       
        static int [][] aPartirDe (String s) {
                /*
                 * Prérequis : s est une chaîne contenant au moins n^4 chiffres décimaux
                 * Résultat : un plateau de sudoku initialisé avec les n^4 premiers chiffres
                 * décimaux de s (les chiffres sont considérés comme rangés par lignes).
                 */
                int [][] m = new int [n*n][n*n] ;
                int k = 0 ;
                for (int i = 0; i < m.length ; i++) {
                        for (int j = 0; j < m[i].length ; j++) {
                                while ("0123456789".indexOf(s.charAt(k))==-1) {k++;}
                                m[i][j] = (int) s.charAt(k) - (int) '0' ;
                                k++ ;
                        }                      
                }
                return m ;
               
        } // aPartirDe
       
        static boolean présentLigne (int [][] m, int v, int i) {
                /*
                 * Prérequis :
                 *  - m est un plateau de sudoku
                 *  - v est compris entre 1 et n^2
                 *  - i est compris entre 0 et n^2-1
                 * Résultat : dans m, v est présent dans la ligne i
                 *
                 */
                return true ; // A MODIFIER
        } // présentLigne
       
        static boolean présentColonne (int [][] m, int v, int j) {
                /*
                 * Prérequis :
                 *  - m est un plateau de sudoku
                 *  - v est compris entre 1 et n^2
                 *  - j est compris entre 0 et n^2-1
                 * Résultat : dans m, v est présent dans la colonne j
                 *
                 */
                return true ; // A MODIFIER
        } // présentColonne
       
        static boolean présentRégion  (int [][] m, int v, int i, int j) {
                /*
                 * Prérequis :
                 *  - m est un plateau de sudoku
                 *  - v est compris entre 1 et n^2
                 *  - i et j sont compris entre 0 et n^2-1
                 * Résultat : dans m, v est présent dans la région contenant la case <i, j>
                 *
                 */
                return true ; // A MODIFIER
        } // présentRégion
       
        static boolean [] lesPossiblesEn (int [][] m, int i, int j) {
                /*
                 * Prérequis :
                 *  - m est un plateau de sudoku
                 *  - i et j sont compris entre 0 et n^2-1
                 *  - m[i][j] vaut 0
                 * Résultat : un tableau r de longueur n^2+1 tel que, dans la tranche r[1..n^2]
                 * r[v] indique si v peut être placé en <i, j>
                 *
                 */
                return null ; // A MODIFIER
        } // lesPossiblesEn
       
        static String enClair (boolean[] t) {
                /*
                 * Prérequis : t.length != 0
                 * Résultat :
                 * une chaîne contenant tous les indices i de la tranche [1..t.length-1] tels
                 * que t[i] soit vrai
                 */
                String r = "{" ;
                for (int i = 1; i < t.length; i++) {
                        if (t[i]) {r = r + i + ", " ; }
                }
                if (r.length() != 1) {r = r.substring(0, r.length()-2);}
                return r + "}" ;
        } // enClair
       
        static int toutSeul (int [][] m, int i, int j) {
                /*
                 * Prérequis :
                 *  - m est un plateau de sudoku
                 *  - i et j sont compris entre 0 et n^2-1
                 *  - m[i][j] vaut 0
                 * Résultat :
                 *  - v         si la seule valeur possible pour <i, j> est v
                 *  - -1        dans les autres cas
                 *
                 */
                return -1 ; // A MODIFIER
        } // toutSeul
       
        static void essais (String grille) {
                /*
                 * Prérequis : grille représente une grille de sudoku
                 * (les chiffres sont considérés comme rangés par lignes)
                 *
                 * Effet :
                 * 1) affiche en clair la grille
                 * 2) affecte, tant que faire se peut, toutes les cases pour lesquelles il n'y
                 *    a qu'une seule possibilité
                 * 3) affiche en clair le résultat final
                 */
                int[][] m = aPartirDe(grille);
                System.out.println("Problème\n\n"+enClair(m));

                // A COMPLETER
               
                System.out.println("Il se peut qu'on ait avancé\n\n"+enClair(m));
        } // essais
       
        public static void main(String[] args) {
                String grille1 =
                        "040 001 006 \n" +
                        "007 900 800 \n" +
                        "190 086 074 \n" +
                        "            \n" +
                        "200 690 010 \n" +
                        "030 405 090 \n" +
                        "060 017 003 \n" +
                        "            \n" +
                        "910 750 042 \n" +
                        "008 002 700 \n" +
                        "400 300 080   " ;
                String grille2 =
                        "030 000 006 \n" +
                        "000 702 300 \n" +
                        "104 038 000 \n" +
                        "            \n" +
                        "300 020 810 \n" +
                        "918 000 265 \n" +
                        "062 050 007 \n" +
                        "            \n" +
                        "000 140 708 \n" +
                        "001 209 000 \n" +
                        "800 000 020   " ;
               
                essais(grille1) ;
                essais(grille2) ;
        }
               
}