2 Verschachtelte Schleifen sollen eine Auswirkung von -7 pro Durchgang haben

[Anfaengerin]

Hallo!

Ich soll ein 4-gewinnt-Spiel bauen. Hierfür habe ich eine Gridpane mit Buttons gefüllt und wenn man einen der Buttons in der oberen Reihe drückt, "fällt" ein gefärbter Button in das Spielgestell.

Hierfür habe ich eine Liste, die buttonList, und hoehe und breite als Orientierungsmaße. zielindex ist die Variable, die zeigt, wohin ein Steinchen gefallen ist.
Jetzt soll ich den Gewinn prüfen. Bei der horizontalen Reihe und der vertikalen Reihe läufts schon, nur frage ich mich, wie ich es bei der diagonalen hinbekomme.

Ich hab dafür Höhe und Breite(hier 8) je als Limit für zwei For-Schleifen genommen und zähle immer v-- und w++. Das müsste in der Umrechnung, wo ich die Koordinaten wieder in den Index für die buttonList umrechne, zwischen zwei Werten eine Schrittweite von -7(-breite+1) ergeben. Aber es gibt entweder -8 oder+1, je nachdem, welche Schleife ich voranstelle.

Vielleicht kann mir jemand helfen. Wie bekomme ich es hin, dass die Ergebnisse bei umrechnen -7 voneinander entfernt sind?
Schrittweite in umrecnen=-8

