检查C中的随机字符矩阵中是否存在单词

我目前正在用C语言创建一个单词搜索/猜谜游戏。播放器将在其上输入一个单词，程序将检查输入的单词是否存在于随机字符的2D矩阵中。我在C语言方面有困难。如果我做得对，有人能帮忙吗？或者我需要更改代码。非常感谢你的帮助

这是我的全部代码。当我尝试猜测时，总是打印

未找到

，即使单词是随机字符的2D矩阵。那么，我需要帮助来解决什么问题？检查单词是否存在的正确代码是什么

#包括
#包括
#包括
#包括
#包括
#定义尺寸6
#定义最大值10
typedef枚举{true，false}bool；
//用随机字符画黑板
空心板（字符矩阵[尺寸][尺寸]）{
int i，j；
对于（i=0；iSIZE-1 | | j>strlen（矩阵[0]）-1）{
返回true；
}
if（矩阵[i][j]！=查找[索引]）{
返回false；
}
矩阵[i][j]='*'；
布尔搜索进一步=邻接搜索（矩阵，查找，i+1，j，索引+1）||
邻接搜索（矩阵，查找，i-1，j，索引+1）||
邻接搜索（矩阵，查找，i，j-1，索引+1）||
邻接搜索（矩阵，查找，i，j+1，索引+1）；
矩阵[i][j]=查找[索引]；
进一步返回搜索；
}
布尔存在（字符矩阵[SIZE][SIZE]，字符*查找，整数r，整数c）{
int len=strlen（查找）；
if（len>r*c）
返回false；
对于（int i=0；i”）；
fgets（字、最大值、标准输入）；
//printf（“单词：%s”，单词）；
如果（存在（矩阵、字、大小、大小））{
printf（“找到的”\n）；
}否则{
printf（“未找到”）；
}
返回0；
}

数组索引问题。检查此代码

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <ctype.h>

#define SIZE 6
#define MAX 10

// typedef enum {true, false} bool;

// Draw the board with random characters
void board(char* matrix){
    int i, j;
    for(i=0; i<SIZE; i++){
            for(j=0; j<SIZE; j++){
                matrix[i*SIZE + j] = 'A'+(50 *i *j)%('Z'-'A'+1);
        }
    }
}

// Prints the board
void printBoard(char* matrix){
    int i, j;
    srand((unsigned int)time(NULL));
    board(matrix);

    for(i=0; i<SIZE; i++){
            for(j=0; j<SIZE; j++){
                    printf(" %c ", matrix[i*SIZE + j]);
            }
        printf("\n");
    }
}

enum class Direction : int
{
    Left = 0,
    Right,
    Up,
    Down,
    Unknown
};

bool SearchGivenStart(char* matrix,
char* find, int length,
int startRowIndex,
int startColumnIndex,
Direction direction)
{
     printf("Start %d %d\n", startRowIndex, startColumnIndex);
    int nextRowIndex = startRowIndex;
    int nextColumnIndex = startColumnIndex;
    for(int i = 1; i< length - 1 ;i++)
    {
        if(direction == Direction::Left)
        {
            nextColumnIndex -= 1;
        }
        else if (direction == Direction::Right)
        {
            nextColumnIndex += 1;
        }
        else if (direction == Direction::Up)
        {
            nextRowIndex -= 1;
        }
        else if (direction == Direction::Down)
        {
            nextRowIndex += 1;
        }
        else
        {
            // Assert error
        }

         printf("Next %d %d\n", nextRowIndex, nextColumnIndex);
        // Check bounds
        if(nextRowIndex  < 0 ||
        nextRowIndex > SIZE  ||
        nextColumnIndex  < 0 ||
        nextColumnIndex > SIZE )
        {
            printf("returning false out of bound\n");
            return false;
        }

        if (matrix [nextRowIndex * SIZE + nextColumnIndex] != find [i])
        {
            printf("returning false\n");
            return false;
        }

    }

    printf("returning true\n");
    return true;
}

bool Search(char* matrix, char* find, int length)
{
    // Find start
    // For each start candidate, serach all possible direction

    printf("%s %d\n", find, length);
    bool found = false;
    for (int i = 0; i < SIZE; i++)
    {
        for(int j= 0; j< SIZE; j++)
        {
            if ( matrix[i*SIZE + j] == find[0] )
                {
                    printf("%d %d\n", i, j);
                     found = SearchGivenStart(matrix,
                     find,
                     length,
                     i,
                     j,
                     Direction::Left);
                     if (found)
                        return true;

                     found = SearchGivenStart(matrix,
                     find,
                     length,
                     i,
                     j,
                     Direction::Right);
                     if (found)
                        return true;
                     found = SearchGivenStart(matrix,
                     find,
                     length,
                     i,
                     j,
                     Direction::Up);
                     if (found)
                        return true;
                     found = SearchGivenStart(matrix,
                     find,
                     length,
                     i,
                     j,
                     Direction::Down);
                     if (found)
                        return true;
                }
        }
    }
    return found;
}

