【简单AI井字棋】

最新推荐文章于 2024-07-07 22:05:41 发布
最新推荐文章于 2024-07-07 22:05:41 发布
阅读量7.2k 收藏 49
点赞数 18
分类专栏： 笔记 计算机博弈 文章标签： c语言 开发语言 后端 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52882232/article/details/122346837
版权

井字棋AI开发


我们要开发一款AI项目，最重要的是得理解它的原理

1.井字棋的原理

O方获胜
双方轮流下棋，若其中一方在水平、垂直、斜线方向上形成三个棋子连线，则获胜

井字棋流程图

在这里插入图片描述

井字棋实现过程

1.游戏菜单

这是一个双人游戏，自然有一个先后的问题，那么人先走和电脑先走的情况肯定是不一样的，所以我们得用switch函数将其分开来运行。

void menu()
{
	printf("\n\n\n");

	printf("*************************************************\n");
	printf("*******                                  ********\n");
	printf("*******    欢迎使用井字棋人机对弈系统    ********\n");
	printf("*******                                  ********\n");
	printf("*************************************************\n");

	printf("\n\n\n");

	printf("正在为您跳转，请稍后...\n");
	Sleep(2000);
	system("CLS");

	printf("\n\n\n");
	printf("**************************************\n");
	printf("*******    1.PlayerFirst      ********\n");
	printf("*******    2.ComputerFirst    ********\n");
	printf("*******    0.Exit             ********\n");
	printf("**************************************\n");

}

2.打印棋盘

在没有下棋之前，棋盘肯定是空的，所以我们得将棋盘初始化，我们每下一次，棋盘就变化一次，因此我们还得打印一下棋盘，以便我们观察。
棋盘呢有多种形式，带边框的和不带边框的就看你喜欢哪种了，具体思路是一样的，就是细节上有略微的差异

//棋盘初始化
void Inintboard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
}


//打印棋盘
void Displayboard()
{
	system("CLS");
	int i, j;
	for (i = 0; i < COL; i++)
	{
		printf("-------------\n");
		for (j = 0; j < ROW; j++)
		{
			if (board[i][j] == COM)
			{
				printf("| X ");
			}
			else if (board[i][j] == MAN)
			{
				printf("| O ");
			}
			else
			{
				printf("|   ");
			}

		}
		printf("|\n");
	}
	printf("-------------\n");
}

3.人先走

void game1()
{
	//存储数据--二维数组
	char board[ROW][COL];
	//棋盘初始化
	Inintboard(board, ROW, COL);
	//打印棋盘
	Displayboard();

	char ret = 0;

	while (1)
	{

		//玩家下棋
		PlayerMove();
		Displayboard();
		//判断玩家是否赢了
		ret = IsWin();
		if (ret != 'C')
			break;

		//电脑下棋
		ComputerMove();
		Displayboard();
		//判断电脑是否赢了
		ret = IsWin();
		if (ret != 'C')
			break;
	}
	if(ret == 'O')
	{
		Sleep(1000);
		system("CLS");
		printf("玩家赢了\n");
		Sleep(2000);
	}
	else if (ret == 'X')
	{
		Sleep(1000);
		system("CLS");
		printf("电脑赢了\n");
		Sleep(2000);
	}
	else if(ret == 'Q')
	{
		Sleep(1000);
		system("CLS");
		printf("平局\n");
		Sleep(2000);
	}
	Displayboard();
}

4.电脑先走

void game2()
{
	//存储数据--二维数组
	char board[ROW][COL];
	//棋盘初始化
	Inintboard(board, ROW, COL);
	//打印棋盘
	Displayboard();

	char ret = 0;

	while (1)
	{
		//电脑下棋
		ComputerMove();
		Displayboard();
		//判断电脑是否赢了
		ret = IsWin();
		if (ret != 'C')
			break;

		//玩家下棋
		PlayerMove();
		Displayboard();
		//判断玩家是否赢了
		ret = IsWin();
		if (ret != 'C')
			break;
	}
	if (ret == 'O')
	{
		Sleep(1000);
		system("CLS");
		printf("玩家赢了\n");
		Sleep(2000);
	}
	else if (ret == 'X')
	{
		Sleep(1000);
		system("CLS");
		printf("电脑赢了\n");
		Sleep(2000);
	}
	else if (ret == 'Q')
	{
		Sleep(1000);
		system("CLS");
		printf("平局\n");
		Sleep(2000);
	}
	Displayboard();
}

