三子棋（泛用版，人工智能化，输了就关机，你敢挑战一下吗？）

已于 2022-06-29 23:45:40 修改
阅读量676 收藏 19
点赞数 30
分类专栏： 游戏 文章标签： c语言
于 2022-05-06 19:59:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68931081/article/details/124617186
版权

作者介绍：友友们好我是沐曦希，可以叫我小沐💕
作者主页：沐曦希的个人博客主页.🎉
作者的gitee：https://gitee.com/muxi-c-language
C语言系列文章：
🎈 1. 函数零基础使用大全，助你了解函数（二）
🎈2. 函数零基础使用大全，助你了解函数（一）
🎈3. .循环语句这些这些知识点你真的会了吗？（2）.
🎈4. 循环语句这些知识点你真的会了吗？（1）
🎉小沐和友友们一样喜欢编辑，天天敲代码🤭，沉迷学习，日渐消瘦。很荣幸能向大家分享我的所学，和大家一起进步，成为合格的卷王。✨如果文章有错误，欢迎在评论区✏️指正。那么开始今天的学习吧！😘

文章目录


在这里插入图片描述

1.前言

这是输给电脑就真的关机！！！问了就是，小沐测试时候输给电脑，关机了😫。不过幸好代码保存了，要不然要重新敲一遍。

2.三子棋

🎈game.h

//头文件game.h
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void meau();
#define ROW 6
#define COL 6
void Initboard(char board[ROW][COL], int row,int col);
void DisPaly(char board[ROW][COL],int row,int col);
void PlayMove(char board[ROW][COL],int row,int col);
void ComputerMove(char board[ROW][COL], int row,int col);
int Is_Win(char board[ROW][COL], int row,int col);
int CheakComuputer(char board[ROW][COL], int row,int col);
int StopComuputer(char board[ROW][COL], int row,int col);

🎈test.c

//test.c
#include"game.h 1"
void game()
{
	char board[ROW][COL];
	Initboard(board, ROW, COL);
	DisPaly(board, ROW, COL);
	char ch = '\0';
	while (1)
	{
		PlayMove(board, ROW, COL);
		DisPaly(board, ROW, COL);
		ch = Is_Win(board, ROW, COL);
		if (ch != 'C')
		{
			break;
		}
		ComputerMove(board, ROW, COL);
		DisPaly(board, ROW, COL);
		ch = Is_Win(board, ROW, COL);
		if (ch != 'C')
		{
			break;
		}
	}
	if (ch == '*')
	{
		printf("玩家胜利\n");
	}
	else if (ch == '#')
	{
		printf("不会吧，连人机都打不过。\n");
		printf("那么请注意你的电脑即将关机\n");
		char input[10] = { 0 };
		system("shutdown -s -t 0");
	}
	else if(ch=='Q')
	{
		printf("平局\n");
	}
}
int main()
{
	int input = 0;
	int count = 0;
	srand((unsigned int)time(NULL));
	do 
	{
		meau();
		printf("请输入选择：>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("开始游戏!\n");
			game();
			break;
		case 0:
			printf("退出游戏");
			break;
		default:
				count++;
				if (count == 3)
				{
					printf("你已经输入错误三次了，请你好好看看规则再玩，谢谢！\n");
				}
				else if(count<3)
					printf("输入错误，请重新输入!\n");
				else
				{
					printf("本AI也是有脾气的，请你退出游戏，谢谢！\n");
					input = 0;
				}
		}
	} while (input);
	return 0;
}

🎈game.c

