c语言实现简单递归扫雷

最新推荐文章于 2024-09-10 17:22:42 发布
最新推荐文章于 2024-09-10 17:22:42 发布
阅读量111 收藏
点赞数
文章标签： c语言 学习 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74461263/article/details/128768624
版权

一、前言

游戏说明

  1. 选择是否开始游戏

  1. 输入对应的横纵坐标 x y （含输入合法性检查）

  1. 坐标为（x , y）的点显示周围地雷的数量

  1. 可自定义界面大小和地雷数量

游戏效果

二、实现步骤

    • 头文件，宏定义，全局变量及函数说明

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
#include<time.h>


#define ROW 9
#define COL 9
#define COLS COL+2
#define ROWS ROW+2
#define COUNT 10


//初始化棋盘
void init_board(char board[ROWS][COLS], int rows, int cols,char set);
//显示棋盘
void display_board(char board[ROWS][COLS], int row, int col);
//布置雷
void set_mine(char board[ROWS][COLS], int row, int col);
//统计雷
int get_mine_cout(char mine[ROWS][COLS], int x, int y);
//排查雷
void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
//递归排雷
void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int* win);
//显示地雷位置，排雷成功或被炸死后 向玩家展示地雷位置
void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

    • 函数说明

初始化雷盘
初始化show，mine两个数组，show 存放 '*' , mine存放 '0' 
void init_board(char board[ROWS][COLS], int rows, int cols,char set)
{
    int i, j;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board[i][j] = set;
        }
    }

}
打印雷盘
void display_board(char board[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    printf("|");
    for (i = 0; i <= row; i++)
    {
        printf(" %d |", i);
    }
    printf("\n");
    printf("|");
    for (j = 0; j <= col; j++)
    {
        printf("---|");
    }
    printf("\n");
    for (i = 1; i<=row; i++)
    {
        printf("|");
        printf(" %d ", i);
        printf("|");
        for (j = 1; j <= col; j++)
        {
            
            printf(" %c ", board[i][j]);    
            printf("|");
        }
        printf("\n");
        printf("|");
        for (j = 0; j <=col; j++)
        {
            printf("---|");
        }
        printf("\n");
    }
}
随机布置雷
随机布置雷，将mine中的 '0' 改为 '1' 
void set_mine(char board[ROWS][COLS], int row, int col)
{
    int count = COUNT;
    while (count)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0')
        {
            board[x][y] = '1';
            count--;
        }
    }
}
获取坐标周围雷数
计算该坐标在mine中 周围 '1'的个数 
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
    return (mine[x - 1][y] +
        mine[x - 1][y - 1] +
        mine[x][y - 1] +
        mine[x + 1][y - 1] +
        mine[x + 1][y] +
        mine[x + 1][y + 1] +
        mine[x][y + 1] +
        mine[x - 1][y + 1] - 8 * '0');
}
递归展开
当这个格子周围没雷时，显示空白，然后继续递归它周围的八个格子
有雷时，显示雷数，停止递归。 
void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
{
    if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
    {
        int count = get_mine_count(mine, x, y);//获得雷数
        if (count == 0)//四周无雷，递归展开
        {
这里定义了一个 win 来表示翻开的格子数，当翻开的格子数量 = 行 x 列 - 雷数 ===> 排雷成功。            show[x][y] = ' ';
            int i = 0;
            //向周围八个方向展开
            for (i = x - 1; i <= x + 1; i++)
            {
                int j = 0;
                for (j = y - 1; j <= y + 1; j++)
                {
                    //只对 '*' 进行展开，防止死循环
                    if (show[i][j] == '*')
                    {
                        expand(mine, show, i, j, win);
                    }
                }
            }
        }
        else
        {
            show[x][y] = count + '0';
        }
        (*win)++;
    }
}
胜负判断
这里定义了一个 win 来表示翻开的格子数，当翻开的格子数量 = 行 x 列 - 雷数 ===> 排雷成功。 
void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int win = 0;//初始化 翻开的格子数量

    while (win<row*col-COUNT)
    {
        printf("请输入要排查的坐标:>");
        int x, y;
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (mine[x][y] == '1')
            {
                printf("你被炸死了\n");
                display_board(show, ROW, COL);
                break;
            }
            else
            {
                expand(mine, show, x, y, &win);
                display_board(show, ROW, COL);
            }
        }
        else
        {
            printf("排查坐标非法\n");
        }
    }
    if (win == row * col - COUNT)
    {
        printf("排雷成功\n");
    }
}
游戏结束显示雷位置
void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int i = 0;
    for (i = 1; i <= row; i++)
    {
        int j = 0;
        for (j = 1; i <= col; j++)
        {
            if (mine[i][j] == '1')
            {
                show[i][j] = '@';
            }
        }
    }
     display_board(show,row,col);
}

