(C语言篇)扫雷的实现

news2024/9/23 5:30:24

文章目录

  • 一、开始时的基本思维：
  • 二、进入游戏的逻辑(test.c文件中实现)
  • 三、游戏的编写
    • 1. 初始化棋盘
      • I. test.c
      • II. game.h
      • III. game.c
    • 2.打印棋盘
      • I. test.c
      • II. game.h
      • III. game.c
    • 3.布置雷
      • I. test.c
      • II. game.h
      • III. game.c
    • 4.排查雷
      • I. test.c
      • II. game.h
      • III. game.c
  • 四、完整代码
    • 1.test.c
    • 2.game.h
    • 3.game.c

前言：本次扫雷分为三个文件，分别为test.c、game.h、game.c文件，其中test.c文件主要是用来实现扫雷的逻辑，game.c用于编写游戏的主要实现方法。
在这里插入图片描述

一、开始时的基本思维：

在这里插入图片描述

这里我们可以看到要实现初级的扫雷需要9 * 9的格子，所以需要使用一个二维数组，而我们需要创建两个棋盘，一个是用于放雷的(玩家不可见)，一个是用于排查显示的。

在这里插入图片描述

二、进入游戏的逻辑(test.c文件中实现)

#include "game.h"


void menu() {
	printf("-------------欢迎进入超好玩的扫雷游戏---------------
");
	printf("---------------       1.play       ---------------
");
	printf("---------------       0.exit       ---------------
");
	printf("--------------------------------------------------
");
}
void test() {
	int input = 0;
	do {
		menu();//打印菜单
		printf("请输入1/0: ");
		scanf("%d", &input);
		printf("
");
		switch (input) {
		case 1:
			printf("进入游戏
");
			break;
		case 0:
			printf("退出游戏: 
");
			break;
		default:
			printf("你很调皮哦没有输入正确的数字，请重新输入！
");
		}
	} while(input);
}
int main() {

	test();
	return 0;
 }

这里头文件的引用就不再介绍了讲三子棋的时候有说过。这里我们来看看效果：

在这里插入图片描述

这里我们可以看到进入游戏的逻辑没有问题，这时就可以把case 1:中的 printf(“进入游戏 ”);改为game函数了。

三、游戏的编写

1. 初始化棋盘

I. test.c

void game() {
	//创建两个字符数组
	char mine[ROWS][COLS] = { 0 };  //用于放雷
	char show[ROWS][COLS] = { 0 };  //用于存放显示不是雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');  //这里我们把数组全部初始化为'0'，代表没有雷  
	InitBoard(show, ROWS, COLS, '*');  //这里用'*'进行显示
	
}

II. game.h

//头文件的包含
#include <stdio.h>

//符号的声明
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2

//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char a);

这里使用#define是方便于改变。如果想做难度高的扫雷可以随时改变棋盘大小。

III. game.c

#include "game.h"

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

2.打印棋盘

初始化完后我们就需要打印棋盘了。

I. test.c

void game() {
	//创建两个字符数组
	char mine[ROWS][COLS] = { 0 };  //用于放雷
	char show[ROWS][COLS] = { 0 };  //用于存放显示不是雷的信息
	//初始化棋盘
	InitBoard(mine, ROW, COL, '0');  //这里我们把数组全部初始化为'0'，代表没有雷 
	InitBoard(show, ROW, COL, '*');  //这里用'*'进行显示
	//打印棋盘
	PrintBoard(mine, ROW, COL);
	PrintBoard(show, ROW, COL);
	
}

这里传的数组还是11* 11，因为我们只操作中间的9*9的数，所以在传行和列时只需要传大小为9的就行。

II. game.h

//头文件的包含
#include <stdio.h>

//符号的声明
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2

//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int row, int col, char a);
//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col);

III. game.c

//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col) {
	int i = 0;
	int j = 0;
	for (i = 1; i <= row; i++) {	
		for (j = 1; j <= col; j++) {	
			printf(" %c ", board[i][j]);
		}
		printf("
");  //打印完一行需要换行
	}
}

这里我们可以看到棋盘打印出来了，但是这样的话玩家进行判断时还要数他是几行几列，有点麻烦所以可以加上坐标。

在这里插入图片描述

可以改为：

//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col) {
	int i = 0;
	int j = 0;
	//打印列号
	for (i = 0; i <= col; i++) {
		printf("%d ", i);
	}
	printf("
");
	for (i = 1; i <= row; i++) {
		printf("%d ", i); //打印行号
		for (j = 1; j <= col; j++) {
			
				printf("%c ", board[i][j]);
		}
		printf("
");  //打印完一行需要换行

	}
}

接下来我们来看看结果：
在这里插入图片描述

3.布置雷

当我们实现棋盘的打印后就可以布置雷了

I. test.c

void game() {
	//创建两个字符数组
	char mine[ROWS][COLS] = { 0 };  //用于放雷
	char show[ROWS][COLS] = { 0 };  //用于存放显示不是雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');  //这里我们把数组全部初始化为'0'，代表没有雷 
	InitBoard(show, ROWS, COLS, '*');  //这里用'*'进行显示
	//打印棋盘
	//PrintBoard(mine, ROW, COL);
	//printf("
");
	//PrintBoard(show, ROW, COL);

	//布置雷
	PutMine(mine, ROW, COL);
	PrintBoard(mine, ROW, COL); 
}

注意想要使用rand函数需要在test函数里加入：
srand((unsigned int)time(NULL));

II. 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 COUNT 10

//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int row, int col, char a);
//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col);

使用rand函数时需要包含#include <stdlib.h>这个头文件，time函数需要包含#include <time.h>头文件。

III. game.c

//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col) {
	int count = 10;//10个雷
	while (count) {
		int x = rand() % row + 1;//生成1~9的随机数
		int y = rand() % col + 1;
		if (mine[x][y] == '0') {		//排除1重复在一个位置的可能
			mine[x][y] = '1';
			count--;
		}
	}
}

通过下图可以看出我们成功的布置了10个雷：

在这里插入图片描述

4.排查雷

I. test.c

void game() {
	//创建两个字符数组
	char mine[ROWS][COLS] = { 0 };  //用于放雷
	char show[ROWS][COLS] = { 0 };  //用于存放显示不是雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');  //这里我们把数组全部初始化为'0'，代表没有雷
	InitBoard(show, ROWS, COLS, '*');  //这里用'*'进行显示
	//打印棋盘
	//PrintBoard(mine, ROW, COL);
	//printf("
");
	//PrintBoard(show, ROW, COL);

	//布置雷
	PutMine(mine, ROW, COL);
	//PrintBoard(mine, ROW, COL);
	PrintBoard(show, ROW, COL);

	//排雷
	FineMine(mine, show, ROW, COL);
}

II. 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


//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int row, int col, char a);
//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col);
//排雷
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

III. game.c

//排雷

//判断玩家输入坐标周围有几个雷
int 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');//周围有8格所以乘8个'0'
}
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
	int x = 0;
	int y = 0;
	int win = 0; 
	while (win < row * col - 10) {  //当排了71次后就表示赢了	
		printf("请输入坐标: ");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col) {  //限制输入1~9的数
			if (mine[x][y] == '1') {  //中雷
				printf("恭喜你被雷砸上天了，祝你旅行愉快，游戏结束
");
				PrintBoard(mine, row, col);//打印
				break;
			}
			else {
				int num = mine_count(mine, x, y);  //判断玩家输入坐标周围有几个雷并且返回，需要用mine数组判断
				show[x][y] = num + '0';  //因为num是整型所以需要加一个'0'使其变为字符型。加了'0'后还是num这个数。
				PrintBoard(show, row, col);
				win++;
			}
		}
		else {
			printf("你输入的值不在范围内，请重新输入
");
		}
	}
	if (win == row * col - 10) {
		printf("恭喜你，你成功了，剩下的都是雷
");
		PrintBoard(mine, row, col);	//赢了打印雷在哪里
	}
}

对字符转化的思想及判断周围有几个雷的思想：
在这里插入图片描述在这里插入图片描述运行结果：
从图中可以看出，当输入坐标时，它就会显示周围有几个雷
在这里插入图片描述
踩雷时：
在这里插入图片描述
赢时:

为了方便这里我们可以在头文件用#define MINE_COUNT规定雷的总数，这样需要改时就在头文件改即可，为了快速测出赢了我们设置80给雷并且显示mine函数：
此时代码变为：
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 MINE_COUNT 80

//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int row, int col, char a);
//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col);
//排雷
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

game.c
这里涉及到用#define MINE_COUNT雷的改变为布雷时候和排雷时

//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col) {
	int count = MINE_COUNT;
	while (count) {
		int x = rand() % row + 1;//生成1~9的随机数
		int y = rand() % col + 1;
		if (mine[x][y] == '0') {		//排除1重复在一个位置的可能
			mine[x][y] = '1';
			count--;
		}
	}
}

//排雷

//判断玩家输入坐标周围有几个雷
int 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');//周围有8格所以乘8个'0'
}
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
	int x = 0;
	int y = 0;
	int win = 0; 
	while (win < row * col - MINE_COUNT) {  //当排了71次后就表示赢了	
		printf("请输入坐标: ");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col) {  //限制输入1~9的数
			if (mine[x][y] == '1') {  //中雷
				printf("恭喜你被雷砸上天了，祝你旅行愉快，游戏结束
");
				PrintBoard(mine, row, col);//打印
				break;
			}
			else {
				int num = mine_count(mine, x, y);  //判断玩家输入坐标周围有几个雷并且返回，需要用mine数组判断
				show[x][y] = num + '0';  //因为num是整型所以需要加一个'0'使其变为字符型。加了'0'后还是num这个数。
				PrintBoard(show, row, col);
				win++;
			}
		}
		else {
			printf("你输入的值不在范围内，请重新输入
");
		}
	}
	if (win == row * col - MINE_COUNT) {
		printf("恭喜你，你成功了，剩下的都是雷
");
		PrintBoard(mine, row, col);//赢了打印雷在哪里
	}
}

如图可以看到当我们输入3 8时就赢了：

在这里插入图片描述赢了：
在这里插入图片描述

四、完整代码

1.test.c

#include "game.h"
void game() {
	//创建两个字符数组
	char mine[ROWS][COLS] = { 0 };  //用于放雷
	char show[ROWS][COLS] = { 0 };  //用于存放显示不是雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');  //这里我们把数组全部初始化为'0'，代表没有雷
	InitBoard(show, ROWS, COLS, '*');  //这里用'*'进行显示
	//打印棋盘
	//PrintBoard(mine, ROW, COL);
	//printf("
");
	//PrintBoard(show, ROW, COL);

	//布置雷
	PutMine(mine, ROW, COL);
	PrintBoard(mine, ROW, COL);
	printf("
");
	PrintBoard(show, ROW, COL);

	//排雷
	FineMine(mine, show, ROW, COL);
}

void menu() {
	printf("-------------欢迎进入超好玩的扫雷游戏-------------
");
	printf("---------------       1.play       ---------------
");
	printf("---------------       0.exit       ---------------
");
	printf("--------------------------------------------------
");
}
void test() {
	int input = 0;
	srand((unsigned int)time(NULL));
	do {
		menu();//打印菜单
		printf("请输入1/0: ");
		scanf("%d", &input);
		printf("
");
		switch (input) {
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏: 
");
			break;
		default:
			printf("你很调皮哦没有输入正确的数字，请重新输入！
");
		}
	} while(input);
}
int main() {

	test();
	return 0;
}

2.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 MINE_COUNT 10

//函数声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int row, int col, char a);
//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col);
//排雷
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

3.game.c

#include "game.h"


//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char a) {
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++) {	//这里一定要初始化全部，不然后面计算周围有几个雷时会出错。
		for (j = 0; j < cols; j++) {	
			board[i][j] = a;
		}
	}
}

//打印棋盘
void PrintBoard(char board[ROWS][COLS], int row, int col) {
	int i = 0;
	int j = 0;
	//打印列号
	for (i = 0; i <= col; i++) {
		printf("%d ", i);
	}
	printf("
");
	for (i = 1; i <= row; i++) {
		printf("%d ", i); //打印行号
		for (j = 1; j <= col; j++) {
			
				printf("%c ", board[i][j]);
		}
		printf("
");  //打印完一行需要换行

	}
}


//布置雷
void PutMine(char mine[ROWS][COLS], int row, int col) {
	int count = MINE_COUNT;
	while (count) {
		int x = rand() % row + 1;//生成1~9的随机数
		int y = rand() % col + 1;
		if (mine[x][y] == '0') {		//排除1重复在一个位置的可能
			mine[x][y] = '1';
			count--;
		}
	}
}

//排雷

//判断玩家输入坐标周围有几个雷
int 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');//周围有8格所以乘8个'0'
}
void FineMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
	int x = 0;
	int y = 0;
	int win = 0; 
	while (win < row * col - MINE_COUNT) {  //当排了71次后就表示赢了	
		printf("请输入坐标: ");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col) {  //限制输入1~9的数
			if (mine[x][y] == '1') {  //中雷
				printf("恭喜你被雷砸上天了，祝你旅行愉快，游戏结束
");
				PrintBoard(mine, row, col);//打印
				break;
			}
			else {
				int num = mine_count(mine, x, y);  //判断玩家输入坐标周围有几个雷并且返回，需要用mine数组判断
				show[x][y] = num + '0';  //因为num是整型所以需要加一个'0'使其变为字符型。加了'0'后还是num这个数。
				PrintBoard(show, row, col);
				win++;
			}
		}
		else {
			printf("你输入的值不在范围内，请重新输入
");
		}
	}
	if (win == row * col - MINE_COUNT) {
		printf("恭喜你，你成功了，剩下的都是雷
");
		PrintBoard(mine, row, col);//赢了打印雷在哪里
	}
}

好了，扫雷就暂时讲到这里了，因博主能力有限，这次的扫雷小游戏还有很多可以优化的地方，如右键标记，输入一个坐标会展开一片等等。当然等博主再厉害点会优化的这些功能的。喜欢的可以点个赞哦。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/357155.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java集合学习之Map

Java集合学习之Map

1.什么是Map Java里的Map接口是一个集合根接口&#xff0c;表示一个 键值对&#xff08;Key-Value&#xff09; 的映射。 简单来说就是键和值是一对的&#xff0c;每一个 Key都有唯一确定的 Value对应。 其中要求 键&#xff08;Key&#xff09; 唯一&#xff0c;因为是按照…
阅读更多...
宏观经济研究：全国各省、地级市-社会融资规模增量数据（包含总额及8类明细）2013-2021年

宏观经济研究：全国各省、地级市-社会融资规模增量数据（包含总额及8类明细）2013-2021年

数据来源&#xff1a;中国人民银行 时间跨度&#xff1a;2013-2021年&#xff0c;季度数据&#xff08;累计数&#xff09; 区域范围&#xff1a;全国31省份 数据字段&#xff1a; 31个省市社会融资规模增量数据&#xff0c;包含社会融资总额以及8类明细&#xff08;人民币…
阅读更多...
12-Composer的配置与使用详解

12-Composer的配置与使用详解

1、自定义类与非类的自动加载与测试 # composer> php 包管理工具 &#xff0c;类似npm1.自己写的类&#xff0c;函数&#xff0c;接口&#xff0c;常量等全局成员&#xff0c;通过自动加载来实现按需加载 2.自己写的代码&#xff0c;有哪些依赖&#xff0c;用到了哪些外部成…
阅读更多...
MySQL数据库调优————GROUP BY及DISTINCT优化

MySQL数据库调优————GROUP BY及DISTINCT优化

GROUP BY 三种处理GROUP BY的方式 松散索引扫描&#xff08;Loose Index Scan&#xff09;紧凑索引扫描&#xff08;Tight Index Scan&#xff09;临时表&#xff08;Temporary table&#xff09; 三种方式的性能一次递减 松散索引扫描 无需扫描满足条件的所有索引键即可返…
阅读更多...
基于SSM,Spring, BootStrap 毕业设计管理系统的设计与实现

基于SSM,Spring, BootStrap 毕业设计管理系统的设计与实现

目录 一.前言介绍 二、主要技术 2.1 SSM框架介绍 2.2 MYSQL数据库 2.3 持久层框架MyBatis 2.4 前端框架BootStrap 三. 系统设计 3.1 系统架构设计 3.2 系统功能模块 3.2.1 学生模块 3.2.2 教师模块 3.2.3 管理员模块 四、数据库设计 4.1 数据分析 4.2 概念设计 …
阅读更多...
SpringBoot搭建SpringMVC项目

SpringBoot搭建SpringMVC项目

前言据我的了解&#xff0c;现在不管是大公司或是小公司&#xff0c;如果使用java开发一个web项目&#xff0c;大部分都会选择使用SpringBoot&#xff0c;关于Springboot的好处&#xff0c;就不在这里过多赘述&#xff0c;总之Springboot有一套完整的生态&#xff0c;从项目构建…
阅读更多...
Java【七大排序】算法详细图解，一篇文章吃透

Java【七大排序】算法详细图解，一篇文章吃透

文章目录一、排序相关概念二、七大排序1&#xff0c;直接插入排序2&#xff0c;希尔排序3&#xff0c;选择排序4&#xff0c;堆排序5&#xff0c;冒泡排序5.1冒泡排序的优化6&#xff0c;快速排序6.1 快速排序的优化7&#xff0c;归并排序三、排序算法总体分析对比总结提示&…
阅读更多...
多层感知机

多层感知机

多层感知机理论部分 本文系统的讲解多层感知机的pytorch复现&#xff0c;以及详细的代码解释。 部分文字和代码来自《动手学深度学习》&#xff01;&#xff01; 目录多层感知机理论部分隐藏层多层感知机数学逻辑激活函数1. ReLU函数2. sigmoid函数3. tanh函数多层感知机的从零…
阅读更多...
Allegro如何快速把推挤的走线变平滑操作指导

Allegro如何快速把推挤的走线变平滑操作指导

Allegro如何快速把推挤的走线变平滑操作指导 Allegro有个非常强大的功能，推挤命令，可以快速的让走线以不报DRC的形式避让目标 推挤后的效果如下图 但是走线不够平滑，如果每一段都去再推一下比较费时间，下面介绍allegro本身自带的优化类似走线的功能 具体操作如下 点击Rout…
阅读更多...
sklearn学习-朴素贝叶斯

sklearn学习-朴素贝叶斯

文章目录一、概述1、真正的概率分类器2、sklearn中的朴素贝叶斯二、不同分布下的贝叶斯1、高斯朴素贝叶斯GaussianNB2、探索贝叶斯&#xff1a;高斯朴素贝叶斯擅长的数据集3、探索贝叶斯&#xff1a;高斯朴素贝叶斯的拟合效果与运算速度总结一、概述 1、真正的概率分类器 算法…
阅读更多...
计算机组成与体系结构

计算机组成与体系结构

目录 1.计算机结构 2.寻址方式 3.CISC与RISC 4.流水线 1.计算机结构 运算器 算术逻辑单元ALU&#xff1a;数据的算术运算和逻辑运算累加寄存器AC&#xff1a;通用寄存器&#xff0c;为ALU提供一个工作区&#xff0c;用在暂存数据数据缓存寄存器DR&#xff1a;写内存中&…
阅读更多...
Linux LVM逻辑卷

Linux LVM逻辑卷

目录 LVM逻辑卷 什么是LVM LVM常用术语 管理逻辑卷相关命令 创建LVM逻辑卷 LVM扩容 LVM缩小 LVM快照卷 删除LVM LVM逻辑卷 什么是LVM LVM&#xff08;Logical Volume Manager&#xff09;逻辑卷管理器&#xff0c;是一种硬盘的虚拟化技术&#xff0c;能够实现用户对硬…
阅读更多...
基于微信小程序的校园顺路代送小程序

基于微信小程序的校园顺路代送小程序

文末联系获取源码 开发语言&#xff1a;Java 框架&#xff1a;ssm JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7/8.0 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven3.3.9 浏览器…
阅读更多...
还真不错，今天 Chatgpt 教会我如何开发一款小工具开发(Python 代码实现)

还真不错，今天 Chatgpt 教会我如何开发一款小工具开发(Python 代码实现)

上次使用 Chatgpt 写爬虫&#xff0c;虽然写出来的代码很多需要修改后才能运行&#xff0c;但Chatgpt提供的思路和框架都是没问题。 这次让 Chatgpt 写一写GUI程序&#xff0c;也就是你常看到的桌面图形程序。 由于第一次测试&#xff0c;就来个简单点的&#xff0c;用Python…
阅读更多...
Linux命令之grep

Linux命令之grep

Linux grep是一个非常强大的文本搜索工具。按照给定的正则表达式对目标文本进行匹配检查&#xff0c;打印匹配到的行。grep命令可以跟其他命令一起使用&#xff0c;对其他命令的输出进行匹配。 grep语法如下&#xff1a; grep [options] [pattern] content 文本检索 grep可以对…
阅读更多...
51单片机蜂鸣器的使用

51单片机蜂鸣器的使用

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、有源蜂鸣器和无源蜂鸣器的区别二、代码编写总结前言 本文旨在介绍如何使用51单片机驱动蜂鸣器。 一、有源蜂鸣器和无源蜂鸣器的区别 有源蜂鸣器是一种电子…
阅读更多...
easyExcel 写复杂表头

easyExcel 写复杂表头

写模板 模板图片&#xff1a; 实体类&#xff08;这里没有用Data 是因为Lombok和easyExcal的版本冲突&#xff0c;在导入读取的时候获取不到值&#xff09; package cn.iocoder.yudao.module.project.controller.admin.goods.vo;import com.alibaba.excel.annotation.ExcelI…
阅读更多...
编译安装MySQL

编译安装MySQL

MySQL 5.7主要特性 随机root 密码&#xff1a;MySQL 5.7 数据库初始化完成后&#xff0c;会自动生成一个 rootlocalhost 用户&#xff0c;root 用户的密码不为空&#xff0c;而是随机产生一个密码。原生支持&#xff1a;Systemd 更好的性能&#xff1a;对于多核CPU、固态硬盘、…
阅读更多...
【蓝桥集训】第四天——双指针

【蓝桥集训】第四天——双指针

作者&#xff1a;指针不指南吗 专栏&#xff1a;Acwing 蓝桥集训每日一题 &#x1f43e;或许会很慢&#xff0c;但是不可以停下&#x1f43e; 文章目录1.字符串删减2.最长连续不重复子序列3.数组元素的目标和1.字符串删减 给定一个由 n 个小写字母构成的字符串。 现在&#xff…
阅读更多...
GCC 同名符号冲突解决办法

GCC 同名符号冲突解决办法

一、绪论 作为 C/C 的开发者&#xff0c;大多数都会清楚课本上动态库以及静态库的优缺点&#xff0c;在教科书上谈及到动态库的一个优点是可以节约磁盘和内存的空间&#xff0c;多个可执行程序通过动态库加载的方式共用一段代码段 &#xff1b;而时至今日&#xff0c;再看看上…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023