5.玩家下棋

此项目中，我们用的是二维数组来制作的棋盘，所以玩家在下棋的时候只用输入需要落入棋子的坐标即可，既然是输入坐标，那么就有可能是输入错的，或者在该位置已经有棋子了，因此我们需要先判断输入坐标的合法性，如果合法了我们再判断该位置是否有棋子了。

//玩家下棋
void PlayerMove()
{
	printf("玩家走\n");
	int x = 0;
	int y = 0;
	while (1)
	{
		printf("请输入下棋的坐标>\n");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] =  MAN;
				break;
			}
			else
			{
				printf("坐标被占用，请重新输入\n");
				
			}
		}
		else
		{
			printf("坐标错误，请重新输入\n");
			
		}
	}
}

6.电脑下棋

原始方法

利用srand，rand函数产生1-3的随机值x和y（因此无需判断电脑下棋坐标的合法性），然后判断该位置是否有棋子了，就可以了，本质上就是把玩家下棋里玩家输入的坐标改成rand函数生成的随机值，很简单。

为啥这没有代码呢，别问，问就是博主要给你们看更高逼格的

AI下棋

针对井字棋游戏，在游戏设计过程中可按照以下基本原则进行：
1. 如果下在该位置可以赢棋，那么久下在该位置
2. 如果对手下在该位置可以赢棋，那就下在该位置
3. 如果中心位置空闲，那么下在中心位置要优于边上和角上位置
4. 如果角上位置空闲，那么下在角上位置要优于边上位置
5. 如果只有边上位置空闲，那么只能下在边上位置

在这呢，博主提供两种方法，第一种暴力枚举所有下棋的可能，然后下棋，第二种通过极大极小搜索算法找到每次下棋的最优解，然后下棋。

1.暴力枚举

此种方法有局限性，只能是电脑先手，才能做到肯定赢棋，最差也是平局的局面，如果是人先手的话，人的下棋有9种可能，暴力枚举的次数太多，这就没必要了，这就是枚举的局限性。