3.主函数

颜色设置
//0 = 黑色                8 = 灰色　　
//1 = 蓝色                9 = 淡蓝色        十六进制
//2 = 绿色                10 = 淡绿色        A
//3 = 湖蓝色              11 = 淡浅绿色      B　
//4 = 红色                12 = 淡红色        C　　
//5 = 紫色                13 = 淡紫色        D
//6 = 黄色                14 = 淡黄色        E
//7 = 白色                15 = 亮白色        F

void color(short x)
{
    if (x >= 0 && x <= 15)
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);
    else
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
菜单
void menu()
{
    //color(0);       //Black 黑色
    //system("cls");    //清屏.
    color(14);
    printf("|-----------|扫雷游戏|-----------|\n");
    printf("|********************************|\n");
    printf("|★★★★★★★★★★★★★★★★|\n");
    printf("|★★   1.开始  0.退出       ★★|\n");
    printf("|★★★★★★★★★★★★★★★★|\n");
    printf("|0 = 不是雷 ---------- 1 = 它是雷|\n");
    printf("|--------------------------------|\n");

}
游戏
void game()
{
    //定义键盘
    char mine[ROWS][COLS] = { 0 };//布置雷
    char show[ROWS][COLS] = { 0 };//扫雷
    //初始化键盘
    init_board(mine, ROWS, COLS,'0');
    init_board(show, ROWS, COLS,'*');
    //显示棋盘
    display_board(show, ROW, COL);
    //布置雷
    set_mine(mine, ROW, COL);
    //printf("\n");
    //display_board(mine, ROW, COL);
    //排查雷
    find_mine(mine, show, ROW, COL);

}
主函数输入
int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏");
            break;
        default:
            printf("请重新选择");
            break;
        }
    } while (input);
}

三、游戏完整代码

game.h

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
#include<time.h>


#define ROW 9
#define COL 9
#define COLS COL+2
#define ROWS ROW+2
#define COUNT 10

//初始化棋盘
void init_board(char board[ROWS][COLS], int rows, int cols,char set);
//显示棋盘
void display_board(char board[ROWS][COLS], int row, int col);
//布置雷
void set_mine(char board[ROWS][COLS], int row, int col);
//统计雷
int get_mine_cout(char mine[ROWS][COLS], int x, int y);
//排查雷
void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
//递归排雷
void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int* win);
//void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y, int* win);
// 
//显示地雷位置，排雷成功或被炸死后 向玩家展示地雷位置
void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

game.c

#define _CRT_SECURE_NO_WARNINGS
#include"game.h"

void init_board(char board[ROWS][COLS], int rows, int cols,char set)
{
    int i, j;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board[i][j] = set;
        }
    }

}

void display_board(char board[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    printf("|");
    for (i = 0; i <= row; i++)
    {
        printf(" %d |", i);
    }
    printf("\n");
    printf("|");
    for (j = 0; j <= col; j++)
    {
        printf("---|");
    }
    printf("\n");
    for (i = 1; i<=row; i++)
    {
        printf("|");
        printf(" %d ", i);
        printf("|");
        for (j = 1; j <= col; j++)
        {
            
            printf(" %c ", board[i][j]);    
            printf("|");
        }
        printf("\n");
        printf("|");
        for (j = 0; j <=col; j++)
        {
            printf("---|");
        }
        printf("\n");
    }
}

void set_mine(char board[ROWS][COLS], int row, int col)
{
    int count = COUNT;
    while (count)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0')
        {
            board[x][y] = '1';
            count--;
        }
    }
}

int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
    return (mine[x - 1][y] +
        mine[x - 1][y - 1] +
        mine[x][y - 1] +
        mine[x + 1][y - 1] +
        mine[x + 1][y] +
        mine[x + 1][y + 1] +
        mine[x][y + 1] +
        mine[x - 1][y + 1] - 8 * '0');
}

void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
{
    if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
    {
        int count = get_mine_count(mine, x, y);//获得雷数
        if (count == 0)//四周无雷，递归展开
        {
            show[x][y] = ' ';
            int i = 0;
            //向周围八个方向展开
            for (i = x - 1; i <= x + 1; i++)
            {
                int j = 0;
                for (j = y - 1; j <= y + 1; j++)
                {
                    //只对 '*' 进行展开，防止死循环
                    if (show[i][j] == '*')
                    {
                        expand(mine, show, i, j, win);
                    }
                }
            }
        }
        else
        {
            show[x][y] = count + '0';
        }
        (*win)++;
    }
}


void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int win = 0;//初始化 翻开的格子数量

    while (win<row*col-COUNT)
    {
        printf("请输入要排查的坐标:>");
        int x, y;
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (mine[x][y] == '1')
            {
                printf("你被炸死了\n");
                display_board(show, ROW, COL);
                break;
            }
            else
            {
                expand(mine, show, x, y, &win);
                display_board(show, ROW, COL);
            }
        }
        else
        {
            printf("排查坐标非法\n");
        }
    }
    if (win == row * col - COUNT)
    {
        printf("排雷成功\n");
    }
}

void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int i = 0;
    for (i = 1; i <= row; i++)
    {
        int j = 0;
        for (j = 1; i <= col; j++)
        {
            if (mine[i][j] == '1')
            {
                show[i][j] = '@';
            }
        }
    }
     display_board(show,row,col);
}

main.c

#define _CRT_SECURE_NO_WARNINGS
#include"game.h"

//0 = 黑色                8 = 灰色　　
//1 = 蓝色                9 = 淡蓝色        十六进制
//2 = 绿色                10 = 淡绿色        A
//3 = 湖蓝色              11 = 淡浅绿色      B　
//4 = 红色                12 = 淡红色        C　　
//5 = 紫色                13 = 淡紫色        D
//6 = 黄色                14 = 淡黄色        E
//7 = 白色                15 = 亮白色        F

void color(short x)
{
    if (x >= 0 && x <= 15)
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);
    else
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}

void menu()
{
    //color(0);       //Black 黑色
    //system("cls");    //清屏.
    color(14);
    printf("|-----------|扫雷游戏|-----------|\n");
    printf("|********************************|\n");
    printf("|★★★★★★★★★★★★★★★★|\n");
    printf("|★★   1.开始  0.退出       ★★|\n");
    printf("|★★★★★★★★★★★★★★★★|\n");
    printf("|0 = 不是雷 ---------- 1 = 它是雷|\n");
    printf("|--------------------------------|\n");

}

void game()
{
    //定义键盘
    char mine[ROWS][COLS] = { 0 };//布置雷
    char show[ROWS][COLS] = { 0 };//扫雷
    //初始化键盘
    init_board(mine, ROWS, COLS,'0');
    init_board(show, ROWS, COLS,'*');
    //显示棋盘
    display_board(show, ROW, COL);
    //布置雷
    set_mine(mine, ROW, COL);
    //printf("\n");
    //display_board(mine, ROW, COL);
    //排查雷
    find_mine(mine, show, ROW, COL);

}

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏");
            break;
        default:
            printf("请重新选择");
            break;
        }
    } while (input);
}

niu_sama
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（C语言）—— -1递归：gray码
<Hunter>
06-15 709
gray码C语言实现
格雷码转十进制 c语言,格雷码的转换方法
weixin_42502016的博客
05-19 2813
这种方法基于格雷码是反射码的事实，利用递归的如下规则来构造： 1位格雷码有两个码字 (n+1)位格雷码中的前2n个码字等于n位格雷码的码字，按顺序书写，加前缀0 (n+1)位格雷码中的后2n个码字等于n位格雷码的码字，按逆序书写，加前缀1 n+1位格雷码的集合 = n位格雷码集合(顺序)加前缀0 + n位格雷码集合(逆序)加前缀1 2位格雷码3位格雷码4位格雷码4位自然二进制码0001...
c语言格雷算法递归,数据结构与算法-LeetCode 格雷编码(No.89)
weixin_34109927的博客
05-24 149
LeetCode 89. 格雷编码格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。第一个数与最后一位数 也只差以为一位数 ‘首尾相连’ 所以又称为循环码或反射码示例 1:输入: 2输出: [0,1,3,2]解释:00 - 001 - 111 - 310 - 2对于给定的 n，其...
格雷码的递归输出
z474263814的专栏
09-08 496
格雷码递归输出
格雷码（多种方法）
u012067392的专栏
05-31 831
class GrayCode { public: vector getGray1(int n) { vectorv; if(n<=0)return v; int num=pow(2,n); for(int i=0;i<num;i++) { string vi;
C语言实现简单扫雷
qq_43632625的博客
05-22 1277
相信大家都玩过扫雷吧，以前机房上机，无聊的时候就开始玩扫雷和蜘蛛纸牌，有时候能玩好久好久。那今天，我们就来写一个简易的扫雷游戏吧！ 和三子棋游戏一样，我们先把它需要的游戏功能列出来： （1）void Menu();菜单 （2）void Game();游戏框架 （3）int GetRandIndex(int start, int end);随机生成雷的下标 （4）void SetMines(char...
C语言实现自定义扫雷（递归版）
Caco
04-17 3184
实现过程 对于用C语言实现扫雷游戏得实现，可将游戏过程分为两个板块。 实现游戏关键功能得函数 搭建合理得游戏过程 实现游戏关键功能 为了将游戏功能方便管理和键入，首先我们创建一个头文件，mine.h对游戏功能进行声明。 然后创建对应的源文件 mine.c对这些函数进行定义。 对于游戏功能，我们首先想到的是构建一个目标规格的雷盘，也就是二维数组。 为了使游戏更...
C语言扫雷（递归展开）（详细注释）（完整代码）
AAAAA_9的博客
08-02 8344
c语言扫雷游戏
C语言实现简单扫雷小游戏
08-25
在本篇介绍中，我们将探讨如何使用C语言实现一个简单的扫雷小游戏。扫雷游戏是一种经典的游戏，旨在训练玩家的空间推理和逻辑能力。通过提供的代码片段，我们可以看到以下几个关键知识点： 1. **游戏菜单**： 游戏...
C语言实现扫雷游戏及其优化
08-25
C语言实现扫雷游戏及其优化 本文将详细介绍C语言实现扫雷游戏及其优化，具体包括游戏的设计思想、实现代码和优化方法。 游戏设计思想 扫雷游戏的设计思想是使用两个二维数组，一个用于显示，一个用于后台雷的布置...
【扫雷游戏】C语言 用递归实现扫雷游戏
m0_57549888的博客
04-23 2481
用递归实现扫雷游戏
linux简易扫雷c语言代码,C语言实现简易版扫雷的完整过程
05-19
下面是一个简单的 Linux 下扫雷游戏的 C 语言代码： ```c #include #include #include #define MINE -1 #define UNOPENED 9 #define FLAG 10 int ROW, COL, MINES, UNOPENED_COUNT; int **board; int **...
【keda编程】#P0648. [CSP-S2019] 格雷码
kivyp的博客
08-17 217
咳咳，虽然是CSP-S的题，不过也挺水的，学了算法的都会。
C++ 数学与算法系列之认识格雷码
y6123236的专栏
12-06 2096
程序中所涉及到的任何数据，计算机底层均需转换成二进制数值后方可存储，这个过程也称为。反之，把底层二进制数据转换成应用数据称为解码，不同的数据类型需要不同的编（解）码方案，如音频数据编码、视频数据编码、图形数据编码……即使是同类型的数据，根据不同的应用场景，也有多种编码方案可选。如字符编译就有以及本文将要讲解的。讲解之前，首先了解一下的定义：格雷码的优点：一种编码的出现，一定是为了弥补已有编码的不足，这里以编码中的字符的码值开始研究：的编码是，的编码是。从宏观的计数角度而言，计数增长仅为，但是有 个数据位发
C语言---循环程序设计万字总结（2）
Wanyu667的博客
09-05 1198
break语句不仅可以流程跳出switch结构，继续执行switch语句后的内容，还可以让流程跳出循环体，即提前跳出循环体。switch(整形表达式)case 整型常量表达式:break;while()语句;break;for()语句;break;break语句的一般形式就是break;它的作用就是让流程跳出循环体之外，结束本次循环。
C语言从头学55——学习头文件errno.h、float.h
m0_72128260的博客
09-03 997
学习头文件errno.h、float.h中的相关宏。
iomuxc、pinctrl子系统、gpio子系统（学习总结）
weixin_61385844的博客
09-04 964
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
区块链学习笔记2--区块链技术的形成 以太坊
最新发布
weixin_61074128的博客
09-10 250
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 836
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值