for(int w=0;w<breite;w++) {
        for (v = hoehe-1; v >= 0; v--) {

                    umrechnen = (v) * breite + (w);

(...)

Schrittweite in umrechnen=1

  for (v = hoehe-1; v >= 0; v--) {
[CODE=java]for(int w=0;w<breite;w++) {

                  umrechnen = (v) * breite + (w);

[/CODE]
(...)

 

[Oneixee5]

etwa so:

    public static boolean checkWin(char[][] board, char player) {
        int rows = board.length;
        int cols = board[0].length;

        // Check horizontal
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols - 3; col++) {
                if (board[row][col] == player && board[row][col + 1] == player &&
                    board[row][col + 2] == player && board[row][col + 3] == player) {
                    return true;
                }
            }
        }

        // Check vertical
        for (int row = 0; row < rows - 3; row++) {
            for (int col = 0; col < cols; col++) {
                if (board[row][col] == player && board[row + 1][col] == player &&
                    board[row + 2][col] == player && board[row + 3][col] == player) {
                    return true;
                }
            }
        }

        // Check diagonal (bottom-left to top-right)
        for (int row = 3; row < rows; row++) {
            for (int col = 0; col < cols - 3; col++) {
                if (board[row][col] == player && board[row - 1][col + 1] == player &&
                    board[row - 2][col + 2] == player && board[row - 3][col + 3] == player) {
                    return true;
                }
            }
        }

        // Check diagonal (top-left to bottom-right)
        for (int row = 0; row < rows - 3; row++) {
            for (int col = 0; col < cols - 3; col++) {
                if (board[row][col] == player && board[row + 1][col + 1] == player &&
                    board[row + 2][col + 2] == player && board[row + 3][col + 3] == player) {
                    return true;
                }
            }
        }

        return false;
    }

 

[Anfaengerin]

Vielen Dank, das hatte ich auch schon gefunden. Mich würde aber interessieren, ob es auch eine Lösung ohne [row][col] und mit meiner Liste gibt. Aber trotzdem vielen Dank! Vor allem würde mich interessieren, warum die Schrittweite zwischen zwei Umrechnen-Ergebnisse bei 2 verschachtelten Schleifen immer -8 ergibt.

 

[Jw456]

Wie ist denn deine Liste überhaupt aufgebaut?
Es ist einfacher dafür ein 2D Array zu benutzen als ein eindimensionales Array was du wahrscheinlich hast.

Horizontal wäre es ja zb 0,1,2,3 vertikal 0,8,16,24 aus deinem Array
Diagonal zb 0,9,18,27 also immer 8 plus 1

 

[KonradN]

Also Du kannst alles 1:1 von der 2D Darstellung in die 1D Darstellung umwandeln und das hattest Du ja auch schon.

Du hattest ja etwas wie:
umrechnen = (v) * breite + (w);

Und das kannst Du ja dann immer nutzen. Bei Zugriffen wie board[row - 3][col + 3] musst du dann nur aufpassen, denn das was da in den eckigen Klammern steht sind dann ja die Werte für v und w der Gleichung, also umrechnen = (row - 3) * breite + (col + 3).

Das "-7" ist ja nur ein Ergebnis, dass Du halt bei col 1 abgezogen hast.

Und hier wird dann auch klar: Das ist extrem unleserlich. Du hast irgend eine Berechnung ohne das "fachliche" erkennen zu können. Da ist dann ein board[row - 3][col + 3] deutlich besser lesbar.

Aber ganz am Rande: Wenn sowas vorgegeben wäre, dann würde ich das über Methoden lesbarer machen. Also einfach eine Methode, die row/col entgegen nimmt um dann etwas zu schreiben wie board[get1DIndex(row - 3, col +3)] - nur damit direkt erkennbar ist, worauf man zugreifen möchte.

 

[Anfaengerin]

Wie ist denn deine Liste überhaupt aufgebaut?
Es ist einfacher dafür ein 2D Array zu benutzen als ein eindimensionales Array was du wahrscheinlich hast.

Horizontal wäre es ja zb 0,1,2,3 vertikal 0,8,16,24 aus deinem Array
Diagonal zb 0,9,18,27 also immer 8 plus 1

Es ist eine eindimensionale Arraylist.

Ja, es gibt ja zwei Fälle von Diagonalen:
von links unten nach rechts oben: z.B. 48-41-34-27, da ist der Schritt -7 (die bearbeite ich gerade)

und von Links oben nach rechts unten: z.B. 0-9-18-27, da ist der Schritt +9

@KonradN: Dankeschön, also werde ich wohl um das Zweidimensionale nicht herumkommen. Ja, mein Ausbilder meinte auch, ich solle mir für alles Methoden anlegen.

 

[Oneixee5]

Das Spielfeld intern als:

eine eindimensionale Arraylist

zu verwalten sollte auch kein großes Problem sein. ArrayList ist schon generisch, das kann man also gleich übernehmen:

package de.playground;

import java.util.ArrayList;

public class Main {

    static final class Board<T> {

        private final ArrayList<T> list;
        private final int rows;
        private final int columns;

        public Board(final int rows, final int columns) {
            this.rows = rows;
            this.columns = columns;
            this.list = new ArrayList<>(rows * columns);
            // Initialize the board with null or default values
            for (int i = 0; i < rows * columns; i++) {
                this.list.add(null);
            }
        }

        public T getFieldPlayer(final int row, final int column) {
            if (row < 0 || row >= this.rows || column < 0 || column >= this.columns) {
                throw new IndexOutOfBoundsException("Invalid row or column index");
            }
            final int index = row * this.columns + column;
            return this.list.get(index);
        }

        public void setFieldPlayer(final int row, final int column, final T player) {
            if (row < 0 || row >= this.rows || column < 0 || column >= this.columns) {
                throw new IndexOutOfBoundsException("Invalid row or column index");
            }
            final int index = row * this.columns + column;
            this.list.set(index, player);
        }

        public boolean checkWin(final T player) {
            // Check horizontal
            for (int row = 0; row < this.rows; row++) {
                for (int col = 0; col < this.columns - 3; col++) {
                    if (player.equals(this.getFieldPlayer(row, col))
                            && player.equals(this.getFieldPlayer(row, col + 1))
                            && player.equals(this.getFieldPlayer(row, col + 2))
                            && player.equals(this.getFieldPlayer(row, col + 3))) {
                        return true;
                    }
                }
            }

            // Check vertical
            for (int row = 0; row < this.rows - 3; row++) {
                for (int col = 0; col < this.columns; col++) {
                    if (player.equals(this.getFieldPlayer(row, col))
                            && player.equals(this.getFieldPlayer(row + 1, col))
                            && player.equals(this.getFieldPlayer(row + 2, col))
                            && player.equals(this.getFieldPlayer(row + 3, col))) {
                        return true;
                    }
                }
            }

            // Check diagonal (bottom-left to top-right)
            for (int row = 3; row < this.rows; row++) {
                for (int col = 0; col < this.columns - 3; col++) {
                    if (player.equals(this.getFieldPlayer(row, col))
                            && player.equals(this.getFieldPlayer(row - 1, col + 1))
                            && player.equals(this.getFieldPlayer(row - 2, col + 2))
                            && player.equals(this.getFieldPlayer(row - 3, col + 3))) {
                        return true;
                    }
                }
            }

            // Check diagonal (top-left to bottom-right)
            for (int row = 0; row < this.rows - 3; row++) {
                for (int col = 0; col < this.columns - 3; col++) {
                    if (player.equals(this.getFieldPlayer(row, col))
                            && player.equals(this.getFieldPlayer(row + 1, col + 1))
                            && player.equals(this.getFieldPlayer(row + 2, col + 2))
                            && player.equals(this.getFieldPlayer(row + 3, col + 3))) {
                        return true;
                    }
                }
            }

            return false;
        }
    }

    public static void main(final String[] args) {

        final Board<String> board = new Board<>(8, 8);
        board.setFieldPlayer(0, 0, "X");
        board.setFieldPlayer(1, 1, "X");
        board.setFieldPlayer(2, 2, "X");
        board.setFieldPlayer(3, 3, "X");
        System.out.println(board.checkWin("X")); // Output: true

    }
}