C语言实现扫雷——详解

最新推荐文章于 2024-02-29 14:50:52 发布
最新推荐文章于 2024-02-29 14:50:52 发布
阅读量7.2w 收藏 712
点赞数 190
分类专栏： C程序设计 文章标签： 扫雷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yc1515707718/article/details/78744978
版权

目录

功能设计

扫雷大家应该都玩过，这是一个十分经典的游戏，今天我将给大家讲解如何用C语言实现扫雷，我的这个扫雷有如下几个功能：

  1. 显示该点周围雷的个数
  2. 第一次下子，不炸死
  3. 坐标周围没雷，可以实现展开
  4. 游戏结束后展示玩家用时

效果展示

话不多说，先附上效果图：
这里写图片描述

这里写图片描述

这里写图片描述

设计思路

我们只要输入坐标就可以扫雷了，是不是很有趣？
其实要想实现这也不难，我们要用几个算法模块来模拟游戏规则，需要用函数来调用各个模块使游戏跑起来。
那么第一步我们就要构思一个棋盘，看见上面第一张图没，在开始游戏的界面我打印了两个棋盘，有0和1的棋盘是给我们设计者看的，它可以显示出当前雷的真实分布，这有利于我们测试代码的正确性，而全是 * 的棋盘是给玩家扫雷用的。

那我们就需要用二维数组来打印两个棋盘，假如我们要打印10X10的棋盘，那我们的二维数组元素也要为10X10个吗？，不能，因为我们在设计算法时需要统计坐标周围8个方位雷的个数，假如要统计边界坐标周围雷的个数，那么就会有数组越界的问题，那我们就要在10X10的边界多上一圈元素，也就要定义12X12的数组元素，这些元素我们不要打印出来，心里有数就行，如下图：

#define row 12
#define col 12
show_mine[row][col];//玩家数组
real_mine[row][col];//设计者数组

扫雷结构
我们在一个项目里建立三个源文件，如下:
这里写图片描述

  1. 我们打印设计者棋盘要用数组real_mine,打印玩家棋盘要用数组show_mine,两个数组在开始必须要初始化，在设计者棋盘中字符0代表不是雷，字符1代表雷，先初始化两个数组
    代码如下：
void init_mine()//初始化两个雷阵
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++) 
	{
		for (j = 0; j < col; j++)
		{
			show_mine[i][j] = '*';
			real_mine[i][j] = '0';
		}
	}
}
  1. 打印两个雷阵（不要忘了打印横竖序号以便确定坐标）
void print_player()//打印玩家棋盘
{
	int i = 0;
	int j = 0;
	printf("0  ");
	for (i = 1; i <row-1; i++)
	{
		printf("%d ", i);//打印横标（0--10）
	}
	printf("\n");
	for (i = 1; i <row-2; i++)//打印竖标（1--10）
	{
		printf("%d  ", i);
		for (j = 1; j < col-1; j++)
		{
			printf("%c ", show_mine[i][j]);//玩家棋盘数组
		}
		printf("\n");
	}
	printf("10 ");//开始打印最后一行
	for (i = 1; i < row-1; i++)
	{
		printf("%c ", show_mine[10][i]);
	}
	printf("\n");
}


void print_mine()//打印设计者棋盘
{
	int i = 0;
	int j = 0;
	printf("0  ");
	for (i = 1; i <row - 1; i++)
	{
		printf("%d ", i);//打印横标（0--10）
	}
	printf("\n");
	for (i = 1; i <row - 2; i++)//打印竖标（1--10）
	{
		printf("%d  ", i);
		for (j = 1; j < col - 1; j++)
		{
			printf("%c ", real_mine[i][j]);
		}
		printf("\n");
	}
	printf("10 ");//开始打印最后一行
	for (i = 1; i < row - 1; i++)
	{
		printf("%c ", real_mine[10][i]);
	}
	printf("\n");
}
  1. 我们在每一次玩的时候设计者棋盘中的雷分布都必须不相同，使用随机数生成横竖坐标确定布雷坐标，代码如下：
