【C语言】扫雷（拓展版）

最新推荐文章于 2024-10-14 09:08:48 发布
最新推荐文章于 2024-10-14 09:08:48 发布
阅读量173 收藏
点赞数 4
文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh306059/article/details/134352534
版权

  大家好，今天让我们一起来用C语言写一个电脑自带的经典小游戏——扫雷。

程序目标

  1. 通过代码编写，实现扫雷游戏的基本功能；
  2. 明白C语言实现游戏功能代码通用写法，掌握模块化编程；
  3. 锻炼自己的编程能力，学习新知识。

程序设计

界面初始化

  以埋了10个炸弹的9×9的布局为例，如图所示

image-20231111112441621

  为了实现这个界面我们可以创建一个二维数组，并进行初始化，我就全部初始化为‘*’了，最终的效果如下图

image-20231111122439024

  其中上方和左侧的数字对应行列，方便玩家选择排雷点。

设置炸弹

  当界面初始化完成后，我们就需要随机设置10个炸弹，炸弹用字符‘1’表示，没有炸弹用字符‘0’表示，这里我们可以通过rand()函数进行实现，但注意我们还需要在主函数里调用srand()函数来设置rand()函数的随机种子。效果如下

image-20231111123648155

  注意此处界面的二维数组，并不是我们之前初始化的二维数组，也就是说在这个游戏中我们创建了两个二维数组，用于对外显示进行打印的为数组show[][]，用于实现设置雷和对雷个数进行判断等功能的为数组mine[][]。

  那么为什么要设置两个二维数组呢？那么假设我们只设置了一个二维数组，那么我们会在这个数组设置炸弹，接下来玩家输入排雷点，这个时候我们肯定需要将数组打印出来，因为需要知道是否踩到了雷以及该坐标周围8个元素还有多少个雷，可是我们就这样打印出来的话，我们前面设置的雷也一样被打印出来了，这就相当于直接告诉了玩家雷设置的位置，这样显然是不行的。

判断炸弹个数

  当我们输入排雷点位置后，如果刚好踩到雷，那么游戏就结束，如果没有踩到雷，则需要返回该坐标周围8个元素含有的雷的个数，示意图如下

image-20231111151311629

  在编写代码需要注意的是，这里的1、0、3都是字符型，并不是整型。

展开一片功能

  在我们玩电脑上的扫雷游戏时，发现当我们第一次输入排雷点的时候，如果该位置不是雷，打印出来的界面可能是这样的

image-20231111144020482

  也有可能是这样的

image-20231111144102601

  前者使我们前面所设想的正常情况，可后者一下子却展开出了这么一大片区域，这是怎么回事呢？

  后者的功能我们就称之为展开一片功能，其具体功能时如何实现的呢，如下图所示

image-20231111152955383

在排雷点没有雷的前提下，排雷点周围8个元素都没有雷，即该坐标返回值为‘0’，为了更符合游戏规则，我们可以令其返回值为空格’ ’，这个时候我们可以再定义一个函数，这个函数实现的功能为当排雷点的返回值为‘0’时，再去判断该坐标周围8个元素，看他们的返回值是否也为‘0’，如果也为‘0’，则再判断这个坐标周围8个元素返回值是否为’0‘，然后再进行判断，一直如此，直至判断坐标返回值不在为’0‘，就停止。这是一个循环的过程，我们可以用递归来实现。

  但需要注意的是，在上面这种情况下，往往一个坐标位置会被递归许多次，也就是会出现死递归。为了防止这种情况的出现，提高代码运行效率，我们就需要再写一个函数来实现判断这个坐标位置是不是已经被判断过了，如果已经判断过了，则不在进行判断，没判断过，则继续判断。

炸弹位置标记

  在我们玩扫雷游戏的过程中，我们发现它还有一个功能，那就是当我们判断某一个位置为炸弹时，可以进行标记，在本代码中，标记为’0‘，有标记也就有取消，这样我们就实现了炸弹位置的标记和取消标记。

