c语言实现智能三子棋

最新推荐文章于 2024-08-14 20:16:41 发布
最新推荐文章于 2024-08-14 20:16:41 发布
阅读量66 收藏
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bananawolf/article/details/130050028
版权 
#define _CRT_SECURE_NO_WARNINGS 1

#include"game.h"


void game()
{
	
	
	char chessboard[ROW][LEF] = { 0 };
	initialize(chessboard, ROW, LEF);
	int ret = 0;//决定棋盘下面该怎么走
	int n = 0;
	int m = 0;
	int chi = 0;//控制棋盘翻转的关键字
	while (1)
	{
		n++;
		chi = changechess(chessboard, ROW, LEF, n, ret, m, chi);//控制翻转回来棋盘
		n--;
		print_chessboard(chessboard, ROW, LEF);//打印棋盘
		if (m > 2)
		{
			if ('A' == judgment(chessboard, ROW, LEF))//判断
			{

				printf("恭喜你获胜了,厉害啊\n");
				break;
			}
			else if ('B' == judgment(chessboard, ROW, LEF))
			{

				printf("不会吧，这么菜\n");
				break;
			}
			else if ('D' == judgment(chessboard, ROW, LEF))
			{

				printf("棋逢对手，可以可以\n");
				break;
			}
		}
		playgame(chessboard, ROW, LEF);//玩家下棋
		n++;
		print_chessboard(chessboard, ROW, LEF);//打印棋盘
		if (n > 2)
		{
			if ('A' == judgment(chessboard, ROW, LEF))//判断
			{
				
				printf("恭喜你获胜了,厉害啊\n");
				break;
			}
			else if ('B' == judgment(chessboard, ROW, LEF))
			{
				
				printf("不会吧，这么菜\n");
				break;
			}
			else if ('D' == judgment(chessboard, ROW, LEF))
			{
				
				printf("棋逢对手，可以可以\n");
				break;
			}
			else
			{
				printf("加油！\n");
			}
		}
		chi = changechess(chessboard, ROW, LEF ,  n,  ret,  m,  chi);//控制翻转棋盘
		//print_chessboard(chessboard, ROW, LEF);//打印棋盘
		Sleep(1000);
		//computergame(chessboard, ROW, LEF);//电脑下棋
		ret = computergameend(chessboard, ROW, LEF, n, ret, m);
		//print_chessboard(chessboard, ROW, LEF);//打印棋盘
		m++;
		
	}

}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		
		meun(1);//开始界面
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("三子棋\n");
			game();
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入");
			break;
		}
	} while (input);
	return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1

#include"game.h"

void meun(int n)//开始界面
{
	printf("************************************\n");
	printf("********  1:play   0.:exit  *********\n");
	printf("************************************\n");
	printf("请选择：>\n");
}
//   |   |   
//---|---|---
//   |   |   
//---|---|---
//   |   |    
void print_chessboard(char chessboard[ROW][LEF],int row, int lef)//打印棋盘
{
	int i = 0;
	int j = 0;
	for (j = 0; j < row; j++)
	{
		for (i = 0; i < lef; i++)
		{
			printf(" %c ", chessboard[j][i]);
			if (i < lef - 1)
			{
				printf("|");
			}
		}
		printf("\n");
		i = 0;
		if (j < lef - 1)
		{
			for (i = 0; i < lef; i++)
			{
				printf("---");
				if (i < lef - 1)
				{
					printf("|");
				}
			}
		}
		printf("\n");
	}
}


void initialize( char chessboard[ROW][LEF],int row,int lef)//初始化棋盘
{
	int x = 0;
	int y = 0;
	for (x = 0; x < row; x++)
	{
		for (y = 0; y < lef; y++)
		{
			chessboard[x][y] = ' ';
		}
	}
}


