Java Sudoku-Programm | Endlossschleife hört nicht auf

[BaseUser]

Hallo Zusammen,

ich versuche ein Sudoku-Java-Programm zu schreiben - wie man sich denken kann funktioniert es nicht, sonst würde es diesen Thread nicht geben...

Nun, ich glaube ich bin kurz davor dass es funktioniert - aber ich kann einfach den Fehler nicht finden!

Folgendes Problem:

Das Programm wird mit den Parametern "java Sudoku 001 012 023 034" gestartet.

Jeder dieser Werte steht für eine Koordinate im Array; also steht beispielsweise 034 für Zeile 0, Spalte 3, Wert 4.

Somit erhalten wir ein "rohes Array", welches so aussieht:

1 2 3 4
0 0 0 0
0 0 0 0
0 0 0 0

Ich versuche nun die Nullen mit zufallszahlen im Wert von 1-4 zu bestücken, hierbei soll geprüft werden, ob die Werte in der Spalte oder Zeile schon vorhanden sind (Methode:

public static boolean hor_ver_pruefung(int zeilennummer, int spaltennummer, int uebernahmezahl, int temparray[][])

soll hier die Prüfung vornehmen).

Diese Prüfung funktioniert aber nicht so wie ich es gerne hätte... Wenn ich die Positionen mit Zufallszahlen besetzten möchte, hört meine while (true) Schleife nicht auf, bekommt also kein True zurück. Aber warum...?

Kann mir hier jemand helfen? Ich wäre wirklich ÄUßERST dankbar

import java.util.*;

class Sudoku
{
  public static void main(String[] args)
  {
    sudoku(args);
  }//ENDE main

public static void sudoku(String[] args)
  {
        
    if (args.length !=4) 
    {
      System.err.println("Das Programm benoetigt 4 Eingabewerte um ein Sudoku-Game zu loesen. Bitte starten");
      System.err.println("Sie das Programm erneut mit entsprechenden Eingabeparametern. ");
      System.err.println("");
	  System.err.println("Parameter. Das Programm wird jetzt beendet. ");
      System.exit(1);
    }
       
    String a = new String(args[0]);
    String b = new String(args[1]);
    String c = new String(args[2]);
    String d = new String(args[3]);
    
    //AUSKOMMENTIEREN, um eingegebene Variablen zu sehen
    //System.out.println(a);
    //System.out.println(b);
    //System.out.println(c);
    //System.out.println(d);
   
       
    //Splitten des ersten Eingabe-Parameters
    //Mit dem Trennparameter ("") werden die einzelnen Buchstaben getrennt
    //und in das Array 'splittArray_a' eingetragen. Die einzelnen Werte werden 
    //durch die For-Schleife in das 'splittArray_a' eingetragen. 
    String[] splittArray_a = a.split("");
    
    //Deklaration der Variablen fuer die Weiterverbeitung - (Z)eile, (S)palte, (W)ert
    int z1 = Integer.parseInt(splittArray_a[1]);
    int s1 = Integer.parseInt(splittArray_a[2]);
    int w1 = Integer.parseInt(splittArray_a[3]);
    
    //Splitten des zweiten Eingabe-Parameters
    String[] splittArray_b = b.split("");

    //Deklaration der Variablen fuer die Weiterverbeitung - (Z)eile, (S)palte, (W)ert
    int z2 = Integer.parseInt(splittArray_b[1]);
    int s2 = Integer.parseInt(splittArray_b[2]);
    int w2 = Integer.parseInt(splittArray_b[3]);
    
    
    //Splitten des dritten Eingabe-Parameters
    String[] splittArray_c = c.split("");
      
    int z3 = Integer.parseInt(splittArray_c[1]);
    int s3 = Integer.parseInt(splittArray_c[2]);
    int w3 = Integer.parseInt(splittArray_c[3]);
    
    
    //Splitten des vierten Eingabe-Parameters
    String[] splittArray_d = d.split("");
     
    //Deklaration der Variablen fuer die Weiterverbeitung - (Z)eile, (S)palte, (W)ert
    int z4 = Integer.parseInt(splittArray_d[1]);
    int s4 = Integer.parseInt(splittArray_d[2]);
    int w4 = Integer.parseInt(splittArray_d[3]);
    
    //Deklaration des Sudoku-Arrays
	//sa == Sudoku-Array
    int[][] sa = new int[4][4];
    
    //Zufallsgenerator

    
	//Vergabe der vorgegebenen Werte, welche ueber die Eingabeparameter festgelegt wurden
    sa[z1][s1] = w1;
    sa[z2][s2] = w2;
    sa[z3][s3] = w3;
    sa[z4][s4] = w4;
    
	//Ausdruck des leeren Arrays mit den eingegebenen Parametern
    for (int i = 0; i < sa.length; i++)
    {
      for (int j = 0; j < sa[i].length; j++)
      {
        System.out.print(sa[i][j]+"\t");
      }
       System.out.print("\n");
    }

   //Aufruf der Methode array_fuellung, Uebergabe des Arrays zum Fuellen und gleich anschliessende Uebergabe des gefuellten arrays  an "array_gefuellt"
   int sa_array_gefuellt[][] = array_fuellung(sa); 
   
   for (int i = 0; i < sa_array_gefuellt.length; i++)
    {
      for (int j = 0; j < sa_array_gefuellt[i].length; j++)
      {
        System.out.print(sa_array_gefuellt[i][j]+"\t");
      }
     System.out.print("\n");
    }
   
   }//ENDE Sudoku
  
  //Das Sudoku-Array wird hier mit Zahlen aufgefuellt
  public static int[][] array_fuellung(int sa[][])
  {
	int uebernahmezahl = 0; 
	Random r = new Random();
	for (int i = 0; i < sa.length; i++)
    {
      for (int j = 0; j < sa[i].length; j++)
      {
        if (sa[i][j] == 0)
		{
		  while (true)
		  {
		    uebernahmezahl = r.nextInt(4); 
			if (hor_ver_pruefung(i, j, uebernahmezahl, sa) == true)
			{
			  sa[i][j] = uebernahmezahl;
			  break;
			}
			
          }		  
        }
      }
    }
  return sa;
  }
  
  public static boolean hor_ver_pruefung(int zeilennummer, int spaltennummer, int uebernahmezahl, int temparray[][])
  {
    
	//Vertikale Ueberpruefung der Zahl
	for (int i = 0; i <= temparray.length-1; i++)
	{
	  if (temparray[i][spaltennummer] == uebernahmezahl)
	  {
		return false;
	  }
	}//ENDE for
	
	//Horizontale Ueberpruefung der Zahl
	for (int j = 0; j <= temparray.length-1; j++)
	{
	  if (temparray[zeilennummer][j] == uebernahmezahl)
	  {
		return false;
	  }
	}//ENDE for
	
	//Diagonale Ueberpruefung der Zahl
	for (int k = 0; k <= temparray.length-1; k++)
	{
	  if (temparray[k][k] == uebernahmezahl)
	  {
		return false;
	  }
	}//ENDE for
	
	//Im Idealfall wird TRUE zurueck gegeben
  return true;
  }//ENDE hor_ver_pruefung
  
}//ENDE Main

 

[bibler]

sorry das ich nicht helfen kann, aber ich find den thread titel lustig. wenn es aufhören würde wärs ja keine endlosschleife
SPAß
helfen kann ich dir leider nicht. kenn mich da nicht aus...
aber trotzdem noch viel erfolg.
mfg bibler

 

[RAMMSTEiN0815]

wenn du debuggst in welcher schleife hängt er denn?

 

[1668mib]

@bibler: Hab genau das selbe gedacht ^^
sorry for spam

 

[munchkin]

Hi BaseUser,

ich habe den Quellcode kurz überflogen und vermute, dass es daran liegt, dass Deine Schleife zu einer wirklichen Endlosschleife wird . Sie läuft sicherlich in einen Zustand rein, in dem keine der generierten Zahlen mehr in die gewünschte Array-Zelle passen würden. Damit liefert die Methode hor_ver_pruefung() ständig false und deine "Endlosschleife" wird nie über das Break abgebrochen.
Ein Besipiel:
1 2 3 4 --- 1 2 3 4 --- 1 2 3 4
0 0 0 0 --- 3 4 1 2 --- 3 4 1 2
0 0 0 0 --- 0 0 0 0 --- 2 1 x 0
0 0 0 0 --- 0 0 0 0 --- 0 0 0 0

Bei x "knallt" es dann. Eigentlich würde da nur eine 4 passen, aber hor_ver_pruefung () prüft auch diagonal (auch wenn nur von links oben nach rechts unten) und damit kann auch keine 4 mehr rein. Somit ist jede Zahl zwischen 1 und 4 unpassend.

Sudoku zu programmieren ist nicht so einfach wie man es sich vorstellt. Ein einfacher Ansatz wäre, wenn du als Ausgangsmatrix eine Matrix nimmst in der jede Zeile um eine Stelle nach rechts bzw. links verschoben (im Vergleich zu der darüber liegenden) ist. Die beiden resultierenden Varianten sehen dann so aus:
1 2 3 4 ------ 1 2 3 4
4 1 2 3 ------ 2 3 4 1
3 4 1 2 oder 3 4 1 2
2 3 4 1 ------ 4 1 2 3

Jetzt kann man mit entsprechenden Matrixoperationen (rotieren, spiegeln etc) die Zahlen mischen, sodass das Ergebnis fürs Erste reichen sollte. Ich hoffe, dass es Dir etwas hilft.

schöne Grüße
munchkin

 

[andr_gin]

In welchem Schleifendurchgang hängt die Schleife denn? Wenn es irgendwo in der Mitte ist, dann wäre es gut den bisherigen Datenstand auszugeben. Wenn es in der ersten Schleife ist, dann hat es wirklich was.