7×7 Bingo游戏C语言程序获胜后无法终止问题求助

完整代码 #

// Bingo Game

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#define SPN 7
#define BTT 99 
#define MARKER 'X'


//Player functions
void create_card_game(int matriz[SPN][SPN]);
int create_random_number(int released_numbers[SPN*SPN], int released_numbers_count);
bool iguality_hunter_matriz(int released_numbers[SPN*SPN], int released_numbers_count, int random_number);

// Roulette functions
void create_roulette(int lista[BTT]);
int create_roulette_numbers(int roulette_released_numbers[BTT], int roulette_released_numbers_count);
bool iguality_hunter_list(int roulette_released_numbers[BTT], int roulette_released_numbers_count, int roulette_numbers);

//print functions
void print_card(int matriz[SPN][SPN], int list[BTT], int i);

//checks win
bool win_coll(int matriz[SPN][SPN]);
bool win_arow(int matriz[SPN][SPN]);


// Matriz functions, Card Game side 
int create_random_number(int released_numbers[SPN*SPN], int released_numbers_count)
{
    int random_number;
    do
    {
        random_number=rand()%100;
    }
    while(iguality_hunter_matriz(released_numbers, released_numbers_count, random_number));
    
    return random_number;
}



void create_card_game(int matriz[SPN][SPN])
{
    int released_numbers[SPN*SPN];
    int released_numbers_count = 0;
    int random_number;
    for(int i=0; i<SPN; i++)
        for(int j=0; j<SPN; j++)
        {
            random_number = create_random_number(released_numbers, released_numbers_count);
            matriz[i][j] = random_number;
            released_numbers[released_numbers_count] = random_number;
            released_numbers_count++;
        }
}



bool iguality_hunter_matriz(int released_numbers[SPN*SPN], int released_numbers_count, int random_number)
{
    for(int i=0; i<released_numbers_count; i++)
    {
        if (released_numbers[i] == random_number)
            return true;
    }
    return false;
}



// Lists functions, roulette side 
int create_roulette_numbers(int roulette_released_numbers[BTT], int roulette_released_numbers_count)
{
    int roulette_numbers;
    do
    {
        roulette_numbers=rand()%100;
    }
    while(iguality_hunter_list(roulette_released_numbers, roulette_released_numbers_count, roulette_numbers));
    
    return roulette_numbers;
}



bool iguality_hunter_list(int roulette_released_numbers[BTT], int roulette_released_numbers_count, int roulette_numbers)
{
    for(int i=0; i<roulette_released_numbers_count; i++)
    {
        if (roulette_released_numbers[i] == roulette_numbers)
            return true;
    }
    return false;
}



void create_roulette(int lista[BTT])
{
    int roulette_released_numbers[BTT];
    int roulette_released_numbers_count = 0;
    int roulette_numbers;
    for(int i=0; i<BTT; i++)
    {
        roulette_numbers = create_roulette_numbers(roulette_released_numbers, roulette_released_numbers_count);
        lista[i] = roulette_numbers;
        roulette_released_numbers[roulette_released_numbers_count] = roulette_numbers;
        roulette_released_numbers_count++;
    }
}


// print both
void print_card(int matriz[SPN][SPN], int list[BTT], int i)
{
    for(int i=0; i<BTT; i++)
    {
        printf("\n");
        for(int j=0; j<SPN; j++)
        {
            for(int n=0; n<SPN; n++)
            {
                if(matriz[j][n] == 88 || matriz[j][n] == list[i])
                {
                    matriz[j][n]=MARKER;
                    printf("|");
                    printf("%2c", matriz[j][n]);
                }
                else
                {
                    printf("|");
                    printf("%2d", matriz[j][n]);
                }
            }
            printf("|\n");
        }
        printf("\n");
        printf(" e o numero escolhido e: %2d", list[i]);
        printf("\n");
        getchar();
    }
}


// verify victory
bool win_coll(int matriz[SPN][SPN])
{
    int i=0;
    for(int j=0; j<SPN; j++)
    {
        if(matriz[i][j]==88 && matriz[i+1][j]==88 && matriz[i+2][j]==88 && matriz[i+3][j]==88 && matriz[i+4][j]==88 && matriz[i+5][j]==88 && matriz[i+6][j]==88) 
        {    
            return true;
        }
    }
    return false;
}



