Tp tableau et sudoku

public class Sudoku {
    /*
     * API, TP n°2 Groupe 4 Binôme 
     */
    static final int n = 3; // taille des régions

    /*
     * 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 presentLigne(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
         */
        boolean ligne = false;
        int k = 0;
        while (k < 9) {
            if (m[i][k] == v) {
                ligne = true;
            }
            k++;
        }
        return ligne;
    }

    static boolean presentColonne(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
         */
        boolean colonne = false;
        int k = 0;
        while (k < 9) {
            if (m[k][j] == v) {
                colonne = true;
            }
            k++;
        }
        return colonne;
    }

    static boolean presentRegion(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>
         */
        int l;
        int c;
        for (l = (i / n) * n; l < (i / n) * n + n; l++) {
            for (c = (j / n) * n; c < (j / n) * n + n; c++) {
                if (m[l][c] == v) {
                    return true;
                }
            }
        }
        return false;
    }

    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>
         */
        boolean r[] = new boolean[10];
        int z = 1;
        while (z < 10) {
            if (presentLigne(m, z, i) || presentColonne(m, z, j) || presentRegion(m, z, i, j)) {
                r[z] = false;
            } else
                r[z] = true;
            z++;
        }
        return r;
    }

    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) {
        /*
         * Prerequis :
         * - m est un plateau de sudoku
         * - i et j sont compris entre 0 et n^2-1
         * - m[i][j] vaut 0
         * 
         * Resultat :
         * - v si la seule valeur possible pour <i, j> est v
         * - -1 dans les autres cas
         */
        boolean b = false;
        int val = 0;
        boolean[] r = lesPossiblesEn(m, i, j);
        for (int k = 0; k < 10; k++) {
            if (r[k] == true || b == false) {
                b = true;
                k = val;
            }
            return val;
        }
        // A MODIFIER
    } // toutSeul

    static void essais(String grille) {
        /*
         * Prerequis :
         * grille represente une grille de sudoku (les chiffres sont consideres comme ranges 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("Probleme\n\n" + enClair(m));

        // A COMPLETER

        System.out.println("Il se peut qu'on ait avance\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) ;

        // for (int i = 0; i < 10; i++)
        // System.out.println(lesPossiblesEn(aPartirDe(grille2),5,0)[i]);

        System.out.println(enClair(lesPossiblesEn(aPartirDe(grille2), 5, 0)));

        System.out.println(toutSeul(aPartirDe(grille2), 5, 0));
    }
}