void playgame(char chessboard[ROW][LEF], int row, int lef)//玩家下棋
{
	int x = 1;
	int y = 1;
	
	while (1)
	{
		printf("请玩家下棋，写坐标：\n");
		scanf("%d%d", &x, &y);
		if (chessboard[x - 1][y - 1] == ' ' && x >= 1 && x<= row && y >= 1 && y <= lef)
		{
			chessboard[x - 1][y - 1] = '*'; 
			break;
		}
		else
			printf("输入格式错误，请重新输入\n");
	}
}



void computergame(char chessboard[ROW][LEF], int row, int lef, int j)//电脑随机下棋
{
	int x = 1;
	int y = 1;
	printf("电脑下棋：\n");
	
	while (1)             
	{
		x = rand() % row;
		y = rand() % lef;
		if (chessboard[x][y] == ' ' && x >= 0 && x <= row-1 && y >= 0 && y <= lef-1 && j == 0)
		{
			chessboard[x][y] = '#';
			break;
		}
	}
}

int computer(char chessboard[ROW][LEF], int x, int y,int j)//判断是否可以在这个位置下棋
{
	if (chessboard[x][y] == ' ' && j == 0)
	{
		chessboard[x][y] = '#';
		return 1;
	}
	return j;
}

int computer_centre(char chessboard[ROW][LEF], int row, int lef, int j)//优先在中间下棋
{
	if (chessboard[1][1] == ' ')
	{
		chessboard[1][1] = '#';
		j++;
	}
	return j;
}


int computer_corner(char chessboard[ROW][LEF], int row, int lef, int j)//只在角落随机下棋
{
	int x = 0;
	int y = 0;
	while (1)
	{
		if (chessboard[0][0] != ' ' && chessboard[2][2] != ' ' && chessboard[2][0] != ' ' && chessboard[0][2] != ' ')
		{
			break;
		}
		x = rand() % row;
		y = rand() % lef;
		if (chessboard[x][y] == ' ' && x >= 0 && x <= row - 1 && y >= 0 && y <= lef - 1 && x != 1 && y != 1 && j == 0)
		{
			chessboard[x][y] = '#';
			j++;
			break;
		}
	}
	return j;
}

int computer_corner22(char chessboard[ROW][LEF], int row, int lef, int j)//只在角落随机下棋!22
{
	int x = 0;
	int y = 0;
	while (1)
	{
		if (chessboard[0][0] != ' '  && chessboard[2][0] != ' ' && chessboard[0][2] != ' ')
		{
			break;
		}
		x = rand() % row;
		y = rand() % lef;
		if (chessboard[x][y] == ' ' && x >= 0 && x <= row - 1 && y >= 0 && y <= lef - 1 && x != 1 && y != 1 && j == 0 && (x != 2 || y != 2))
		{
			chessboard[x][y] = '#';
			j++;
			break;
		}
	}
	return j;
}

int computer_corner02(char chessboard[ROW][LEF], int row, int lef, int j)//只在角落随机下棋!02
{
	int x = 0;
	int y = 0;
	while (1)
	{
		if (chessboard[0][0] != ' ' && chessboard[2][2] != ' ' && chessboard[2][0] != ' ' )
		{
			break;
		}
		x = rand() % row;
		y = rand() % lef;
		if (chessboard[x][y] == ' ' && x >= 0 && x <= row - 1 && y >= 0 && y <= lef - 1 && x != 1 && y != 1 && j == 0 && (x != 0 || y != 2))
		{
			chessboard[x][y] = '#';
			j++;
			break;
		}
	}
	return j;
}

int computer_sxzy(char chessboard[ROW][LEF], int row, int lef, int j)//只在上下左右随机下棋
{
	int x = 0;
	int y = 0;
	while (1)
	{
		if (chessboard[0][1] != ' ' && chessboard[1][0] != ' ' && chessboard[1][2] != ' ' && chessboard[2][1] != ' ')
		{
			break;
		}
		x = rand() % row;
		y = rand() % lef;
		if (chessboard[x][y] == ' ' && x >= 0 && x <= row - 1 && y >= 0 && y <= lef - 1 && ((x == 1 && y == 0) || (x == 0 && y == 1) || (x == 1 && y == 2) || (x == 2 && y == 1)) && j == 0)
		{
			chessboard[x][y] = '#';
			j++;
			break;
		}
	}
	return j;
}