void set_mine()//给设计者棋盘布雷
{
	int x = 0;
	int y = 0;
	int count = COUNT;//雷总数
	while (count)//雷布完后跳出循环
	{
		int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
		int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
		if (real_mine[x][y] == '0')//找不是雷的地方布雷
		{
			real_mine[x][y] = '1';
			count--;
		}
	}
}
  1. 为了统计当前坐标周围雷的个数，定义一个函数实现：
int count_mine(int x, int y)//检测周围8个区域雷的个数
{
	int count = 0;
	if (real_mine[x - 1][y - 1] == '1')
		count++;
	if (real_mine[x - 1][y] == '1')
		count++;	
	if (real_mine[x - 1][y + 1] == '1')
		count++;
	if (real_mine[x][y - 1] == '1')
		count++;	
	if (real_mine[x][y + 1] == '1')
		count++;	
	if (real_mine[x + 1][y - 1] == '1')
		count++;	
	if (real_mine[x + 1][y] == '1')
		count++;	
	if (real_mine[x + 1][y + 1] == '1')
		count++;
	return count;
}
  1. 为了确保第一次不被雷炸死，我们需要定义个函数来实现，如果第一次选到雷就将这颗雷放在其他不是雷的地方，代码如下：
void safe_mine()//避免第一次炸死
{
	int x = 0;
	int y = 0;
	char ch = 0;
	int count = 0;
	int ret = 1;
	printf("输入坐标扫雷\n");
	while (1)
	{
		scanf("%d%d", &x, &y);//只能输入1到10，输入错误重新输入
		if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误
		{
			if (real_mine[x][y] == '1')//第一次踩到雷后补救
			{
				real_mine[x][y] = '0';
				char ch = count_mine(x, y);
				show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				while (ret)//在其余有空的地方设置一个雷
				{
					int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
					int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
					if (real_mine[x][y] == '0')//找不是雷的地方布雷
					{
						real_mine[x][y] = '1';
						ret--;
						break;
					}
				}break;//跳出此函数	
			}
			if (real_mine[x][y] == '0')
			{
				char ch = count_mine(x, y);
				show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				break;
			}
		}
		else//坐标错误
		{
			printf("输入错误重新输入\n");
		}
	}
}
  1. 为了实现展开功能，需要展开函数模块（展开的坐标还要显示其坐标周围的雷数），如下：
void open_mine(int x, int y)//坐标周围展开函数
{
	if (real_mine[x - 1][y - 1]== '0')
	{
		show_mine[x - 1][y - 1] = count_mine(x - 1, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x - 1][y] == '0')
	{
		show_mine[x - 1][y] = count_mine(x - 1, y) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x - 1][y + 1] == '0')
	{
		show_mine[x - 1][y + 1] = count_mine(x - 1, y + 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x][y - 1] == '0')
	{
		show_mine[x][y - 1] = count_mine(x, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x][y + 1] == '0')
	{
		show_mine[x][y + 1] = count_mine(x, y + 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y - 1] == '0')
	{
		show_mine[x + 1][y - 1] = count_mine(x + 1, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y] == '0')
	{
		show_mine[x + 1][y] = count_mine(x + 1, y) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y + 1] == '0')
	{
		show_mine[x + 1][y + 1] = count_mine(x + 1, y + 1) + '0';//显示该坐标周围雷数
	}
}
  1. 扫雷函数是一个重要的模块，代码如下：
int sweep_mine()//扫雷函数，踩到雷返回1，没有踩到雷返回0
{
	int x = 0;
	int y = 0;
	int count = 0;
	printf("输入坐标扫雷\n");
		scanf("%d%d", &x, &y);//只能输入1到10
		if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误，输入错误重新输入
		{
			if (real_mine[x][y] == '0')//没踩到雷
			{
				char ch = count_mine(x,y);
				show_mine[x][y] = ch+'0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				if (count_show_mine() == COUNT)//判断剩余未知区域的个数，个数为雷数时玩家赢
				{
					print_mine();
					printf("玩家赢！\n\n");
					return 0;
				}
			}
			else if (real_mine[x][y]=='1')//踩到雷
			{
				return 1;
			}

		}
		else
		{
			printf("输入错误重新输入\n");
		}
	return 0;//没踩到雷
}