//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	int ret = CountNum(board, row, col);
	while (1)
	{
		if (ret == 1|| ret == 3 || ret == 5 || ret == 7)
		{
			x = rand() % row;
			y = rand() % col;
			if (board[x][y] == ' ')
				board[x][y] = 'X';
			break;
		}
	}

	if (ret == 0)
	{
		board[0][0] = 'X';
	}
	if (ret == 2)
	{

		//5 types , 8 situations

		// 1
		if (board[0][1] == 'O')
		{
			board[2][0] = 'X';
		}
		// 2
		if (board[1][0] == 'O')
		{
			board[0][2] = 'X';
		}
		// 3 
		if (board[0][2] == 'O')
		{
			board[2][2] = 'X';
		}
		// 4
		if (board[2][0] == 'O')
		{
			board[2][2] = 'X';
		}
		// 5
		if (board[2][1] == 'O')
		{
			board[2][0] = 'X';
		}
		// 6
		if (board[1][2] == 'O')
		{
			board[0][2] = 'X';
		}
		// 7
		if (board[1][1] == 'O')
		{
			board[0][1] = 'X';
		}
		// 8
		if (board[2][2] == 'O')
		{
			board[0][2] = 'X';
		}
	}
	if (ret == 4)
	{
		// 1@1
		if (board[0][1] == 'O' && board[2][0] == 'X')
		{
			if (board[1][0] == 'O')
			{
				board[2][2] = 'X';
			}
			else
			{
				board[1][0] = 'X';
			}
		}
		// 2@1
		if (board[1][0] == 'O' && board[0][2] == 'X')
		{
			if (board[0][1] == 'O')
			{
				board[2][2] = 'X';
			}
			else
			{
				board[0][1] = 'X';
			}
		}
		// 3@1
		if (board[0][2] == 'O' && board[2][2] == 'X')
		{
			if (board[1][1] == 'O')
			{
				board[2][0] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 4@1
		if (board[2][0] == 'O' && board[2][2] == 'X')
		{
			if (board[1][1] == 'O')
			{
				board[0][2] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 5@1
		if (board[2][1] == 'O' && board[2][0] == 'X')
		{
			if (board[1][0] == 'O')
			{
				board[0][2] = 'X';
			}
			else
			{
				board[1][0] = 'X';
			}
		}
		// 6@1
		if (board[1][2] == 'O' && board[0][2] == 'X')
		{
			if (board[0][1] == 'O')
			{
				board[2][0] = 'X';
			}
			else
			{
				board[0][1] = 'X';
			}
		}
		// 7@1
		if (board[1][1] == 'O' && board[0][1] == 'X')
		{
			if (board[0][2] == 'O')
			{
				board[2][0] = 'X';
			}
			else
			{
				board[0][2] = 'X';
			}
		}
		// 8@1
		if (board[2][2] == 'O' && board[0][2] == 'O')
		{
			if (board[0][1] == 'O')
			{
				board[2][0] = 'X';
			}
			else
			{
				board[0][1] = 'X';
			}
		}
	}
	if (ret == 6)
	{
		// 1@1@1
		if (board[0][0] == 'X' && board[2][0] == 'X'
			&& board[2][2] == 'X' && board[0][1] == 'O'
			&& board[1][0] == 'O')
		{
			if (board[1][1] == ' ')
			{
				board[1][1] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 2@1@1
		if (board[0][0] == 'X' && board[0][2] == 'X' &&
			board[2][2] == 'X' && board[0][1] == 'O' &&
			board[1][0] == 'O')
		{
			if (board[1][1] == ' ')
			{
				board[1][1] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 3@1@1
		if (board[0][0] == 'X' && board[2][0] == 'X' &&
			board[2][2] == 'X' && board[0][2] == 'O' &&
			board[1][1] == 'O')
		{
			if (board[1][0] == ' ')
			{
				board[1][0] = 'X';
			}
			else
			{
				board[2][1] = 'X';
			}
		}
		// 4@1@1
		if (board[0][0] == 'X' && board[0][2] == 'X' &&
			board[2][2] == 'X' && board[2][0] == 'O' &&
			board[1][1] == 'O')
		{
			if (board[0][1] == ' ')
			{
				board[0][1] = 'X';
			}
			else
			{
				board[1][2] = 'X';
			}
		}
		// 5@1@1
		if (board[0][0] == 'X' && board[2][0] == 'X' &&
			board[0][2] == 'X' && board[1][0] == 'O' &&
			board[2][1] == 'O')
		{
			if (board[0][1] == ' ')
			{
				board[0][1] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 6@1@1
		if (board[0][0] == 'X' && board[0][2] == 'X' &&
			board[2][0] == 'X' && board[0][1] == 'O' &&
			board[1][2] == 'O')
		{
			if (board[1][0] == ' ')
			{
				board[1][0] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
		// 7@1@1
		if (board[0][0] == 'X' && board[0][1] == 'X' &&
			board[2][0] == 'X' && board[1][1] == 'O' &&
			board[0][2] == 'O')
		{
			if (board[1][0] == 'O')
			{
				board[1][2] = 'X';
			}
			else
			{
				board[1][0] = 'X';
			}
		}
		// 8@1@1
		if (board[0][0] == 'X' && board[0][2] == 'X' &&
			board[2][0] == 'X' && board[0][1] == 'O' &&
			board[2][2] == 'O')
		{
			if (board[1][0] == ' ')
			{
				board[1][0] = 'X';
			}
			else
			{
				board[1][1] = 'X';
			}
		}
	}
	if (ret == 8)
	{
		//7@1@1@1
		if (board[0][0] == 'X' && board[0][1] == 'X' &&
			board[1][2] == 'X' && board[2][0] == 'X' &&
			board[0][2] == 'O' && board[1][0] == 'O' &&
			board[1][1] == 'O')
		{
			if (board[2][1] == 'O')
			{
				board[2][2] = 'X';
			}
			else
			{
				board[2][1] = 'X';
			}
		}
	}
	
}
2.极大极小算法

为方便表达游戏的状态，通常使用树或图来表达


为了更好的理解搜索过程，这里就先介绍博弈树中一些常用的概念

  1. 分支因子：指从游戏起始出发游戏者可以移动到的位置。例如井字棋的分支因子为9（游戏开始时，下棋共有9个位置可以选择）
  2. 层次：博弈树的层次。游戏者通过下棋进入博弈树的下一层次。
  3. 深度：在博弈树中向下搜索的层次称为深度（或搜索深度）。例如井字棋游戏的搜索深度一般为6~7，而国际象棋的通常要达到40。

最重要的就是估值函数，估值函数的能力真正决定了你所写的AI的能力，估值函数判断的越准确，AI越能找到最优解。

估值函数并不是唯一的，不同的人有不同的想法，用的编程语言也不相同，所写出来的估值函数也就不一样，所以下面我就展示伪码来体现一种估值函数，希望读者能有所感悟，能写出更好的估值函数

function eval()
{
	int temp[9] = 0
	for i:0 to 8
	temp[i] = board[i]
	int win = 0
	int lose = 0
	for i:0 to 8
		int sum = 0
		for j:0 to 2
			sum += temp[line[i][j]]
			if(sum == 3)
				then return MAX = +INFINITY
			else if (sum == -3)
				then return MIN = -INFNINTY
			else if (-3<sum<0)
				then lose ++
			else if(0<sum<3)
				then win ++
			endif
	return win-lose
}

估值函数的不同，写出来的极大极小搜索算法也不同，下面我也仅通过伪码来展示极大极小搜索算法

function minmaxSearch()
{
	    int bestMoves[9] = { 0 }
		index = 0
		int bestValue = -INFINITY
		if (depth == 0 and isFull())
			then return eval()
		else
			for pos:0 to 8
				if(board[pos] == NULL)
					then board[pos] = MAX
					int value = minSearch(depth-1)
					if(value>bestValue)
						then bestValue = value
						int index = 0
						bestMoves[index] = pos
					else if (value == bestValue)
						then bestMoves[++index] = pos
					endif
					board[pos] = NULL
				endif
	  endif
	  return bestMoves[index]
}

上述例子才用的是一维数组表示棋盘，在打印棋盘时每打印3个数据就换行，这样就保证了棋盘的正常展示，根据实际需要也可以用二维数组，改一改过程即可

还有一个十分重要的算法：阿尔法-贝塔剪枝算法，在搜索过程中，我们会发现，当搜索到一定程度时，下面的结果都不能取得最优解了，继续搜索下去，就会造成时间的浪费，因此就要把他cut掉，这就诞生了剪枝算法
但由于井字棋的搜索树并不大，搜索时间也不多，所以是用不到阿尔法-贝塔剪枝算法的。这里就不继续阐述了。

至此，井字棋AI介绍就完了，你get到了吗？

贩梦先生007
关注
专栏目录
蒙特卡洛算法实现的井字棋
07-25
本项目通过Python实现了一个井字棋游戏，利用蒙特卡洛搜索树（MCTS）算法，使AI具备智能决策能力，并且带有用户界面，方便人机对战。 蒙特卡洛算法是一种基于概率统计的搜索方法，广泛应用于游戏AI中，特别是像井字...
极小化极大算法实现井字棋
weixin_54618249的博客
01-09 4559
Minimax算法 Minimax 算法又叫极小化极大算法，是一种找出失败的最大可能性中的最小值的算法。（维基百科） alpha-beta 剪枝 Minimax算法中，由于每个节点都是取的极值，所以可以利用这个性质进行剪枝。 以上是简介，下面通过井字棋这个游戏，按照 DFS -> Minimax -> a - b剪枝 这样的顺序进行引导 一、需要解决的问题 井字棋中，我们要做到电脑每一步棋都是下在所有他可以下的位置中对他最有利的位置。 也就是Minimax算法的找出失败的最大可能性中的最小值，换
井字棋游戏
SOGD
05-03 4195
案例目的 本章案例研究，通过井字棋游戏案例帮助读者深入了解，使用数据结构和算法实现游戏，人工智能井字棋游戏包括较为复杂的计算机人工智能落子算法，判断输赢算法等，通过把不同功能定义为独立的函数，可以减少程序的复杂性。 案例内容 井字棋，英文名叫Tic-Tac-Toe，是一种在3*3格子上进行的连珠游戏，和五子棋类似，由于棋盘一般不画边框，格线排成井字故得名。游戏需要的工具仅为纸和笔，然后由分别代表O和X的两个游戏者轮流在格子里留下标记（一般来说先手者为X），任意三个标记形成一条直线，则为获胜。 表 1..
井字棋 AI-Python
最新发布
2401_86075647的博客
07-07 1444
具体来说，如果当前是MAX节点（即玩家希望最大化收益的节点），它会评估所有可能的走法，并选择能带来最大价值的走法。通过这种递归方式，Minimax算法能够找到一条最优路径，使得在对方采取最佳反应的情况下，自己的损失最小。这种技术通过维护两个值——Alpha（当前找到的最大下界）和Beta（当前找到的最小上界），在搜索过程中剪枝那些不可能优于已有选择的子树，从而显著减少搜索量。总的来说，Minimax算法通过构建博弈树并递归评估每个可能的游戏状态，寻找在对手采取最优反应的情况下能够保证的最佳结果。
神经网络井字棋AI对战版的开发与测试
王德昌的博客
01-09 1417
本文主要介绍基于“确定性神经网络”开发AI对战版井字棋（三连子）的过程，并用开发出的软件进行对战来生成对弈数据，这些数据可用于训练确定性神经网络模型。另外，通过测试发现了一些井字棋的特性和对弈数据的情形。 1. AI对战版井字棋 这是基于MFC对话框开发的神经网络连子棋的一个特定版本，即获胜连子数为3的版本——三连子，而且，是AI与AI对战的版本，不需要人工参与即可进行对弈。 （1）创建项目 运行Visual Studio 2015，选择菜单“文件-->新建-->项目”，在对话框的左侧选
TicTacToe（井字棋）的算法——不比人的智商低的AI
runfeel
03-28 2505
何为TicTacToe？ TicTacToe也俗称井字棋或三连棋(两人轮流在一有九格方盘上划加字或圆圈, 谁先把三个同一记号排成横线、直线、斜线, 即是胜者)，男女老少皆宜的入门级棋类游戏。 关于游戏的实现方式，比较简单，在这就不多说了。直接谈一谈如何写出在TicTacToe游戏中不输给人类棋手的电脑。 想要写出游戏AI，第一步是自己要会玩游戏，有自己的策略。第二部才是告诉我们的A...
Minimax博弈算法设计井字棋AI(Golang)
qq_22328011的博客
10-19 3086
minimax井字棋Go语言
井字棋（tictactoe）matlab代码实现
09-06
井字棋，也被称为“Noughts and Crosses”或“Xs and Os”，是一种简单但策略性十足的两人对弈游戏。在MATLAB中实现井字棋，可以通过编程逻辑来模拟游戏流程，包括游戏界面的创建、玩家的回合交替、胜负判断以及智能...
极小极大算法实现井字棋AI
01-14
井子棋是棋类中最简单的一种，通常作为算法的练手项目，该资源使用极小极大算法实现了一个井字棋的人机对弈，只需运行资源里的play_to_bot就可以在命令行里与AI对弈了，可以肯定的是你绝对不可能战胜它。虽然实现它...
JavaScript 井字棋人工智能实现代码
01-19
下面是一个简单的JavaScript实现示例，展示了如何使用最小最大算法来开发井字棋的人工智能。 ```javascript // 定义游戏状态 let board = [ ["", "", ""], ["", "", ""], ["", "", ""] ]; const AI_PLAYER = "O...
人工智能课程设计，基于α-β剪枝算法的井字棋
03-01
由于其简单的规则和有限的决策空间，井字棋常被用作教学人工智能算法的基础案例。 α-β剪枝算法是优化搜索树的策略，广泛应用于棋类游戏的决策过程中。它是一种基于最小化-最大化搜索的优化版本，用于减少在评估...
井字棋AI对战小游戏（前端开发）
03-16
这是一个拥有智能AI对手的井字棋小游戏，使用JavaScript语音进行开发，是一个前端小游戏，打开之后运行井字棋.html即可在网页上与AI进行井字棋游戏对战。也可以参考https://blog.csdn.net/qq_36171287/article/details/104887248这篇博客，主要代码博客中也都有。
实现AI下井字棋的alpha-beta剪枝算法（python实现）
GO追风少年
01-30 1万+
AlphaBeta剪枝算法是对Minimax方法的优化，能够极大提高搜索树的效率。代码参考自中国大学mooc上人工智能与信息社会陈斌老师的算法，我在原来的基础上增加了玩家输入的异常捕获
井字棋AI算法
鸟人的博客
03-17 1818
井字棋，英文名叫Tic-Tac-Toe，是一种在3*3格子上进行的连珠游戏，和五子棋类似，由于棋盘一般不画边框，格线排成井字故得名。游戏需要的工具仅为纸和笔，然后由分别代表O和X的两个游戏者轮流在格子里留下标记（一般来说先手者为X），任意三个标记形成一条直线，则为获胜。 训练AI package com.lab8.a1; import java.util.Random; import java.util.Scanner; import java.util.concurrent.CopyOnWriteAr
基于Alpha-Beta剪枝树的井字棋人机博弈系统【附源码】
热门推荐
嵌入式阿齐Archie
12-20 3万+
这篇文章全面介绍了算法设计与分析的基础知识，并以实际案例展示了算法在解决井字棋博弈问题中的应用。
python实现AI井字棋极大极小算法和Alpha-beta算法
hell_orld的博客
11-07 4932
python实现AI井字棋极大极小算法和Alpha-beta算法程序设计思路主要步骤和代码对于两个算法流程图运行结果 程序设计思路 大致思路： 井字棋最后的结果无非就是玩家赢、电脑赢和平局三种结果，而最后的结果正对应这整棵棋盘生成树的叶子节点，那么可以把玩家赢、电脑赢和平局三种结果赋值，然后根据当前深度是Max层还是Min层来，往上推出该子节点的父子节点的值，一直往上走到根节点，这也正是极大极小搜索的一个过程，而alpha-beta算法只要在极大极小上加以修改即可。 主要步骤和代码 1、 棋盘：用一个长度为
井字棋 tictactoe 极大极小算法 α-β剪枝算法【python】
Jing_HJY的博客
11-29 1万+
文章目录一、 实验内容二、 极大极小算法和α-β剪枝算法总结1.极大极小算法2.α-β剪枝三、 实验步骤以及结果1.极大极小算法完成井字棋游戏2.α-β剪枝四、 结果、反思与分析1.极大极小算法运行结果、发现的问题与解决方式2.α-β剪枝运行结果、发现的问题与解决方式3.极大极小算法和α-β剪枝的比较总结 一、 实验内容 实验利用极大极小算法和α-β剪枝算法完成对井字游戏的实现。 大家首先下载对应代码；另外需要安装pygame库；pipinstall pygame 项目中主要包含两个文件 runner.
【C语言从入门到入土】——“井字棋”
hehelm的博客
11-14 1626
井字棋又叫三子棋，作为童年经典小游戏，相信各位无论是在上课摸鱼亦或者打磨时间的时候一定与小伙伴来过这么几局游戏。游戏规则很简单，玩家只需要在3*3格子棋盘上进行连珠，双方轮流依次下棋，率先在棋盘上连成三子者获胜
【井字棋】
m0_熊猫馆主的博客
08-06 4643
大家好，今天我们一起来动手完成学习数组时必写小游戏之一–井字棋，井字棋也叫三子棋，是一种在3*3格子上进行的连珠游戏，和五子棋类似，由于棋盘一般不画边框，格线排成井字故得名。由分别代表O和X的两个游戏者轮流在格子里留下标记（一般来说先手者为X），任意三个标记形成一条直线，则为获胜。以上就是今天要讲的内容，本文仅仅简单介绍了井字棋的实现，而该井字棋实现还有很多可以改进的地方，比如判断条件只对33的井字棋有效，若改为55便不行了、还有就是只能判断三连子，更多的四连、五连则不行、......
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贩梦先生007

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

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

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

打赏作者

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

抵扣说明：

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

余额充值