贝蒂快扫雷~（C语言）

         ✨✨欢迎大家来到贝蒂大讲堂✨✨

        ​​​​🎈🎈养成好习惯，先赞后看哦~🎈🎈

                 所属专栏：贝蒂的游戏        

                 贝蒂的主页：Betty‘s blog

引言：

          扫雷相信大家小时候到玩过吧，那我们通过目前已学的知识，自己实现一个扫雷小游戏呢，答案自然是肯定的。

         本章你可能会用到的知识：

         1. 数组的使用：小小数组，给贝蒂坐下

         2. 随机数的生成：贝蒂的捣蛋小游戏

1. 游戏要求 

1. 玩家可以通过菜单选择玩游戏和退出游戏。

2. 默认棋盘为9×9的格子。

3. 默认雷的个数为10。

4可以排查雷
 （1） 如果位置不是雷，就显⽰周围有⼏个雷，并且循环展开。
 （2）如果位置是雷，就炸死游戏结束
 （3）把除10个雷之外的所有⾮雷都找出来，排雷成功，游戏结束

 （4）玩家可以对认为是雷的位置进行可能是雷或肯定是雷的标记。 

2. 游戏分析

1. 我们要在9×9的棋盘上操作，自然使用数组模拟，并且我们先假设0代表无雷，1代表雷

2. 玩家选择一个格子排查，如果没雷，将显示周围八个格子雷的个数。

    为了解决可能得数组越界问题，所以尝试在外围增加“一圈”。

3. 但是我们不可能把这个棋盘布置的信息给玩家看，所以要创建两个数组，一个数组(mine)负责布置雷的信息，一个数组(show)负责展现给玩家看。

4. 如果玩家排查的位置没有雷，我们将显示周围雷的个数，为了不与布置雷的信息冲突，所以将无雷改为‘0’，有雷改为‘1’。

5. 玩家棋盘初始全为‘*’，代表未排查。 

3. 多文件操作

         为了方便代码的管理和保证游戏实现逻辑的清晰性，我们将采用多文件管理的模式。

        （1）创建头文件game.h，包含所有头文件(其他源文件只需引用它即可)，以及所有游戏功能的展现。

        （2）创建源文件game.c，负责所有功能的具体代码实现。

        （3）创建源文件main.c，负责展现游戏实现的总体逻辑。

4.  简易菜单的实现

  4.1功能

1.玩家可以通过选择1进入游戏，0退出游戏。

2.选错的话提醒玩家，重新选择。

  4.2代码实现 

    为了完成这些目标，我们可以简单的do-while,switch结构实现。

     代码如下：

void menu()
{
	printf("****************************\n");
	printf("*******    1. play    ******\n");
	printf("*******    0. exit    ******\n");
	printf("****************************\n");
}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));//设置时间种子
	do
	{
		menu();//简易菜单的实现
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			system("cls");//清空屏幕，头文件<stdlib.h>
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);//选0结束游戏
	return 0;
}

5. 游戏功能实现

  5.1 预定义信息

#define ROW 9//棋盘的行
#define COL 9//棋盘的列
#define ROWS ROW+2//扩展后的行
#define COLS COL+2//扩展后的列
#define MINES 10//雷的个数
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

  5.2 初始化棋盘

   （1）要求

1. mine棋盘初始化为全‘0’。

2. show棋盘初始化为全‘1’。

    （2）实现
void InitBoard(char board[ROWS][COLS], int rows ,int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			 board[i][j] = set;
		}
	}
}

贝蒂说：“因为在game.c中实现游戏的具体功能，所以千万不要忘了在game.h中声明哦~”

 5.3 打印棋盘

    （1）要求

1. 打印出棋盘中的元素。

2. 利用---,|模拟出棋盘框。