到最后需要确定游戏胜利的条件，我们要统计当前状态玩家棋盘中显示的剩余 * 的个数，如果个数等于总雷数时说明扫雷完成，游戏胜利，定义一个函数实现：

int count_show_mine()//判断剩余未知区域的个数，个数为雷数时玩家赢
{
	int count = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i <= row - 2; i++)
	{
		for (j = 1; j <= col - 2; j++)
		{
			if (show_mine[i][j] == '*')
			{
				count++;
			}
		}

	}
	return count;
}

我们将以上函数的定义放在 game.c 文件中

以上就是我们要实现扫雷的模块，要想把这些模块整合起来运行，就需要一个游戏执行函数来调用这些模块，定义个game()函数实现，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
double  start, finish;
void game()
{
	
	int ret = 0;
	init_mine();//初始化玩家棋盘和设计者棋盘
	set_mine();//给设计者棋盘布雷
	print_mine();//打印设计者棋盘（可不打印）
	printf("\n");
	print_player();//打印玩家棋盘
	start = clock();
	safe_mine();//避免第一次被炸死
	
	if (count_show_mine() == COUNT)//一步就赢的情况
	{
		print_mine();
		printf("玩家赢！\n\n");
		return ;
	}print_player();打印玩家棋盘
	
	while (1)//循环扫雷
	{
		int ret=sweep_mine();//扫雷,踩到雷返回1，没有踩到雷返回0
		if (count_show_mine() == COUNT)//若玩家棋盘的'*'个数为雷数时，扫雷完成，游戏胜利
		{
			print_mine();//打印设计者棋盘
			printf("玩家赢！\n\n");
			finish = clock();//取结束时间
			printf("用时%d 秒\n",(int) (finish - start) / CLOCKS_PER_SEC);
			break;
		}
		if (ret)//判断是否踩到雷
		{
			printf("被雷炸死\t");
			finish = clock();//取结束时间
			printf("用时%d 秒\n", (int)(finish - start) / CLOCKS_PER_SEC);
			print_mine();//打印设计者雷阵查看雷的分布
			break;
		}print_player();//打印玩家棋盘
	}
}


int main()
{
	srand((unsigned int)time(NULL));//产生随机数生成器
	int input = 0;
	muen();//菜单
	do
	{
		scanf("%d", &input);
		switch (input)
		{
		case 1:game();
			break;
		case 0:exit(1);//退出游戏
			break;
		default:
			printf("输入错误，重新输入\n");
			break;
		}
		muen();
		printf("contiue?\n");
	} while (1);//循环玩游戏
	system("pause");
	return 0;
}

在头文件game.h中声明各种函数：
game.h

#ifndef __GAME_H__
#define __GAME__H__

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

#define row 12
#define col 12
#define COUNT 10//棋盘中雷的总数
extern char show_mine[row][col];//展示数组
extern char real_mine[row][col];//布雷数组

void muen();//菜单函数
void init_mine();//初始化数组函数
void set_mine();//布雷函数
int count_mine();//统计周围雷的个数
void print_player();//打印玩家棋盘
void print_mine();//打印设计者棋盘 
int  sweep_mine();//扫雷函数
void safe_mine();//避免第一次被雷炸死的函数
void open_mine(int x, int y);//展开函数
int count_show_mine(); ///判断玩家棋盘剩余未知区域的个数

#endif  //__GAME_H__

将上面这个函数放在main.c文件中

以上我们便完成了扫雷的所有C语言代码，接下来我们测验一下：

  1. 检测第一次是否能不被炸死
  2. 检测周围没雷可以展开
    这里写图片描述

总结

测试显示我们的代码没有问题，我们总结一下，这个程序的难点的就是如何实现展开和和保证第一次不被炸死，如果你仔细理解以上的程序，你就会明白其中的原理，包括为什么要在数组元素周围多一圈元素，这些模块都是游戏的核心，等你掌握了这个程序，你的逻辑思维能力就会有很大的提高！

附game.c文件源码:

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
char show_mine[row][col] = { 0 };
char real_mine[row][col] = { 0 };


