source: Java_Quellcode_SOOP_Vorlesung/arrays/SudokuHelper.java @ 187

package eu.hsrw.tr.prog.vl.arrays;

/**
 * Hilfsfunktionen für die SudokuSolver
 * @author Thomas Richter
 *
 */
public class SudokuHelper {
    protected static long loopCount = 0;
    
    /**
     * Testet, ob die Zahl an der Stelle ohne Verletzung der Sudokubedingung
     * eingefügt werden kann. Die Methode kombiniert die Suche in Zeile, Spalte
     * und Block in nur einer Schleife.
     * 
     * @param a
     *            9x9 Array mit dem Sudoku
     * @param zeile
     *            Zeile der zu prüfenden Zelle
     * @param spalte
     *            Spalte der zu prüfenden Zelle
     * @param zahl
     *            Kandidat für die Einfügung
     * @return false, falls die Kandidatenzahl die Sudkobedingung verletzt,
     *         sonst true
     */
    public static boolean kandidatOK(int[][] a, int zeile, int spalte, int zahl) {
        // Feststellen in welchem Block wir eigentlich sind -> wir benötigen die
        // kleinste Zeile und die kleinste Spalte dieses Blocks als Offset
        int offsetZ = (zeile / 3) * 3;
        int offsetS = (spalte / 3) * 3;
        
        for (int i = 0; i < a.length; i++) {
            loopCount++;
            
            // teste Zeile, Spalte, Block
            if (Math.abs(a[zeile][i]) == zahl
                || Math.abs(a[i][spalte]) == zahl
                || Math.abs(a[offsetZ + i / 3][offsetS + i % 3]) == zahl) {
                
                return false;
            }
        }
        return true;        
    }
    
    /**
     * Initialisiert ein Sudoku als Array aus einem String mit 81 Zeichen.
     * 
     * @param s
     *            Das Sudoku in reduzierter Form: 81 Zeichen, zeilenweise von
     *            oben links nach unten rechts.
     * @return Array, in dem die Vorbelegungen als negative Werte eingetragen
     *         sind.
     */
    public static int[][] parseSudokuString(String sudokuKanonisch) {
        int[][] a = new int[9][9];
        // Eingabe in ein Array von Zeichen umwandeln
        char[] zeichen = sudokuKanonisch.toCharArray();

        for (int z = 0; z < a.length; z++) {
            for (int s = 0; s < a[z].length; s++) {
                // Um die tatsächliche Ziffer zu bekommen wird jeweils der
                // ASCII-Code des Zeichens '0' abgezogen.
                // Der Index wird aus der aktuellen Zeile und Spalte errechnet.
                a[z][s] = -1 * (zeichen[z * a.length + s] - (int) '0');
            }
        }

        return a;
    }
    
    /**
     * Gibt ein Sudoku formatiert auf der Konsole aus
     * 
     * @param a
     *            Array, in dem das auszugebende Sudiku gespeichert ist
     */
    public static void printSudoku(int[][] a) {
        System.out.println("\n-------------------------");
        
        for (int i = 0; i < a.length; i++) {
            System.out.print("| ");

            for (int j = 0; j < a[i].length; j++) {

                System.out.print(Math.abs(a[i][j]));

                if (j % 3 == 2) {
                    System.out.print(" | ");
                } else {
                    System.out.print(" ");                  
                }
            }
            if (i % 3 == 2) {
                System.out.print("\n-------------------------");
            }
            System.out.println();
        }
    }   
}