3. 显示出每行，每列的序号。

    （2）实现 
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
    printf("-----------------扫雷游戏----------------\n");
    for (int i = 0; i <= col; i++)
    {
        if (i == 0)
        {
            printf("    ");//四个空格
        }
        else
        {
            printf(" %d  ", i);//两个空格一个数字
        }

    }
    printf("\n");
    for (int i = 0; i <= col; i++)
    {
        if (i == 0)
        {
            printf("   |");//三个空格
        }
        else
        {
            printf("---|");
        }
    }
    printf("\n");
    for (int i = 1; i <= row; i++)
    {
        printf(" %d |", i);
        for (int j = 1; j <= col; j++)
        {
            printf(" %c |", board[i][j]);
        }
        printf("\n");
        for (int j = 1; j <= col; j++)
        {
            if (j == 1)
            {
                printf("   ");//三个空格
                printf("|---|");
            }
            else
            {
                printf("---|");
            }
        }
        printf("\n");
    }
    printf("-------------------结束线----------------\n");
}
  （3）效果展示

  5.4 埋雷 

    （1）要求

1.在mine棋盘中随机布置10个雷，雷为‘0’。

2.重复位置不能布置。

    （2）实现 
void SetMine(char board[ROWS][COLS], int row, int col)
{
    int num = MINES;
    while (num)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0')
        {
            board[x][y] = '1';
            num--;
        }
    }
}
（3）效果展示

 5.5 排雷和标记

  （1）要求·

1. 玩家可以选择排雷或者标记。

2. 保证玩家输入的值合法。

3. 对于同一个坐标，第一次标记为！代表肯定是雷；第二次标记为？代表可能是雷；第三次   标记恢复‘*’。（'!'的数量最多等于雷的数量）

4. 标记时，统计正确标记雷的个数。

5. 排雷时，玩家输入要排除的坐标，如果是雷，则游戏结束；如果不是雷，则统计周围雷的个数。

6. 如果周围没有雷，则向周围展开至有雷或者有标志位置为止。

 贝蒂说：“因为布置的雷为‘1’，字符在内存中是以ascii码值存储，所以统计方法为将周围八个格子值加起来减去8*‘0’。” 

  （2）排雷与递归排雷的实现 
