【问题标题】:Connect 4 check for a win algorithm连接 4 检查获胜算法
【发布时间】:2015-12-22 14:04:05
【问题描述】:

我知道有很多关于连接 4 检查是否获胜的问题。问题是大多数其他算法使我的程序出现运行时错误,因为它们试图访问我的数组之外的索引。 我的算法是这样的:

private int checkWin(int[][] gridTable,int rowNum,int colNum, int maxRow, int maxCol) 
{
//  For checking whether any win or lose condition is reached. Returns 1 if win or lose is reached. else returns 0
//  gridTable[][] is the game matrix(can be any number of rows and columns between 4 and 40)
//  colNum is the column number where the last token was placed
//  rowNum is the row number where the last token was placed
//  maxRow is the number of rows in my grid
//  maxCol is the number of columns in my grid

int player = gridTable[rowNum][colNum]; //player ID
int count=0;

// Horizontal check
for (int i=0;i<maxCol;i++)
{
    if (gridTable[rowNum][i]==player)
        count++;
    else
        count=0;

    if (count>=4)
        return 1;
}
//Vertical check
for (int i=0;i<maxRow;i++)
{
    if (gridTable[i][colNum]==player)
        count++;
    else
        count=0;

    if (count>=4)
        return 1;
} 
count=0;
// 4 in a row diagonally
for(int i=colNum+1,j=rowNum+1;i<maxRow && j<maxCol;i++,j++) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}
// 4 in a row diagonally
for(int i=colNum-1,j=rowNum-1;i>=0 && j>=0;i--,j--) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}
// 4 in a row diagonally
for(int i=colNum+1,j=rowNum-1;i<maxRow && j>=0;i++,j--) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}

for(int i=colNum-1,j=rowNum+1;i>=0 && j<maxCol;i--,j++) 
{ // 4 in a row diagonally
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}

if(count>=4)
    return 1;

return 0;
}

count 是检查是否获胜的变量,如果 count 等于或大于 4 意味着它们应该是同一玩家的 4 个或更多连续令牌。

问题:有时该方法在没有按顺序排列 4 个令牌的情况下检查获胜,而其他时候在按顺序排列 4 个令牌时不检查获胜。

【问题讨论】:

  • 那么索引边界错误发生在哪一行?
  • @MarcB 这个算法不返回任何绑定错误,这个问题更多的是一个逻辑错误,因为有时当 4 个元素连续时不返回胜利,有时当更少时返回胜利连续超过 3 个元素。
  • 基本上你有一个二维矩阵,在这个矩阵中,你需要能够从给定的点开始,向给定的方向移动,检查它们是否是四个匹配的元素。我为tic tac toe 做了类似的事情,但从概念上讲,这是同一件事
  • @MadProgrammer 我试着那样做,但是当我有 3 个令牌、一个空白令牌和另一个令牌时发生了一些事情,当我丢弃生成 5 个直接令牌的令牌时它没有返回胜利
  • 我可以看到的一个问题是,当您检查一个单元格时,您要么增加计数,要么将其重置为 0 并继续检查。您可能应该跳出循环并改为检查下一个方向(如果您没有找到四个匹配项)。但是随后您开始做一些不同的事情,在某些情况下,如果检查失败,您甚至不会重置计数...

标签: java arrays algorithm netbeans


【解决方案1】:

由于某种原因我不太喜欢柜台,所以我这样做了(它适用于不同尺寸的板)。

public boolean areFourConnected(int player){

    // horizontalCheck 
    for (int j = 0; j<getHeight()-3 ; j++ ){
        for (int i = 0; i<getWidth(); i++){
            if (this.board[i][j] == player && this.board[i][j+1] == player && this.board[i][j+2] == player && this.board[i][j+3] == player){
                return true;
            }           
        }
    }
    // verticalCheck
    for (int i = 0; i<getWidth()-3 ; i++ ){
        for (int j = 0; j<this.getHeight(); j++){
            if (this.board[i][j] == player && this.board[i+1][j] == player && this.board[i+2][j] == player && this.board[i+3][j] == player){
                return true;
            }           
        }
    }
    // ascendingDiagonalCheck 
    for (int i=3; i<getWidth(); i++){
        for (int j=0; j<getHeight()-3; j++){
            if (this.board[i][j] == player && this.board[i-1][j+1] == player && this.board[i-2][j+2] == player && this.board[i-3][j+3] == player)
                return true;
        }
    }
    // descendingDiagonalCheck
    for (int i=3; i<getWidth(); i++){
        for (int j=3; j<getHeight(); j++){
            if (this.board[i][j] == player && this.board[i-1][j-1] == player && this.board[i-2][j-2] == player && this.board[i-3][j-3] == player)
                return true;
        }
    }
    return false;
}