void du_king(char chessboard[ROW][LEF], int row, int lef, int n, int m)//赢棋->堵棋->先在中间下棋->在角落下棋->随机下棋
{
	int i = 0;
	int j = 0;
	if (m >= 2)
	{
		for (i = 0; i < row; i++)//同一行是否有相同的
		{
			if (chessboard[i][0] == chessboard[i][1] && chessboard[i][0] == '#')
			{
				j = computer(chessboard, i, 2, j);
			}
			else if (chessboard[i][0] == chessboard[i][2] && chessboard[i][0] == '#')
			{
				j = computer(chessboard, i, 1, j);
			}
			else if (chessboard[i][1] == chessboard[i][2] && chessboard[i][1] == '#')
			{
				j = computer(chessboard, i, 0, j);
			}
		}
		i = 0;
		for (i = 0; i < lef; i++)//同一列是否有相同的
		{
			if (chessboard[0][i] == chessboard[1][i] && chessboard[0][i] == '#')
			{
				j = computer(chessboard, 2, i, j);
			}
			else if (chessboard[0][i] == chessboard[2][i] && chessboard[0][i] == '#')
			{
				j = computer(chessboard, 1, i, j);
			}
			else if (chessboard[1][i] == chessboard[2][i] && chessboard[1][i] == '#')
			{
				j = computer(chessboard, 0, i, j);
			}
		}
		if (chessboard[0][0] == chessboard[1][1] && chessboard[0][0] == '#')//斜线的是否相同
		{
			j = computer(chessboard, 2, 2, j);
		}
		else if (chessboard[0][0] == chessboard[2][2] && chessboard[0][0] == '#')
		{
			j = computer(chessboard, 1, i, j);
		}
		else if (chessboard[1][1] == chessboard[2][2] && chessboard[1][1] == '#')
		{
			j = computer(chessboard, 0, 0, j);
		}
		else if (chessboard[0][2] == chessboard[1][1] && chessboard[0][2] == '#')
		{
			j = computer(chessboard, 2, 0, j);
		}
		else if (chessboard[0][2] == chessboard[2][0] && chessboard[0][2] == '#')
		{
			j = computer(chessboard, 1, 1, j);
		}
		else if (chessboard[1][1] == chessboard[2][0] && chessboard[1][1] == '#')
		{
			j = computer(chessboard, 0, 2, j);
		}
	}
	if (j == 0)
	{
		for (i = 0; i < row; i++)//同一行是否有相同的
		{
			if (chessboard[i][0] == chessboard[i][1] && chessboard[i][0] == '*')
			{
				j = computer(chessboard, i, 2, j);
			}
			else if (chessboard[i][0] == chessboard[i][2] && chessboard[i][0] == '*')
			{
				j = computer(chessboard, i, 1, j);
			}
			else if (chessboard[i][1] == chessboard[i][2] && chessboard[i][1] == '*')
			{
				j = computer(chessboard, i, 0, j);
			}
		}
		i = 0;
		for (i = 0; i < lef; i++)//同一列是否有相同的
		{
			if (chessboard[0][i] == chessboard[1][i] && chessboard[0][i] == '*')
			{
				j = computer(chessboard, 2, i, j);
			}
			else if (chessboard[0][i] == chessboard[2][i] && chessboard[0][i] == '*')
			{
				j = computer(chessboard, 1, i, j);
			}
			else if (chessboard[1][i] == chessboard[2][i] && chessboard[1][i] == '*')
			{
				j = computer(chessboard, 0, i, j);
			}
		}
		if (chessboard[0][0] == chessboard[1][1] && chessboard[0][0] == '*')//斜线的是否相同
		{
			j = computer(chessboard, 2, 2, j);
		}
		else if (chessboard[0][0] == chessboard[2][2] && chessboard[0][0] == '*')
		{
			j = computer(chessboard, 1, 1, j);
		}
		else if (chessboard[1][1] == chessboard[2][2] && chessboard[1][1] == '*')
		{
			j = computer(chessboard, 0, 0, j);
		}
		else if (chessboard[0][2] == chessboard[1][1] && chessboard[0][2] == '*')
		{
			j = computer(chessboard, 2, 0, j);
		}
		else if (chessboard[0][2] == chessboard[2][0] && chessboard[0][2] == '*')
		{
			j = computer(chessboard, 1, 1, j);
		}
		else if (chessboard[1][1] == chessboard[2][0] && chessboard[1][1] == '*')
		{
			j = computer(chessboard, 0, 2, j);
		}	
	}
	if (j == 0)
	{
		j = computer_centre(chessboard, row, lef, j);//中间下棋
	}
	if (j == 0)
	{
		j = computer_corner(chessboard, row, lef, j);//角落下棋
	}
	if (j == 0)
	{
		computergame(chessboard, row, lef,j);//随机
	}
}