排雷成功

  最后我们还需要实现判断排雷成功的功能，我们一共有10个雷需要排，在我们排雷的过程中，当我们知道某一个坐标为雷的时候，为了排雷成功，我们只可能作出两种选择：1.标记雷的位置；2.不去踩这个雷。在前面我们说了标记雷位置的符号为’0‘，如果我们不去踩这个雷，那么最后剩下的也就是我们初始化的字符’*‘。

  所以我们可以作出如下判断，当用于显示的show[][]二维数组中’0‘与’*'的个数之和为10，则说明我们排雷成功。

代码编写

  我一共创建了三个文件来实现扫雷游戏的功能，分别是main.c、game.c、game.h，即两个源文件一个头文件。

main.c文件

  首先创建一个main()函数，用来实现开始游戏的基本功能。

int main()
{
	srand((unsigned int)time(NULL));//设置rand()函数随机数种子
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("非法输入，请重新选择\n");
			break;
		}
	} while (input != 0);
	return 0;
}

  menu()函数实现打印游戏开始菜单的功能

void menu(void)
{
	printf("*********扫雷游戏*********\n");
	printf("****  1.start 0.exit  ****\n");
	printf("**************************\n");
}

  game()函数实现游戏的主体功能

void game(void)
{
	char hide[ROWS][COLS] = { 0 };//用来存放雷，不打印显示
	char show[ROWS][COLS] = { 0 };//用来打印，将排雷结果显示在玩家面前
	char sign[ROWS][COLS] = { 0 };//再死递归中，用来判断坐标点是否已经被排查过，不打印显示
	//初始化
	InitHide(hide, ROWS, COLS);
	InitShow(show, ROWS, COLS);
	InitSign(sign, ROWS, COLS);
	//打印初始化棋盘
	PrintBoard(show, ROWS, COLS);
	//随机设置炸弹的位置
	SetMine(hide, ROWS, COLS);

	while (1)
	{
		int count = 0;//初始化炸弹个数
		int ret = 0;//初始化排雷点周围8个元素含炸弹个数
		//初始化排雷点坐标
		int x = 0;
		int y = 0;

		printf("请输入排雷点:>");
		scanf("%d %d", &x, &y);

		if ((x > 0) && (x < ROWS - 1) && (y > 0) && (y < COLS - 1))//判断输入坐标是否合法
		{
			if (hide[x][y] == '1')//判断排雷点是否有炸弹
			{
				PrintBoard(hide, ROWS, COLS);//打印炸弹位置
				printf("炸弹爆炸，游戏结束\n");
				break;
			}
			else
			{
				if (show[x][y] == '*')//判断输入排雷点是否已经被占用
				{
					ret = MineCount(hide, x, y);//返回坐标点周围8个元素的炸弹个数
					if (ret == 0)
					{
						//实现一片展开功能
						SpreadBoard(hide, show, sign, ROWS, COLS, x, y);
					}
					else
					{
						show[x][y] = '0' + ret;//数组show是char类型的，48对应的字符为'0'
					}
					PrintBoard(show, ROWS, COLS);
				}
				else
				{
					printf("该位置已被选择，请重新输入\n");
				}
			}
		}
		else
		{
			printf("非法输入，请重新选择\n");
		}

		MarkBomb(show, ROWS, COLS);//标记或者取消标记炸弹位置
		//判断是否排雷成功
		count = IsWin(show, ROWS, COLS);
		if (count == 10)
		{
			printf("恭喜你，排雷成功\n");
			break;
		}
	}
}

game.c文件

二维数组初始化

void InitBoard(char board[ROWS][COLS], int row, int col, char c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = c;
		}
	}
}

打印数组

void PrintBoard(char Board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf(" ");//在第一行先提前打印一个空格，保证与接下来每列都对齐
	for (i = 1; i < row - 1; i++)
	{
		printf(" %d", i);//在第一行打印序号
	}
	printf("\n");
	for (i = 1; i < row - 1; i++)
	{
		printf("%d ", i);//在每一列开头打印序号
		for (j = 1; j < col - 1; j++)
		{
			printf("%c ", Board[i][j]);//打印二维数组中每一个元素
		}
		printf("\n");
	}
}