bool win_arow(int matriz[SPN][SPN])
{
    int j=0;
    for(int i=0; i<SPN; i++)
    {
        if(matriz[i][j]==88 && matriz[i][j+1]==88 && matriz[i][j+2]==88 && matriz[i][j+3]==88 && matriz[i][j+4]==88 && matriz[i][j+5]==88 && matriz[i][j+6]==88)
        {
            return true;
        }
    }
    return false;
}


int main()
{
    int card_game_player[SPN][SPN];
    int roulette[BTT];
    
    srand(time(NULL));
    
// Create Player 1 and Player 2 Matriz
    create_card_game(card_game_player);   

// Create Roulette List 
    create_roulette(roulette);

// Print Player 1 and Player 2 Card Game     
    for(int n=0; n<BTT; n++)
    {
        print_card(card_game_player, roulette, n);
        if(win_arow(card_game_player) || win_coll(card_game_player))
        {
            printf("vitoria");
            break;
        }
    }
    return 0;
}

功能模块说明 #

• 生成不重复随机数（依赖iguality_hunter_matriz函数去重）
• 创建存储随机数的游戏卡片矩阵
• 检测矩阵内重复数字
• 为轮盘列表生成不重复随机数
• 检测轮盘列表内重复数字
• 创建完整的轮盘随机数列表
• 打印卡片与轮盘数字，匹配数字标记为X
• 检测列全标记的获胜条件
• 检测行全标记的获胜条件

问题描述 #

当前代码中，当win_arow或win_coll函数判定玩家满足获胜条件时，程序并未终止，仍会继续遍历所有轮盘数字。

问题根源与修复 #

核心问题 #

print_card函数内部存在独立的for(int i=0; i<BTT; i++)循环，会一次性跑完所有99个轮盘数字。而main函数的获胜检测要等到print_card执行完所有迭代后才会触发一次，完全失去了中途终止程序的机会。

修复方案 #

1. 修复print_card函数

移除内部循环，改为仅处理当前传入的轮盘数字索引，让main的循环控制迭代流程：

void print_card(int matriz[SPN][SPN], int list[BTT], int idx)
{
    printf("\n");
    for(int j=0; j<SPN; j++)
    {
        for(int n=0; n<SPN; n++)
        {
            if(matriz[j][n] == MARKER || matriz[j][n] == list[idx])
            {
                matriz[j][n] = MARKER;
                printf("|");
                printf("%2c", matriz[j][n]);
            }
            else
            {
                printf("|");
                printf("%2d", matriz[j][n]);
            }
        }
        printf("|\n");
    }
    printf("\n");
    printf(" 选出的数字是: %2d", list[idx]);
    printf("\n");
    getchar();
}

2. 优化获胜检测函数

替换硬编码的88为MARKER，改用循环遍历行列，代码更简洁且适配SPN的修改：

bool win_coll(int matriz[SPN][SPN])
{
    for(int j=0; j<SPN; j++)
    {
        bool col_win = true;
        for(int i=0; i<SPN; i++)
        {
            if(matriz[i][j] != MARKER)
            {
                col_win = false;
                break;
            }
        }
        if(col_win) return true;
    }
    return false;
}

bool win_arow(int matriz[SPN][SPN])
{
    for(int i=0; i<SPN; i++)
    {
        bool row_win = true;
        for(int j=0; j<SPN; j++)
        {
            if(matriz[i][j] != MARKER)
            {
                row_win = false;
                break;
            }
        }
        if(row_win) return true;
    }
    return false;
}

修复说明 #

• print_card改为单次处理一个轮盘数字，让main的循环可以在每次打印后立即检测获胜条件，满足时直接终止程序。
• 获胜检测函数用循环替代硬编码判断，提升代码可维护性。
• 用MARKER替代硬编码的ASCII值，增强代码可读性。

预期输出示例 #

|55|22|40|11|38|56|73|
|89|17|27|13|72|68|43|
|94|82|70|48|24| 2|47|
|34|79| 5|44|30|81|98|
| X| X| X| X| X| X| X|
|87| 6|95| 0|63|58|37|
|92|59|14| 3|93|23|76|

 选出的数字是: 97

内容的提问来源于stack exchange，提问作者David feoerwg