void muen()
{
	printf("*******************************\n");
	printf("*****1.play       0.exit*******\n");
	printf("*******************************\n");
}


void init_mine()//初始化两个棋盘
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++) 
	{
		for (j = 0; j < col; j++)
		{
			show_mine[i][j] = '*';
			real_mine[i][j] = '0';
		}
	}
}


void print_player()//打印玩家棋盘
{
	int i = 0;
	int j = 0;
	printf("0  ");
	for (i = 1; i <row-1; i++)
	{
		printf("%d ", i);//打印横标（0--10）
	}
	printf("\n");
	for (i = 1; i <row-2; i++)//打印竖标（1--10）
	{
		printf("%d  ", i);
		for (j = 1; j < col-1; j++)
		{
			printf("%c ", show_mine[i][j]);//玩家棋盘数组
		}
		printf("\n");
	}
	printf("10 ");//开始打印最后一行
	for (i = 1; i < row-1; i++)
	{
		printf("%c ", show_mine[10][i]);
	}
	printf("\n");
}


void print_mine()//打印设计者棋盘
{
	int i = 0;
	int j = 0;
	printf("0  ");
	for (i = 1; i <row - 1; i++)
	{
		printf("%d ", i);//打印横标（0--10）
	}
	printf("\n");
	for (i = 1; i <row - 2; i++)//打印竖标（1--10）
	{
		printf("%d  ", i);
		for (j = 1; j < col - 1; j++)
		{
			printf("%c ", real_mine[i][j]);
		}
		printf("\n");
	}
	printf("10 ");//开始打印最后一行
	for (i = 1; i < row - 1; i++)
	{
		printf("%c ", real_mine[10][i]);
	}
	printf("\n");
}



void set_mine()//给设计者棋盘布雷
{
	int x = 0;
	int y = 0;
	int count = COUNT;//雷总数
	while (count)//雷布完后跳出循环
	{
		int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
		int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
		if (real_mine[x][y] == '0')//找不是雷的地方布雷
		{
			real_mine[x][y] = '1';
			count--;
		}
	}
}


int count_mine(int x, int y)//检测周围8个区域雷的个数
{
	int count = 0;
	if (real_mine[x - 1][y - 1] == '1')
		count++;
	if (real_mine[x - 1][y] == '1')
		count++;	
	if (real_mine[x - 1][y + 1] == '1')
		count++;
	if (real_mine[x][y - 1] == '1')
		count++;	
	if (real_mine[x][y + 1] == '1')
		count++;	
	if (real_mine[x + 1][y - 1] == '1')
		count++;	
	if (real_mine[x + 1][y] == '1')
		count++;	
	if (real_mine[x + 1][y + 1] == '1')
		count++;
	return count;
}

void safe_mine()//避免第一次炸死
{
	int x = 0;
	int y = 0;
	char ch = 0;
	int count = 0;
	int ret = 1;
	printf("输入坐标扫雷\n");
	while (1)
	{
		scanf("%d%d", &x, &y);//只能输入1到10，输入错误重新输入
		if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误
		{
			if (real_mine[x][y] == '1')//第一次踩到雷后补救
			{
				real_mine[x][y] = '0';
				char ch = count_mine(x, y);
				show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				while (ret)//在其余有空的地方设置一个雷
				{
					int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
					int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
					if (real_mine[x][y] == '0')//找不是雷的地方布雷
					{
						real_mine[x][y] = '1';
						ret--;
						break;
					}
				}break;//跳出此函数	
			}
			if (real_mine[x][y] == '0')
			{
				char ch = count_mine(x, y);
				show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				break;
			}
		}
		else//坐标错误
		{
			printf("输入错误重新输入\n");
		}
	}
}


int sweep_mine()//扫雷函数，踩到雷返回1，没有踩到雷返回0
{
	int x = 0;
	int y = 0;
	int count = 0;
	printf("输入坐标扫雷\n");
		scanf("%d%d", &x, &y);//只能输入1到10
		if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误，输入错误重新输入
		{
			if (real_mine[x][y] == '0')//没踩到雷
			{
				char ch = count_mine(x,y);
				show_mine[x][y] = ch+'0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
				open_mine(x, y);
				if (count_show_mine() == COUNT)//判断剩余未知区域的个数，个数为雷数时玩家赢
				{
					print_mine();
					printf("玩家赢！\n\n");
					return 0;
				}
			}
			else if (real_mine[x][y]=='1')//踩到雷
			{
				return 1;
			}

		}
		else
		{
			printf("输入错误重新输入\n");
		}
	return 0;//没踩到雷
}



