Question

我正在尝试编写一个程序来玩Connect-N游戏，它基本上是Connect-4，但用户决定了棋盘的大小（不一定是正方形）和连续棋子的数量（它可以大于棋盘的大小 - 如果棋盘是3x3，用户可以指定你需要4个棋子才能获胜，而我的代码必须将游戏打成平局，因为它不可能赢得比赛。我正在检查4个案例：横向胜利，纵向胜利，左对角胜利和右对角胜利。我写出了实际检查胜利的逻辑步骤，然后尝试将其转换为代码。但是，当我运行实际程序时，它会继续返回，即使玩家赢了也是一场平局游戏，只有当所有4个win函数都返回false时才能达到。有人能在我的代码中发现错误吗？

这是我的代码：（仅供参考，变量代表X或O）

横向胜利：

bool horizontalWin(char **board, const int numRows, const int numCols, const char blankSpace, const int numToWin, const char pieces) {
  int match = 0;

  if (numCols < numToWin) {
    return false;
  }
  else {
    for (int row = 0; row < numRows; ++row) {
      for (int col = 0; col <= numCols - numToWin; ++col) {
        for (int k = 0; k < numToWin; ++k) {
          if (board[row][col + k] != pieces) {
            match = 0;
          }
          else {
            ++match;
            if (match == numToWin) {
              return true;
            }
          }
        }
      }
    }
  }
  return false;
}

垂直胜利：

bool verticalWin(char **board, const int numRows, const int numCols, const char blankSpace, const int numToWin, const char pieces) {
  int match = 0;

  if (numRows < numToWin) {
    return false;
  }
  else {
    for (int col = 0; col < numCols; ++col) {
      for (int row = 0; row <= numRows - numToWin; ++row) {
        for(int k = 0; k < numToWin; ++k){
          if (board[row + k][col] != pieces) {
            match = 0;
          }
          else {
            ++match;
            if (match == numToWin) {
              return true;
            }
          }
        }
      }
    }
  }
  return false;
}

左对角线：

bool leftDiagonalWin(char **board, const int numRows, const int numCols, const char blankSpace, const int numToWin, const char pieces) {
  int match = 0;

  if (numCols < numToWin || numRows < numToWin) {
    return false;
  }
  else {
    for (int row = 0; row <= numRows - numToWin; ++row) {
      for (int col = 0; col <= numCols - numToWin; ++col) {
        for (int k = 0; k < numToWin; ++k) {
          if(board[k][k] != pieces) {
            match = 0;
          }
          else {
            ++match;
            if (match == numToWin) {
              return true;
            }
          }
        }
      }
    }
  }
  return false;
}

右对角线：

bool rightDiagonalWin(char **board, const int numRows, const int numCols, const char blankSpace, const int numToWin, const char pieces) {
  int match = 0;

  if (numCols < numToWin || numRows < numToWin) {
    return false;
  }
  else {
    for (int row = numRows - 1; row >= numRows - numToWin; --row) {
      for (int col = 0; col <= numCols - numToWin; ++col) {
        for (int k = 0; k < numToWin; ++k) {
          if (board[numRows - 1 - k][col + k] != pieces) {
            match = 0;
          } else {
            ++match;
            if (match == numToWin) {
              return true;
            }
          }
        }
      }

    }
  }
  return false;
}

编辑：这是我用来创建电路板的功能：

char** createBoard(const int numRows, const int numCols, const char blankSpace) {
  char** board = (char**) malloc(numRows * sizeof(char*));
  for (int row = 0; row < numRows; ++row) {
    board[row] = (char*) malloc(numCols * sizeof(char));
    for (int col = 0; col < numCols; ++col) {
      board[row][col] = blankSpace;
    }
  }
  return board;
}

Answer 1

你的横向解决方案太复杂了。甚至不使用或不需要“blankSpace”参数。这是一个非常简化的版本：

bool horizontalWin(char **board, const int numRows, const int numCols,
                  const int numToWin, const char piece) {

    int match = 0;

    for (int row = 0; row < numRows; ++row) {
        for (int col = 0; col <= numCols; ++col) {
            match = (board[row][col] == piece) ? (match + 1) : 0;
            if (match == numToWin) {
                break;
            }
        }
     }
    return (match >= numToWin);
}

你也可以为verticalWin函数复制相同的逻辑。

Answer 2

我知道这已经晚了:(但我就是这样做的，希望对您有帮助

    //check win
int checkWin(char *board){
    return (horizontalCheck(board) || verticalCheck(board) || diagonalCheck(board));
}

int checkFour(char *board, int a, int b, int c, int d){
    //board[a] = won;
    //board[b] = won;
    //board[c] = won;
    //board[d] = won;
    return (board[a] == board[b] && board[b] == board[c] && board[c] == board[d] && board[a] != ' ');
}

int horizontalCheck(char *board){
    int row, col, idx;
    const int WIDTH = 1;

    for(row = 0; row < BOARD_ROWS; row++){
       for(col = 0; col < BOARD_COLS - 3; col++){
          idx = BOARD_COLS * row + col;
          if(checkFour(board, idx, idx + WIDTH, idx + WIDTH * 2, idx + WIDTH * 3)){
             return 1;
          }
       }
    }
    return 0;
}

int verticalCheck(char *board){
    int row, col, idx;
    const int HEIGHT = 7;

    for(row = 0; row < BOARD_ROWS - 3; row++){
       for(col = 0; col < BOARD_COLS; col++){
          idx = BOARD_COLS * row + col;
          if(checkFour(board, idx, idx + HEIGHT, idx + HEIGHT * 2, idx + HEIGHT * 3)){
              return 1;
          }
       }
    }
    return 0;
}

//diagonal check for win
int diagonalCheck(char *board){
   int row, col, idx, count = 0;
   const int DIAG_RGT = 6, DIAG_LFT = 8;

   for(row = 0; row < BOARD_ROWS - 3; row++){
      for(col = 0; col < BOARD_COLS; col++){
         idx = BOARD_COLS * row + col;
         if(((count <= 3) && (checkFour(board, idx, idx + DIAG_LFT, idx + DIAG_LFT * 2, idx + DIAG_LFT * 3))) ||
             ((count >= 3) && (checkFour(board, idx, idx + DIAG_RGT, idx + DIAG_RGT * 2, idx + DIAG_RGT * 3)))){
            return 1;
         }
         count++;
      }
      count = 0;
   }
   return 0;
}

C中的Connect-N游戏检查胜利功能无效

2 个答案: