• C语言学习-数组应用-扫雷（4.2）

    目录

    扫雷的设计思路：

    1. 游戏菜单功能的实现

     2. 游戏功能具体实现

    2.1 初始化存放与排查雷的信息

    2.2 扫雷地图的初始化与打印

    2.2.1 初始化布雷与排雷地图的实现：

    2.2.2 打印扫雷地图的实现：

    2.3 布置雷的信息

     2.3.1 布置雷信息的具体实现：

    2.4 玩家排雷的信息

    2.4.1 玩家排雷的具体实现

    2.4.2 递归排空的具体实现

    2.4.3 计算格子周围有多少颗地雷的具体实现

    2.4.4 判断输赢的函数的具体实现

    2.4.5 被雷炸死后的惩罚的具体实现

    3. 游戏测试：

    4. 扫雷源码

    写在最后：

    扫雷的设计思路：

    我们创建三个文件拆分扫雷的实现过程：

    一个测试文件（test.c）游戏实现文件（game.c）头文件（game.h）

    我们先对测试文件进行编辑。

    其实扫雷的设计思路是与三字棋相通的。

    1. 游戏菜单功能的实现

    在 test.c 中写一个主函数：

    1. int main()//主函数中的代码量较少
    2. {
    3. 	test();//我们通过分装一个函数实现全过程
    4. 	return 0;
    5. }

    我们通过刚刚创建的 test 函数实现一些功能：

    1. 玩一把不过瘾，能再玩一把

    2. 创建游戏菜单

    3. 创建扫雷游戏实现函数

    1. void test()
    2. {
    3. 	int choice = 0;
    4. 	do //我们使用一个do while循环，如果玩一把扫雷不过瘾，可以再玩一把
    5. 	{
    6. 		menu();//创建游戏菜单
    7. 		printf("请输入:>");
    8. 		scanf("%d", &choice);//接收玩家输入的值
    9. 		switch (choice)
    10. 		{
    11. 		case 1:
    12. 			printf("扫雷惊魂游戏开始\n");
    13. 			game();//我们将游戏的实现分装成一个函数
    14. 			break;
    15. 		case 0:
    16. 			printf("游戏已退出\n");
    17. 			break;
    18. 		default:
    19. 			printf("输入错误，请重新输入\n");
    20. 			break;
    21. 		}
    22. 	} while (choice);
    23. }

    这是我们的游戏菜单：

    1. void menu()
    2. {
    3. 	printf("*****************************************\n");
    4. 	printf("************** 扫 雷 惊 魂 **************\n");
    5. 	printf("*****************************************\n");
    6. 	printf("******* 开始游戏：1  退出游戏：0 ********\n");
    7. 	printf("*****************************************\n");
    8. }

    写到这里，我们可以先测试一下代码运行的结果：

    （注：如果有错误可以及时纠正，以防写到最后运行错误却难以查找）

    这样，我们就完成了菜单逻辑的制作。 

     2. 游戏功能具体实现

    接下来我们要具体实现函数 game 。

    实现思路：

    2.1 初始化存放与排查雷的信息

    通过思考，我打算创建一个标准的9*9的扫雷地图

    需要创建两个数组进行操作：

    1. 一个存放埋雷的信息，是隐藏的

    2. 另一个存放玩家排查的信息，是给玩家提示的

    我们在头文件中用#define定义常量，便于日后观察或修改、

    再在测试文件中引用：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"//引用自己的头文件
    4.  
    5. void game()  //排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
    6. {            //扫雷地图的大小从 9*9 -> 11*11
    7. 	char mine[ROWS][COLS] = { 0 }; //初始化布置雷的信息
    8. 	char show[ROWS][COLS] = { 0 }; //初始化排查雷的信息
    9. }

    2.2 扫雷地图的初始化与打印

    接下来我们需要将扫雷地图进行初始化和打印：

    我们可以分装成两个函数进行实现：

    1. void game()  //排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
    2. {            //扫雷地图的大小从 9*9 -> 11*11
    3. 	char mine[ROWS][COLS] = { 0 }; //初始化布置雷的信息
    4. 	char show[ROWS][COLS] = { 0 }; //初始化排查雷的信息
    5.  
    6. 	//初始化扫雷地图
    7. 	InitBoard(mine, ROWS, COLS, '0');//初始化布雷的地图
    8. 	InitBoard(show, ROWS, COLS, '*');//初始化排雷的地图
    9.  
    10. 	//打印扫雷地图
    11. 	PrintBoard(show, ROW, COL);//打印的式给玩家看的，用于排雷的地图
    12. }
    13.

    2.2.1 初始化布雷与排雷地图的实现：

    1. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    2. {
    3. 	int i = 0;
    4. 	for (i = 0; i < rows; i++)
    5. 	{
    6. 		int j = 0;
    7. 		for (j = 0; j < cols; j++)
    8. 		{
    9. 			board[i][j] = set;//将布置雷的数组初始化成‘0’
    10. 		}                     //将排雷的数组（玩家看到的）布置成‘*’
    11. 	}
    12. }

    2.2.2 打印扫雷地图的实现：

    1. void PrintBoard(char board[ROWS][COLS], int row, int col)
    2. {
    3. 	printf(" ------扫雷惊魂------\n");//添加头尾（美观）
    4. 	printf(" --------------------\n|");
    5. 	int i = 0;
    6. 	for (i = 0; i <= col; i++)
    7. 	{
    8. 		printf("%d ", i);//打印横坐标
    9. 	}
    10. 	printf("|\n");
    11. 	for (i = 1; i <= row; i++)
    12. 	{
    13. 		int j = 1;
    14. 		printf("|%d ", i);//打印纵坐标
    15. 		for (j = 1; j <= col; j++)
    16. 		{
    17. 			printf("%c ", board[i][j]);//打印扫雷地图
    18. 		}
    19. 		printf("|");//添加边框（美观）
    20. 		printf("\n");
    21. 	}
    22. 	printf(" --------------------\n");
    23. 	printf(" -地图 碎片大厦的回忆-\n");
    24. }

    记得在头文件 game.h 中引用：

    1. //初始化地图
    2. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    3. //打印地图
    4. void PrintBoard(char board[ROWS][COLS], int row, int col);

    最后呈现出的效果是：

    接下来我们就要布置雷了：

    2.3 布置雷的信息

    我们需要分装一个函数进行实现：

    1. void game()  //排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
    2. {            //扫雷地图的大小从 9*9 -> 11*11
    3. 	char mine[ROWS][COLS] = { 0 }; //初始化布置雷的信息
    4. 	char show[ROWS][COLS] = { 0 }; //初始化排查雷的信息
    5.  
    6. 	//初始化扫雷地图
    7. 	InitBoard(mine, ROWS, COLS, '0');//初始化布雷的地图
    8. 	InitBoard(show, ROWS, COLS, '*');//初始化排雷的地图
    9.  
    10. 	//打印扫雷地图
    11. 	PrintBoard(show, ROW, COL);//打印的式给玩家看的，用于排雷的地图
    12. 	
    13. 	//布置雷的信息
    14. 	SetMine(mine, ROW, COL);//悄悄地布置
    15.  
    16. }

     2.3.1 布置雷信息的具体实现：

    1. void SetMine(char mine[ROWS][COLS], int row, int col)
    2. {
    3. 	int count = MINE_NUMBER;
    4. 	while (count)
    5. 	{
    6. 		//生成随机下标
    7. 		int x = rand() % row + 1;//生成1~9之间的数
    8. 		int y = rand() % col + 1;
    9. 		//布置雷
    10. 		if (mine[x][y] == '0')
    11. 		{
    12. 			mine[x][y] = '1';
    13. 			count--;
    14. 		}
    15. 	}
    16. }

    在头文件中引用：

    1. #include 
    2. #include 
    3.  
    4. #define MINE_NUMBER 10 //定义雷的数量
    5.  
    6. //布置雷的信息
    7. void SetMine(char mine[ROWS][COLS], int row, int col);

    我们可以将埋雷的信息打印出来，查看是否有误：

    仔细一数，确实埋了10个雷。

    接下来，就到了玩家排雷的环节

    2.4 玩家排雷的信息

    我们需要分装一个函数进行实现：

    1. void game()  //排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
    2. {            //扫雷地图的大小从 9*9 -> 11*11
    3. 	char mine[ROWS][COLS] = { 0 }; //初始化布置雷的信息
    4. 	char show[ROWS][COLS] = { 0 }; //初始化排查雷的信息
    5.  
    6. 	//初始化扫雷地图
    7. 	InitBoard(mine, ROWS, COLS, '0');//初始化布雷的地图
    8. 	InitBoard(show, ROWS, COLS, '*');//初始化排雷的地图
    9.  
    10. 	//打印扫雷地图
    11. 	PrintBoard(show, ROW, COL);//打印的式给玩家看的，用于排雷的地图
    12.  
    13. 	//布置雷的信息
    14. 	SetMine(mine, ROW, COL);//悄悄地布置
    15. 	//PrintBoard(mine, ROW, COL);//打印埋雷信息出来，观察一下
    16.  
    17. 	//排查雷
    18. 	FindMine(mine, show, ROW, COL);//目标是实现排雷时，能自动排空,并能判断输赢
    19. }

    2.4.1 玩家排雷的具体实现

    函数之间是一环扣一环的：

    我们通过函数的嵌套一步步完善功能，

    1. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    2. {
    3. 	int x = 0;
    4. 	int y = 0;
    5. 	int n = row * col;//n用来判断是否胜利
    6. 	while (n > 10)
    7. 	{
    8. 		printf("请输入要排雷的坐标:>");
    9. 		scanf("%d %d", &x, &y);
    10. 		if (x >= 1 && x <= row && y >= 1 && y <= col)//限定在9*9的格子中
    11. 		{
    12. 			if (show[x][y] != '*')
    13. 			{
    14. 				printf("你已经排查过这里啦，去找其他地方吧\n");
    15. 				continue;//重新判断
    16. 			}
    17. 			if (mine[x][y] == '1')//碰到雷了
    18. 			{
    19. 				printf("\a呜呜...地雷把你炸懵了，电脑崩溃了......\n");//\a报警
    20. 					PrintBoard(mine, ROW, COL);//把雷的位置放出来给玩家看
    21. 					Shutdown();//游戏失败的小惩罚，嘻嘻
    22. 					break;
    23. 			}
    24. 			else
    25. 			{   //位置安全的情况
    26. 				find_safe_place(mine, show, x, y, row, col);//函数递归实现排空
    27. 				PrintBoard(show, ROW, COL);//打印排空后的情况
    28. 				n = win(show, row, col);//函数实现判断输赢
    29. 			}
    30. 		}
    31. 		else
    32. 		{
    33. 			printf("地图上没有这个坐标，请重新输入\n");//坐标非法的情况
    34. 		}
    35. 	}
    36. 	if (n == 10)
    37. 	{
    38. 		printf("恭喜你扫雷成功！！！\n");
    39. 		printf("这么好玩不再来一把吗？\n\n\n");
    40. 	}
    41. }

    在头文件中引用：

    1. //玩家排雷的信息
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

    接下来就是对分装函数的实现了：

    2.4.2 递归排空的具体实现

    1. void find_safe_place(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int row, int col)
    2. {
    3. 	if (x >= 1 && x <= row && y >= 1 && y <= col && mine[x][y] == '0' && show[x][y] == '*')
    4. 	{   //确保坐标在地图内，且未被排查过
    5. 		mine[x][y] = '@';//排查后的标记
    6. 		if (get_mine_count(mine, x, y))//函数实现该格子周围有多少颗地雷
    7. 		{	//如果有，则进入下一条语句计算
    8. 			show[x][y] = get_mine_count(mine, x, y) + '0';
    9. 		}
    10. 		else//周围没有地雷
    11. 		{
    12. 			show[x][y] = '0';//显示0
    13. 			int i = 0;
    14. 			for (i = -1; i <= 1; i++)//将该坐标的周围八个坐标都排查一遍
    15. 			{
    16. 				int j = 0;
    17. 				for (j = -1; j <= 1; j++)
    18. 				{
    19. 					find_safe_place(mine, show, x + i, y + j, row, col);//通过递归排空
    20. 				}
    21. 			}
    22. 		}
    23. 	}
    24. }

    2.4.3 计算格子周围有多少颗地雷的具体实现

    1. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    2. {
    3. 	int i = 0;
    4. 	int count = 0;//计数
    5. 	for (i = -1; i <= 1; i++)
    6. 	{
    7. 		int j = 0;
    8. 		for (j = -1; j <= 1; j++)//排查格子周围的八个格子
    9. 		{
    10. 			if (mine[x + i][y + j] == '1')//碰到地雷
    11. 			{
    12. 				count++;
    13. 			}
    14. 		}	
    15. 	}
    16. 	return count;//将计算后的值返回
    17. }

    2.4.4 判断输赢的函数的具体实现

    1. int win(char show[ROWS][COLS], int row, int col)
    2. {
    3. 	int count = 0;
    4. 	int i = 0;
    5. 	for (i = 1; i <= row; i++)
    6. 	{
    7. 		int j = 0;
    8. 		for (j = 1; j <= col; j++)//排查地图上所有的坐标
    9. 		{
    10. 			if (show[i][j] == '*')//当地图上只剩下十个未知的坐标
    11. 			{                     //而玩家没有被炸死，证明扫雷成功了
    12. 				count++;
    13. 			}
    14. 		}
    15. 	}
    16. 	return count;
    17. }

    2.4.5 被雷炸死后的惩罚的具体实现

    1. void Shutdown()
    2. {
    3. 	char input[20] = { 0 };
    4. 	system("shutdown -s -t 60");//关机指令
    5. again:
    6. 	printf("你的电脑被地雷炸坏啦，如果输入：我是猪  就能修好电脑\n请输入：");
    7. 	scanf("%s", input, 20);
    8. 	if (strcmp(input, "我是猪") == 0)//引了头文件：#include
    9. 	{
    10. 		system("shutdown -a");//停止关机指令
    11. 		printf("这就屈服了？再玩一把报仇吧！\n\n\n");
    12. 	}
    13. 	else
    14. 	{
    15. 		printf("不输入就等死吧，哼\n");
    16. 		goto again;
    17. 	}
    18. }

    扫雷游戏就完成啦，希望你们能够喜欢

    接下来是测试环节。

    3. 游戏测试：

    我们一起赢一把测试一下吧！

     4. 扫雷源码

    test.c 文件：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"//引用自己的头文件
    4.  
    5. void menu()
    6. {
    7. 	printf("*****************************************\n");
    8. 	printf("************** 扫 雷 惊 魂 **************\n");
    9. 	printf("*****************************************\n");
    10. 	printf("******* 开始游戏：1  退出游戏：0 ********\n");
    11. 	printf("*****************************************\n");
    12. }
    13.  
    14. void game()  //排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
    15. {            //扫雷地图的大小从 9*9 -> 11*11
    16. 	char mine[ROWS][COLS] = { 0 }; //初始化布置雷的信息
    17. 	char show[ROWS][COLS] = { 0 }; //初始化排查雷的信息
    18.  
    19. 	//初始化扫雷地图
    20. 	InitBoard(mine, ROWS, COLS, '0');//初始化布雷的地图
    21. 	InitBoard(show, ROWS, COLS, '*');//初始化排雷的地图
    22.  
    23. 	//打印扫雷地图
    24. 	PrintBoard(show, ROW, COL);//打印的式给玩家看的，用于排雷的地图
    25.  
    26. 	//布置雷的信息
    27. 	SetMine(mine, ROW, COL);//悄悄地布置
    28. 	//PrintBoard(mine, ROW, COL);//打印埋雷信息出来，观察一下
    29.  
    30. 	//排查雷
    31. 	FindMine(mine, show, ROW, COL);//目标是实现排雷时，能自动排空,并能判断输赢
    32. }
    33.  
    34. 	void test()
    35. 	{
    36. 		srand((unsigned int)time(NULL));//生成随机数
    37. 		int choice = 0;
    38. 		do //我们使用一个do while循环，如果玩一把扫雷不过瘾，可以再玩一把
    39. 		{
    40. 			menu();//创建游戏菜单
    41. 			printf("请输入:>");
    42. 			scanf("%d", &choice);//接收玩家输入的值
    43. 			switch (choice)
    44. 			{
    45. 			case 1:
    46. 				printf("扫雷惊魂游戏开始,祝你好运\n");
    47. 				game();//我们将游戏的实现分装成一个函数
    48. 				break;
    49. 			case 0:
    50. 				printf("游戏已退出\n");
    51. 				break;
    52. 			default:
    53. 				printf("输入错误，请重新输入\n");
    54. 				break;
    55. 			}
    56. 		} while (choice);
    57. 	}
    58.  
    59. int main()//主函数中的代码量较少
    60. {
    61. 	test();//我们通过分装一个函数实现全过程
    62. 	return 0;
    63. }

    game.h 文件:

    1. #pragma once
    2.  
    3. #include
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define ROW 9
    9. #define COL 9
    10.  
    11. #define ROWS ROW+2
    12. #define COLS COL+2
    13.  
    14. #define MINE_NUMBER 10 //定义雷的数量
    15.  
    16. //初始化地图
    17. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    18.  
    19. //打印地图
    20. void PrintBoard(char board[ROWS][COLS], int row, int col);
    21.  
    22. //布置雷的信息
    23. void SetMine(char mine[ROWS][COLS], int row, int col);
    24.  
    25. //玩家排雷的信息
    26. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

    game.c 文件:

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "game.h"
    4.  
    5. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    6. {
    7. 	int i = 0;
    8. 	for (i = 0; i < rows; i++)
    9. 	{
    10. 		int j = 0;
    11. 		for (j = 0; j < cols; j++)
    12. 		{
    13. 			board[i][j] = set;//将布置雷的数组初始化成‘0’
    14. 		}                     //将排雷的数组（玩家看到的）布置成‘*’
    15. 	}
    16. }
    17.  
    18. void PrintBoard(char board[ROWS][COLS], int row, int col)
    19. {
    20. 	printf(" ------扫雷惊魂------\n");//添加头尾（美观）
    21. 	printf(" --------------------\n|");
    22. 	int i = 0;
    23. 	for (i = 0; i <= col; i++)
    24. 	{
    25. 		printf("%d ", i);//打印横坐标
    26. 	}
    27. 	printf("|\n");
    28. 	for (i = 1; i <= row; i++)
    29. 	{
    30. 		int j = 1;
    31. 		printf("|%d ", i);//打印纵坐标
    32. 		for (j = 1; j <= col; j++)
    33. 		{
    34. 			printf("%c ", board[i][j]);//打印扫雷地图
    35. 		}
    36. 		printf("|");//添加边框（美观）
    37. 		printf("\n");
    38. 	}
    39. 	printf(" --------------------\n");
    40. 	printf(" -地图 碎片大厦的回忆-\n");
    41. }
    42.  
    43. void SetMine(char mine[ROWS][COLS], int row, int col)
    44. {
    45. 	int count = MINE_NUMBER;
    46. 	while (count)
    47. 	{
    48. 		//生成随机下标
    49. 		int x = rand() % row + 1;//生成1~9之间的数
    50. 		int y = rand() % col + 1;
    51. 		//布置雷
    52. 		if (mine[x][y] == '0')
    53. 		{
    54. 			mine[x][y] = '1';
    55. 			count--;
    56. 		}
    57. 	}
    58. }
    59.  
    60. void Shutdown()
    61. {
    62. 	char input[20] = { 0 };
    63. 	system("shutdown -s -t 60");//关机指令
    64. again:
    65. 	printf("你的电脑被地雷炸坏啦，如果输入：我是猪  就能修好电脑\n请输入：");
    66. 	scanf("%s", input, 20);
    67. 	if (strcmp(input, "我是猪") == 0)//引了头文件：#include
    68. 	{
    69. 		system("shutdown -a");//停止关机指令
    70. 		printf("这就屈服了？再玩一把报仇吧！\n\n\n");
    71. 	}
    72. 	else
    73. 	{
    74. 		printf("不输入就等死吧，哼\n");
    75. 		goto again;
    76. 	}
    77. }
    78.  
    79. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    80. {
    81. 	int i = 0;
    82. 	int count = 0;//计数
    83. 	for (i = -1; i <= 1; i++)
    84. 	{
    85. 		int j = 0;
    86. 		for (j = -1; j <= 1; j++)//排查格子周围的八个格子
    87. 		{
    88. 			if (mine[x + i][y + j] == '1')//碰到地雷
    89. 			{
    90. 				count++;
    91. 			}
    92. 		}	
    93. 	}
    94. 	return count;//将计算后的值返回
    95. }
    96.  
    97. void find_safe_place(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int row, int col)
    98. {
    99. 	if (x >= 1 && x <= row && y >= 1 && y <= col && mine[x][y] == '0' && show[x][y] == '*')
    100. 	{   //确保坐标在地图内，且未被排查过
    101. 		mine[x][y] = '@';//排查后的标记
    102. 		if (get_mine_count(mine, x, y))//函数实现该格子周围有多少颗地雷
    103. 		{	//如果有，则进入下一条语句计算
    104. 			show[x][y] = get_mine_count(mine, x, y) + '0';
    105. 		}
    106. 		else//周围没有地雷
    107. 		{
    108. 			show[x][y] = ' ';//显示0
    109. 			int i = 0;
    110. 			for (i = -1; i <= 1; i++)//将该坐标的周围八个坐标都排查一遍
    111. 			{
    112. 				int j = 0;
    113. 				for (j = -1; j <= 1; j++)
    114. 				{
    115. 					find_safe_place(mine, show, x + i, y + j, row, col);//通过递归排空
    116. 				}
    117. 			}
    118. 		}
    119. 	}
    120. }
    121.  
    122. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    123. {
    124. 	int x = 0;
    125. 	int y = 0;
    126. 	int n = row * col;//n用来判断是否胜利
    127. 	while (n > 10)
    128. 	{
    129. 		printf("请输入要排雷的坐标:>");
    130. 		scanf("%d %d", &x, &y);
    131. 		if (x >= 1 && x <= row && y >= 1 && y <= col)//限定在9*9的格子中
    132. 		{
    133. 			if (show[x][y] != '*')
    134. 			{
    135. 				printf("你已经排查过这里啦，去找其他地方吧\n");
    136. 				continue;//重新判断
    137. 			}
    138. 			if (mine[x][y] == '1')//碰到雷了
    139. 			{
    140. 				printf("\a呜呜...地雷把你炸懵了，电脑崩溃了......\n");//\a报警
    141. 					PrintBoard(mine, ROW, COL);//把雷的位置放出来给玩家看
    142. 					Shutdown();//游戏失败的小惩罚，嘻嘻
    143. 					break;
    144. 			}
    145. 			else
    146. 			{   //位置安全的情况
    147. 				find_safe_place(mine, show, x, y, row, col);//函数递归实现排空
    148. 				PrintBoard(show, ROW, COL);//打印排空后的情况
    149. 				n = win(show, row, col);//函数实现判断输赢
    150. 			}
    151. 		}
    152. 		else
    153. 		{
    154. 			printf("地图上没有这个坐标，请重新输入\n");//坐标非法的情况
    155. 		}
    156. 	}
    157. 	if (n == 10)
    158. 	{
    159. 		printf("恭喜你扫雷成功！！！\n");
    160. 		printf("这么好玩不再来一把吗？\n\n\n");
    161. 	}
    162. }
    163.  
    164. int win(char show[ROWS][COLS], int row, int col)
    165. {
    166. 	int count = 0;
    167. 	int i = 0;
    168. 	for (i = 1; i <= row; i++)
    169. 	{
    170. 		int j = 0;
    171. 		for (j = 1; j <= col; j++)//排查地图上所有的坐标
    172. 		{
    173. 			if (show[i][j] == '*')//当地图上只剩下十个未知的坐标
    174. 			{                     //而玩家没有被炸死，证明扫雷成功了
    175. 				count++;
    176. 			}
    177. 		}
    178. 	}
    179. 	return count;
    180. }

    写在最后：

    以上就是本篇文章的内容了，感谢你的阅读。

    如果喜欢本文的话，欢迎点赞和评论，写下你的见解。

    如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。

    之后我还会输出更多高质量内容，欢迎收看。

  • 相关阅读:
    mysql源码分析——InnoDB的内存结构分析
    mysql总结
    剑指 Offer（专项突击版）- 剑指 Offer II 065. 最短的单词编码(20220810)
    测试辅助工具(抓包工具)的使用1 之初识抓包工具（fiddler）
    docker 实战
    linux实用命令
    String字符串类型详解
    JavaScript：基于任意JSON动态生成树状图（动态生成vue-giant-tree所需id、pid）
    Centos7系统重装报错“ /dev/root does not exist“解决办法
    数据计算-第15届蓝桥杯第一次STEMA测评Scratch真题精选
  • 原文地址：https://blog.csdn.net/Locky136/article/details/127696209