Fehlermeldung nicht nachvollziehbar

[Newcomer2]

Hallo Leute, hab da mal nen Problem. Ich will die Methode erzeugen in sich selbst aufrufen lassen, sobald eine die Variable abbruch den Wert true zurück gibt.
Hier mal der Quelltext:

static boolean abbruch(int i)
	{
		dt2=new Date();
		if(dt2.getTime()-time>i*100)
			return true;
		else
			return false;
	}

       static void erzeugen()
	{
		int[][] feld = 
			{//Pos.0,1,2,3,4,5,6,7,8
				  {1,2,3,4,5,6,7,8,9}, // Zeile 0
				  {1,2,3,4,5,6,7,8,9}, // Zeile 1
				  {1,2,3,4,5,6,7,8,9}, // Zeile 2
				  {1,2,3,4,5,6,7,8,9}, // Zeile 3
				  {1,2,3,4,5,6,7,8,9}, // Zeile 4
				  {1,2,3,4,5,6,7,8,9}, // Zeile 5
				  {1,2,3,4,5,6,7,8,9}, // Zeile 6
				  {1,2,3,4,5,6,7,8,9}, // Zeile 7
				  {1,2,3,4,5,6,7,8,9}  // Zeile 8
			};
		for(int i=0;i<9;i++)
		{	
			for (int j=0;j<9;j++)
			{				
				l=r.nextInt(9);
				if(i==0)
				{
					if(i==0)
						while (feld[i][l]==0)
						{
							l=r.nextInt(9);
							time = dt1.getTime();
							if(abbruch(2)) { a=i; b=j; 
							erzeugen();}
						}
					sud[i][j]=feld[i][l];	
				}
                                 ...
                         }
                         ...
                 }
                 ...
         }

public static void main(String[] args) 
	{
		
			erzeugen();
		
		str+="___|_____|_____|_____|_____|_____|_____|_____|_____|";
		System.out.println(str);		
	}

Leider erhalte ich dabei immer den folgenden Fehlercode.
Kann mir da jemand weiterhelfen?

Exception in thread "main" java.lang.StackOverflowError
	at Sudoku.erzeugen(Sudoku.java:52)
	at Sudoku.erzeugen(Sudoku.java:61)
	at Sudoku.erzeugen(Sudoku.java:61)

 

[JavaMeister]

Endlosschleife.

Führe ein Debug durch, um die Quelle zu finden.

 

[Barista]

Hallo Newcomer2,

in Zeile 37 Deines Listings rufst Du die Methode erzeugen noch mal auf, das verursacht den Stackoverflow.

Ganz allgemein scheint Dein Programm aber auch nicht korrekt zu sein.

Willst Du mit Rekursion arbeiten bzw weisst Du was Rekursion ist?

Willst Du ein gültiges Sudoku erzeugen, also jeder Wert je Zeile, Spalte und Block nur einmal gesetzt?

Wenn Du möchtest, können wir hier zusammen eine Lösung erarbeiten.

Bis dann

 

[Newcomer2]

@ JavaMeister: Wie führ ich denn ein Debug aus? Hab das noch nie gemacht, bisher Probleme immer so gelöst bekommen ^^

@ Barista: Die Sache ist die, das Programm läuft eig. ganz reibungslos. Ich bekomme richtige Sudokus heraus. Das Problem kommt erst dann, wenn die Methode erzeugen() zur Ermittlung einer passenden Zufallszahl länger als z.B. 200ms benötigt. Denn dann möcht ich gern, dass sie von Beginn an neu startet. Ich hab da schon verschiedene Dinge versucht, aber noch keine richtige Lösung gefunden.
Habs auch mal mit

return;

versucht. Auch das hat nicht funktioniert.

Um was es sich genau bei Rekursion handelt, weiß ich leider nicht. Aber dachte, damit ist gemeint, dass sich eine Methode selbst aufruft.

Will hier mal als Beispiel nen Programm zeigen, was ich zuvor geschrieben hab. Bin kein so neuer Einsteiger in Java ^^

 

[Barista]

@ Barista: Die Sache ist die, das Programm läuft eig. ganz reibungslos. Ich bekomme richtige Sudokus heraus. Das Problem kommt erst dann, wenn die Methode erzeugen() zur Ermittlung einer passenden Zufallszahl länger als z.B. 200ms benötigt. Denn dann möcht ich gern, dass sie von Beginn an neu startet. Ich hab da schon verschiedene Dinge versucht, aber noch keine richtige Lösung gefunden.
Habs auch mal mit return; versucht. Auch das hat nicht funktioniert.

