001    package de.hska.info1.uebung.felder;
002    
003    /**
004     * Überprüft bei einem ausgefüllten Sudoku, ob die Regeln eingehalten wurden oder nicht.
005     * 
006     * @author Christian Pape
007     *
008     */
009    public class Sudoku {
010    
011            /**
012             * Das Sudoku als 9x9 Feld.
013             */
014            private int [] [] sudoku;
015    
016            /**
017             * Erzeugt ein neues Sudoku mit den gegebenen Feld sudoku.
018             * 
019             * @param sudoku ein 9x9 int Feld
020             */
021            public Sudoku(int [] [] sudoku) {
022                    if (sudoku == null | sudoku.length != 9) {
023                            throw new IllegalArgumentException("Kein 9x9 Feld");
024                    }
025                    this.sudoku = sudoku;
026            }
027            
028            /**
029             * Gibt genau dann true zurück, wenn beim Sudoku in jeder Zeile, Spalte
030             * und jedem 3x3 Block die Zahlen 1 bis 9 genau einmal vorkommen.
031             */
032            public boolean isKorrektesSudoku() {
033                    for (int i = 0; i < 9; i++) {
034                            if (! isKorrekteZeile(i)
035                                            | ! isKorrekteSpalte(i)
036                                            | ! isKorrekteBox(i) ) {
037                                    return false;
038                            }
039                    }
040                    
041                    return true;
042            }
043    
044            private boolean isKorrekteBox(int box) {
045                    int [] zahlen = new int[11];
046                    
047                    for (int i = 0; i < 9; i++) {
048                            int zeile = 3 * (box / 3) + i / 3;
049                            int spalte = 3 * (box / 3) + i % 3;
050                            if ( ! isKorrekt(zahlen, zeile, spalte) ) {
051                                    return false;
052                            }
053                zahlen[ sudoku[zeile][spalte] ]++;
054                    }
055                    
056                    return true;
057            }
058    
059            private boolean isKorrekt(int[] zahlen, int zeile, int spalte) {
060                    return 1 <= sudoku[zeile][spalte] && sudoku[zeile][spalte] <= 9
061                                    && zahlen[sudoku[zeile][spalte] - 1] == 0;
062            }
063    
064            private boolean isKorrekteSpalte(int spalte) {
065                    int [] zahlen = new int[11];
066                    
067                    for (int i = 0; i < 9; i++) {
068                            if (! isKorrekt(zahlen, i, spalte) ) {
069                            return false;
070                            }
071                            zahlen[ sudoku[i][spalte] ]++;
072                    }
073                    return true;
074            }
075    
076            private boolean isKorrekteZeile(int zeile) {
077                    int [] zahlen = new int[11];
078                    
079                    for (int i = 0; i < 9; i++) {
080                            if (! isKorrekt(zahlen, zeile, i)) {
081                            return false;
082                            }
083                            zahlen[ sudoku[zeile][i] - 1]++;
084                        
085                    }
086                    
087                    return true;
088            }
089    
090    }