bool adjacentSearch(char* matrix, char* find, int i, int j, int index){
    if(index == strlen(find))
        return true;

    if(i < 0 || j < 0 || i > SIZE-1 || j > SIZE - 1){
        return true;
    }

    if(matrix[i *SIZE + j] != find[index]){
        return false;
    }

    matrix[i*SIZE + j] = '*';

    bool searchFurther = adjacentSearch(matrix, find, i+1, j, index+1) || adjacentSearch(matrix, find, i-1, j, index+1) || adjacentSearch(matrix, find, i, j-1, index+1) || adjacentSearch(matrix, find, i, j+1, index+1);

    matrix[i * SIZE + j] = find[index];
    return searchFurther;
}

bool exist(char* matrix, char* find, int r, int c){
    int len = strlen(find);

    if(len > r * c)
        return false;

    for(int i=0; i<SIZE; i++){
        for(int j=0; j<SIZE; j++){
            if(matrix[i*SIZE + j] == find[0]){
                if(adjacentSearch(matrix, find, i, j, 0)){
                    return true;
                }
            }
        }
    }
    return false;
}


// Driver
int main(){
    char matrix[SIZE][SIZE];
    char word[MAX] = "SOKK";

    printBoard((char *)matrix);

    printf("\nThink of a word> ");
    fgets(word, MAX, stdin);
    printf("word: %s", word);

   /*if(exist((char *)matrix, word, SIZE, SIZE)){
        printf("Found\n");
   }*/
   if(Search((char *)matrix, word, strlen(word)))
      {
          printf("%s Found\n", word);
      }
    /*if(found)
    {
        printf("%s Found\n", word);
    }*/
    else{
        printf("%s Not Found\n", word);
    }
    return 0;
}

#包括
#包括
#包括
#包括
#定义尺寸6
#定义最大值10
//typedef枚举{true，false}bool；
//用随机字符画黑板
空心板（字符*矩阵）{
int i，j；
对于（i=0；i尺寸-1）{
返回true；
}
if（矩阵[i*SIZE+j]！=查找[索引]）{
返回false；
}
矩阵[i*SIZE+j]='*'；
布尔搜索进一步=邻接搜索（矩阵，查找，i+1，j，索引+1）|邻接搜索（矩阵，查找，i-1，j，索引+1）|邻接搜索（矩阵，查找，i，j-1，索引+1）|邻接搜索（矩阵，查找，i，j+1，索引+1）；
矩阵[i*SIZE+j]=查找[索引]；
进一步返回搜索；
}
布尔存在（字符*矩阵，字符*查找，整数r，整数c）{
int len=strlen（查找）；
if（len>r*c）
返回false；
对于（int i=0；i代码中存在多个问题：


true
和
false
的定义不正确：您应该写：

typedef enum { false, true } bool;


不能通过
fgets（）
去除缓冲区中剩余的尾随换行符。程序找不到该单词，因为该换行符不在矩阵中。请使用以下命令删除此字符：

word[strcspn(word, "\n")] = '\0';


测试
j>strlen（矩阵[0]）-1
不正确：您应该测试
j>=SIZE
，以验证坐标是否在矩阵内

当
i
或
j
在矩阵之外时，
adjacentSearch（）
应返回false


以下是更正的版本：

#包括
#包括
#包括
#包括
#定义尺寸6
#定义最大值40
typedef枚举{false，true}bool；
//用随机字符画黑板
空心板（字符矩阵[尺寸][尺寸]）{
对于（int i=0；i=SIZE | | | j>=SIZE | |矩阵[i][j]！=find[index]）
返回false；
矩阵[i][j]='*'；
boolfound=（邻接搜索（矩阵，find，i+1，j，索引+1）||
邻接搜索（矩阵，查找，i-1，j，索引+1）||
邻接搜索（矩阵，查找，i，j-1，索引+1）||
邻接搜索（矩阵，查找，i，j+1，索引+1）；
矩阵[i][j]=查找[索引]；
发现退货；
}
布尔存在（字符矩阵[SIZE][SIZE]，常量字符*查找）{
int len=strlen（查找）；
如果（透镜>尺寸*尺寸）
返回false；
对于（int i=0；i