void open_mine(int x, int y)//坐标周围展开函数
{
	if (real_mine[x - 1][y - 1]== '0')
	{
		show_mine[x - 1][y - 1] = count_mine(x - 1, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x - 1][y] == '0')
	{
		show_mine[x - 1][y] = count_mine(x - 1, y) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x - 1][y + 1] == '0')
	{
		show_mine[x - 1][y + 1] = count_mine(x - 1, y + 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x][y - 1] == '0')
	{
		show_mine[x][y - 1] = count_mine(x, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x][y + 1] == '0')
	{
		show_mine[x][y + 1] = count_mine(x, y + 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y - 1] == '0')
	{
		show_mine[x + 1][y - 1] = count_mine(x + 1, y - 1) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y] == '0')
	{
		show_mine[x + 1][y] = count_mine(x + 1, y) + '0';//显示该坐标周围雷数
	}
	if (real_mine[x + 1][y + 1] == '0')
	{
		show_mine[x + 1][y + 1] = count_mine(x + 1, y + 1) + '0';//显示该坐标周围雷数
	}
}


int count_show_mine()//判断剩余未知区域的个数，个数为雷数时玩家赢
{
	int count = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i <= row - 2; i++)
	{
		for (j = 1; j <= col - 2; j++)
		{
			if (show_mine[i][j] == '*')
			{
				count++;
			}
		}

	}
	return count;
}
CodeMoggy
关注
  • 190
    点赞
  • 踩
  • 712
    收藏
    觉得还不错? 一键收藏
  • 33
    评论