随机设置炸弹位置

void SetMine(char hide[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	for (i = 0; i < MINECOUNTS; i++)
	{
		x = (rand() % ROW) + 1;//横坐标为1~9
		y = (rand() % COL) + 1;//纵坐标为1~9
		if (hide[x][y] == '0')//防止随机设置的炸弹位置坐标重复
		{
			hide[x][y] = '1';
			continue;
		}
		i--;
	}
}

数排雷点周围8个元素炸弹个数

int MineCount(char hide[ROWS][COLS], int a, int b)
{
	int count = 0;
	int i = 0;
	int j = 0;
	//遍历该坐标周围8个元素，计算炸弹个数
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (hide[a + i][b + j] == '1')
			{
				count++;
			}
		}
	}
	return count;
}

一片展开功能实现

//标记已经判断过的排雷点，防止死递归
char Mark(char sign[ROWS][COLS], int e, int f)
{
	if (sign[e][f] == ' ')//如果没有被判断过，先进行标记，标记为'#'，再返回' '
	{
		sign[e][f] = '#';
		return ' ';
	}
	if (sign[e][f] == '#')//如果已经判断过了，则返回'#'
	{
		return '#';
	}
}

void SpreadBoard(char hide[ROWS][COLS], char show[ROWS][COLS], char sign[ROWS][COLS], int row, int col, int c, int d)
{
	int i = 0;
	int j = 0;
	int ret = 0;
	if (((c > 0) && (c < row - 1) && (d > 0) && (d < row - 1)) && (MineCount(hide, c, d) == 0))//限制条件：1.在二维数组边界范围内；2.排雷点周围8个元素炸弹数为0
	{
		//Mark(sign, c, d)函数标记已经判断过的排雷点，标记记号为'#'
		if (Mark(sign, c, d) != '#')//判断该位置是否已经被标记过了，防止死递归
		{
			show[c][d] = ' ';//赋予空格
			//重复判断排雷点周围8个元素，即开始“递”
			SpreadBoard(hide, show, sign, row, col, c - 1, d - 1);
			SpreadBoard(hide, show, sign, row, col, c - 1, d);
			SpreadBoard(hide, show, sign, row, col, c - 1, d + 1);
			SpreadBoard(hide, show, sign, row, col, c, d - 1);
			SpreadBoard(hide, show, sign, row, col, c, d + 1);
			SpreadBoard(hide, show, sign, row, col, c + 1, d - 1);
			SpreadBoard(hide, show, sign, row, col, c + 1, d);
			SpreadBoard(hide, show, sign, row, col, c + 1, d + 1);
		}
	}
	else
	{
		show[c][d] = '0' + MineCount(hide, c, d);//打印数字字符，开始“归”
	}
}

标记炸弹点位置

void Cancelmark(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	do
	{
		printf("是否取消炸弹标记，是-1，否-0:>");
		scanf("%d", &input);
		switch(input)
		{
		case 1:
			printf("请输入取消标记炸弹点坐标:>");
			int x = 0;
			int y = 0;
			scanf("%d %d", &x, &y);
			show[x][y] = '*';//取消炸弹点标记，重新标为'*'
			PrintBoard(show, row, col);
			break;
		case 0:
			break;
		default:
			printf("错误选择，请重新输入\n");
			break;
		} 
	} while (input != 0);
}

void MarkBomb(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	int count = 0;

	do
	{
		//选择是否发现炸弹
		printf("是否发现炸弹，是-1，否-0:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入炸弹坐标点:>");
			int x = 0;
			int y = 0;
			scanf("%d %d", &x, &y);
			show[x][y] = '0';//发现炸弹并标记炸弹位置为字符'0'
			PrintBoard(show, row, col);
			count++;

			//当标记炸弹数大于等于1时，选择是否取消炸弹标记点
			if (count >= 1)
			{
				Cancelmark(show, row, col);
			}
			break;
		case 0:
			break;
		default:
			printf("选择错误，请重新输入\n");
			break;
		}
	} while (input != 0);
}

判断排雷成功

int IsWin(char show[ROWS][COLS], int row, int col)
{
	int count = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i < row - 1; i++)
	{
		for (j = 1; j < col - 1; j++)
		{
			if (show[i][j] == '0')//如果有炸弹标记符号，则count++
			{
				count++;
			}
			if (show[i][j] == '*')//如果有'*'符号，则count++
			{
				count++;
			}
		}
	}
	return count;
}

程序运行结果

image-20231111192001844

附录

main.c代码

#include "game.h"

void menu(void)
{
	printf("*********扫雷游戏*********\n");
	printf("****  1.start 0.exit  ****\n");
	printf("**************************\n");
}

void game(void)
{
	char hide[ROWS][COLS] = { 0 };//用来存放雷，不打印显示
	char show[ROWS][COLS] = { 0 };//用来打印，将排雷结果显示在玩家面前
	char sign[ROWS][COLS] = { 0 };//再死递归中，用来判断坐标点是否已经被排查过，不打印显示
	//初始化
	InitBoard(hide, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	InitBoard(sign, ROWS, COLS, ' ');
	//打印初始化棋盘
	PrintBoard(show, ROWS, COLS);
	//随机设置炸弹的位置
	SetMine(hide, ROWS, COLS);

	while (1)
	{
		int count = 0;//初始化炸弹个数
		int ret = 0;//初始化排雷点周围8个元素含炸弹个数
		//初始化排雷点坐标
		int x = 0;
		int y = 0;

		printf("请输入排雷点:>");
		scanf("%d %d", &x, &y);

		if ((x > 0) && (x < ROWS - 1) && (y > 0) && (y < COLS - 1))//判断输入坐标是否合法
		{
			if (hide[x][y] == '1')//判断排雷点是否有炸弹
			{
				PrintBoard(hide, ROWS, COLS);//打印炸弹位置
				printf("炸弹爆炸，游戏结束\n");
				break;
			}
			else
			{
				if (show[x][y] == '*')//判断输入排雷点是否已经被占用
				{
					ret = MineCount(hide, x, y);//返回坐标点周围8个元素的炸弹个数
					if (ret == 0)
					{
						//实现一片展开功能
						SpreadBoard(hide, show, sign, ROWS, COLS, x, y);
					}
					else
					{
						show[x][y] = '0' + ret;//数组show是char类型的，48对应的字符为'0'
					}
					PrintBoard(show, ROWS, COLS);
				}
				else
				{
					printf("该位置已被选择，请重新输入\n");
				}
			}
		}
		else
		{
			printf("非法输入，请重新选择\n");
		}

		MarkBomb(show, ROWS, COLS);//标记或者取消标记炸弹位置
		//判断是否排雷成功
		count = IsWin(show, ROWS, COLS);
		if (count == 10)
		{
			printf("恭喜你，排雷成功\n");
			break;
		}
	}
}

int main()
{
	srand((unsigned int)time(NULL));//设置rand()函数随机数种子
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("非法输入，请重新选择\n");
			break;
		}
	} while (input != 0);
	return 0;
}

game.c代码

#include "game.h"

void InitBoard(char board[ROWS][COLS], int row, int col, char c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = c;
		}
	}
}

void PrintBoard(char Board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf(" ");//在第一行先提前打印一个空格，保证与接下来每列都对齐
	for (i = 1; i < row - 1; i++)
	{
		printf(" %d", i);//在第一行打印序号
	}
	printf("\n");
	for (i = 1; i < row - 1; i++)
	{
		printf("%d ", i);//在每一列开头打印序号
		for (j = 1; j < col - 1; j++)
		{
			printf("%c ", Board[i][j]);//打印二维数组中每一个元素
		}
		printf("\n");
	}
}

