Question

以下是现在整个事情的样子。

然后有一些细节，你被迫添加更多细节，更多细节和更多细节，越来越多，越来越多，越来越多< / p>

import java.util.Scanner;

public class Tictactoe {
    static char[][] MakeMove(char[][] spelplan, char spelare, int rad, int kolumn) {
        spelplan[rad][kolumn] = spelare;
        char[][] board = new char[4][4];
        System.out.println(spelplan[rad][kolumn]);
        return spelplan;
    }

    static boolean CheckMove(char[][] spelplan, int x, int y) {
        if (spelplan[x][y] != ' ') {
            return false;
        } else {
            return true;
        }
    }

    static void SkrivUtSpelplan(char[][] spelplan) {
        System.out.println("-------");
        System.out.println("|" + spelplan[1][1] + "|" + spelplan[1][2] + "|" + spelplan[1][3] + "|");
        System.out.println("|-+-+-|");
        System.out.println("|" + spelplan[2][1] + "|" + spelplan[2][2] + "|" + spelplan[2][3] + "|");
        System.out.println("|-+-+-|");
        System.out.println("|" + spelplan[3][1] + "|" + spelplan[3][2] + "|" + spelplan[3][3] + "|");
        System.out.println("-------");
    }

    static boolean KollaVinst(char[][] spelplan) {
        return false;
    }

    public static void main(String[] args) {
        char spelplan[][] = new char[4][4];
        char spelare;
        int rad = 3, kolumn = 3, i = 0;
        for (int x = 1; x < 4; x++) {
            for (int y = 1; y < 4; y++) {
                spelplan[x][y] = ' ';
            }
        }

        System.out.println("-------");
        System.out.println("| | | |");
        System.out.println("|-+-+-|");
        System.out.println("| | | |");
        System.out.println("|-+-+-|");
        System.out.println("| | | |");
        System.out.println("-------");

        while (KollaVinst(spelplan) == false) {

            CheckMove(spelplan, rad, kolumn);

            for (i = 0; i < 9; i++) {
                if (i % 2 == 0) {
                    spelare = 'X';
                } else {
                    spelare = 'O';
                }

                System.out.println("Spelare 1 skriv vilken rad: 1-3");
                int x = new Scanner(System.in).nextInt();

                System.out.println("Spelare 1 skriv vilken kolumn: 1-3");
                int y = new Scanner(System.in).nextInt();

                if (CheckMove(spelplan, x, y) == true) {
                    MakeMove(spelplan, spelare, x, y);
                }
                System.out.println(" ");
                SkrivUtSpelplan(spelplan);
            }
        }
    }
}

Answer 1

根据你到目前为止发布的内容（我真的希望有一个编辑来澄清你的尝试）

我假设您正在尝试构建一个在电路板完成之前不会结束的循环。直到它完成，向玩家询问一个动作。采取行动（如果合法）。然后打印板。

您的代码存在许多问题：

CheckMove（spelplan，rad，kolumn）只执行rad = 3，kolumn = 3。我希望这可以使用用户输入来运行。
您重用循环变量。（int i =新扫描仪）及以后（i = i）。永远不要那样做。 i = i无论如何都是毫无意义的，你最终做了i ++，这意味着你失去了用户输入。
在while循环中你永远不会做makeMove（spelplan，i，j）。我希望在印刷电路板之前就能发生这种情况。
for循环（i和j）似乎没用。您的方法skrivutSpelPlan已经打印了电路板，只需要调用一次。你不要使用循环变量i或j。

我正在反对写出建议/代码的冲动，因为你表示你不想要它。在伪代码中，您希望循环结构如下：

while (!isBoardSolved) {
    (x,y) = getUserInput(); // this is not java :D don't use it
    if (isLegalMove(x,y)) {
         makeMove(x,y);
    } else {
         reportError();
    }
    printBoard();
}

在你的printBoard方法中，你应该循环。你目前有硬编码[0] [1]等。使用forloop for row和forloop for col。

你的checkmove不检查董事会。它会检查电路板[x] [y]！=电路板[x] [y]是否为真。（从技术上讲，在多线程环境中，如果出现竞争条件且可以访问，则可能是真的）你必须考虑checkMove的作用。

MakeMove没问题，除了你不需要返回新的比赛场地。如果你这样做

char[][] board = new char[4][4];
MakeMove(board, 'a', x, y);
System.out.println(board[x][y]); // should print 'a' unless x or y were out of bounds.

然后更新电路板并打印a。

如果你有这个工作，我建议把它发布到https://codereview.stackexchange.com/，并获得更多关于良好编码风格和实践的反馈。

测试对角线，您可以使用：

// y = row number, so y = y + 1 means the row below y
// x = column number. so x = x + 1 means the column to the right of x
public boolean isSolved(char[][] board) {
    // check horizontal rows
    return isHorizontalSolved(board) || isVerticalSolved(board) || isDiagonalSolved(board);
}

public boolean isHorizontalSolved(board) {
    for (int y = 0; y < board.length; ++y) { 
        // for each row, test if all columns are the same
        boolean solved = true;
        char first = board[y][0];
        for (int x = 0; x < boards[y].length; ++x) {
            if (boards[y][x] == ' ' || first != boards[y][x]) { 
                // if an element is not filled in, this row is not solved
                // if an element in this row is different than any other element, this row is not solved
                solved = false;          
            }
        }
        if (solved == true) {
            return true;
        }
    }
    return false;
}

// check vertical rows
// leaving this for your own imagination

// check diagonals
public boolean isDiagonalSolved(char[][] board) {
    // check topLeft to bottomRight:
    char first = board[0][0];
    boolean solved = true;
    for (int y = 0, x = 0; y < board.length && x < board[y].length; ++y, ++x) {
        if (board[y][x] == ' ' || first != board[y][x]) {
            // if field is empty or the fields are not all equal to one another
            solved = false;
        }
    }
    if (solved) {
        return true;
    }

    int topRightX = board[0].length - 1;
    solved = true;
    first = board[0][topRightX];
    for (int y = 0, x = topRightX; y < board.length && x >= 0; ++y, --x) {
        if (board[y][x] == ' ' || first != board[y][x]) {
            // if field is empty or the fields are not all equal to one another
            solved = false;
        }
    }
    if (solved) {
        return true;
    }

}

不能保证它的错误少，但这大致是我会做的。对角线，横向至右下角（0,0）（1,1）（2,2）和左上角（0,2），（1,1）（2,0）

使用3 * 3的游戏板你可以硬编码，但我习惯使用循环。

tic tac toe Jcreator卡住了

1 个答案: