Connect-N游戏在C中检查wins函数不起作用

Question

我正在尝试编写一个程序来玩游戏Connect-N，它基本上是Connect-4，但用户决定了棋盘的大小(它不一定是正方形)和要赢得的连续棋子的数量(可以大于棋盘的大小-如果棋盘是3x3，用户可以指定您需要4个棋子才能获胜，而我的代码必须将游戏打成平局，因为不可能获胜)。我检查了4种情况:水平赢，垂直赢，左对角线赢，右对角线赢。我写出了实际检查wins的逻辑步骤，然后尝试将其转换为代码。然而，当我运行实际的程序时，它总是返回这是一个平局游戏，即使玩家已经赢了，这只能在所有4个win函数都返回false的情况下才能达到。有人能发现我代码中的错误吗？

下面是我的代码：(仅供参考，变量pieces表示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;
}

Edit:这是我用来创建电路板的函数：

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;
}