int changexy(char chessboard[ROW][LEF], int row, int lef, int ch)//翻转棋盘
{
	int x = 0;
	int y = 0;
	char o = '@';
	if (ch == 1)//交换↙↗ 2表示翻转过一次 1表示翻转回来
	{
		for (x = 0; x < row-1; x++)
		{
			for (y = 0; y > x && y < lef-1; y++)
			{
				o = chessboard[x][y];
				chessboard[x][y] = chessboard[y][x];
				chessboard[y][x] = o;
			}
		}
		return 2;
	}
    else if (ch == 2)
	{
		for (x = 0; x < row - 1; x++)
		{
			for (y = 0; y > x && y < lef - 1; y++)
			{
				o = chessboard[x][y];
				chessboard[x][y] = chessboard[y][x];
				chessboard[y][x] = o;
			}
		}
		return 1;
	}
    else if (ch == 3)//交换↖↘ 4表示翻转过一次 3表示翻转回来
	{
		o = chessboard[0][0];
		chessboard[0][0] = chessboard[2][2];
		chessboard[2][2] = o;
		o = chessboard[0][1];
		chessboard[0][1] = chessboard[1][2];
		chessboard[1][2] = o;
		o = chessboard[1][0];
		chessboard[1][0] = chessboard[2][1];
		chessboard[2][1] = o;
		return 4;
	}
	else if (ch == 4)
	{
		o = chessboard[0][0];
		chessboard[0][0] = chessboard[2][2];
		chessboard[2][2] = o;
		o = chessboard[0][1];
		chessboard[0][1] = chessboard[1][2];
		chessboard[1][2] = o;
		o = chessboard[1][0];
		chessboard[1][0] = chessboard[2][1];
		chessboard[2][1] = o;
		return 3;
	}
	else if (ch == 5)//↑↓翻转棋盘 6代表已经上下翻转过 5代表要上下翻转
	{
		x = 0;
		for (y = 0; y < lef; y++)
		{
			o = chessboard[x][y];
			chessboard[x][y] = chessboard[x+2][y];
			chessboard[x+2][y] = o;
		}
		return 6;
	}
	else if (ch == 6)
	{
		x = 0;
		for (y = 0; y < lef; y++)
		{
			o = chessboard[x][y];
			chessboard[x][y] = chessboard[x + 2][y];
			chessboard[x + 2][y] = o;
		}
		return 5;
	}
    else if (ch == 7)//←→翻转 7表示要翻转 8表示翻转过
	{
		y = 0;
		for (x = 0; x < row; x++)
		{
			o = chessboard[x][y];
			chessboard[x][y] = chessboard[x][y + 2];
			chessboard[x][y + 2] = o;
		}
		return 8;
	}
	else if (ch == 8)
	{
		y = 0;
		for (x = 0; x < row; x++)
		{
			o = chessboard[x][y];
			chessboard[x][y] = chessboard[x][y + 2];
			chessboard[x][y + 2] = o;
		}
		return 7;
	}
}