void SetMine(char hide[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	for (i = 0; i < MINECOUNTS; i++)
	{
		x = (rand() % ROW) + 1;//横坐标为1~9
		y = (rand() % COL) + 1;//纵坐标为1~9
		if (hide[x][y] == '0')//防止随机设置的炸弹位置坐标重复
		{
			hide[x][y] = '1';
			continue;
		}
		i--;
	}
}

int MineCount(char hide[ROWS][COLS], int a, int b)
{
	int count = 0;
	int i = 0;
	int j = 0;
	//遍历该坐标周围8个元素，计算炸弹个数
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (hide[a + i][b + j] == '1')
			{
				count++;
			}
		}
	}
	return count;
}

//标记已经判断过的排雷点，防止死递归
char Mark(char sign[ROWS][COLS], int e, int f)
{
	if (sign[e][f] == ' ')//如果没有被判断过，先进行标记，标记为'#'，再返回' '
	{
		sign[e][f] = '#';
		return ' ';
	}
	if (sign[e][f] == '#')//如果已经判断过了，则返回'#'
	{
		return '#';
	}
}

void SpreadBoard(char hide[ROWS][COLS], char show[ROWS][COLS], char sign[ROWS][COLS], int row, int col, int c, int d)
{
	int i = 0;
	int j = 0;
	int ret = 0;
	if (((c > 0) && (c < row - 1) && (d > 0) && (d < row - 1)) && (MineCount(hide, c, d) == 0))//限制条件：1.在二维数组边界范围内；2.排雷点周围8个元素炸弹数为0
	{
		//Mark(sign, c, d)函数标记已经判断过的排雷点，标记记号为'#'
		if (Mark(sign, c, d) != '#')//判断该位置是否已经被标记过了，防止死递归
		{
			show[c][d] = ' ';//赋予空格
			//重复判断排雷点周围8个元素，即开始“递”
			SpreadBoard(hide, show, sign, row, col, c - 1, d - 1);
			SpreadBoard(hide, show, sign, row, col, c - 1, d);
			SpreadBoard(hide, show, sign, row, col, c - 1, d + 1);
			SpreadBoard(hide, show, sign, row, col, c, d - 1);
			SpreadBoard(hide, show, sign, row, col, c, d + 1);
			SpreadBoard(hide, show, sign, row, col, c + 1, d - 1);
			SpreadBoard(hide, show, sign, row, col, c + 1, d);
			SpreadBoard(hide, show, sign, row, col, c + 1, d + 1);
		}
	}
	else
	{
		show[c][d] = '0' + MineCount(hide, c, d);//打印数字字符，开始“归”
	}
}

void Cancelmark(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	do
	{
		printf("是否取消炸弹标记，是-1，否-0:>");
		scanf("%d", &input);
		switch(input)
		{
		case 1:
			printf("请输入取消标记炸弹点坐标:>");
			int x = 0;
			int y = 0;
			scanf("%d %d", &x, &y);
			show[x][y] = '*';//取消炸弹点标记，重新标为'*'
			PrintBoard(show, row, col);
			break;
		case 0:
			break;
		default:
			printf("错误选择，请重新输入\n");
			break;
		} 
	} while (input != 0);
}

void MarkBomb(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	int count = 0;

	do
	{
		//选择是否发现炸弹
		printf("是否发现炸弹，是-1，否-0:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入炸弹坐标点:>");
			int x = 0;
			int y = 0;
			scanf("%d %d", &x, &y);
			show[x][y] = '0';//发现炸弹并标记炸弹位置为字符'0'
			PrintBoard(show, row, col);
			count++;

			//当标记炸弹数大于等于1时，选择是否取消炸弹标记点
			if (count >= 1)
			{
				Cancelmark(show, row, col);
			}
			break;
		case 0:
			break;
		default:
			printf("选择错误，请重新输入\n");
			break;
		}
	} while (input != 0);
}

int IsWin(char show[ROWS][COLS], int row, int col)
{
	int count = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i < row - 1; i++)
	{
		for (j = 1; j < col - 1; j++)
		{
			if (show[i][j] == '0')//如果有炸弹标记符号，则count++
			{
				count++;
			}
			if (show[i][j] == '*')//如果有'*'符号，则count++
			{
				count++;
			}
		}
	}
	return count;
}