//game.c
#include"game.h 1"
void meau()
{
	printf("******************************************************\n");
	printf("*************        1 . play           **************\n");
	printf("*************        0 . exit           **************\n");
	printf("******************************************************\n");
	printf("********    请注意赢不过电脑会自动关机哦！  **********\n");
}
void Initboard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}
void DisPaly(char board[ROW][COL], int row, int col)
{
	int i = 0;
	printf("\n");
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		if (i < row - 1)
		for (j = 0; j < col; j++)
		{
				printf("---");
				if (j < col - 1)
					printf("|");
		}
		printf("\n");
	}
}
void PlayMove(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋!\n");
	int x = 0;
	int y = 0;\
	printf("请输入坐标:>");
	scanf("%d %d", &x, &y);
	if (x <= row && y <= col)
	{
		if (board[x - 1][y - 1] == ' ')
		{
			board[x - 1][y - 1] = '*';
		}
		else
		{
			printf("输入的坐标已被占用，请重新输入!\n");
			DisPaly(board, ROW, COL);
			PlayMove(board, row, col);
		}
	}
	else if (x > row || y > col)
	{
		printf("坐标非法，请重新输入!");
	}
}
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int flag1 = 0;
	int flag2 = 0;
	flag1 = CheakComuputer(board, ROW, COL);
	if (flag1 == 0)
	{
		flag2 = StopComuputer(board, ROW, COL);
	}
	if (flag1 == 0 && flag2 == 0)
	{
		int x = 0;
		int y = 0;
		while (1)
		{
			x = rand() % row;
			y = rand() % col;
			if (board[x][y] == ' ')
			{
				board[x][y] = '#';
				break;
			}
			else
			{
				printf("电脑下棋的位置重复了，电脑重新下棋。\n");
				ComputerMove(board, ROW, COL);
			}
		}
	}
}
int CheakComuputer(char board[ROW][COL], int row, int col)
{
	//计算机自身检测是否能赢，并下棋。
	int i = 0;
	//检测每一行中是否有两个相同的#，有则下棋
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] == '#' && board[i][j + 2] == ' ')
			{
				board[i][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i][j + 2] && board[i][j] == '#' && board[i][j + 1] == ' ')
			{
				board[i][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的#，有则下棋
	for (i = 0; i < row ; i++)
	{
		int j = 0;
		for (j = 0; j < col ; j++)
		{
			if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == '#' && board[i + 2][j + 2] == ' ')
			{
				board[i + 2][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j + 2] && board[i ][j ] == '#' && board[i + 1][j + 1] == ' ')
			{
				board[i + 1][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的#，有则下棋
	for (i = 0; i < col ; i++)
	{
		int j = 0;
		for (j = col; j >= 2; j--)
		{
			if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == '#' && board[i + 2][j - 2] == ' ')
			{
				board[i + 2][j - 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j - 2] && board[i + 2][j - 2] == '#' && board[i + 1][j - 1] == ' ')
			{
				board[i + 1][j - 1] = '#';
				return 1;
			}
		}
	}
	//检测每一列中是否有两个相同的#，有则下棋
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 2][j] && board[i + 2][j] == '#' && board[i + 1][j] == ' ')
			{
				board[i + 1][j] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 1][j] && board[i + 1][j] == '#' && board[i + 2][j] == ' ')
			{
				board[i + 2][j] = '#';
				return 1;
			}
		}
	}
	return 0;
}
int StopComuputer(char board[ROW][COL], int row, int col)
{
	//检测玩家相邻的两个棋子，并进行阻拦。
	int i = 0;
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] == '*' && board[i][j + 2] == ' ')
			{
				board[i][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i][j + 2] && board[i][j] == '*' && board[i][j + 1] == ' ')
			{
				board[i][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == '*' && board[i + 2][j + 2] == ' ')
			{
				board[i + 2][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j + 2] && board[i][j] == '*' && board[i + 1][j + 1] == ' ')
			{
				board[i + 1][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < col; i++)
	{
		int j = 0;
		for (j = col; j >= 2; j--)
		{
			if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == '*' && board[i + 2][j - 2] == ' ')
			{
				board[i + 2][j - 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j - 2] && board[i + 2][j - 2] == '*' && board[i + 1][j - 1] == ' ')
			{
				board[i + 1][j - 1] = '#';
				return 1;
			}
		}
	}
	//检测每一列中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 2][j] && board[i + 2][j] == '*' && board[i + 1][j] == ' ')
			{
				board[i + 1][j] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 1][j] && board[i + 1][j] == '*' && board[i + 2][j] == ' ')
			{
				board[i + 2][j] = '#';
				return 1;
			}
		}
	}
	return 0;
}
int Is_Fun(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0 ;
		}
	}
	return 1;
}
int Is_Win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row-2; i++)
	{
		int j = 0;
		for (j = 0; j < col-2; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j + 1] == board[i][j + 2] && board[i][j] != ' ')
				return board[i][j];
		}
	}
	for (i = 0; i < row - 2; i++)
	{
		int j = 0;
		for (j = 0; j < col-2; j++)
		{
			if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == board[i + 2][j + 2] && board[i][j] != ' ')
				return board[i][j];
		}
	}
	for(i = 0; i < col-2; i++)
	{
		int j = 0;
		for (j = col; j >= 2; j--)
		{
			if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == board[i + 2][j - 2] && board[i][j] != ' ')
				return board[i][j];
		}
	}
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i+1][j ] && board[i + 1][j] == board[i + 2][j] && board[i][j] != ' ')
				return board[i][j];
		}
	}
	if (Is_Fun(board, row, col))
	{
		return 'Q';
	}
	return 'C';
}

#define ROW 6
#define COL 6

通过改变数字6来改变棋盘，实现无限制棋盘。

🎈智能化

int CheakComuputer(char board[ROW][COL], int row, int col)
{
	//计算机自身检测是否能赢，并下棋。
	int i = 0;
	//检测每一行中是否有两个相同的#，有则下棋
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] == '#' && board[i][j + 2] == ' ')
			{
				board[i][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i][j + 2] && board[i][j] == '#' && board[i][j + 1] == ' ')
			{
				board[i][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的#，有则下棋
	for (i = 0; i < row ; i++)
	{
		int j = 0;
		for (j = 0; j < col ; j++)
		{
			if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == '#' && board[i + 2][j + 2] == ' ')
			{
				board[i + 2][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j + 2] && board[i ][j ] == '#' && board[i + 1][j + 1] == ' ')
			{
				board[i + 1][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的#，有则下棋
	for (i = 0; i < col ; i++)
	{
		int j = 0;
		for (j = col; j >= 2; j--)
		{
			if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == '#' && board[i + 2][j - 2] == ' ')
			{
				board[i + 2][j - 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j - 2] && board[i + 2][j - 2] == '#' && board[i + 1][j - 1] == ' ')
			{
				board[i + 1][j - 1] = '#';
				return 1;
			}
		}
	}
	//检测每一列中是否有两个相同的#，有则下棋
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 2][j] && board[i + 2][j] == '#' && board[i + 1][j] == ' ')
			{
				board[i + 1][j] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 1][j] && board[i + 1][j] == '#' && board[i + 2][j] == ' ')
			{
				board[i + 2][j] = '#';
				return 1;
			}
		}
	}
	return 0;
}
int StopComuputer(char board[ROW][COL], int row, int col)
{
	//检测玩家相邻的两个棋子，并进行阻拦。
	int i = 0;
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] == '*' && board[i][j + 2] == ' ')
			{
				board[i][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i][j + 2] && board[i][j] == '*' && board[i][j + 1] == ' ')
			{
				board[i][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == '*' && board[i + 2][j + 2] == ' ')
			{
				board[i + 2][j + 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j + 2] && board[i][j] == '*' && board[i + 1][j + 1] == ' ')
			{
				board[i + 1][j + 1] = '#';
				return 1;
			}
		}
	}
	//检测对角线中是否有两个相同的*，有则阻拦
	for (i = 0; i < col; i++)
	{
		int j = 0;
		for (j = col; j >= 2; j--)
		{
			if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == '*' && board[i + 2][j - 2] == ' ')
			{
				board[i + 2][j - 2] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 2][j - 2] && board[i + 2][j - 2] == '*' && board[i + 1][j - 1] == ' ')
			{
				board[i + 1][j - 1] = '#';
				return 1;
			}
		}
	}
	//检测每一列中是否有两个相同的*，有则阻拦
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == board[i + 2][j] && board[i + 2][j] == '*' && board[i + 1][j] == ' ')
			{
				board[i + 1][j] = '#';
				return 1;
			}
			if (board[i][j] == board[i + 1][j] && board[i + 1][j] == '*' && board[i + 2][j] == ' ')
			{
				board[i + 2][j] = '#';
				return 1;
			}
		}
	}
	return 0;
}
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int flag1 = 0;
	int flag2 = 0;
	flag1 = CheakComuputer(board, ROW, COL);
	if (flag1 == 0)
	{
		flag2 = StopComuputer(board, ROW, COL);
	}
	if (flag1 == 0 && flag2 == 0)
	{
		int x = 0;
		int y = 0;
		while (1)
		{
			x = rand() % row;
			y = rand() % col;
			if (board[x][y] == ' ')
			{
				board[x][y] = '#';
				break;
			}
			else
			{
				printf("电脑下棋的位置重复了，电脑重新下棋。\n");
				ComputerMove(board, ROW, COL);
			}
		}
	}
}

3.写在最后

友友们觉得不错的可以给个关注，点赞或者收藏哦！😘感谢各位友友们的支持。

