# java ~ Diagonale eines Arrays überprüfen



## Kusarr (8. Juni 2015)

*java ~ Diagonale eines Arrays überprüfen*

Servus Leute,

versuche mich gerade an einem 4-Gewinnt zu programmieren.
Hab auch soweit alles fertig auser eines, und zwar die Überprüfung der Diagonalen vom Spielfeld.
Spalten- und Zeilenüberprüfung war easy, aber hier hängts.


(um die dritte for-schleife gehts)
und ja, es sind zwei for-schleifen nötig. einmal von linksoben nach rechtsunten und einmal von rechtsoben nach linksunten. hab aber erst mal eine versucht.

```
public boolean isSpielZuEnde() {
        int spalte, zeile;


        for (spalte = 0; spalte < 7; spalte++) { 
            int zaehlerA = 0, zaehlerB = 0;
            for (zeile = 0; zeile < 6; zeile++) {
                if (getFeld(spalte, zeile) == 1) {
                    zaehlerA += 1;
                    zaehlerB = 0;
                } else if (getFeld(spalte, zeile) == 2) {
                    zaehlerB += 1;
                    zaehlerA = 0;
                }
                if (zaehlerA == 4 || zaehlerB == 4) {
                    this.unentschieden = false;
                    return true;
                }
            }
        }


        for (zeile = 0; zeile < 6; zeile++) {
            int zaehlerA = 0, zaehlerB = 0;
            for (spalte = 0; spalte < 7; spalte++) {
                if (getFeld(spalte, zeile) == 1) {
                    zaehlerA += 1;
                    zaehlerB = 0;
                } else if (getFeld(spalte, zeile) == 2) {
                    zaehlerB += 1;
                    zaehlerA = 0;
                }
                if (zaehlerA == 4 || zaehlerB == 4) {
                    this.unentschieden = false;
                    return true;
                }
            }
        }


        for (spalte = 0; spalte < 4; spalte++) {
            int spalte2 = 0, zeile2 = 0;
            for (zeile = 0; zeile < 3; zeile++) {
                spalte2 = 0;
                zeile2 = 0;
                int zaehlerA = 0, zaehlerB = 0;
                do {
                    if (getFeld(spalte2, zeile2) == 1) {
                        zaehlerA += 1;
                        zaehlerB = 0;
                    } else if (getFeld(spalte2, zeile2) == 2) {
                        zaehlerB += 1;
                        zaehlerA = 0;
                    }
                    if (zaehlerA == 4 || zaehlerB == 4) {
                        this.unentschieden = false;
                        return true;
                    }
                    spalte2++;
                    zeile2++;
                } while (zeile2 < 3 && spalte2 < 4);
            }
        }


        for (spalte = 0; spalte < 7; spalte++) {
            if (getFeld(spalte, 0) == 0) {
                return false;
            }
        }


        return true;
    }
```

wo isn der fehler?
Problem ist, es passiert einfach NICHTS wenn ich 4 in der digonale eingegeben hab, ich kann einfach weiter meine spielsteine setzen.


----------



## SimonG (8. Juni 2015)

*AW: java ~ Diagonale eines Arrays überprüfen*

Ohne mir deinen Code genauer angeschaut zu haben, zeige ich dir mal wie ich das machen würde:

```
private static Pair<Integer> find_diagonal() {
        for (int row = 3; row < grid.length; row++) {
            for (int column = 0; column < grid[row].length - 3; column++) {
                for (int offset = 0; offset <= 3; offset++) {
                    if (!grid[row - offset][column + offset])
                        break;
                    if (offset == 3)
                        return new Pair<Integer>(column, row);
                }
            }
        }
        return null;
    }
```

Hier das komplette Code-Beispiel: https://gist.github.com/anonymous/23948591e4edd7ba6b29

grid: Spielfeld, der Einfachheit wegen, hier ein 2D Array von booleans
row: Zeilen Zähler
column: Spalten Zähler
offset: Abstand vom Startpunkt (spalten- bzw. zeilenweise)
Pair: Datentyp für 2 Werte vom selbem Typ (im Gist enthalten)

Die Funktion findet Diagonalen der Länge 4 (oder mehr), die von links unten nach rechts oben verlaufen.

Erklärung der Schleifen:
1. Schleife:
Durchlaufen der Zeilen. Ich beginne bei Zeile 3, denn in den Zeilen darüber können sich keine Diagonalen der Länge 4 mehr befinden.
2. Schleife:
Durchlaufen der Spalten(-Einträge der aktuellen Zeile). Die letzten 3 Einträge jeder Zeile lasse ich weg, weil dort kein Platz mehr für 4er-Diagonalen ist.
3. Schleife:
Solange die das Spielfeld an der Position grid[row - offset][column + offset] "true" ist, gehe einen Schritt nach rechts und einen nach oben. Läuft die Schleife  4 mal Durch haben wir eine Diagonale gefunden.

Durch das Weglassen der ersten 3 Zeilen und letzten 3 Spalten kann man IndexOutOfBound Exceptions vermeiden und spart sich dabei noch unnötige Schleifendurchläufe.


----------



## Kusarr (8. Juni 2015)

*AW: java ~ Diagonale eines Arrays überprüfen*

okay vielen Dank, habs hinbekommen 

nur das mit grid.length klappt nich ganz, da schmeißts ne exception. muss ne zahl reinschreiben. ka wieso, ma morgen schauen. hauptsache es läuft erst ma ^^


----------



## DKK007 (9. Juni 2015)

*AW: java ~ Diagonale eines Arrays überprüfen*

Schau einfach mal in die Dokumentation wie grid.length definiert ist.


----------