专栏目录
C语言实现扫雷游戏及其优化
08-25
主要为大家详细介绍了C语言实现扫雷游戏及其优化，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言——如何实现扫雷游戏，详细解析
昵称就是昵称吧的博客
04-04 2491
目录 一、扫雷游戏介绍 二、基本流程设计思路 三、代码实现 1、整体框架 2、菜单选项 3、游戏内部的实现 3.1 雷盘的初始化 3.2 打印雷盘 3.3 布置雷 3.4 扫雷 四、总代码 1、主函数源文件test.c 2、头文件game.h 3、自定义函数源文件game.c 五、代码运行实例展示 一、扫雷游戏介绍 扫雷游戏的规则是，当点击某个位置时： 如果这个位置有雷，玩家就会被炸，展示雷盘中所有雷的位置，游戏结束； 如果这个位置没有雷，则点击的这个位置..
C#进阶：扫雷 附完整源码与解读
最新发布
Serendipitor的博客
02-29 299
C#版本扫雷，有flag标记和计时功能，难度自适应。原创代码，源码完整，思路解析清晰。
【C语言项目】扫雷（详解，附图、附代码示范）
weixin_70218204的博客
07-27 732
C语言扫雷详解，附代码示范
C语言扫雷游戏简单实现
爱编程的鱼的博客
07-02 1091
定义二维数组存放雷时，将数组定义大两个，9×9的棋盘采用11×11的数组，如此，即便是判断边缘格子时也可以采用一样的函数，不用担心越界；定义函数时，可将只会在本.c文件中用到的函数前加上static，防止其他文件调用，同时也让在其他.c文件中定义函数时更为方便；// B、未踩雷->a、周边有雷->显示雷的数量。printf("------- 扫雷 ------\n");printf("------- 扫雷 ------\n");printf("此处有雷，游戏结束\n");
C语言实现扫雷游戏
m0_47179741的博客
08-17 2183
C语言实现扫雷游戏
c++自制game.h头文件
11-15
解压后放到D盘 写代码时加上1行代码： #include <D:\game.h>即可 相当于万能头文件+fstream库+windows.h库+conio.h库 还有一些类型和函数
【C语言】 -- 扫雷（代码+详解）
Ljy_cx_21_4_3的博客
02-16 6454
详解版扫雷，全是干货，很详细。
C语言扫雷(三个版本 - 简单易懂)
qq_74319491的博客
11-02 180
C语言扫雷游戏
【C语言】 扫雷游戏(保姆级的实现过程)
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
03-15 1万+
扫雷游戏，想必大家都有玩过吧。没完过的话也可以试着玩一玩，这样对写扫雷游戏这个小游戏的化是会有一个很好的思路的。那么本片博客就来介绍如何实现扫雷游戏的具体步骤。扫雷游戏链接????扫雷游戏网页版 - Minesweeper ​
详解C语言实现扫雷游戏
weixin_73053512的博客
05-13 1605
优点实现了扫雷函数的大部分功能，比如展开，标记，清除标记等等。游戏难度没办法由玩家手动设置，扫雷过程中标记和清除标记的顺序比较固定，这些交由读者来完善~
C语言实现——“扫雷小游戏”
01-09
内含：代码、图片、音乐、可运行的exe文件。 关注——下载——取关，一气呵成。
小白C语言实现扫雷游戏
02-17
利用函数和数组的有关知识，C语言实现简单的扫雷游戏，有助于刚学习C语言的新手对于代码和逻辑结构的理解和运用，比较有价值
C语言实现扫雷程序
08-25
主要为大家详细介绍了C语言实现扫雷程序，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言贪吃蛇（详解）——链表实现
热门推荐
一砚梨花雨
05-26 4万+
贪吃蛇设计思路：屏幕坐标：拓展功能：1.F1，F2控制加速减速 空格暂停游戏 Esc退出2.加速每个食物得分更高先打印出游戏界面，还有初始化蛇，蛇的节点用字符串★表示，游戏背景用■表示，因为这些字符串占两个字节的宽度，所以每次x,y坐标的对应关系是x=y*2。在相应位置打印出蛇，初始化蛇为五个节点初始化蛇头的移动方向为右，根据按键来确定蛇的移动状态，要是吃到食物，就让食物为蛇头，然后随机生成食...
头文件windows.h和宏定义而引发的错误
一砚梨花雨
04-03 3160
先看下面一段代码：#define _CRT_SECURE_NO_WARNINGS 1 #define N 6 #include&lt;stdio.h&gt; #include&lt;Windows.h&gt; int main() { printf("%d \n", N); system("pause"); return 0; }这段代码一般人觉得对很正常，%90的人都会觉得没错，但是...
你必须掌握的C语言运算符都在这
一砚梨花雨
11-24 2375
分类 1.算术操作符 2.移位操作符 3.位操作符 4.赋值操作符 5.单目操作符 解引用操作符： （类型）强制转换 6.关系操作符 7.逻辑操作符 8.条件操作符： 9.逗号表达式： 10.下表引用，函数调用和结构成员 分类 1.算术操作符 + - * / % 加减法和数学中的一样 ， 其中乘除法对于整数的结果是整数，对于浮点数的结果...
用C语言实现1——n中，9的个数
04-03
以下是用C语言实现1——n中，9的个数的代码： ```c #include <stdio.h> int countNine(int n) { int count = 0; for (int i = 1; i <= n; i++) { int num = i; while (num > 0) { if (num % 10 == 9) { count++; } num /= 10; } } return count; } int main() { int n; printf("请输入一个正整数n："); scanf("%d", &n); printf("1——%d中，9的个数为：%d\n", n, countNine(n)); return 0; } ``` 首先定义一个函数`countNine`，它的参数是一个整数`n`，表示要求1——n中9的个数。在函数中，定义一个计数器`count`，初始化为0。然后用一个循环从1到n枚举每一个数，对于每一个数，使用一个循环不断取出它的个位数字，如果是9，则计数器加1，然后将这个数除以10，去掉个位数字，继续判断下一个数字。最后返回计数器的值。 在`main`函数中，先读入一个正整数n，然后调用`countNine`函数求出1——n中9的个数，并输出结果。 以上就是用C语言实现1——n中，9的个数的代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值