int changechess(char chessboard[ROW][LEF], int row, int lef, int n, int ret, int m,int chi)//控制翻转棋盘
{
	int ch = 0;
	if (n == 1)
	{
		if (chessboard[0][2] == '*')
		{
			ch = 7;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chessboard[2][0] == '*')
		{
			ch = 5;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chessboard[2][2] == '*')
		{
			ch = 3;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chessboard[0][1] == '*')
		{
			ch = 1;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chessboard[2][1] == '*')
		{
			ch = 3;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chessboard[1][2] == '*')
		{
			ch = 7;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else
		{
			return 0;
		}
	}
	if (m >= 1)
	{
		if (chi == 1)
		{
			ch = 1;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 2)
		{
			ch = 2;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 3)
		{
			ch = 3;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 4)
		{
			ch = 4;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 5)
		{
			ch = 5;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 6)
		{
			ch = 6;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 7)
		{
			ch = 7;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else if (chi == 8)
		{
			ch = 8;
			chi = changexy(chessboard, row, lef, ch);//翻转棋盘
			return chi;
		}
		else
		{
			return 0;
		}
	}
	return 0;
}

int computergameend(char chessboard[ROW][LEF], int row, int lef,int n,int ret ,int m)//无敌版 ret接收下一步怎么走返回值，也是接收值
{
	if (n == 1)//n判断下的第几颗棋
	{
		if (chessboard[1][1] == '*')
		{
			int j = 0;
			du_king(chessboard, row, lef, n, m);
			//chessboard[0][0] = '#';
			return 1;
		}
		else if (chessboard[0][0] == '*')
		{
			int j = 0;
			j = computer_centre(chessboard, row, lef, j);//中间下棋
			//chessboard[1][1] = '#';
			return 2;
		}
		else if (chessboard[1][0] == '*')
		{
			int j = 0;
			j = computer_centre(chessboard, row, lef, j);//中间下棋
			//chessboard[1][1] = '#';
			return 3;
		}
	}
	if (n >= 2)//第二步棋
	{
		if (ret == 1)
		{
			du_king(chessboard, row, lef , n, m);
			return 1;//开堵就行
		} 
		else if (ret == 2)
		{
			if (chessboard[2][2] == '*')
			{
				int j = 0;
				j = computer_sxzy(chessboard, row, lef, j);//只在上下左右随机下棋
				return 1;//开堵就行
			}
			else if (chessboard[0][2] == '*' || chessboard[2][0] == '*' || chessboard[0][1] == '*' || chessboard[1][0] == '*')
			{
				du_king(chessboard, row, lef, n, m);
				return 1;//开堵就行
			}
			else if (chessboard[1][2] == '*')
			{
				chessboard[0][2] = '#';
				return 1;//开堵就行
			}
			else if (chessboard[2][1] == '*')
			{
				chessboard[2][0] = '#';
				return 1;//开堵就行
			}
		}
		else if (ret == 3)
		{
			if (chessboard[1][2] == '*')
			{
				du_king(chessboard, row, lef, n, m);
				return 1;//开堵就行
			}
			else if (chessboard[0][0] == '*' || chessboard[2][0] == '*')
			{
				du_king(chessboard, row, lef, n, m);
				return 1;//开堵就行
			}
			else if (chessboard[0][1] == '*' || chessboard[0][2] == '*')
			{
				int j = 0;
				j = computer_corner22(chessboard, row, lef, j); //角落下棋除了22
				return 1;
			}
			else if (chessboard[2][1] == '*' || chessboard[2][2] == '*')
			{
				int j = 0;
				j = computer_corner02(chessboard, row, lef, j); //角落下棋除了02
				return 1;
			}

		}
	
	}
}
//j = computer_corner22(chessboard, row, lef, j);角落下棋除了22
char draw(char chessboard[ROW][LEF], int row, int lef)//判断是不是平局
{
	int i = 0;
	int j = 0;
	int flag = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < lef; j++)
		{
			if (chessboard[i][j] == ' ')
			{
				return 'c';
			}
		}
	}
	return 'd';
}