【讨论】:

  • 我喜欢这个解决方案,因为它能够检查任意棋盘而不需要知道最后一个玩家的动作是什么。
  • 不是升序对角线和降序对角线吗?除此之外,终于有了一个独立于最后一块石头的解决方案!
【解决方案2】:

看起来您的代码对于水平和垂直情况都是正确的。棘手的部分是对角线的情况。

我们来一张图试试:

对于绿线,您的起始行位置是 0 ... maxRow - 4。列将是 0 ... startingRow -

伪代码:

// top-left to bottom-right - green diagonals
for( rowStart = 0; rowStart < rowMax - 4; rowStart++){
    count = 0;
    int row, col;
    for( row = rowStart, col = 0; row < rowMax && col < colMax; row++, col++ ){
        if(gridTable[row][col] == player){
            count++;
            if(count >= 4) return 1;
        }
        else {
            count = 0;
        }
    }
}

// top-left to bottom-right - red diagonals
for( colStart = 1; colStart < colMax - 4; colStart++){
    count = 0;
    int row, col;
    for( row = 0, col = colStart; row < rowMax && col < colMax; row++, col++ ){
        if(gridTable[row][col] == player){
            count++;
            if(count >= 4) return 1;
        }
        else {
            count = 0;
        }
    }
}

你可以对其他方向的对角线(从左下角到右上角)做类似的事情。