Du machst einfach eine Schleife um den Aufruf Deiner erzeuge-Methode

while ( ! erzeuge() );

Deine erzeuge-Methode stattest Du mit einem boolean-return für
ok bzw nicht-ok aus.

 

[Newcomer2]

Vielen dank Barista.
Das funktioniert sehr gut. Manchmal schien er sich dennoch an irgendeiner Stelle festzufahren und arbeitete nicht weiter. Hab hier mal vorsichtshalber den vollständigen Code angefügt. Etwa um die Zeilen 105 bis 113, also bei der ersten

while

-Schleife, wenn das Programm länger benötigt als 2000ms.

Hatte dann aber mal bei der

abbruch()

-Methode einen

return

-Status weggenommen und nun bekomme ich nur noch richtige Sudokus:

import java.util.Random;
import java.util.Date;
	
public class Sudoku 
{
	static int[][] feld = 
		{//Pos.0,1,2,3,4,5,6,7,8
			  {1,2,3,4,5,6,7,8,9}, // Zeile 0
			  {1,2,3,4,5,6,7,8,9}, // Zeile 1
			  {1,2,3,4,5,6,7,8,9}, // Zeile 2
			  {1,2,3,4,5,6,7,8,9}, // Zeile 3
			  {1,2,3,4,5,6,7,8,9}, // Zeile 4
			  {1,2,3,4,5,6,7,8,9}, // Zeile 5
			  {1,2,3,4,5,6,7,8,9}, // Zeile 6
			  {1,2,3,4,5,6,7,8,9}, // Zeile 7
			  {1,2,3,4,5,6,7,8,9}  // Zeile 8
		};
	static int[][] sud = new int[9][9];
	static Random r = new Random();
	static String str=" ___________________________________________________\n|";
	static int l=0,a=0,b=0;
	static Date dt1 = new Date(),dt2;
	static long time;
	
	@SuppressWarnings("unused")
	static boolean abbruch(int i)
	{
		dt2=new Date();
		if(dt2.getTime()-time>i*100)
		{	
			for(int j=0;j<9;j++)
			{
				for(int k=0;k<9;k++)
				{
					if(sud[j][k]!=0)
						return false;
					else return true;
				}
			}
			return false;
		}
		else return false;
	}
	