char judgment(char chessboard[ROW][LEF], int row, int lef)//裁判
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		if (chessboard[i][0] == chessboard[i][1] && chessboard[i][1] == chessboard[i][2] && chessboard[i][1] != ' ')
		{
			if (chessboard[i][1] == '*')
			{
				return 'A';
			}
			if (chessboard[i][1] == '#')
			{
				return 'B';
			}
		}
		if (chessboard[0][i] == chessboard[1][i] && chessboard[1][i] == chessboard[2][i] && chessboard[1][i] != ' ')
		{
			if (chessboard[1][i] == '*')
			{
				return 'A';
			}
			if (chessboard[1][i] == '#')
			{
				return 'B';
			}
		}
		if (chessboard[0][0] == chessboard[1][1] && chessboard[1][1] == chessboard[2][2] && chessboard[1][1] != ' ')
		{
			if (chessboard[1][1] == '*')
			{
				return 'A';
			}
			else
			{
				return 'B';
			}
		}
		if (chessboard[0][2] == chessboard[1][1] && chessboard[1][1] == chessboard[2][0] && chessboard[1][1] != ' ')
		{
			if (chessboard[1][1] == '*')
			{
				return 'A';
			}
			else
			{
				return 'B';
			}
		}
	}
	if ('d' == draw(chessboard, ROW, LEF))
	{
		return 'D';
	}
	return 'C';
}


#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>

#define ROW 3
#define LEF 3



void print_chessboard(char chessboard[ROW][LEF],int row, int lef);
void meun(int n);

void initialize(char chessboard[ROW][LEF], int row, int lef);
void playgame(char chessboard[ROW][LEF], int row, int lef);
void computergame(char chessboard[ROW][LEF], int row, int lef, int j);
char judgment(char chessboard[ROW][LEF], int row, int lef);
int computergameend(char chessboard[ROW][LEF], int row, int lef, int n, int ret, int m);
void du_king(char chessboard[ROW][LEF], int row, int lef, int n, int m);
int computer_corner(char chessboard[ROW][LEF], int row, int lef, int j);//只在角落随机下棋
int changexy(char chessboard[ROW][LEF], int row, int lef, int ch);//翻转棋盘
int changechess(char chessboard[ROW][LEF], int row, int lef, int n, int ret, int m, int chi);//控制翻转棋盘