int GetMineCount(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 SpreadBoard(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)//递归排雷
{
    if (x < 1 || x>ROW || y < 1 || y>COL)//坐标不合理不递归
    {
        return;
    }
    if (show[x][y] != '*')//递归结束条件
    {
        return;
    }
    int count = GetMineCount(mine, x, y);
    if (count == 0)//无雷继续扩展
    {
        show[x][y] = ' ';//扩建为' '
        SpreadBoard(mine,show, x, y + 1);
        SpreadBoard(mine,show, x, y - 1);
        SpreadBoard(mine, show, x + 1, y - 1);
        SpreadBoard(mine, show, x + 1, y +1);
        SpreadBoard(mine, show, x + 1, y);
        SpreadBoard(mine, show, x - 1, y + 1);
        SpreadBoard(mine, show, x - 1, y - 1);
        SpreadBoard(mine, show, x - 1, y);
    }
    else
    {
        show[x][y] = '0' + count;//有雷输出个数
    }
}
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)//排查雷
{
    int x = 0;
    int y = 0;
    printf("请输入你要排查的坐标:>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)//坐标要合法
    {
        if (show[x][y] != '*')
        {
            if (show[x][y] == '!' || show[x][y] == '?')
            {
                printf("该位置已被标记，暂时不可排雷！\n");
            }
            else
            {
                printf("该位置已排雷，不可重复排雷！\n");
            }
        }
        else
        {
            if (mine[x][y] == '1')
            {
                return 0;//被炸死
            }
            else
            {
                SpreadBoard(mine, show, x, y);//递归扩展
            }
        }
    }
    else
    {
        printf("坐标非法！\n");
    }
    return 1;
}

  效果展示： 

  （3）标记的实现 
void MineMark(char mine[ROWS][COLS],char show[ROWS][COLS],int row, int col,int *p)
{
    static int sum = 0;//判断！的个数
    if (sum == MINES)
    {
        printf("！已满，请减少！的使用\n");
    }
    int x = 0, y = 0;
    printf("请输入标记的坐标:>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)//输入的坐标数值合法
    {
        if (show[x][y] == '*')//第一次标记
        {
            if (sum < MINES)
            {
                show[x][y] = '!';
                if (mine[x][y] == '1')
                {
                    (*p)++;//统计标记正确雷的个数
                }
                sum++;//！的个数+1
            }
        }
        else if (show[x][y] == '!')//第二次标记
        {
            show[x][y] = '?';
            if (mine[x][y] == '1')
            {
                (*p)--;//标记正确雷的个数减1
            }
            sum--;
        }
        else if(show[x][y]=='?')//第三次标记
        {
            show[x][y] = '*';
        }
        else
        {
            printf("该位置已经排查过，不能标记！\n");
        }
    }
    else
    {
        printf("输入坐标不合法，请重新输入！\n");
    }
}

5.6 胜利条件

（1）要求

1. 成功用‘!’标记所有雷的正确位置，游戏胜利。

2. 或者成功排查完除雷外所有格子，游戏胜利。

（2）实现
int IsWin(char board[ROWS][COLS],int row,int col, int* p)
{
    int count = 0;
    for (int i = 1; i <= row; i++)//遍历所有格子，看看是否已经排查完
    {
        for (int j = 1; j <= col; j++)
        {
            if (board[i][j] != '*' && board[i][j] != '!' && board[i][j] != '?')
            {
                count++;
            }
        }
    }
    if (count == row * col - MINES||*p==MINES)//如果排查完，或者成功标记完雷的个数
    {
        return 1;//游戏胜利
    }

    return 0;
}

6. 游戏主逻辑的搭建 

  6.1搭建顺序

1. 初始化棋盘。

2. 埋雷。

3. 玩家选择标记还是埋雷。

4. 判断玩家是否被炸死。

5. 判断玩家是否胜利。

6.如果步骤4或5未成功执行，就重复执行步骤3,4,5。

  6.2 实现

void game()
{
	char mine[ROWS][COLS]; //存放布置好的雷
	char show[ROWS][COLS]; //展示棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	//DisplayBoard(show, ROW, COL);
	//1. 布置雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//2. 排查雷
	//FindMine(mine, show, ROW, COL);
	int input = 0;
	int flag = 0;
	int num = -1;
	while (1)
	{
		DisplayBoard(show, ROW, COL);
		choose();
		printf("请选择排雷或者标记\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			num=FindMine(mine, show, ROW, COL);
			Sleep(900);//停顿0.9秒
			system("cls");//刷新棋盘
			break;
		case 2:
		    MineMark(mine, show, ROW, COL, &flag);
			Sleep(900);
			system("cls");//刷新棋盘
			break;
		default:
			printf("输入非法情重新输入\n");
			Sleep(900);
			system("cls");//刷新棋盘
			break;
		}
		if (num == 0)//判断是否被炸死
		{
			DisplayBoard(show, ROW, COL);
			DisplayBoard(mine, ROW, COL);
			printf("很遗憾，你被炸死了\n");
			break;
		}
		int ret=IsWin(show,ROW,COL,&flag);
		if (ret)//判断是否胜利
		{
			DisplayBoard(show, ROW, COL);
			DisplayBoard(mine, ROW, COL);
			printf("恭喜你，扫雷成功\n");
			break;
		}
	}
}

 6.3 补充

   为了让玩家正确理解如何进行游戏，我们应该提前告诉玩家游戏规则。

void rules()
{
	printf("游戏规则如下：\n");
	printf("1.你可以通过排雷和标记逐渐逼近胜利条件\n");
	printf("2.对同一坐标标记1次是!，标记2次是?，第3次恢复*\n");
	printf("3.标记!代表肯定是雷，标记?代表可能是雷\n");
	printf("4.标记!的次数最多为雷的个数\n");
	printf("5.如果选中雷，则游戏失败\n");
	printf("6.当成功标记所有雷，或者排查完所有格子，游戏胜利\n");
}

7. 源码 

  （1）main.c

#include"game.h"
void menu()
{
	printf("****************************\n");
	printf("*******    1. play    ******\n");
	printf("*******    0. exit    ******\n");
	printf("****************************\n");
}
void choose()
{
	printf("********************************************\n");
	printf("***************    1. 排雷     *************\n");
	printf("***************    2. 标记     *************\n");
	printf("********************************************\n");
}
void rules()
{
	printf("游戏规则如下：\n");
	printf("1.你可以通过排雷和标记逐渐逼近胜利条件\n");
	printf("2.对同一坐标标记1次是!，标记2次是?，第3次恢复*\n");
	printf("3.标记!代表肯定是雷，标记?代表可能是雷\n");
	printf("4.标记!的次数最多为雷的个数\n");
	printf("5.如果选中雷，则游戏失败\n");
	printf("6.当成功标记所有雷，或者排查完所有格子，游戏胜利\n");
}
void game()
{
	char mine[ROWS][COLS]; //存放布置好的雷
	char show[ROWS][COLS]; //展示棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	//DisplayBoard(show, ROW, COL);
	//1. 布置雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//2. 排查雷
	//FindMine(mine, show, ROW, COL);
	int input = 0;
	int flag = 0;
	int num = -1;
	while (1)
	{
		DisplayBoard(show, ROW, COL);
		choose();
		printf("请选择排雷或者标记\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			num=FindMine(mine, show, ROW, COL);
			Sleep(900);//停顿0.9秒
			system("cls");//刷新棋盘
			break;
		case 2:
		    MineMark(mine, show, ROW, COL, &flag);
			Sleep(900);
			system("cls");//刷新棋盘
			break;
		default:
			printf("输入非法情重新输入\n");
			Sleep(900);
			system("cls");//刷新棋盘
			break;
		}
		if (num == 0)//判断是否被砸死
		{
			DisplayBoard(show, ROW, COL);
			DisplayBoard(mine, ROW, COL);
			printf("很遗憾，你被炸死了\n");
			break;
		}
		int ret=IsWin(show,ROW,COL,&flag);
		if (ret)
		{
			DisplayBoard(show, ROW, COL);
			DisplayBoard(mine, ROW, COL);
			printf("恭喜你，扫雷成功\n");
			break;
		}
	}
}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));//设置时间种子
	printf("   欢迎来到贝蒂的扫雷游戏\n");
	do
	{
		menu();//简易菜单的实现
		rules();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			system("cls");//清空屏幕，头文件<stdlib.h>
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);//选0结束游戏
	return 0;
}