【讨论】:

    【解决方案3】:

    所以,在挖掘了你的代码之后,对角线检查似乎只能在一个方向上获胜(如果我在最低行和最低列添加一个标记会发生什么?)

    相反,基本检查算法始终是相同的过程,无论您检查哪个方向。

    您需要一个起点 (x/y) 和 x/y 增量(移动方向)。您可以将其总结为一个方法...

    public boolean didWin(int[][] grid, int check, int row, int col, int rowDelta, int colDelta) {
    
        boolean win = true;
        for (int count = 0; count < 4; count++) {
            if (row < ROWS && row >= 0 && col < COLUMNS && col >= 0) {
                int test = grid[row][col];
                if (test != check) {
                    win = false;
                    break;
                }
            }
            row += rowDelta;
            col += colDelta;
        }
        return win;
    
    }
    

    这基本上可以让你检查四个方向,但也可以向后做

    所以,如果我们要使用类似...

    int[][] gridTable = new int[ROWS][COLUMNS];
    
    gridTable[ROWS - 1][3] = 1;
    gridTable[ROWS - 2][3] = 1;
    gridTable[ROWS - 3][3] = 1;
    gridTable[ROWS - 4][3] = 1;
    
    System.out.println("Vertical");
    
    System.out.println(didWin(gridTable, 1, ROWS - 4, 3, 1, 0) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, ROWS - 1, 3, -1, 0) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 0, 3, 1, 0) ? "Win" : "Lose");
    
    gridTable = new int[ROWS][COLUMNS];
    gridTable[3][1] = 1;
    gridTable[3][2] = 1;
    gridTable[3][3] = 1;
    gridTable[3][4] = 1;
    
    System.out.println("");
    System.out.println("Horizontal");
    System.out.println(didWin(gridTable, 1, 3, 1, 0, 1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 3, 4, 0, -1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 3, 0, 0, 1) ? "Win" : "Lose");
    
    gridTable = new int[ROWS][COLUMNS];
    gridTable[0][1] = 1;
    gridTable[1][2] = 1;
    gridTable[2][3] = 1;
    gridTable[3][4] = 1;
    
    System.out.println("");
    System.out.println("Diag");
    System.out.println(didWin(gridTable, 1, 0, 1, 1, 1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 3, 4, -1, -1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 1, 2, 1, 1) ? "Win" : "Lose");
    

    哪些输出...

    Vertical
    Win
    Win
    Lose
    
    Horizontal
    Win
    Win
    Lose
    
    Diag
    Win
    Win
    Lose
    

    现在,您可以将其总结为...

    public boolean didWin(int[][] grid, int check, int row, int col) {
        return didWin(grid, check, row, col, 1, 0) ||
                        didWin(grid, check, row, col, -1, 0) ||
                        didWin(grid, check, row, col, 0, 1) ||
                        didWin(grid, check, row, col, 0, -1) ||
                        didWin(grid, check, row, col, 1, 1) ||
                        didWin(grid, check, row, col, -1, -1) ||
                        didWin(grid, check, row, col, -1, 1) ||
                        didWin(grid, check, row, col, 1, -1);
    }
    

    所以,使用类似...

    int[][] gridTable = new int[ROWS][COLUMNS];
    
    gridTable[ROWS - 1][3] = 1;
    gridTable[ROWS - 2][3] = 1;
    gridTable[ROWS - 3][3] = 1;
    gridTable[ROWS - 4][3] = 1;
    
    System.out.println("Vertical");
    
    System.out.println(didWin(gridTable, 1, ROWS - 1, 3) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, ROWS - 4, 3) ? "Win" : "Lose");
    
    gridTable = new int[ROWS][COLUMNS];
    gridTable[3][1] = 1;
    gridTable[3][2] = 1;
    gridTable[3][3] = 1;
    gridTable[3][4] = 1;
    
    System.out.println("");
    System.out.println("Horizontal");
    System.out.println(didWin(gridTable, 1, 3, 1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 3, 4) ? "Win" : "Lose");
    
    gridTable = new int[ROWS][COLUMNS];
    gridTable[0][1] = 1;
    gridTable[1][2] = 1;
    gridTable[2][3] = 1;
    gridTable[3][4] = 1;
    
    System.out.println("");
    System.out.println("Diag");
    System.out.println(didWin(gridTable, 1, 0, 1) ? "Win" : "Lose");
    System.out.println(didWin(gridTable, 1, 3, 4) ? "Win" : "Lose");
    

    打印出类似...

    Vertical
    Win
    Win
    
    Horizontal
    Win
    Win
    
    Diag
    Win
    Win
    

    我要补充的是,这种方法只有在您连续提供 4 个筹码的正确开始时才有效。例如 didWin(gridTable, 1, 3, 3) 将为您的水平检查提供 false 而不是 true,因为循环只能检查一个方向。

    其目的不是提供“成熟的、开箱即用的”解决方案,而是提供一个可以开发更广泛解决方案的概念(我的意思是,我不希望人们真正不得不思考;) )。我还根据 OP 知道最后一块放在哪里的想法设计了解决方案,即起点;)

    通过稍微修改didWin 方法,可以从任何点通过n 网格检查n...

    public boolean didWin(int[][] grid, int check, int row, int col, int rowDelta, int colDelta) {
        boolean match = false;
        int matches = 0;
        while (row < ROWS && row >= 0 && col < COLUMNS && col >= 0) {
            int test = grid[row][col];
            if (test != check && match) {
                break;
            } else if (test == check) {
                match = true;
                matches++;
            }
            row += rowDelta;
            col += colDelta;
        }
        return matches == 4;
    }
    

    所以,我用...

    public static final int ROWS = 8;
    public static final int COLUMNS = 8;
    //...
    int[][] gridTable = new int[ROWS][COLUMNS];
    
    gridTable[ROWS - 1][3] = 1;
    gridTable[ROWS - 2][3] = 1;
    gridTable[ROWS - 3][3] = 1;
    gridTable[ROWS - 4][3] = 1;
    for (int[] row : gridTable) {
        StringJoiner sj = new StringJoiner("|", "|", "|");
        for (int col : row) {
            sj.add(Integer.toString(col));
        }
        System.out.println(sj);
    }
    System.out.println(didWin(gridTable, 1, 3, 3));
    

    并且能够让它工作。有时答案并不是一个完整的解决方案,而是一个想法的种子,可以将某人带到一个新的地方;)

    进一步的增强将包括提供预期的连体片段的数量,但我很确定这是一个我真的不需要演示的增强;)

    【讨论】:

    • 非常感谢。有什么书推荐给我吗?面向对象(?)
    • 考虑看看 Effective Java
    • 这是一个非常强大的想法,可以应用于许多领域。感谢分享!
    • @Slvrfn 这是一个很棒的想法,可以应用于nxn 矩阵,也可以改装成战舰之类的东西:P
    • 我要补充一点,这种方法只有在您连续提供 4 个筹码的正确开始时才有效。例如 didWin(gridTable, 1, 3, 3) 将为您的水平检查提供 false 而不是 true,因为循环只能检查一个方向。
    【解决方案4】:

    我用 C 语言编写了自己的版本,我认为用另一种语言重新解释很容易。

    //Return values: 1 for Player 1, 2 for Player 2 and 0 for a tie.
    // '-' represents an empty tile, 'X' Player 1, 'O' Player 2
    #include <stddef.h>
    
    int connect4(char *game[], size_t columns, size_t lines)
    {
        int winner = -1;
        for (size_t l = 0; l < lines; l++)
        {
            for (size_t c = 0; c < columns; c++)
            {
                char player = game[l][c];
                if (player == '-')
                    continue;
                if (c + 3 < columns && player == game[l][c + 1]
                    && player == game[l][c + 2] && player == game[l][c + 3])
                    winner = winner < 0 ? player : 0;
                if (l + 3 < lines && player == game[l + 1][c]
                    && player == game[l + 2][c] && player == game[l + 3][c])
                    winner = winner < 0 ? player : 0;
                if (c + 3 < columns && l + 3 < lines && player == game[l + 1][c + 1]
                    && player == game[l + 2][c + 2] && player == game[l + 3][c + 3])
                    winner = winner < 0 ? player : 0;
                if (c >= 3 && l + 3 < lines && player == game[l + 1][c - 1]
                    && player == game[l + 2][c - 2] && player == game[l + 3][c - 3])
                    winner = winner < 0 ? player : 0;
            }
        }
        if (winner < 1)
            return 0;
        else
            return winner == 88 ? 1 : 2;
    }
    

    【讨论】:

      【解决方案5】:

      如果有人仍然需要解决方案,我用 c# 编写一个函数并放入 GitHub repo。

      /// <summary>
          /// WinnerCalc check if blue or red win the game.
          /// </summary>
          /// <returns>Return 1 if 1 win and 2 if 2 win and -1 if no one win.</returns>
          /// <param name="matrix">2d array</param>
          /// <param name="lastRow">The row number.</param>
          /// <param name="lastColumn">The column number.</param>
          public static int WinnerCalc(int[,] matrix, int lastRow, int lastColumn)
          {
              int lastValue = matrix[lastRow, lastColumn];
              Console.WriteLine("drop in row: " + (lastRow) + " and column: " + (lastColumn) + " , the value is: " + lastValue);
              int rows = matrix.GetLength(0); //6
              int columns = matrix.GetLength(1); //7
              Console.WriteLine("number of rows is " + rows + ", and number of colums is " + columns);
      
              int numToWin = 4;
              int winner = -1;//is now one win tha game
              int match;
      
              match = 0;
              //check Horizontal
              for (int c = 0; c < columns; c++)
              {
                  int currentValue = matrix[lastRow, c];
                  if (currentValue == lastValue)
                      match++;
                  else match = 0;
                  if(match == numToWin)
                  {
                      winner = lastValue;
                      break;
                  }
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Horizontal !");
                  return winner;
              }
      
              match = 0;
              //check Vertical
              for (int r = 0; r < rows; r++)
              {
                  int currentValue = matrix[r, lastColumn];
                  if (currentValue == lastValue)
                      match++;
                  else match = 0;
                  if (match == numToWin)
                  {
                      winner = lastValue;
                      break;
                  }
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Vertical !");
                  return winner;
              }
      
              //check diagonal top-left to bottom-right - include middle
              match = 0;
              for (int r = 0; r <= rows - 4; r++)
              {
                  int rowPosition = r;
                  for (int column = 0; column < columns && rowPosition < rows; column++)
                  {
                      int currentValue = matrix[rowPosition, column];
                      if (currentValue == lastValue)
                          match++;
                      else match = 0;
                      if (match == numToWin)
                      {
                          winner = lastValue;
                          break;
                      }
                      rowPosition++;
                  }
                  if (winner != -1) break;
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Diagonal Top left! - include middle");
                  return winner;
              }
      
              //check diagonal top-left to bottom-right - after middle
              match = 0;
              for (int c = 1; c <= columns - 4; c++)
              {
                  int columnPosition = c;
                  for (int row = 0; row < rows && columnPosition < columns; row++)
                  {
                      int currentValue = matrix[row, columnPosition];
                      if (currentValue == lastValue)
                          match++;
                      else match = 0;
                      if (match == numToWin)
                      {
                          winner = lastValue;
                          break;
                      }
                      columnPosition++;
                  }
                  if (winner != -1) break;
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Diagonal Top left! - after middle");
                  return winner;
              }
      
      
              //check diagonal bottom-left to top-right - include middle
              match = 0;
              for (int r = rows - 1; r >= rows - 4; r--)
              {
                  int rowPosition = r;
                  for (int column = 0; column < columns && rowPosition < rows && rowPosition >= 0; column++)
                  {
                      int currentValue = matrix[rowPosition, column];
                      if (currentValue == lastValue)
                          match++;
                      else match = 0;
                      if (match == numToWin)
                      {
                          winner = lastValue;
                          break;
                      }
                      rowPosition--;
                  }
                  if (winner != -1) break;
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Diagonal Bottom left! - include middle");
                  return winner;
              }
      
      
              //check diagonal bottom-left to top-right - after middle
              match = 0;
              for (int c = 1; c < columns; c++)
              {
                  int columnPosition = c;
                  for (int row = rows - 1; row < rows && columnPosition < columns && columnPosition >= 1; row--)
                  {
                      int currentValue = matrix[row, columnPosition];
                      if (currentValue == lastValue)
                          match++;
                      else match = 0;
                      if (match == numToWin)
                      {
                          winner = lastValue;
                          break;
                      }
                      columnPosition++;
                  }
                  if (winner != -1) break;
              }
              if (winner != -1)
              {
                  Console.WriteLine("win Diagonal Bottom left! - after middle");
                  return winner;
              }
      
      
      
              return winner; // no winner return -1
          }
      
      }
      

      这是回购:https://github.com/JoshK2/connect-four-winner

      【讨论】:

        【解决方案6】:

        这对我有用,也没有看起来那么长:
        这些是 x 和 o 的行、列、对角线和反对角线的方法 ;

        public static void checkVertO(){
            if (board[0][0] == 'O' && board[1][0] == 'O' && board[2][0] == 'O' && board[3][0] == 'O' || board[1][0] == 'O' && board[2][0] == 'O' && board[3][0] == 'O' && board[4][0] == 'O' ||
            board[2][0] == 'O' && board[3][0] == 'O' && board[4][0] == 'O' && board[5][0] == 'O' || board[0][1] == 'O' && board[1][1] == 'O' && board[2][1] == 'O' && board[3][1] == 'O' || 
            board[1][1] == 'O' && board[2][1] == 'O' && board[3][1] == 'O' && board[4][1] == 'O' || board[2][1] == 'O' && board[3][1] == 'O' && board[4][1] == 'O' && board[5][1] == 'O' || 
            board[0][2] == 'O' && board[1][2] == 'O' && board[2][2] == 'O' && board[3][2] == 'O' || board[1][2] == 'O' && board[2][2] == 'O' && board[3][2] == 'O' && board[4][2] == 'O' ||
            board[2][2] == 'O' && board[3][2] == 'O' && board[4][2] == 'O' && board[5][2] == 'O' || board[0][3] == 'O' && board[1][3] == 'O' && board[2][3] == 'O' && board[3][3] == 'O' || 
            board[1][3] == 'O' && board[2][3] == 'O' && board[3][3] == 'O' && board[4][3] == 'O' || board[2][3] == 'O' && board[3][3] == 'O' && board[4][3] == 'O' && board[5][3] == 'O' ||
            board[0][4] == 'O' && board[1][4] == 'O' && board[2][4] == 'O' && board[3][4] == 'O' || board[1][4] == 'O' && board[2][4] == 'O' && board[3][4] == 'O' && board[4][4] == 'O' ||
            board[2][4] == 'O' && board[3][4] == 'O' && board[4][4] == 'O' && board[5][4] == 'O' || board[0][5] == 'O' && board[1][5] == 'O' && board[2][5] == 'O' && board[3][5] == 'O' || 
            board[1][5] == 'O' && board[2][5] == 'O' && board[3][5] == 'O' && board[4][5] == 'O' || board[2][5] == 'O' && board[3][5] == 'O' && board[4][5] == 'O' && board[5][5] == 'O' ||
            board[0][6] == 'O' && board[1][6] == 'O' && board[2][6] == 'O' && board[3][6] == 'O' || board[1][6] == 'O' && board[2][6] == 'O' && board[3][6] == 'O' && board[4][6] == 'O'||
            board[2][6] == 'O' && board[3][6] == 'O' && board[4][6] == 'O' && board[5][6] == 'O'){
                System.out.println("Game over, O won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
        public static void checkHorzO(){
            if (board[0][0] == 'O' && board[0][1] == 'O' && board[0][2] == 'O' && board[0][3] == 'O' || board[0][1] == 'O' && board[0][2] == 'O' && board[0][3] == 'O' && board[0][4] == 'O' ||
            board[0][2] == 'O' && board[0][3] == 'O' && board[0][4] == 'O' && board[0][5] == 'O' || board[0][3] == 'O' && board[0][4] == 'O' && board[0][5] == 'O' && board[0][6] == 'O' ||
            board[1][0] == 'O' && board[1][1] == 'O' && board[1][2] == 'O' && board[1][3] == 'O' || board[1][1] == 'O' && board[1][2] == 'O' && board[1][3] == 'O' && board[1][4] == 'O' ||
            board[1][2] == 'O' && board[1][3] == 'O' && board[1][4] == 'O' && board[1][5] == 'O' || board[1][3] == 'O' && board[1][4] == 'O' && board[1][5] == 'O' && board[1][6] == 'O' ||
            board[2][0] == 'O' && board[2][1] == 'O' && board[2][2] == 'O' && board[2][3] == 'O' || board[2][1] == 'O' && board[2][2] == 'O' && board[2][3] == 'O' && board[2][4] == 'O' ||
            board[2][2] == 'O' && board[2][3] == 'O' && board[2][4] == 'O' && board[2][5] == 'O' || board[2][3] == 'O' && board[2][4] == 'O' && board[2][5] == 'O' && board[2][6] == 'O' ||
            board[3][0] == 'O' && board[3][1] == 'O' && board[3][2] == 'O' && board[3][3] == 'O' || board[3][1] == 'O' && board[3][2] == 'O' && board[3][3] == 'O' && board[3][4] == 'O' ||
            board[3][2] == 'O' && board[3][3] == 'O' && board[3][4] == 'O' && board[3][5] == 'O' || board[3][3] == 'O' && board[3][4] == 'O' && board[3][5] == 'O' && board[3][6] == 'O' ||
            board[4][0] == 'O' && board[4][1] == 'O' && board[4][2] == 'O' && board[4][3] == 'O' || board[4][1] == 'O' && board[4][2] == 'O' && board[4][3] == 'O' && board[4][4] == 'O' ||
            board[4][2] == 'O' && board[4][3] == 'O' && board[4][4] == 'O' && board[4][5] == 'O' || board[4][3] == 'O' && board[4][4] == 'O' && board[4][5] == 'O' && board[4][6] == 'O' ||
            board[5][0] == 'O' && board[5][1] == 'O' && board[5][2] == 'O' && board[5][3] == 'O' || board[5][1] == 'O' && board[5][2] == 'O' && board[5][3] == 'O' && board[5][4] == 'O' ||
            board[5][2] == 'O' && board[5][3] == 'O' && board[5][4] == 'O' && board[5][5] == 'O' || board[5][3] == 'O' && board[5][4] == 'O' && board[5][5] == 'O' && board[5][6] == 'O' ){
                System.out.println("Game over, O won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
        public static void checkHorzX(){
            if (board[0][0] == 'X' && board[0][1] == 'X' && board[0][2] == 'X' && board[0][3] == 'X' || board[0][1] == 'X' && board[0][2] == 'X' && board[0][3] == 'X' && board[0][4] == 'X' ||
            board[0][2] == 'X' && board[0][3] == 'X' && board[0][4] == 'X' && board[0][5] == 'X' || board[0][3] == 'X' && board[0][4] == 'X' && board[0][5] == 'X' && board[0][6] == 'X' ||
            board[1][0] == 'X' && board[1][1] == 'X' && board[1][2] == 'X' && board[1][3] == 'X' || board[1][1] == 'X' && board[1][2] == 'X' && board[1][3] == 'X' && board[1][4] == 'X' ||
            board[1][2] == 'X' && board[1][3] == 'X' && board[1][4] == 'X' && board[1][5] == 'X' || board[1][3] == 'X' && board[1][4] == 'X' && board[1][5] == 'X' && board[1][6] == 'X' ||
            board[2][0] == 'X' && board[2][3] == 'X' && board[2][4] == 'X' && board[2][5] == 'X' || board[2][3] == 'X' && board[2][4] == 'X' && board[2][5] == 'X' && board[2][6] == 'X' ||
            board[3][0] == 'X' && board[3][1] == 'X' && board[3][2] == 'X' && board[3][3] == 'X' || board[3][1] == 'X' && board[3][2] == 'X' && board[3][3] == 'X' && board[3][4] == 'X' ||
            board[3][2] == 'X' && board[3][3] == 'X' && board[3][4] == 'X' && board[3][5] == 'X' || board[3][3] == 'X' && board[3][4] == 'X' && board[3][5] == 'X' && board[3][6] == 'X' ||
            board[4][0] == 'X' && board[4][3] == 'X' && board[4][4] == 'X' && board[4][5] == 'X' || board[4][3] == 'X' && board[4][4] == 'X' && board[4][5] == 'X' && board[4][6] == 'X' ||
            board[5][0] == 'X' && board[5][1] == 'X' && board[5][2] == 'X' && board[5][3] == 'X' || board[5][1] == 'X' && board[5][2] == 'X' && board[5][3] == 'X' && board[5][4] == 'X' ||
            board[5][2] == 'X' && board[5][3] == 'X' && board[5][4] == 'X' && board[5][5] == 'X' || board[5][3] == 'X' && board[5][4] == 'X' && board[5][5] == 'X' && board[5][6] == 'X' ){
                System.out.println("Game over, X won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
        public static void checkDiagX(){
            if (board[2][0] == 'X' && board[3][1] == 'X' && board[4][2] == 'X' && board[5][3] == 'X'|| board[1][0] == 'X' && board[2][1] == 'X' && board[3][2] == 'X' && board[4][3] == 'X'||
            board[0][0] == 'X' && board[1][1] == 'X' && board[2][2] == 'X' && board[3][3] == 'X'|| board[0][1] == 'X' && board[1][2] == 'X' && board[2][3] == 'X' && board[3][4] == 'X'||
            board[1][1] == 'X' && board[2][2] == 'X' && board[3][3] == 'X' && board[4][4] == 'X'|| board[2][1] == 'X' && board[3][2] == 'X' && board[4][3] == 'X' && board[5][4] == 'X'||
            board[0][2] == 'X' && board[1][3] == 'X' && board[2][4] == 'X' && board[3][5] == 'X'|| board[1][2] == 'X' && board[2][3] == 'X' && board[3][4] == 'X' && board[4][5] == 'X'||
            board[2][2] == 'X' && board[3][3] == 'X' && board[4][4] == 'X' && board[5][5] == 'X'|| board[0][3] == 'X' && board[1][4] == 'X' && board[2][5] == 'X' && board[3][6] == 'X'||
            board[1][3] == 'X' && board[2][4] == 'X' && board[3][5] == 'X' && board[4][6] == 'X'|| board[2][3] == 'X' && board[3][4] == 'X' && board[4][5] == 'X' && board[5][6] == 'X'){
                System.out.println("Game over, X won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
        public static void checkDiagO(){
            if (board[2][0] == 'O' && board[3][1] == 'O' && board[4][2] == 'O' && board[5][3] == 'O'|| board[1][0] == 'O' && board[2][1] == 'O' && board[3][2] == 'O' && board[4][3] == 'O'||
            board[0][0] == 'O' && board[1][1] == 'O' && board[2][2] == 'O' && board[3][3] == 'O'|| board[0][1] == 'O' && board[1][2] == 'O' && board[2][3] == 'O' && board[3][4] == 'O'||
            board[1][1] == 'O' && board[2][2] == 'O' && board[3][3] == 'O' && board[4][4] == 'O'|| board[2][1] == 'O' && board[3][2] == 'O' && board[4][3] == 'O' && board[5][4] == 'O'||
            board[0][2] == 'O' && board[1][3] == 'O' && board[2][4] == 'O' && board[3][5] == 'O'|| board[1][2] == 'O' && board[2][3] == 'O' && board[3][4] == 'O' && board[4][5] == 'O'||
            board[2][2] == 'O' && board[3][3] == 'O' && board[4][4] == 'O' && board[5][5] == 'O'|| board[0][3] == 'O' && board[1][4] == 'O' && board[2][5] == 'O' && board[3][6] == 'O'||
            board[1][3] == 'O' && board[2][4] == 'O' && board[3][5] == 'O' && board[4][6] == 'O'|| board[2][3] == 'O' && board[3][4] == 'O' && board[4][5] == 'O' && board[5][6] == 'O'){
                System.out.println("Game over, O won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
        public static void checkAntiDiagX(){
            if (board[3][0] == 'X' && board[2][1] == 'X' && board[1][2] == 'X' && board[0][3] == 'X'|| board[4][0] == 'X' && board[3][1] == 'X' && board[2][2] == 'X' && board[1][3] == 'X'||
            board[3][1] == 'X' && board[2][2] == 'X' && board[1][3] == 'X' && board[0][4] == 'X'|| board[5][0] == 'X' && board[4][1] == 'X' && board[3][2] == 'X' && board[2][3] == 'X'||        
            board[4][1] == 'X' && board[3][2] == 'X' && board[2][3] == 'X' && board[1][4] == 'X'|| board[3][2] == 'X' && board[2][2] == 'X' && board[1][4] == 'X' && board[0][5] == 'X'||
            board[5][1] == 'X' && board[4][2] == 'X' && board[3][3] == 'X' && board[2][4] == 'X'|| board[4][2] == 'X' && board[3][3] == 'X' && board[2][4] == 'X' && board[1][5] == 'X'||
            board[3][3] == 'X' && board[2][4] == 'X' && board[1][5] == 'X' && board[0][6] == 'X'|| board[5][2] == 'X' && board[4][3] == 'X' && board[3][4] == 'X' && board[2][5] == 'X'||
            board[4][3] == 'X' && board[3][4] == 'X' && board[2][5] == 'X' && board[1][6] == 'X'|| board[5][3] == 'X' && board[4][4] == 'X' && board[3][5] == 'X' && board[2][6] == 'X'){
                System.out.println("Game over, X won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        
         public static void checkAntiDiagO(){
            if (board[3][0] == 'O' && board[2][1] == 'O' && board[1][2] == 'O' && board[0][3] == 'O'|| board[4][0] == 'O' && board[3][1] == 'O' && board[2][2] == 'O' && board[1][3] == 'O'||
            board[3][1] == 'O' && board[2][2] == 'O' && board[1][3] == 'O' && board[0][4] == 'O'|| board[5][0] == 'O' && board[4][1] == 'O' && board[3][2] == 'O' && board[2][3] == 'O'||        
            board[4][1] == 'O' && board[3][2] == 'O' && board[2][3] == 'O' && board[1][4] == 'O'|| board[3][2] == 'O' && board[2][2] == 'O' && board[1][4] == 'O' && board[0][5] == 'O'||
            board[5][1] == 'O' && board[4][2] == 'O' && board[3][3] == 'O' && board[2][4] == 'O'|| board[4][2] == 'O' && board[3][3] == 'O' && board[2][4] == 'O' && board[1][5] == 'O'||
            board[3][3] == 'O' && board[2][4] == 'O' && board[1][5] == 'O' && board[0][6] == 'O'|| board[5][2] == 'O' && board[4][3] == 'O' && board[3][4] == 'O' && board[2][5] == 'O'||
            board[4][3] == 'O' && board[3][4] == 'O' && board[2][5] == 'O' && board[1][6] == 'O'|| board[5][3] == 'O' && board[4][4] == 'O' && board[3][5] == 'O' && board[2][6] == 'O'){
                System.out.println("Game over, O won.");
                printBoard();
                doIt();
            }else {
                return;
            }
        }
        

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 1970-01-01
          • 2019-05-10
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 2013-12-28
          • 1970-01-01
          相关资源
          最近更新 更多