	static int[][] sud0()
	{
		int[][] sudneu = 
			{
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0}
			};
		return sudneu;
	}
	
	static int[][] neuesFeld()
	{
		int[][] neu = 
			{//Pos.0,1,2,3,4,5,6,7,8
				  {1,2,3,4,5,6,7,8,9}, // Zeile 0
				  {1,2,3,4,5,6,7,8,9}, // Zeile 1
				  {1,2,3,4,5,6,7,8,9}, // Zeile 2
				  {1,2,3,4,5,6,7,8,9}, // Zeile 3
				  {1,2,3,4,5,6,7,8,9}, // Zeile 4
				  {1,2,3,4,5,6,7,8,9}, // Zeile 5
				  {1,2,3,4,5,6,7,8,9}, // Zeile 6
				  {1,2,3,4,5,6,7,8,9}, // Zeile 7
				  {1,2,3,4,5,6,7,8,9}  // Zeile 8
			};
		return neu;
	}
	
	static boolean erzeugen()
	{
		dt1 = new Date();
		time = dt1.getTime();
		System.out.println(time);
		feld=neuesFeld();
		for(int i=0;i<9;i++)
		{
			for(int j=0;j<9;j++)
			{
				System.out.print(sud[i][j]+"  |  ");
			}
			System.out.print("\n");
		}
		if(sud[8][8]!=0) return true;
		
		System.out.print("\n");		
		sud=sud0();
		for(int i=0;i<9;i++)
		{	
			for (int j=0;j<9;j++)
			{	
				
				l=r.nextInt(9);
				if(i==0)
				{
					while (feld[i][l]==0)
					{
						l=r.nextInt(9);
						if(abbruch(20)) {			
							a=i; b=j;  
							System.out.println(i+"   "+feld[i][j]); 
							return false;
						}
					}
					sud[i][j]=feld[i][l];	
				}
				if(i==1)
				{
					if(j==0|j==3|j==6)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
											 sud[i-1][j+1]==feld[i][l]|
											 sud[i-1][j+2]==feld[i][l])
						{
							l--;
							if(l<0) l=8;
							if(abbruch(20)) 
							{  
								a=i; b=j; 
								System.out.println(i+"  "+feld[i][j]); 
								return false;
							}
							else;
						}
					if(j==1|j==4|j==7)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
										     sud[i-1][j+1]==feld[i][l]|
										     sud[i-1][j-1]==feld[i][l])
						{
							l++;
							if(l>8) l=0;
							if(abbruch(2)) 
							{ 
								a=i; b=j; 
								System.out.println(i+"  "+feld[i][j]); 
								return false;
							}
							else ;
						}
					if(j==2|j==5|j==8)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
											 sud[i-1][j-1]==feld[i][l]|
											 sud[i-1][j-2]==feld[i][l])
						{
							l--;
							if(l<0) l=8;
							if(abbruch(2)) 
							{ 
								a=i; b=j; 
								System.out.println(i+"  "+feld[i][j]); 
								return false;
							}
						}
					sud[i][j]=feld[i][l];	
				}
				if(i==2)
				{
					if(j==0|j==3|j==6)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
											 sud[i-2][j  ]==feld[i][l]|
											 sud[i-1][j+1]==feld[i][l]|
											 sud[i-2][j+1]==feld[i][l]|
											 sud[i-1][j+2]==feld[i][l]|
											 sud[i-2][j+2]==feld[i][l])
						{
							l++;
							if(l>8) l=0;
							if(abbruch(2)) { a=i; b=j; return false;}
						}
					if(j==1|j==4|j==7)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
						 					 sud[i-2][j  ]==feld[i][l]|
						 					 sud[i-1][j-1]==feld[i][l]|
											 sud[i-2][j-1]==feld[i][l]|
											 sud[i-1][j+1]==feld[i][l]|
											 sud[i-2][j+1]==feld[i][l])
						{
							l--;
							if(l<0) l=8;
							if(abbruch(2)) 
							{ 
								a=i; b=j; 
								return false;
							}
						}
					if(j==2|j==5|j==8)
						while (feld[i][l]==0|sud[i-1][j  ]==feld[i][l]|
						 					 sud[i-2][j  ]==feld[i][l]|
						 					 sud[i-1][j-1]==feld[i][l]|
											 sud[i-2][j-1]==feld[i][l]|
											 sud[i-1][j-2]==feld[i][l]|
											 sud[i-2][j-2]==feld[i][l])
						{
							l++;
							if(l>8) l=0;
							if(abbruch(2)) 
							{  
								a=i; b=j; return false;
							} 
						}
					sud[i][j]=feld[i][l];
					
					
				}
				if(i>2)
				{
					if(j==0|j==1|j==3|j==4|j==6|j==7)
					{
						if(i==3|i==6)
							sud[i][j]=sud[i-1][j+1];
						if(i==4|i==7)
							sud[i][j]=sud[i-4][j+1];
						if(i==5|i==8)
							sud[i][j]=sud[i-4][j+1];
					}
					if(j==2|j==5|j==8)
					{
						if(i==3|i==6)
							sud[i][j]=sud[i-1][j-2];
						if(i==4|i==7)
							sud[i][j]=sud[i-4][j-2];
						if(i==5|i==8)
							sud[i][j]=sud[i-4][j-2];
					}
				}
				feld[i][l]=0;				
				str+=sud[i][j]+"  |  ";
			}
			str+="\n|";
		}
		return true;
	}
	
	public static void main(String[] args) 
	{
		while(!erzeugen()) ;
		{
		}
		str=" ___________________________________________________\n|";
		for(int i=0;i<9;i++)
		{
			for(int j=0;j<9;j++)
			{
				str+=sud[i][j]+"  |  ";
			}
			str+="\n|";
		}
				
		System.out.println(erzeugen()+"  "+sud[a][b]+"  "+a+"  "+b);
		str+="___|_____|_____|_____|_____|_____|_____|_____|_____|";
		System.out.println(str);		
	}
}

Hier dann die überarbeitete

abbruch()

-Methode:

@SuppressWarnings("unused")
	static boolean abbruch(int i)
	{
		dt2=new Date();
		if(dt2.getTime()-time>i*100)
		{	
			for(int j=0;j<9;j++)
			{
				for(int k=0;k<9;k++)
				{
					if(sud[j][k]!=0) ; //<-- geändert!
					else return true;
				}
			}
			return false;
		}
		else return false;
	}

und nun funktionierts
vielen dank nochmal für die Hilfe!!