Informatiker Board (http://www.informatikerboard.de/board/index.php)
- Themengebiete (http://www.informatikerboard.de/board/board.php?boardid=1)
-- Praktische Informatik (http://www.informatikerboard.de/board/board.php?boardid=6)
--- Array TEst (http://www.informatikerboard.de/board/thread.php?threadid=1996)

Geschrieben von neuling96 am 11.12.2014 um 15:12:

  Array TEst

Beim Spiel Sudoku muss ein Gitter nach bestimmten Regeln mit Ziffern gefüllt werden.
Der Parameter
int[] zeile der untenstehenden Methode
gueltigeZeile
ist ein Array der Länge 9, wobei
jedes Element eine Ziffer zwischen 1 und 9 (jeweils unterschiedlich) ist. Implementieren Sie diese Methode so, dass sie
true zurückgibt, genau dann wenn jede dieser Ziffe
rn genau einmal in zeile vor

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

class Sudoku {
public static boolean gueltigeZeile(int[] zeile) {
loop1:
 for (i=0,i<9,i++){
  boolean A= true;
 for(y=0,y<9,y++){
 If(!(i==y) {
 If( zeile[i]==zeile[y])
  boolean A= false;
    break loop1
       }
  }
}


Geschrieben von Karlito am 11.12.2014 um 16:42:

 

Hallo neuling96,

  1. Du machst unnötig viele Vergleiche. Angenommen i ist 1 (das zweite Element), dann musst Du doch nicht noch mal prüfen, ob es sich von y=0 unterscheided... Wenn Du den Start der zweiten schleife geschickt wählst, brauchst du auch nicht prüfen, ob i!=y.
  2. A müsste den richtigen Wert haben. Es ist jedoch so, dass Du A auch noch zurückgeben musst...


Gruß,

Karlito


Geschrieben von neuling96 am 11.12.2014 um 16:50:

  RE: Array TEst

hallo,
ich verusche deine Vorschläge umzusetzen:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

class Sudoku {
public static boolean gueltigeZeile(int[] zeile) {
loop1:
 for (i=0,i<9,i++){
  boolean A= true;
 for(y=9;y>0,y--){
 If( zeile[i]==zeile[y])
  boolean A= false;
    break loop1
       }
  } 
 If boolean A= true{
  return gueltige Zeile;
  }else{
 return ungueltige Zeile;
   }
 }


Geschrieben von Karlito am 11.12.2014 um 22:57:

 

Hallöchen,

mal ein paar Tipps:
Fange erstmal gaaaanz einfach an. Das mache ich auch so, wenn ich eine neue Programmierspache lerne. D.h. entwickle dein Programm Schritt für Schritt und schaue bei jedem Schritt, dass dein Programm macht was du willst. Sehr wichtig dabei: lerne wie ein Debugger funktioniert um dein Programm bei jedem Schritt zu beobachten. Wenn Du keinen Debugger benutzen kannst oder zusätzlich dazu kannst du Ausgaben Programmieren. Der erste Schritt wäre also erst einmal ein lauffähiges Programm. Beispiel dein Sudoku-Programm:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

public class Sudoku {
    public static void main(String[] args) {
        int[] beispiel1 = {1,1,2,3}; //falsche länge
        int[] beispiel2 = {1,1,2,3,5,6,8,1,2}; //doppelte...
        int[] beispiel3 = {1,2,3,4,5,6,7,8,9}; //gültig

        System.out.println(gueltigeZeile(beispiel1));
        System.out.println(gueltigeZeile(beispiel2));
        System.out.println(gueltigeZeile(beispiel3));
    }

    static boolean gueltigeZeile(int[] zeile)
    {
        boolean erg = false; //Ergebnisvariable
        return erg;
    }
}


Danach kannst Du das Programm weiter entwickeln und bei jedem Schritt testen, ob es das Richtige macht.
Bsp:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

public class Sudoku {
    public static void main(String[] args) {
        int[] beispiel1 = {1,1,2,3}; //falsche länge
        int[] beispiel2 = {1,1,2,3,5,6,8,1,2}; //doppelte...
        int[] beispiel3 = {1,2,3,4,5,6,7,8,9}; //gültig

        System.out.println(gueltigeZeile(beispiel1)); // führt zu fehler, weil zu kurz
        System.out.println(gueltigeZeile(beispiel2));
        System.out.println(gueltigeZeile(beispiel3));
    }

    static boolean gueltigeZeile(int[] zeile)
    {
        boolean erg = true; //Ergebnisvariable


        loop1: for(int i=0; i<9; i++)
        {
            for(int y=0; y<9; y++)
            {
                if(i==y)
                {
                    continue;
                }
                else
                {
                    if(zeile[i]==zeile[y])
                    {
                        erg = false;
                    }
                }
            }
        }
        return erg;
    }
}


Die Fehlerfreie Variante (hoffe ich zumindest Augenzwinkern )
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

public class Sudoku {
    public static void main(String[] args) {
        int[] beispiel1 = {1,1,2,3}; //falsche länge
        int[] beispiel2 = {1,1,2,3,5,6,8,1,2}; //doppelte...
        int[] beispiel3 = {1,2,3,4,5,6,7,8,9}; //gültig

        System.out.println(gueltigeZeile(beispiel1)); // führt zu fehler, weil zu kurz
        System.out.println(gueltigeZeile(beispiel2));
        System.out.println(gueltigeZeile(beispiel3));
    }

    static boolean gueltigeZeile(int[] zeile)
    {
        boolean erg = true; //Ergebnisvariable

        if(zeile.length != 9)
        {
            erg = false;
        }

        loop1: for(int i=0; erg==true&&i<9; i++)
        {
            for(int y=0; y<9; y++)
            {
                if(i==y)
                {
                    continue;
                }
                else
                {
                    if(zeile[i]==zeile[y])
                    {
                        erg = false;
                    }
                }
            }
        }
        return erg;
    }
}


Und dann die Optimierung (keine doppelten Vergleiche)
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:

public class Sudoku {
    public static void main(String[] args) {
        int[] beispiel1 = {1,1,2,3}; //falsche länge
        int[] beispiel2 = {1,1,2,3,5,6,8,1,2}; //doppelte...
        int[] beispiel3 = {1,2,3,4,5,6,7,8,9}; //gültig

        System.out.println(gueltigeZeile(beispiel1)); // führt zu fehler, weil zu kurz
        System.out.println(gueltigeZeile(beispiel2));
        System.out.println(gueltigeZeile(beispiel3));
    }

    static boolean gueltigeZeile(int[] zeile)
    {
        boolean erg = true; //Ergebnisvariable

        if(zeile.length != 9)
        {
            erg = false;
        }

        loop1: for(int i=0; erg==true&&i<9; i++) //erg&&i<9 würde hier eigentlich reichen...
        {
            for(int y=i+1; y<9; y++)
            {
                if(i==y)
                {
                    continue;
                }
                else
                {
                    if(zeile[i]==zeile[y])
                    {
                        erg = false;
                        break loop1;
                    }
                }
            }
        }
        return erg;
    }
}


Übrigens: je mehr Testfälle, desto besser und am Besten Du machst dir vorher Gedanken, in welchen Fällen dein Algorithmus fehlschlagen könnte.

Gruß,

Karlito


Geschrieben von neuling96 am 12.12.2014 um 00:54:

 

Vielen Dank für deinen tollen Beitrag smile
Beim diesem Code spukt der Compiler keinen Fehler aus
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

class Sudoku {
   
public static boolean gueltigeZeile(int[] zeile) {
  boolean A= true;

loop1: for (int i=0;i<9;i++)
 {
    for(int y=9;y>0;y--)
     {
       if( zeile[i]==zeile[y])
           {
               A= false;
                    break loop1;
       }
      } 
    }      if  (A == true)
             {
                  return A;
          }      else  {
                     return false;
        }
    } 

 }



allerdings wenn ich den code erweitere


code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

class Sudoku {
   
public static boolean gueltigeZeile(int[] zeile) {
  boolean A= true;

loop1: for (int i=0;i<9;i++)
 {
    for(int y=9;y>0;y--)
     {
       if( zeile[i]==zeile[y])
           {
               A= false;
                    break loop1;
       }
      } 
    }      if  (A == true)
             {
                  return A;
          }      else  {
                     return false;
        }
    } 

 }
public static void main(String[] args) {
        int[] beispiel1 = {1,1,2,3}; //falsche länge
        int[] beispiel2 = {1,1,2,3,5,6,8,1,2}; //doppelte...
        int[] beispiel3 = {1,2,3,4,5,6,7,8,9}; //gültig

        System.out.println(gueltigeZeile(beispiel1)); // führt zu fehler, weil zu kurz
        System.out.println(gueltigeZeile(beispiel2));
        System.out.println(gueltigeZeile(beispiel3));
    }



funktionert gar nichts!

Was mache ich falsch?


Geschrieben von eulerscheZahl am 12.12.2014 um 07:56:

 


code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:

		if  (A == true)
		{
			return A;
		}
		else
		{
			return false;
		}

hier tut es auch ein return A;. Das ist kürzer und leichter verständlich.

Und noch eine andere Möglichkeit, an das Problem heranzugehen:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

public static boolean gueltigeZeile(int[] zeile)
{
	if (zeile.length != 9) return false;
	boolean[] found = new boolean[zeile.length];
	for (int i = 0; i < zeile.length; i++) {
		if (zeile[i] < 1 || zeile[i] > zeile.length || found[zeile[i] - 1]) {
			return false;
		}
		found[zeile[i] - 1] = true;
	}
	return true;
}

Es wird in einem zweiten Array gespeichert, ob eine Zahl schon vorkam.
Vorteil: jede Zahl des zu prüfenden Array muss nur einmal gelesen werden (bei deinem Code wächst die Zahl der Vergleiche quadratisch zur Länge)
Nachteil: es wird zusätzlicher Speicher benötigt, um sich zu merken, welche Zahlen schon gefunden wurden.


Geschrieben von neuling96 am 12.12.2014 um 18:00:

 

vielen dank, jetzt gehts


Forensoftware: Burning Board, entwickelt von WoltLab GmbH