game.h代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ROW 9
#define COL 9
#define ROWS ROW + 2
#define COLS COL + 2
#define MINECOUNTS 10
void InitBoard(char board[ROWS][COLS], int row, int col, char c);
void SetMine(char hide[ROWS][COLS], int row, int col);
void PrintBoard(char Board[ROWS][COLS], int row, int col);
int MineCount(char hide[ROWS][COLS], int a, int b);
void SpreadBoard(char hide[ROWS][COLS], char show[ROWS][COLS], char sign[ROWS][COLS], int row, int col, int c, int d);
void MarkBomb(char show[ROWS][COLS], int row, int col);
int IsWin(char show[ROWS][COLS], int row, int col);
仰望星空的小辉哥
关注
扫雷游戏的拓展
_Unique_
09-25 782
Linux的基本操作命令linux下的目录结构linux下 目录 的命令操作Linux下 文件 的命令操作压缩相关操作查找匹配操作其他操作 linux下的目录结构 树状目录结构，最上层的目录是根目录（‘/’） 根目录下的所有目录都有特定的含义，都存储着不同功能的文件 linux下 目录 的命令操作 讲解的是最常用的命令: 命令的使用结构 命名名称 [操作选项] [操作源对象] [操作目...
c语言扫雷如何修改游戏难度,C语言实现扫雷游戏及其优化
weixin_39654917的博客
05-22 635
本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码，供大家参考，具体内容如下关于扫雷优化1.核心思想：使用两个二维数组进行设计，一个用于显示，一个用于后台雷的布置。2.使用宏常量，后期可以任意修改游戏难度。3.关于扫雷拓展模块，目前使用的方法比较low，若周围均没有，则全部显示。4.剩余位置数使用全局变量count，必须考虑拓展之后count变化。有待改进之处1.需设计标记雷的步骤，增加用户...
C 小游戏——扫雷（拓展版）
K_A_Irving的博客
04-03 658
1.程序代码 //game.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _GAME_H__ #define _GAME_H__ #include &lt;stdio.h&gt; #include &lt;Windows.h&gt; #include &lt;stdlib.h&gt; #include &lt;time.h&gt; #defin...
扩展版扫雷小游戏
HL_HLHL的博客
12-07 332
game.h#ifndef _GAME_H_ #define _GAME_H_ #include<stdio.h> #include<stdlib.h> #include<time.h> #define ROW 9 #define COL 9 #define ROWS ROW+2 #define COLS COL+2 #define EASY_COUNT 10 #define HARD_
递归思想—扫雷的拓展
Dumaer的博客
08-12 100
voidFindMine(charmine[ROWS][COLS],charshow[ROWS][COLS],introw,intcol) { intstaticx=0;//修改静态局部变量 intstaticy=0; intstaticwin=0; while(win<row*col-EASY_COUNT) { printf("请输入排查的坐标\n"); scanf("%d%d...
c语言扫雷游戏代码学习
qq_45417760的博客
06-28 2614
c语言模拟实现扫雷游戏
【C语言】扫雷游戏的拓展 2.0版（超详细）
wcblh的博客
01-08 629
在前面讲到了如何实现扫雷游戏💡今天来讲讲如何实现它的拓展，全部的代码放在文章的最后处• 选择游戏难度◦ 简单 9*9 棋盘，10个雷◦ 中等 16*16棋盘，40个雷◦ 困难 30*16棋盘，99个雷• 展开周围的一片• 标记雷由于我们之前首先定义了棋盘的row col的大小，导致最多只能玩一种难度，这里我们稍微改动一下 ，给game函数传入参数，使得可以选择三种难度。
C语言扫雷进阶拓展(10)
tan180°的博客
09-05 1286
本文章源代码完全公开在上篇文章中我们对扫雷游戏的基础版本已经有了一个详细且全面的了解，但是基础版本的功能十分有限，游玩体验也不够好，因此，我们来拓展它。行至中江，举帆！感觉这个进阶篇写的比基础篇还好，可能是更用心的缘故吧，继续加油！
C语言实现——简版扫雷（详解）
weixin_73888239的博客
11-11 3691
C语言实现简版扫雷，详解，希望对大家有所帮助。
C语言扫雷完整版——长文 详细分享
bestme
02-17 4059
扫雷完整版详细分享
C语言实现扫雷游戏及其优化
08-25
扫雷拓展模块使用的方法比较low，若周围均没有，则全部显示。 游戏实现代码 游戏的实现代码主要包括以下几个部分： 1. 游戏菜单的实现：使用 printf 函数实现游戏菜单的输出，包括开始游戏和退出游戏两个选项。 2...
C语言实现【扫雷游戏】拓展版
安安的博客
11-11 5636
2021-11-10- 作者：Nico 时间: 2021-11-10 网站地址：[]:https://github.com/sxfinn 摘要 C语言实现我们小时候玩过的扫雷游戏，最近看到了一些扫雷游戏的简单实现，但是总有功能上的缺失，玩起来不那么的“原汁原味”，因此我增加了一些新功能： 确保玩家首次排雷一定不会炸死。 加入了计时器记录结束时间。 扩展式排雷，展开周围的非雷区。 总结 比较难的一点是扩展式排雷，使用用递归函数处理相对方便。 目录2021-11-10-摘要总结难点解析探索八区递归展开完
C语言小游戏之扫雷完整版
热门推荐
bit_xwg的博客
11-06 3万+
C语言小游戏之扫雷一.游戏介绍二.游戏步骤及实现的功能1.初始化雷盘2.打印雷盘3.随机布置雷4.玩家排雷5.防止玩家第一次被炸死6.统计所选位置周围八个位置中雷的个数7.拓展已选位置周围的区域8.标记雷及取消标记 一.游戏介绍 看到这张图片，相信很多小伙伴都非常熟悉，很多小伙伴都玩过扫雷这个小游戏，扫雷是一款益智类游戏，在放松娱乐的同时可以锻炼各位小伙伴的智商。 游戏规则：如上图，玩家需要在不被炸死的前提下找出图中雷的位置，若能找出所有雷，则游戏胜利，若不幸踩到雷则被炸死。 注：先介绍，后文会有完整代码
[C语言] 函数详解：库函数与自定义函数
Kevin ’ s blog
10-11 954
库函数：C标准库中已经实现的函数，开发者可以直接使用。自定义函数：开发者自己编写的函数，用于实现特定功能。自定义函数是开发者自己编写的函数.
消失的数字 C语言 （含原码解析，两种方法）
2301_76838975的博客
10-13 227
分析：按位异或，相同为0，相异为1，0与任何数字异或等于数字本身则令x与数组中所有数异或再遍历实际应有的所有数字与x异或，相同的数字全部抵消，剩下的数字就是缺少的数字。
【文档智能】文本文字识别、公式识别、表格文字识别核心算法及思路及实践-DBNet、CRNN、TrOCR
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
10-13 1273
OCR技术作为文档智能解析链路中的核心组件之一，贯穿整个技术链路，包括：文字识别、表格文字识别、公式识别，参看下面这张架构图：前期介绍了很多关于文档智能解析相关核心技术及思路，本着连载的目的，本次迎来介绍整个链路中的最后一块拼图-OCR。本文简要介绍OCR常见落地的算法模型-DBNet、CRNN，并基于这两个模型，简单介绍文字识别在表格识别中参与的角色；并且额外介绍TrOCR这个端到端的模型，基于这个模型引入公式识别解析的思路及微调方法。
二叉树系列 10/11
2301_78191305的博客
10-11 416
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 223
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
最新发布
csdn_aspnet的专栏
10-14 1154
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
C语言扫雷小游戏代码详解及实现
本资源是一份C语言小游戏代码，专注于实现经典的扫雷游戏。该代码提供了基本的游戏逻辑和用户界面控制功能，旨在帮助学习者理解和实践C语言编程技能，同时激发他们对编程的兴趣。 1. **C语言基础**： 代码使用了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值