bananawolf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
四子棋智能下棋C语言实现
03-15
四子棋是一种简单而有趣的双人对弈游戏，...总结来说，"四子棋智能下棋C语言实现"项目涵盖了C语言编程基础、游戏逻辑实现、人工智能算法以及用户交互等多个方面，既锻炼了编程技能，也提供了对AI决策过程的深入理解。
C语言版三子棋
02-02
**C语言版三子棋**是一款基于C语言编写的简单但具有挑战性的棋类游戏，通常称为井字游戏或Noughts and Crosses。在这个游戏中，两名玩家轮流在3x3的棋盘上放置自己的棋子，目标是首先在行、列或对角线上形成连续的三...
C语言实现的三子棋小游戏！！完整代码！
10-21
【C语言实现的三子棋小游戏】是一款基于C语言编程的简单桌面游戏，适用于初学者理解和实践。游戏的核心是二维数组的应用，通过数组来表示棋盘，并进行逻辑判断。以下是这个游戏的一些关键知识点： 1. **二维数组**...
C语言实现三子棋小游戏详解
12-16
【C语言实现三子棋小游戏详解】 在C语言中实现三子棋小游戏，我们需要遵循一定的步骤，以确保游戏逻辑正确且易于理解。首先，我们要熟悉三子棋的基本规则：游戏在一个9宫格的棋盘上进行，玩家和电脑交替放置棋子，...
用C语言实现3子棋简单思路
01-01
在本文中，我们将深入探讨如何使用C语言来实现一个简单的三子棋游戏。三子棋，也称为井字游戏或Noughts and Crosses，是一个经典的两人对弈游戏，目标是在3x3的格子中先形成一条直线（横、竖、斜）的玩家获胜。以下...
什么是进程？C语言
weixin_66436813的博客
08-14 691
进程的简略知识点
vasp6.3.2安装包
08-19
VASP（Vienna Ab-initio Simulation Package）是一个用于电子结构计算和量子力学-分子动力学模拟的软件包，由维也纳大学的Hafner小组开发。 它基于密度泛函理论（DFT）和赝势平面波基组，广泛应用于材料模拟和计算物质科学研究领域。VASP能够处理周期性和非周期性体系，包括金属、半导体、分子、晶体、掺杂体系、复合材料、纳米材料等，提供精确的电子性质预测和理化性质分析。由于其高效的大规模并行计算能力，VASP在国际上享有很高的声誉，是第一性原理计算领域最权威的软件之一。每年，以VASP作为科研工具发表的论文数量众多，包括在顶级科学期刊上发表的研究成果。物理与电子科学学院等多名教师使用VASP进行科研工作，并取得了多项研究成果。‌
计算机毕业设计SSM员工人事工资管理系统论文
08-19
计算机毕业设计SSM员工人事工资管理系统论文
根据文档框架生成内容草稿版
08-19
根据文档框架生成内容
毕业设计，基于SpringBoot+Vue+MySQL开发的企业客户管理系统，源码+论文答辩+毕业论文+视频演示
08-19
毕业设计，基于SpringBoot+Vue+MySQL开发的企业客户管理系统，源码+论文答辩+毕业论文+视频演示 本论文主要论述了如何使用JAVA语言开发一个企业客户管理系统，本系统将严格按照软件开发流程进行各个阶段的工作，采用B/S架构，面向对象编程思想进行项目开发。在引言中，作者将论述企业客户管理系统的当前背景以及系统开发的目的，后续章节将严格按照软件开发流程，对系统进行各个阶段分析设计。 企业客户管理系统的主要使用者分为管理员和员工，实现功能包括管理员：首页、个人中心、员工管理、客户信息管理、行业类型管理、项目信息管理、项目类型管理、项目收益管理，员工：首页、个人中心、客户信息管理、项目信息管理、项目收益管理等功能。由于本网站的功能模块设计比较全面，所以使得整个企业客户管理系统信息管理的过程得以实现。 本系统的使用可以实现本企业客户管理的信息化，可以方便管理员进行更加方便快捷的管理，可以提高管理人员的工作效率。 关键词：企业客户管理系统 JAVA语言；MySQL数据库；Spring Boot框架
探索图的世界：一键检测连通性的奥秘
最新发布
08-19
数据结构是计算机科学中的一个基本概念，它指的是数据的组织、管理和存储方式，以及对数据的操作。数据结构使得数据的访问和修改更加高效和有序。常见的数据结构包括： 1. **数组**（Array）：一种线性数据结构，可以存储相同类型的元素，并通过索引访问。 2. **链表**（Linked List）：一种线性数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。 3. **栈**（Stack）：一种后进先出（LIFO, Last In First Out）的数据结构，只能在一端进行添加或删除操作。 4. **队列**（Queue）：一种先进先出（FIFO, First In First Out）的数据结构，允许在一端添加元素，在另一端删除元素。 5. **哈希表**（Hash Table）：通过键值对存储数据的数据结构，可以快速地通过键来访问数据。 6. **树**（Tree）：一种层次结构的数据结构，每个节点有零个或多个子节点，通常用于表示具有层次关系的数据。 7. **图**（Graph）：由顶点（节点）和边组成，可以表示复杂的关系和网络结构。 每种数据结构都有其
weixin030英语学习交流平台小程序+ssm--pf.zip
08-19
随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。各行各业在日常企业经营管理等方面也在慢慢的向规范化和网络化趋势汇合。英语学习交流平台小程序的信息化程度体现在将互联网与信息技术应用于经营与管理，以现代化工具代替传统手工作业。无疑，使用网络信息化管理使信息管理更先进、更高效、更科学，信息交流更迅速。 对于之前英语学习交流平台小程序的管理，大部分都是使用传统的人工方式去管理，这样导致了管理效率低下、出错频率高。而且，时间一长的话，积累下来的数据信息不容易保存，对于查询、更新还有维护会带来不少问题。对于数据交接也存在很大的隐患。如果采用电子化的存储方式就会带来很大的改善，而且给用户的查询带来了很大便利，因此设计一个英语学习交流平台小程序刻不容缓，能够提高信息的管理水平。
Dynamic Test Loading
08-19
Dynamic Test Loading
基于 Spring Boot+AIGC的智能数据分析平台 区别于传统 BI，用户只需要导入原始数据集、 并输入分析诉求，就能自动
08-19
基于 Spring Boot+AIGC的智能数据分析平台。区别于传统 BI，用户只需要导入原始数据集、 并输入分析诉求，就能自动生成可视化图表及分析结论，
基于微信小程序的新生报到系统--.zip
08-19
本网站所实现的是一个新生报到系统，该系统严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本系统具有以下优点： 该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。 系统将用户权限进行划分，管理员和学生能看到及操作的信息不一样，两者具备不同的操作权限。 该系统操作界面简单明了，大部分人都可以正常使用。
#-ssm-016-mysql-图书仓储管理系统-(1实用1).zip
08-19
随着社会经济的迅速发展和科学技术的全面进步，计算机事业的飞速发展，以计算机与通信技术为基础的信息系统正处于蓬勃发展的时期，随着经济文化水平的显著提高，人们对生活质量及工作环境的要求也越来越高，书籍做为人类的精神食粮，在现代社会中越来越受到重视，大量的书籍出现在市场上，人们有了各种各样不同的选择，与此同时，为了管理大量的图书，仓储的管理问题也就提上了日程，随着图书的大量增加，其管理难度也越来越大，如何优化仓储的日常管理也就成为了一个大众化的课题。因此，我选择开发这款图书仓储管理系统。 根据需求，确定系统采用JSP技术，SSM框架，JAVA作为编程语言，MySQL作为数据库。整个系统要操作方便、易于维护、灵活实用。主要实现了人员管理、库位管理、图书管理、图书报废管理、图书退回管理等功能。 关键词：图书仓储管理系统； JSP; MYSQL
JAVA WEB jstl资源jar包 包括jstl.jar和standard.jar
08-19
当然可以帮助您撰写关于`jstl.jar`和`standard.jar`这两个JAR包的介绍。以下是一段示例文本： --- ### JAR包资源介绍 #### 1. jstl.jar `jstl.jar`（JavaServer Pages Standard Tag Library，简称 JSTL）是一个用于简化 JavaServer Pages (JSP) 开发的标准标签库。它提供了一组功能强大的标签，这些标签可以用来控制流程、格式化输出、国际化处理、SQL操作等。使用JSTL可以显著减少页面中的Java代码量，提高代码的可读性和可维护性。 - **主要特性**： - **核心标签库**：提供了条件判断、循环、URL重定向等功能。 - **函数标签库**：支持日期、数字、字符串等数据类型的格式化。 - **国际化标签库**：支持多语言和本地化的页面展示。 - **XML标签库**：处理XML文档。 - **SQL标签库**：执行数据库操作。 - **适用场景**： - 适用于任何需要使用JSP技术进行Web开发的应用程序。 - **兼容性**：
基于Android学生课程表软件APP设计与实现.docx
08-19
基于Android学生课程表软件APP设计与实现.docx
计算机毕业设计仿慕课视频系统hsgAHB论文
08-19
计算机毕业设计仿慕课视频系统hsgAHB论文
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值