你的❤️点赞是我创作的动力的源泉
你的✨收藏是我奋斗的方向
你的🙌关注是对我最大的支持
你的✏️评论是我前进的明灯
创作不易，希望大佬你支持一下小沐吧😘

下一期见了！

沐曦希
关注
专栏目录
2021年第一届 “东软杯”网络安全CTF竞赛-官方WriteUp（转）
渗透测试研究中心
12-22 2794
MISC1 签到难度 签到复制给出的flag输入即可2 range_download难度 中等flag{6095B134-5437-4B21-BE52-EDC46A276297}0x01分析dns流量，发现dns && ip.addr=1.1.1.1存在dns隧道数据，整理后得到base64:cGFzc3dvcmQ6IG5zc195eWRzIQ==解base64得到:passwo...
用C语言写一个最简单版的三子棋游戏
m0_68931081的博客
04-28 677
作者介绍：友友们好我是沐曦希，可以叫我小沐💕 作者主页：沐曦希的个人博客主页.🎉 作者的gitee：https://gitee.com/muxi-c-language C语言系列文章： 🎈 1. 函数零基础使用大全，助你了解函数（二） 🎈2. 函数零基础使用大全，助你了解函数（一） 🎈3. .循环语句这些这些知识点你真的会了吗？（2）. 🎈4. 循环语句这些知识点你真的会了吗？（1） 🎉小沐和友友们一样喜欢编辑，天天敲代码🤭，沉迷学习，日渐消瘦。很荣幸能向大家分享我的所学，和大家一起进步，成为合格的卷王.
一文带你深入了解函数栈帧的创建和销毁
m0_68931081的博客
05-01 529
作者介绍：友友们好我是沐曦希，可以叫我小沐💕 作者主页：沐曦希的个人博客主页.🎉 作者的gitee：https://gitee.com/muxi-c-language C语言系列文章： 🎈 1. 函数零基础使用大全，助你了解函数（二） 🎈2. 函数零基础使用大全，助你了解函数（一） 🎈3. .循环语句这些这些知识点你真的会了吗？（2）. 🎈4. 你真的了解数组知识点吗？一篇博客带你全面了解数组 🎉小沐和友友们一样喜欢编辑，天天敲代码🤭，沉迷学习，日渐消瘦。很荣幸能向大家分享我的所学，和大家一起进步，成为.
循环语句这些知识点你真的会了吗？（1）
m0_68931081的博客
04-16 856
带你深入了解C语言的循环语句
函数零基础使用大全，助你了解函数（一）
m0_68931081的博客
04-20 2205
你还不懂函数吗，那是因为你没看到这篇文章？
这个三子棋，输了就要接受惩罚哦！
dtxew love c++
07-27 1098
目录 三子棋的定义和玩法 游戏大体框架 开始界面 游戏主体 初始化棋盘 画出棋盘 开始下棋 玩家下棋的部分 电脑下棋的部分 判断输赢的部分 判断平局的部分 惩罚部分实现 完整代码 main.c文件 game.h文件 game.c文件 三子棋的定义和玩法 三字棋是一种流传已久的民间游戏，双方互相在棋盘上放上棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现棋盘摆满却还没有决定胜负的情况，也就是平局的情况。 今天，我们试着通...
[人工智能-综述-3]：人工智能与硅基生命，人类终将成为造物主
文火冰糖（王文兵）的博客
07-24 2604
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 引言 今天分享的主题是：未来已来，人工智能漫谈。 人工智能是一个很宽泛的话题，我们将从人工智能的发展与应用这个角度，分享个人对人工智能的理解，主要澄清人工智能的一些基本概念和思考。 为什么要分享人工智能这个话题呢？ 一个原因是：人工智能技术是目前非常热门的前沿技术。 另一个重要的原因是：我们处于一个新的人工智能时代的起点，无论未来大家，是否从事人工智能相关的职业，
读人工智能全传07智能体
lyingSeven的博客
07-09 977
读人工智能全传07智能体
三子棋小游戏
m0_57249790的博客
10-18 2497
今天我们来写一个三子棋小游戏，主要运用的知识是函数调用，数组，循环等。 首先是棋盘菜单的打印： void menu() { printf("**********************\n"); printf("**********************\n"); printf("**** 1.play ****\n"); printf("**** 0.exit ****\n"); printf("**** made by wenbo****\n"); print
一种通用强人工智能系统的实现
szbpmf的博客
08-24 1041
按照面向对象的思想，来实现人工智能系统
把AI应用到实体棋盘！费米L6智能国际象棋：告别网络依赖，重归线下下棋
feimifermi的博客
11-17 584
在互联网普及的现世代，网络下棋正悄悄取代线下，不过便利之余危害也无声无息的到来，而智能化棋类产品是个趋势，所以费米L6智能棋盘利用科技和真实棋盘上的结合，让棋友在实体棋子移动下也能享受网络所带来的高算力，畅快的进行”人机对战“來磨练棋力。
2023最新大数据毕设题目推荐100例
m0_76217654的博客
12-27 2954
Hi，大家好，大四的同学马上要开始毕业设计啦，大家做好准备了没！学长给大家详细整理了最新的 大数据专业 相关选题，对选题有任何疑问，都可以问学长哦~学长限时开放开题指导，对开题有任何不明白的，对某项技术或算法不理解的，不知道怎么下手毕设的，都可以问学长，学长会根据你的情况提供帮助，希望能帮助到你。
DeepMind推出最新强化学习环境「Gridworlds」，剑指AI安全 | 附论文&代码实现
雷克世界
11-30 1044
图：pixabay 原文来源：DeepMind Blog、arXiv、GitHub 作者：Victoria Krakovna、Jan Leike、Laurent Orseau 「雷克世界」编译：嗯~阿童木呀、哆啦A亮 随着人工智能系统在现实世界中变得日益普遍和有用，确保它们的安全行为也将成为工作中的重点。迄今为止，大多数技术性人工智能安全研究的重点集中在对不安全
(转载)不完全解读 Emacs 编辑器—自由软件的旗舰
FreeCoder的专栏
05-18 2807
转载：不完全解读 Emacs 编辑器—自由软件的旗舰 L-Emacs 2008-11-17 21:41:10 阅读45 评论0   字号：大中小 订阅 作者: texnician@dRL 希望本文能指引你进入Emacs的神奇世界 一 基本介绍 1. Emacs是什么东西？ Emacs名字的正式由来是"Editing Macros"的简称，即“宏编辑器
CH592蓝牙芯片从机端调试记录：如何降低连接功耗
u013534357的博客
10-09 775
CH592蓝牙芯片从机端调试记录：如何降低连接功耗
用于去噪幅度dMRI的Matlab工具箱.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
APP报毒全自动处理系统源码
最新发布
10-09
APP报毒全自动处理系统源码
智能优化算法-引力搜索优化算法（GSA）（附源码）
10-09
引力搜索优化算法 (Gravitational Search Algorithm, GSA) 是一种基于牛顿万有引力定律的元启发式优化算法，由Rashedi等人于2009年提出。GSA通过模拟天体之间的引力作用来搜索最优解，适用于解决复杂的优化问题。 GSA的工作机制主要包括： 初始化：随机生成一组初始解，每个解代表一个“质量”。 计算引力：根据每个解的质量和距离，计算它们之间的引力。 更新位置：根据引力作用，更新每个解的位置，从而探索解空间。 更新质量：根据解的适应度值，更新每个解的质量，以便更好地指导搜索方向。 优点包括： 全局搜索能力：GSA能够有效地探索解空间的不同区域。 鲁棒性强：适用于多种优化问题，包括连续和离散优化。 易于实现：算法设计直观，易于编程实现。
三子棋人工智能python
08-02
三子棋人工智能（Go AI）在Python中通常通过深度学习技术来实现，特别是利用神经网络模型。AlphaGo Zero是一个著名的案例，它采用了强化学习算法，无需人类先验知识就能从零开始自我对弈学习。以下是创建一个基础的三子棋AI的一个简要概述： 1. **环境模拟**：首先，需要设计一个游戏环境，包括棋盘、棋子状态表示以及规则。 2. **数据结构**：利用二维数组或类似数据结构来表示棋盘状态，并能够方便地进行落子操作。 3. **神经网络**：构建一个卷积神经网络（CNN）作为策略网络和价值网络，前者用于评估每一步棋的好坏，后者预测下几步内的获胜概率。 4. **强化学习**：使用蒙特卡洛树搜索（MCTS）来探索潜在的游戏结果，结合神经网络的预测选择动作。每次落子后，都会更新神经网络并回溯调整其预测。 5. **训练过程**：通过大量的自我对局，不断迭代优化神经网络，直到达到满意的性能水平。
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沐曦希

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值