（2）game.h

#define ROW 9//棋盘的行
#define COL 9//棋盘的列
#define ROWS ROW+2//扩展后的行
#define COLS COL+2//扩展后的列
#define MINES 10//雷的个数
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);//初始化棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);//打印棋盘
void SetMine(char board[ROWS][COLS], int row, int col);//布置雷
void MineMark(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col,int*p);//标记雷
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//排雷
int IsWin(char board[ROWS][COLS],int row,int col,int *p);//判断是否胜利

（3）game.c

#include"game.h"
void InitBoard(char board[ROWS][COLS], int rows ,int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			 board[i][j] = set;
		}
	}
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
    printf("-----------------扫雷游戏----------------\n");
    for (int i = 0; i <= col; i++)
    {
        if (i == 0)
        {
            printf("    ");//四个空格
        }
        else
        {
            printf(" %d  ", i);//两个空格一个数字
        }

    }
    printf("\n");
    for (int i = 0; i <= col; i++)
    {
        if (i == 0)
        {
            printf("   |");//三个空格
        }
        else
        {
            printf("---|");
        }
    }
    printf("\n");
    for (int i = 1; i <= row; i++)
    {
        printf(" %d |", i);
        for (int j = 1; j <= col; j++)
        {
            printf(" %c |", board[i][j]);
        }
        printf("\n");
        for (int j = 1; j <= col; j++)
        {
            if (j == 1)
            {
                printf("   |");//三个空格
                printf("---|");
            }
            else
            {
                printf("---|");
            }
        }
        printf("\n");
    }
    printf("-------------------结束线----------------\n");
}
void SetMine(char board[ROWS][COLS], int row, int col)
{
    int num = MINES;
    while (num)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0')
        {
            board[x][y] = '1';
            num--;
        }
    }
}
void MineMark(char mine[ROWS][COLS],char show[ROWS][COLS],int row, int col,int *p)
{
    static int sum = 0;//判断！的个数
    if (sum == MINES)
    {
        printf("！已满，请减少！的使用\n");
    }
    int x = 0, y = 0;
    printf("请输入标记的坐标:>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)//输入的坐标数值合法
    {
        if (show[x][y] == '*')//第一次标记
        {
            if (sum < MINES)
            {
                show[x][y] = '!';
                if (mine[x][y] == '1')
                {
                    (*p)++;//统计正确雷的个数
                }
                sum++;//！的个数+1
            }
        }
        else if (show[x][y] == '!')//第二次标记
        {
            show[x][y] = '?';
            if (mine[x][y] == '1')
            {
                (*p)--;
            }
            sum--;
        }
        else if(show[x][y]=='?')//第三次标记
        {
            show[x][y] = '*';
        }
        else
        {
            printf("该位置已经排查过，不能标记！\n");
        }
    }
    else
    {
        printf("输入坐标不合法，请重新输入！\n");
    }
}
int GetMineCount(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 SpreadBoard(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)//递归排雷
{
    if (x < 1 || x>ROW || y < 1 || y>COL)//坐标不合理不递归
    {
        return;
    }
    if (show[x][y] != '*')//递归结束条件
    {
        return;
    }
    int count = GetMineCount(mine, x, y);
    if (count == 0)//无雷继续扩展
    {
        show[x][y] = ' ';//扩建为' '
        SpreadBoard(mine,show, x, y + 1);
        SpreadBoard(mine,show, x, y - 1);
        SpreadBoard(mine, show, x + 1, y - 1);
        SpreadBoard(mine, show, x + 1, y +1);
        SpreadBoard(mine, show, x + 1, y);
        SpreadBoard(mine, show, x - 1, y + 1);
        SpreadBoard(mine, show, x - 1, y - 1);
        SpreadBoard(mine, show, x - 1, y);
    }
    else
    {
        show[x][y] = '0' + count;//有雷输出个数
    }
}
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)//排查雷
{
    int x = 0;
    int y = 0;
    printf("请输入你要排查的坐标:>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)//坐标要合法
    {
        if (show[x][y] != '*')
        {
            if (show[x][y] == '!' || show[x][y] == '?')
            {
                printf("该位置已被标记，暂时不可排雷！\n");
            }
            else
            {
                printf("该位置已排雷，不可重复排雷！\n");
            }
        }
        else
        {
            if (mine[x][y] == '1')
            {
                return 0;//被炸死
            }
            else
            {
                SpreadBoard(mine, show, x, y);//递归扩展
            }
        }
    }
    else
    {
        printf("坐标非法！\n");
    }
    return 1;
}
int IsWin(char board[ROWS][COLS],int row,int col, int* p)
{
    int count = 0;
    for (int i = 1; i <= row; i++)//遍历所有格子，看看是否已经排查完
    {
        for (int j = 1; j <= col; j++)
        {
            if (board[i][j] != '*' && board[i][j] != '!' && board[i][j] != '?')
            {
                count++;
            }
        }
    }
    if (count == row * col - MINES||*p==MINES)//如果排查完，或者成功标记完雷的个数
    {
        return 1;//游戏胜利
    }

    return 0;
}

                                              完结撒花，完结撒花 ！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Gin之GORM多表关联查询（多对多；自定义预加载SQL）

Gin之GORM多表关联查询（多对多；自定义预加载SQL）

数据库三个，如下： 注意：配置中间表的时候，表设计层面最好和配置的其他两张表契合，例如其他两张表为fate内的master和slave;要整合其对应关系的话，设计中间表的结构为master_id和slave_id最好（不然会涉及重写外键的操作） 重写外键（介绍） 对于 many2many 关系，连接表…
阅读更多...
DBdoctor，致力于解决数据库的一切性能问题

DBdoctor，致力于解决数据库的一切性能问题

17(一起)&#xff0c;这是我的幸运数字&#xff0c;恰巧今年8月17日在DTCC大会上我们全网首次发布DBdoctor&#xff0c;今天同样是17日&#xff0c;在全网首发整四个月后我们发布重磅大版本V3.1。值此重大更新之际&#xff0c;想与各有识之士深度聊一下这款产品&#xff0c;以及…
阅读更多...
【LeetCode刷题】--244.最短单词距离II

【LeetCode刷题】--244.最短单词距离II

244.最短单词距离II 方法&#xff1a;哈希表双指针 class WordDistance {HashMap<String,List<Integer>> map new HashMap<>();public WordDistance(String[] wordsDict) {int len wordsDict.length;for(int i 0;i< len;i){String word wordsDict[i];…
阅读更多...
Kafka基本原理及使用

Kafka基本原理及使用

目录 基本概念 单机版 环境准备 基本命令使用 集群版 消息模型 成员组成 1. Topic&#xff08;主题&#xff09;&#xff1a; 2. Partition&#xff08;分区&#xff09;&#xff1a; 3. Producer&#xff08;生产者&#xff09;&#xff1a; 4. Consumer&#xff08;…
阅读更多...
2023年12月20日学习总结

2023年12月20日学习总结

今日to do list&#xff1a; 学习kaggle中store sales中的dart forcasting&#x1f3af; 大概搜集一个声纹识别的报告&#xff08;老师给的新项目&#x1f62d;&#xff09; 学习时不刷手机 okkkkkkkkkkkkkk 开始&#x1f44d; 1. 时间序列预测- a complete guide 总结一下这…
阅读更多...
Vim：文本编辑的强大利器

Vim：文本编辑的强大利器

Vim&#xff1a;文本编辑的强大利器 概述1. 工作模式1.1 普通模式1.2 插入模式1.3 可视模式 2. 代码示例2.1 移动光标2.2 复制和粘贴2.3 查找和替换 3. 应用场景结语 概述 Vim&#xff08;Vi Improved&#xff09;是一款强大的文本编辑器&#xff0c;广泛应用于Linux和Unix系统…
阅读更多...
架构设计到底是什么？

架构设计到底是什么？

文章目录 架构设计有哪些内容&#xff1f;架构原理与技术认知分布式技术原理与设计中间件常用组件的原理和设计问题数据库原理与设计问题分布式缓存原理与设计问题互联网高性能高可用设计问题 技术认知架构分析问题分析能力边界 架构设计&#xff0c;是中高级研发工程师逃不开的…
阅读更多...
LabVIEW开发振动数据分析系统

LabVIEW开发振动数据分析系统

LabVIEW开发振动数据分析系统 自动测试系统基于LabVIEW平台设计&#xff0c;采用了多种高级硬件设备。系统的硬件组成包括PCB振动加速度传感器&#xff0c;这是一种集成了传统压电加速度传感器和电荷放大器的先进设备&#xff0c;能够直接与采集仪器连接。此外&#xff0c;系统…
阅读更多...
教师的职业素养有哪些

教师的职业素养有哪些

教师职业素养的重要性不言而喻。一个优秀的教师不仅需要具备专业知识&#xff0c;还需要具备一些基本的职业素养。 具备高尚的职业道德。作为教育工作者&#xff0c;教师应该以身作则&#xff0c;树立良好的榜样。他们应该尊重学生、关心学生、热爱学生&#xff0c;以自己的言行…
阅读更多...
15 使用v-model绑定单选框

15 使用v-model绑定单选框

概述 使用v-model绑定单选框也比较常见&#xff0c;比如性别&#xff0c;要么是男&#xff0c;要么是女。比如单选题&#xff0c;给出多个选择&#xff0c;但是只能选择其中的一个。 在本节课中&#xff0c;我们演示一下这两种常见的用法。 基本用法 我们创建src/component…
阅读更多...
测试自动化平台 | 测试开发工程师的进阶之路

测试自动化平台 | 测试开发工程师的进阶之路

一、测试工程师的现状 很多测试小伙伴在工作中有时会比较迷茫&#xff0c;不知该怎样突破瓶颈&#xff0c;更好的发展。 那么测试人员究竟该如何打破瓶颈继续向上提升呢&#xff1f;如果你苦于不知所措&#xff0c;又满怀斗志向上的话&#xff0c;不妨一起聊聊。测试职业发展…
阅读更多...
(PC+WAP)装修设计公司网站模板 家装公司网站源码下载

(PC+WAP)装修设计公司网站模板 家装公司网站源码下载

(PCWAP)装修设计公司网站模板 家装公司网站源码下载 PbootCMS内核开发的网站模板&#xff0c;该模板适用于装修设计、家装公司类等企业&#xff0c;当然其他行业也可以做&#xff0c;只需要把文字图片换成其他行业的即可&#xff1b; PCWAP&#xff0c;同一个后台&#xff0c…
阅读更多...
暴雨AI服务器：推动大模型算力底座发展

暴雨AI服务器：推动大模型算力底座发展

语言大模型作为人工智能领域的重要分支&#xff0c;其强大的自然语言处理能力和模仿人类的对话决策能力&#xff0c;正逐渐成为人们的关注焦点。近日&#xff0c;据央视新闻报道&#xff0c;工业和信息化部赛迪研究院数据显示&#xff0c;今年我国语言大模型市场规模实现较快提…
阅读更多...
D : B DS二叉排序树_树中第k小的元素

D : B DS二叉排序树_树中第k小的元素

Description 给定一个二叉排序树和一个整数k&#xff0c;要求输出树中第k个最小元素(k从1开始计数)。 Input 第一行输入t&#xff0c;表示有t个测试样例。 第二行起&#xff0c;首先输入n&#xff0c;接着输入n个整数表示一个二叉排序树&#xff0c;接着输入k。 以此类推共…
阅读更多...
分段函数1_分支结构 C语言xdoj112

分段函数1_分支结构 C语言xdoj112

题目描述: 编写程序计算分段函数f(x)的值。 输入格式&#xff1a;输入实数x的值 输出格式&#xff1a;输出f(x)的值&#xff0c;结果保留两位小数。 示例&#xff1a; 输入&#xff1a;4 输出&#xff1a;2.00 #include <stdio.h> #include <math.h>//分段函数1_分…
阅读更多...
Linux常用基础命令（二）

Linux常用基础命令（二）

查看当前的工作目录的路径--pwd 列表显示目录内容--ls 切换工作目录--cd 1.切换用户--su 格式&#xff1a; su 用户名 注意&#xff1a;普通用户切换到管理员用户需要输入密码&#xff0c;管理员用户切换到普通用户不需要输入密码&#xff0c;普通用户之间切换也要输入密码…
阅读更多...
【漏洞复现】Apache Struts CVE-2023-50164

【漏洞复现】Apache Struts CVE-2023-50164

Struts2 官方披露 CVE-2023-50164 Apache Struts 文件上传漏洞&#xff0c;攻击者可利用该漏洞污染相关上传参数导致目录遍历&#xff0c;在具体代码环境中可能导致上传 Webshell&#xff0c;执行任意代码。 漏洞描述 Apache Struts2 是一个开源的 Java Web 应用程序开发框架&a…
阅读更多...
【目标检测实验系列】YOLOv5创新点改进：融合高效轻量级网络结构GSConv，减轻模型复杂度的同时保持检测精度！（内含源代码，超详细改进代码流程）

【目标检测实验系列】YOLOv5创新点改进：融合高效轻量级网络结构GSConv，减轻模型复杂度的同时保持检测精度！（内含源代码，超详细改进代码流程）

自我介绍&#xff1a;本人硕士期间全程放养&#xff0c;目前成果:一篇北大核心CSCD录用,两篇中科院三区已见刊&#xff0c;一篇中科院三区在投。如何找创新点&#xff0c;如何放养过程厚积薄发&#xff0c;如何写中英论文&#xff0c;找期刊等等。本人后续会以自己实战经验详细…
阅读更多...
stable diffusion webui之lora调用

stable diffusion webui之lora调用

1.触发词底模lora效果最好&#xff08;分数不一定要取到1&#xff0c;0.8也行&#xff09;&#xff1b; 2.引用时一定要使用<lora:>&#xff0c;例如<lora:C4D_geometry_bg_v2.5:0.8>&#xff1b; "prompt": "(masterpiece:1.3), (best quality:1.…
阅读更多...
浅谈棉纺织厂电气防火措施及电气防火限流式保护器的应用

浅谈棉纺织厂电气防火措施及电气防火限流式保护器的应用

摘要&#xff1a;棉纺织厂属于火灾危险场所&#xff0c;在进行电气设计时要考虑并采取一定的防火措施。本文从接线、熔断器的选用、中性点接地方式的选择和接地等问题&#xff0c;介绍了电气防火的一些措施。并就引发火灾较严重的线路短路故障问题&#xff0c;介绍了电气防火限…
阅读更多...
最新文章

Copyright @ 2022~2023