Sudoku/BLocküberprüfung

[newbie2009]

Hey leute ich versuche mich gerade an einem Sudokulöser , allerding fehlt mir noch die idee zur überprüfung der dritten regel, nämlich , dass in einem quadrat ein bestimmter wert nur ein mal vorhanden sein darf.

Spaltenüberprüfung und Zeilenüberprüfung habe ich schon implementiert.

		private static boolean zeileok(int [][]array,int zeile, int wert ){
	
			for(int i=0;i<array[zeile].length;i++){
				if(array[zeile][i]==wert){
					System.out.println("wert schon vorhanden");
					return false;
				}
			}
		
		return true;
		

	}
	



private static boolean spalteok(int [][]array,int spalte,int wert){
		
		for(int i=0;i<array.length;i++){
			if(array[i][spalte]==wert){
				System.out.println("wert schon vorhanden");
				return false;
			}
		}

Es handelt sich um eine 9 x 9 Matrix und die beiden aufgeführten methoden funktionieren ganz gut, nur die überprüfung im block funktioniert noch nicht ganz , mir fehlt einfach die idee , thx im voraus.

 

[spongebob]

erstelle dir doch einfach ein array mit 9 bool-werten(default: false). dann gehst du über die felder im sudoku und nimmst die werte als indizies im array um die entsprechenden felder als true zu markieren. wenn jetzt alle felder true sind, ist die bedingung erfüllt.

bsp:
-array = f,f,f,f,...
-im linken oberen feld steht eine 2:
array = f,>t<,f,f,....

du musst halt nur beachten das das array mit 0 beginnt, und deshalb vom index 1 abziehen

edit:
wenn du prüfen willst ob eine zahl bereits gesetzt ist, nimmst du ein integer array und zählst wie oft jede zahl gesetzt wurde. wenn danach im array ein wert >1 steht wurde eine zahl 2 mal benutzt

 

[newbie2009]

das löst aber nicht mein problem ,wenn ich dich richtig verstanden habe , denn wenn man deine idee umsetzen würde bräuchte man ja 9 mal 3*3 matrizen , was mir dann aber die spalten und zeilenüberpüfung erschweren würde.

 

[Michael...]

Du kannst ja mittels verschachtelten for Schleife Deine Matrix blockweise überprüfen.

 

[Nardian]

hab mal vor ner weile auch einen soduko-löser geschrieben (zwar nicht in java, aber von der idee her sollts ja gleich sein)

ich hab damals folgendes gemacht

ich bekomm die x / y koordinaten vom neuen eintrag. dann weiß ich wie groß mein sudoku ist (also 3*3, bzw speichere ich mir halt nur 3). dann:
newX = x / size; wobei size eben die 3 ist. (kannst auch hardcoden, wenn du "nur" 3*3 lösen können willst). und das selbe dann mit y. damit weiß ich in welchem quadranten ich bin
bsp:
wenn ich zb 8 / 8 bekomme (was ja das rechte untere eck sein sollte - also wirklich das letzte kästchen), dann ergibt die newX und newY = 2.

gut, dann (auch wenns komisch klingt) einfach
newX = newX * size;
jetz komm ich aber nicht auf 8 / 8 sondern eben auf meine gewünschte 6/6. das ist immer die linke obere ecke vom quadranten.
jetz noch eine geschachtelte schleife die in etwa so aussehn könnt

for(int i = 0; i < size; i++){
	for(int j = 0; j < size; j++){
		if(array[newX+j][newY+i] == wert){
			//gibts schon
		}
	}
}

 

[newbie2009]

thx an alle

@ michael sowas in der art hatte ich auch vor, aber irgendwie übersteigt das meine vorstellungskraft Was mir probleme macht an solch einer überprüfung , dass die blöcke alle unterschiedliche indizes haben sprich sowas in der art:

Block Nr 1 | 2 | 3

--------------------------------------------------


Indizes/Zeile | 0-2 0-2 0-2

Indizes/Spalte | 0-2 3-5 6-8
---------------------------------------------------


4 | 5 | 6
---------------------------------------------------

Indizes/Zeile | 3-5 3-5 3-5

Indizes/Spalte| 0-2 3-5 6-8
--------------------------------------------------

7 8 9


Indizes/Zeile | 6-8 6-8 6-8
Indizes/Spalte| 0-2 3-5 6-8

 

[Michael...]

ohne Gewähr:

	public boolean isValid(int value) {
		int[][] field = new int[9][9]; //Initialisierung hier nur zur Demo
		
		for (int blockY=0; blockY<3; blockY++) {
			for (int blockX=0; blockX<3; blockX++) {
				//Durchsuchen eines einzelnen Blocks
				System.out.println("Checking block in line " + blockY + " column " + blockX);
				for (int row=0; row<3; row++) {
					for (int col=0; col<3; col++) {
						System.out.print((col + blockY*3) + "|" + (row + blockX*3) + " ");
						if (field[col + blockY*3][row + blockX*3]==value) {
							System.out.println("Wert " + value + " ist ungültig!");
							return false;
						}
					}
					System.out.println();
				}
				//Block abgearbeitet
			}
		}
		return true;
	}

 

[newbie2009]

könntest das vielleicht noch bissl erläutern , also mit den inneren schleifen durchsuchst du die einzelnen zellen eines blocks oder nicht? die äußeren verstehe ich nicht ganz und die multiplikation mit 3 .


vielen dank im voraus

 

[Lowpass]

Den Code von Michael kann ich nicht erklären, da er mir selber schleierhaft ist - zumal er nur einen Wert entgegen nimmt, völlig ohne Verwurzelung im Sudoku-Gitter.

Wir sollten uns besser auf die Lösung von Nardian konzentrieren und diese vielleicht näher erläutern.

Wie gesagt brauchst Du 3 Dinge:
1. Das Brett: ein 9x9 Array von int - und zwar mit dem aktuellen Stand
2. Der neue Wert als int
3. Die Koordinaten des neuen Wertes

Mit den Koordinaten des neuen Wertes kannst Du herausfinden, in welcher 3er-Gruppe das Feld des neuen Wertes liegt.
Nehmen wir an, der neue Wert befindet sich in der sechsten Reihe in der siebten Spalte, dann sind die Koordinaten [5][6].

Nach dem Vorschlag von Nardian teilst Du nun beide Zahlen durch die Anzahl an Felder pro Quadrat um herauszufinden, in welchem Quadrat sich der neue Wert befindet. Dabei kannst du alles nach dem Komma vergessen.
5/3 = 1
6/3 = 2

Jetzt aufgepasst, auch die Quadrate werden von 0 an durchnummeriert!
Also weisst Du jetzt, dass sich der neue Wert in der zweiten Reihe (1) im dritten Quadrat (2) befindet.

Als nächstes berechnest Du, welches das rechte obere Feld dieses Quadrates ist. Und zwar ganz einfach, indem Du die vorhin erhaltene Zahl mit den Anzahl Feldern pro Quadrat multiplizierst:
1*3 = 3
2*3 = 6
Das ergibt die Koordinaten [3][6].
Und von da an durchläufst Du eine verschachtelte Schleife: die äussere zählt bis zu 3 (Anzahl Felder pro Quadrat) zum ersten Wert und die innere Schleife zählt bis zu 3 (Anzahl Felder) zum zweiten Wert.

 

[Michael...]

mit den äusseren zwei Schleifen iteriere ich über die einzelnen Blocks
Man könnte auch deren Zählvariablen pro Scheifendurchgang um 3 inkrementieren, dann muss man innen nicht *3 nehmen.

	public boolean isValid(int value) {
		int[][] field = new int[9][9]; //Initialisierung hier nur zur Demo
		
		for (int blockY=0; blockY<9; blockY+=3) {
			for (int blockX=0; blockX<9; blockX+=3) {
				//Durchsuchen eines einzelnen Blocks
				System.out.println("Block***************");
				for (int row=0; row<3; row++) {
					for (int col=0; col<3; col++) {
						System.out.print((col + blockY) + "|" + (row + blockX) + " ");
						if (field[col + blockY][row + blockX]==value) {
							System.out.println("Wert " + value + " ist ungültig!");
							return false;
						}
					}
					System.out.println();
				}
				//Block abgearbeitet
			}
		}
		return true;
	}

Mit den inneren zwei Schleifen durchsuche ich nur einen 3x3 Block, mit den äusseren zwei Schleifen lege ich fest ab welchem index gestartet werden soll. Quasi:
1. Durchgang starte bei [0][0] (bis [2][2])
2. Durchgang starte bei [0][3] (bis [2][5])
3. Durchgang starte bei [0][6] ...
4. Durchgang starte bei [3][0] (bis [5][2])
...

Was welche Indezes wann überprüft werden sieht man ja in der Konsolenausgabe

 

[Lowpass]

Abgesehen vom kleinen Schönheitsfehler, dass Du die Spalten mit Y-Koordinaten und die Zeilen mit X-Koordinaten bezeichnest: was macht Dein Code schlussendlich eigentlich?
Wenn ich das richtig sehe, durchläuft er komplett jede einzelne Zelle des gesamten 9x9 Sudoku-Spielbretts und sobald er einen Eintrag mit dem Wert der Variable "value" findet, gibt er false zurück und meldet, dass der Wert ungültig ist.

 

[Sonecc]

Eine mögliche Lösung ist:

Die Blocklösung sieht man etwas weiter unten

	/**
	 * Prüfe ob a an der Position fields[i][j] gültig eingesetzt werden kann
	 * @param i Zeile
	 * @param j Spalte
	 * @param a Der Wert der geprüft werden soll
     * @param fields Das Sudoku Feld
	 * @return true wenn a gültig ist
	 */
	private boolean check(int i, int j, int a, int[][] fields) {
		//Zeile durchlaufen und prüfen ob a dort schon vorhanden ist
		for (int k = 0; k < 9; k++) {
			if (fields[k][j] == a) {
				return false;
			}
		}
		//Spalte durchlaufen und prüfen ob a dort schon vorhanden ist
		for (int k = 0; k < 9; k++) {
			if (fields[i][k] == a) {
				return false;
			}
		}
		//Block durchlaufen
		//Ermittle die aktuelle startspalte des Blocks
		int spalte = (int) (i/3 * 3); 
		//Gleiches mit der Zeile
		int zeile = (int) (j/3 * 3);
		//Durchlaufe den Block
		for (int k = spalte; k < spalte + 3; k++) {
			for (int l = zeile; l < zeile + 3; l++) {
				if (fields[k][l] == a) {
					return false;
				}
			}
		}
		// a wurde nirgends gefunden
		return true;
	}

 

[Lowpass]

Variablen sollte man immer sprechend benennen. i und j werden normalerweise als Zähler verwendet und sollten keine Parameter benennen.

Viel besser wäre

check(int row, int column, int insertValue, int[][] sudokufield)

oder ähnlich.

 

[Sonecc]

Ich fang mal keine Diskussion darüber an...
Wie man die Parameter nun nennen will oder nicht, ist mir völlig egal.
Diese Methode habe ich zu meinen anfängen geschrieben und da war es mir gelinde gesagt scheiß egal, was irgendwer von den Namen hält. Der Code war für mich und mir reichen die namen, da ich auch gut genug Dokumentiert habe, wofür sie stehen!
Der Code sollte also gut genug kommentiert sein, um auch ohne die (von dir unglücklich und teils irreführend gewählten) namen zu verstehen was gemacht wurde.

Wo wir aber am mäkeln sind:
Die Kommentare sollten natürlich besser auf Englisch sein, statt auf Deutsch
Ich bitte diese unfeinheiten zu verzeihen :bae:

 

[cz3kit]

Hallöle, also ich mache auch Sudoku zur Zeit. Ich mache aber keinen Sudoku, hab aber einen Generator, ist ja im Prinzip fast das selbe. Wenn du so eine Kachel, Box, 3x3 Feld überprüfen willst, dann kannst du mit %3 arbeiten.

/**
	 * Diese Methode entfernt alle benachbarten Zahlen, die im solvedBoard 
	 * eingetragen sind, von der gegebenen Position.
	 * @param x ist vom Typ int und beschreibt die Spalte.
	 * @param y ist vom Typ int und beschreibt die Zeile.
	 * @param list ist vom Typ List und darf nur Integer enthalten.
	 * @return List die nur Integer enthält.
	 */
	private List<Integer> removeNeighbours(int x, int y, List<Integer> list) {
		/*
		 * overx(overy) wird das Ergebnis aus der Rechnung x Modulo 3 
		 * (y Modulo 3) übergeben. 
		 */
		int overx = x % 3;
		int overy = y % 3;
		
		/*
		 * Wenn overx gleich 0 ist und overy ungleich ist, werden alle
		 * benachbarten Zahlen von der aktuellen Position entfernt.
		 * Das betrifft die Zahlen die sich rechts und eine oder zwei Zeilen
		 * darüber befinden.
		 */
		if (overx == 0 && overy != 0) {
			for (int i = (y - 1); i >= (y - overy); i--) {
				for (int j = (x + 1); j < (x + 3); j++ ) {
					list.remove(this.solvedBoard[i][j]);
				}
			}
		/*
		 * Wenn overx gleich 1 ist und overy ungleich 0 ist, werden alle
		 * benachbarten Zahlen von der aktullen Position entfernt.
		 * Das betrifft die Zahlen die sich links, rechts und eine oder
		 * zwei Spalten darüber befinden.
		 */
		}else if (overx == 1 && overy != 0) {
			for (int i = (y - 1); i >= (y - overy); i--) {
				for (int j = (x - 1); j < (x + 2); j += 2) {
					list.remove(this.solvedBoard[i][j]);
				}
			}
		/*
		 * Wenn overx gleich 2 ist und overy ungleich 0 ist, werden alle
		 * benachbarten Zahlen von der aktullen Position entfernt. 
		 * Das betrifft die Zahlen die sich links und ein oder zwei Spalten
		 * darüber befinden.
		 */
		}else if (overx == 2 && overy != 0) {
			for (int i = (y - 1); i >= (y - overy); i--) {
				for (int j = (x - 2); j < x; j++) {
					list.remove(this.solvedBoard[i][j]);
				}
			}
		}
		return list;
	}

So sieht das bei mir aus. Sieht auf den ersten Blick wirre aus, aber du vorher überlegen ob du Spaltenüberprüfung und Zeilenüberprüfung vor dem Kachelüberprüfer laufen lässt. Wenn dem der Fall ist, muss du einige Felder ja gar nicht mehr überprüfen, da diese bereits von den anderen beiden Methoden bereits überprüft wurden.

Ich hoffe es ist verständlich was hier passiert, sonst einfach eben Fragen.

 

[newbie2009]

einen besonderen dank an lowpass und sonecc für die aufschlussreiche erklärung und implementierung, klingt nun auch logisch allein wäre ich wohl aber niemals auf die idee gekommen
wie kommt man nur auf sowas?

aber auch danke an die anderen die was dazu beigetragen haben

 

[Sonecc]

Probieren und überlegen. Ich habs durch aufzeichnen und spielen mit den indizes entdeckt und dann so umgesetzt wie ich es gezeigt habe

 

[Lowpass]

Auch mir ist es völlig egal, wie Du Deine Variablen benennst, Sonecc - aber wenn Du Anfängern Tipps gibst, dann solltest Du Angewohnheiten, die allen existierenden Guidelines widersprechen, wenn irgendwie möglich nicht weitergeben.
Wenn man immer für sich allein im Kämmerchen programmiert, spielt es absolut keine Rolle - sobald man im Team arbeitet oder seinen Code veröffentlicht, ist eine gewisse Disziplin unabdingbar - und die fängt zuallererst bei den Guidelines an. Wenn man mal eine schlechte Angewohnheit "drin" hat, dann kriegt man sie kaum mehr weg. Ein Entwickler, der Variablen, die keine Zähler sind, nach Buchstaben benennt, ist nach meiner Erfahrung resistent gegen jede Form von gemeinsamer Vereinbarung - und hier geht es ja nicht um meine persönliche Meinung, sondern um weltweit etablierte und von allen halbwegs professionellen Entwicklern akzeptierten Standards.

Schwer zu lesender Code hinterlässt zudem einen sehr schlechten Eindruck, was ebenfalls in jeder Teamarbeit unerwünscht sein dürfte.

Für Einzelkämpfer sind gemeinsame Vereinbarungen natürlich unnötig - aber sowas sollte man nicht weitergeben.
Und auch wenn Dir meine Namensgebung nicht gefällt, ist sie sicher immer noch sprechender als i,j und a - und was Kommentare betrifft: ich kenne ehrlich gesagt keine Guidelines, die für sich globale Gültigkeit beanspruchen und Englisch als einzige Sprache vorschreiben. Das ist ganz klar abhängig vom Projekt.

.

 

[newbie2009]

hmm kann sein, dass hier doch ein fehler ist sonnec, aso die methode an sich klingt logisch und macht sinn aber nun habe ich ma meine matrix gefüllt und mit der methode auf bestimmte zahlen überprüft.
allerdings liefert sie mir auch true , wenn ich zahlen doppelt eingeben möchte, hmm aber eigentlich stimmt die methode...
ich habe kp woran es liegen mag.

ah jetzt weiß ich es hatte, bei mir spalten und zeilen anders als bei dir im array vielen dank nochmal

 

[Sonecc]

Da Lowpass mit seinen Aussagen grundsätzlich Recht hat, hier eine Version mit besseren Namen:

/**
	 * Prüfe ob value gültig eingesetzt werden kann
	 * @param row Zeile
	 * @param column Spalte
	 * @param value Der Wert der geprüft werden soll
	 * @return true wenn a gültig ist
	 */
	private boolean check(int row, int column, int value, int[][] fields) {
		//Zeile durchlaufen und prüfen ob value dort schon vorhanden ist
		for (int i = 0; i < 9; k++) {
			if (fields[i][column] == value) {
				return false;
			}
		}
		//Spalte durchlaufen und prüfen ob value dort schon vorhanden ist
		for (int i = 0; i < 9; k++) {
			if (fields[row][i] == value) {
				return false;
			}
		}
		//Block durchlaufen
		//Ermittle die aktuelle startspalte des Blocks
		int blockColumn = (int) (column/3 * 3); 
		//Gleiches mit der Zeile
		int blockRow = (int) (row/3 * 3);
		//Durchlaufe den Block
		for (int i = blockRow; i < blockRow + 3; i++) {
			for (int j = blockColumn; j < blockColumn + 3; j++) {
				if (fields[i][j] == value) {
					return false;
				}
			}
		}
		// value wurde nirgends gefunden
		return true;
	}

 

[Kaa27]

Hallo; holen wir mal diesen alten Strang hoch.

Ich möchte drei Methoden schreiben um mein schon korrekt eingegebenes Sudoku zu überprüfen.
Die Methoden für die Zeilen und Spalten klappen schon soweit, nur der Block macht Probleme.

	public static boolean block( int[][] puzzle) {

		 int row = 0;
		 int a = 0;
		 for (a = 0; a < puzzle.length; a++) {
		 for (int sum = 0, col = 0; col < row + 3; sum +=puzzle[row][col], col++)
		 {
		 for (row = 0; row < col + 3; sum += puzzle[row][col], row++) {
		 }
		 if (sum != 45)
		 return false;
		 }
		
		 }
		 return true;
		 }

In der Main erfolgt der Aufruf:

public static void main(String[] args) {

		final int[][] sudoku = { 
                                { 1, 3, 2, 5, 4, 9, 8, 6, 7 },
				{ 4, 9, 7, 6, 8, 1, 3, 5, 2 }, { 5, 8, 6, 7, 2, 3, 9, 1, 4 },
				{ 7, 5, 9, 1, 6, 8, 2, 4, 3 }, { 2, 6, 4, 3, 7, 5, 1, 9, 8 },
				{ 8, 1, 3, 4, 9, 2, 6, 7, 5 }, { 3, 7, 5, 2, 1, 6, 4, 8, 9 },
				{ 6, 2, 8, 9, 5, 4, 7, 3, 1 }, { 9, 4, 1, 8, 3, 7, 5, 2, 6 },
                                 };
		{
			for (int i = 0; i < sudoku.length; i++) {
				for (int j = 0; j < sudoku[i].length; j++) {
					System.out.print(sudoku[i][j]);
				}
				System.out.println(" ");
			}
		}

		System.out.println("Is row valid? " + row(sudoku));
		System.out.println("The collums is valid?" + coll(sudoku));
		System.out.println("Is block valid?" + block(sudoku));

Als Ergebnis kommt, das die Blöcke false sind.
Wo ist mein Fehler?

 

[Nardian]

Hi,

stimmt schon, ist durchaus ein eher alter Thread, aber naja ...

Du hast leider einige Fehler reingebaut.

1. das if-statement steht noch innerhalb der mittleren for-schleife - sollte allerdings nach der mittleren aber noch innerhalb der äußeren schleife stehn...
2. deine "berechnung" für die col / row stimmt nicht ganz...
die inner schleife geht beim 1. durchlauf wie geplant von 0 bis 2, das passt ja noch.
das problem beginnt mit dem 2. durchlaufn, da du ihm dort sagst, von 0 bis 3 (da col jetzt 1 ist, und 1+3 == 4, und 3 noch < 4 ist)


ich an deiner stelle würde das block-problem anders angehen...

Ein vorschlag:

public static boolean block(int[][] puzzle) {
		for(int blockNr = 0; blockNr < 9; ++blockNr){
			// berechne die x / y position der linken oberen ecke des aktuellen blocks.
			int startX = (blockNr % 3)*3; 
			int startY = (blockNr / 3)*3; 
		
			int sum = 0;
			for(int x = startX; x < startX +3; ++x){
				for(int y = startY; y < startY +3; ++y){
					sum += puzzle[y][x]; // oder [x][y], sollte ja keine rolle spielen.
				}
			}
			if(sum != 45){
				return false;
			}
		}
		
		return true;
	}

allerdings hat das hier immer noch das problem, dass du damit nicht sicher stellst, dass jede zahl nur einmal vorkommt. 45 kann auf viele arten gebildet werden
zb
9+9+9 = 27
1+1+1 = 3
5+5+5 = 15
ergibt wenn ich mich nich verrechnet hab auch 45, ist allerdings kein gültiger soduko-block.

auf der sicheren seite wärest du wohl mit so einer lösung:

	public static boolean block(int[][] puzzle) {
		
		for(int blockNr = 0; blockNr < 9; ++blockNr){
			// berechne die x / y position der linken oberen ecke des aktuellen blocks.
			int startX = (blockNr % 3)*3; 
			int startY = (blockNr / 3)*3; 
		
			int sum = 0;
			HashSet<Integer> set = new HashSet<Integer>();
			for(int x = startX; x < startX +3; ++x){
				for(int y = startY; y < startY +3; ++y){
					set.add(puzzle[y][x]);
				}
			}
			if(set.size() != 9){ // damit ist sichergestellt dass 9 verschiedene zahlen in dem set sind
				return false;
			}
		}
		
		return true;
	}

Lg


//edit: hab vergessen dass du ja noch zeilen und spalten prüfst... damit könnte man das problem zwar auch beheben, aber eben nur falls die nicht auf auf summe == 45 prüfen.. weiß ehrlich gesagt nich ob es dann noch möglich ist ein falsches sudoku zu erstellen wobei alle summen 45 sind, aber naja.. wie gesagt, mit der oben beschriebenen lösung bist auf der sicheren seite

 

[Kaa27]

Das mit dem hash ist natürlich ne feine Geschichte, kannte ich so noch gar nicht. Danke dafür.

Ich habe jetzt mal probiert das dann auch gleich für die Zeilen und Spalten zu übernehmen.

Aber hier harkts dann irgendwie.

public static boolean row(int[][] puzzle) {
		for (int x = 0; x < 9; x++) {
			for (int y = 0; y < 9; y++) {
				HashSet<Integer> set = new HashSet<Integer>();
				set.add(puzzle[y][x]);
				if (set.size() != 9) {
					return false;
				}

			}
		}
		return true;
	}

public static boolean coll(int[][] puzzle) {
		for (int x = 0; x < 9; x++) {
			for (int y = 0; y < 9; y++) {
				HashSet<Integer> set = new HashSet<Integer>();
				set.add(puzzle[x][y]);
				if (set.size() != 9) {
					return false;
				}

			}
		}
		return true;
	}

Ausgegeben wird wieder false. Hatte jetzt gedacht das even. die if-Schleife wieder falsch sitzt, aber anders funktioniert der Spaß auch nicht so richtig....

Merci schon einmal.

 

[Nardian]

hehe...

du solltest etwas besser aufpassen wo du was definierst / abfragst.

1. du hast in der inneren schleife immer wieder das hashset neu definiert, wodurch NIE mehr als 1 element drin sein kann ...
2. du hast direkt nach dem befüllen abgefragt ob schon 9 sind, obwohl du erst ein einziges element hineingelegt hast.

	public static boolean row(int[][] puzzle) {
		for (int x = 0; x < 9; x++) {
			HashSet<Integer> set = new HashSet<Integer>();
			for (int y = 0; y < 9; y++) {
				set.add(puzzle[y][x]);
			}
			if (set.size() != 9) {
				return false;
			}
		}
		return true;
	}

	public static boolean coll(int[][] puzzle) {
		for (int x = 0; x < 9; x++) {
			HashSet<Integer> set = new HashSet<Integer>();
			for (int y = 0; y < 9; y++) {
				set.add(puzzle[x][y]);
			}
			if (set.size() != 9) {
				return false;
			}
		}
		return true;
	}

ach und sorry - ich kann einfach nicht widerstehn... if-schleife

 

[Kaa27]

Yo
Merci.