如何连续找到三个相同的数字？

Question

我有一个类似下面的数组。

int[][] myArray = 
        {{1, 2, 3, 0, 0, 1}
         {1, 0, 4, 4, 0, 1}
         {1, 2, 4, 3, 4, 0}
         {2, 2, 0, 0, 2, 2}
         {3, 0, 0, 3, 0, 0}
         {4, 2, 3, 0, 0, 0}}

它会说一个赢了，因为第一列的三个 1 中的 1。两个人不会赢，因为他们不在一个“行”中。

我想进行某种获胜检查，以便在行、对角线或列中找到三个相同的数字。有点像井字游戏，但网格更大。在我使用一组凌乱的 if 语句和 goto 语句之前。 （它是用 Basic 编写的。）我尝试使用一个系统，它从最后放置的一块中找到方向，其中有许多相同的，但它不能正常工作。我怎样才能以一种简单且可维护的方式做到这一点？

尝试过的代码：

private static boolean checkBoardCombinations(int[][] board, int inputX, int inputY) {
        int currentPlayer = board[inputX-1][inputY-1];
        boolean[][] directions = new boolean[3][3];
        for(int y = 0; y >= -2; y--){
            for(int x = 0; x >= -2; x--){
                if(inputX+x >= 0 && inputX+x <= 7 && inputY+y >= 0 && inputY+y <= 7 
                        && (board[inputX+x][inputY+y] == currentPlayer)){
                    //System.out.printf("X: %s Y: %s", inputX+x, inputY+y);
                    directions[x+2][y+2] = true;
                }
                else{
                    directions[x+2][y+2] = false;
                }
                //System.out.printf("X: %s Y: %s B: %s,", inputX+x, inputY+y, directions[x+2][y+2]);
            }
            //System.out.println();
        }
        /*
         for(int x = 0; x <= 2; x++){
            for(int y = 0; y <= 2; y++){
                System.out.print(directions[x][y] + " ");
            }
                System.out.println();
        }
        */
        return false;

    }

Answer 1

假设玩家数量已知，您可以逐个遍历所有玩家，并检查是否有玩家正在形成所需长度的连接。

这样的代码如下所示：

private int[][] grid; // Your array of size ROWS x COLUMNS
private final int ROWS = 6, COLUMNS = 6;
private final int CONSECUTIVE_CONNECTION_REQUIRED = 3;

// Returns true if given playerType is forming a connection, else false.
public boolean checkGrid(int playerType)
{
  // Check downward
  for (int i = 0; i <= ROWS - CONSECUTIVE_CONNECTION_REQUIRED; i++)
  {
    for (int j = 0; j < COLUMNS; j++)
    {
      int counter = 0;
      for (int k = i; k < CONSECUTIVE_CONNECTION_REQUIRED + i; k++)
      {
        if (grid[k][j] == playerType)
          counter++;
      }

      if (counter == CONSECUTIVE_CONNECTION_REQUIRED)
        return true;
    }
  }

  // Check across
  for (int i = 0; i <= COLUMNS - CONSECUTIVE_CONNECTION_REQUIRED; i++)
  {
    for (int j = 0; j < ROWS; j++)
    {
      int counter = 0;
      for (int k = i; k < CONSECUTIVE_CONNECTION_REQUIRED + i; k++)
      {
        if (grid[j][k] == playerType)
          counter++;
      }

      if (counter == CONSECUTIVE_CONNECTION_REQUIRED)
        return true;
    }
  }

  // Check left to right diagonally
  for (int i = 0; i <= ROWS - CONSECUTIVE_CONNECTION_REQUIRED; i++)
  {
    for (int j = 0; j <= COLUMNS - CONSECUTIVE_CONNECTION_REQUIRED; j++)
    {
      int counter = 0;
      for (int k = i, m = j; k < CONSECUTIVE_CONNECTION_REQUIRED + i; k++, m++)
      {
        if (grid[k][m] == playerType)
          counter++;
      }

      if (counter == CONSECUTIVE_CONNECTION_REQUIRED)
        return true;
    }
  }

  // Check right to left diagonally
  for (int i = 0; i <= ROWS - CONSECUTIVE_CONNECTION_REQUIRED; i++)
  {
    for (int j = COLUMNS - 1; j >= COLUMNS - CONSECUTIVE_CONNECTION_REQUIRED; j--)
    {
      int counter = 0;
      for (int k = i, m = j; k < CONSECUTIVE_CONNECTION_REQUIRED + i; k++, m--)
      {
        if (grid[k][m] == playerType)
          counter++;
      }

      if (counter == CONSECUTIVE_CONNECTION_REQUIRED)
        return true;
    }
  }

  return false;
}

其中 playerType 是 0、1、2、3 等等...

您可以使用checkGrid() 方法，如下所示：

for(int i = MIN_PLAYER_NUMBER; i <= MAX_PLAYER_NUMBER; i++)
{
  if(checkGrid(i))
  {
    // Player i is forming the connection!!!
  }
}

但是，如果您不想多次迭代您的网格，那么请删除您的二维数组，并使用具有邻接表表示的图形。为它编写一个适当的 API，让您可以轻松地更改您的特定表示，然后您可以在更少的迭代中找到是否有任何玩家在图表中建立了特定长度的连接。

Answer 2

虽然你已经接受了一个答案，但我想也向你提交我的多样性答案:)

public static void main (String[] args)
{
    int[][] myArray = 
    {{1, 2, 3, 0, 0, 1},
     {1, 0, 4, 4, 0, 1},
     {1, 2, 4, 3, 4, 0},
     {2, 2, 0, 0, 2, 2},
     {3, 0, 0, 3, 0, 0},
     {4, 2, 3, 0, 0, 0}};
     System.out.println(testForWinner(myArray));
}

/**
 * Returns -1 if no winner
 */
static int testForWinner(int[][] ar) {
    for(int i=0; i<ar.length; i++) {
        for(int j=0; j<ar[i].length; j++) {
            if(checkNext(ar, i, j, 0, 1, 1)) { //Check the element in the next column
                return ar[i][j];
            }
            for(int k=-1; k<=1; k++) { //Check the three adjacent elements in the next row
                if(checkNext(ar, i, j, 1, k, 1)) {
                    return ar[i][j];
                }
            }
        }
    }
    return -1;
}

/**
 * Step number `step` starting at `ar[i][j]` in direction `(di, dj)`.
 * If we made 3 steps we have a winner
 */
static boolean checkNext(int[][] ar, int i, int j, int di, int dj, int step) {
    if(step==3) {
        return true;
    }
    if(i+di<0 || i+di>ar.length-1 || j+dj<0 || j+dj>ar[i].length-1) {
        return false;
    }
    if(ar[i+di][j+dj]==ar[i][j]) {
        return checkNext(ar, i+di, j+dj, di, dj, step+1);
    }
    return false;
}

查看实际操作：http://ideone.com/Ou2sRh