数组+函数+循环就能实现的三子棋和五子棋（动态匹配输赢）

已于 2022-10-06 09:57:22 修改
阅读量1.5k 收藏 17
点赞数 29
分类专栏： 【C语言】 游戏和实操小项目 文章标签： c语言
于 2022-07-30 21:16:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64212811/article/details/126048156
版权
本文介绍了如何使用C语言编写三子棋和五子棋游戏，包括游戏流程、用户交互、棋盘显示、玩家与电脑下棋的逻辑以及判断输赢的算法。通过游戏设计思路，详细解释了代码实现过程，涵盖了游戏的基本功能和扩展可能性，如动态匹配输赢以适应不同棋子数目的游戏。
摘要由CSDN通过智能技术生成

目录

设计思路：

敲代码的时候要分类文件，这样看起来更加清晰简洁。

三子棋

源文件的实现：

实现menu()

实现Game()

实现头文件：

实现game.c

数组的初始化

棋盘的打印

 玩家下棋

 电脑下棋

判断输赢

完整代码：

game.h

源文件

 game.c

五子棋

游戏的核心来了：动态匹配输赢

我们先来看 行：

再来看列：

对角线左上-右下

对角线右上-左下

动态匹配输赢的完整代码

棋盘更改后的代码

 

 

设计思路：

游戏的主体部分:

 

1.我们下棋，首先需要棋盘。

 

2.我们落的棋子需要存放。

 

3.玩游戏：玩家下棋，电脑下棋（又或者第二个玩家下棋）

 

4.判断输赢

敲代码的时候要分类文件，这样看起来更加清晰简洁。

头文件的相关知识都在这，点"我"即可

1.专门实现我们游戏的函数，放在一个文件中 --->game.c

 

2.一个头文件，专门存放一些函数声明，宏定义，库函数的头文件--->game.h

 

3.主函数所在的源文件。

三子棋

源文件的实现：

就像我们玩小游戏一般，进入游戏先给你菜单-->选择玩与不玩-->进入游戏/退出游戏/输入错误

int main()
{
	int input = 0;
	do
	{
		menu();//菜单
		printf("请选择输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Game();
			break;
		case 0:
			printf("游戏结束\n");
			break;
		default:
				printf("输入错误，请重新输入\n");
				break;
		}
	} while (input);
}

根据我们所示的代码，我们需要分别去实现menu()，和Game()。

实现menu()

简简单单随你怎么设置

void menu()
{
	printf("************************\n");
	printf("************************\n");
	printf("*******  1.play  *******\n");
	printf("*******  0.exit  *******\n");
	printf("************************\n");
}

实现Game()

开篇的时候呢，我们写了游戏的大体设计思路，我们暂且就按照那里实现，一些其他细节写

 

的时候在进行修修改改

void Game()
{
	char board[ROW][COL] = { 0 };
    //定义一个二维数组，用来存棋子

	Init_board(board, ROW, COL);//初始化数组

	Display_board(board, ROW, COL);//打印棋盘

	Player_Play(board, ROW, COL);//玩家下棋  

	Is_win(board, ROW, COL);//判断输赢			

	Computer_Play(board, ROW, COL);//电脑下棋

}

在使用函数的时候，我们要去声明，我们将这些声明放入头文件中。是不是发现有用到

 

ROW，COL（行列），这是我们定义的宏，更加简便，如果你要改动行和列的话，不设置

 

宏，那就需要到每一个函数中删删改改，容易出问题，定义宏，我们可以一劳永逸。

实现头文件：

右击源文件/头文件-->添加-->新有项-->选择头文件 

 

（编译器是VS2019）

f3ff64da1ac642b9831214bd7b56259b.png

#include<stdio.h>

//定义的宏
#define ROW 3
#define COL 3


//函数声明

//数组初始化
void Init_board(char board[ROW][COL], int row, int col);
//打印棋盘
void Display_board(char board[ROW][COL], int row, int col);
//玩家下棋
void Player_Play(char board[ROW][COL], int row, int col);
//电脑下棋
void Computer_Play(char board[ROW][COL], int row, int col);
//判断能否赢
char Is_win(char board[ROW][COL], int row, int col);

实现game.c

右击头文件/源文件-->添加-->新有项-->选择c++(文件)       

 

（编译器是VS2019）

54b9d84ca36b4331a39ac9a345619e5d.png

 

数组的初始化

这个比较简单，双层循环。初始化成空格。

void Init_board(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] = ' ';
		}
	}

}

棋盘的打印

我们先来看看棋盘的样子，看你怎么设计的，你就怎么实现

8b5920d746d5429fb71d9905369fc946.png

 

看棋盘的样子，我们肯定能想到是双层循环，然后实现这些字符“ %c ” ， "|"  ，“---” 的组合。%c，这个位置是我们的棋子。

写的时候要注意最右边是没有"|",最后一行的时候是没有“---”，写的时候我们要把握好控制条件。

void Display_board(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++)
		{
			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");
		}
	}
}

 玩家下棋

在写的时候，我们需要注意的是，没学编程的人肯定不知道数组下标是从0开始的，因此在我们设计的时候呢，输入的坐标要从1开始。

玩家输入坐标后有哪些需要注意的呢？

 

1.坐标的合法性，假如我是3*3的棋盘，那坐标应该是x:1-3,y:1-3

 

2.输入的坐标，坐标处有没有被占用，这也是我们要考虑的。

 

3.输入坐标之后，我们是不是得看下我们的棋子落在哪里呢，所以需要去打印棋盘

 

4.在输入不合法的坐标的时候，需要重新输入。这样一理，我们会想到要用循环。

void Player_Play(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("玩家走:\n");
	while (1)
	{   
		printf("输入坐标:>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标的合法性  x:1-3 y:1-3
		{
			if (board[x - 1][y - 1] == ' ')//判断坐标处有没有被占用
			{
				board[x - 1][y - 1] = '*';//下棋
				Display_board(board, ROW, COL);//打印棋盘
				printf("\n");
				break;
			}
			else
			{
				printf("坐标处已被占用，重新输入\n");
			}
		}
		else
		{
			printf("坐标输入错误，重新输入\n");
		}
	}
}

 电脑下棋

电脑下棋的时候，需要注意一下的就是坐标的产生。

随机数的产生我们只要记住一个组合就可以了。

 

 rand() --产生随机数，srand((unsigned int)time(NULL))--作用就是让rand()产生时时刻刻变化的随机数。

如果没有srand((unsigned int)time(NULL)),每一次rand()产生的数都是固定的。

time(NULL)是一个时间戳，时时刻刻都在变化，这样srand()接收的数一直在变化，因此rand()产生的数不会固定。

 

srand((unsigned int)time(NULL)); 这个只要调用一次就可以了，我们就放入主函数之中

我们需要产生0-2（0，1，2）之间的数（根据我们的行和列来考虑的），rand()/row的余数就是我们想要的值，所以我们就用%

也需要判断，坐标有没有被占用，输入完之后也要打印棋盘

void Computer_Play(char board[ROW][COL], int row, int col)
{
	printf("电脑走:\n");
	//x,y 放在循环里面和循环外面有什么区别嘛？有区别。
	// 如果x y和我们玩家输入的一样，不在循环里的话，x，y就不能改变
	// 程序会出问题
	
	//int x = rand() % row; //0-2
	//int y = rand() % col;
	while (1)
	{
		int x = rand() % row; //0-2
		int y = rand() % col;
			if (board[x][y] == ' ')//判断坐标处有没有被占用
			{
				board[x][y] = '#';
				Display_board(board, ROW, COL);//打印棋盘
				printf("\n");
				break;
			}
	}
}

判断输赢

我们想一下游戏的结果有哪些？

玩家赢或者电脑赢：有三个字符一样（不是' '）。

 

平局：棋盘写满了，又或是不是其他三种情况的时候

 

游戏继续：不是上面三种情况，就是游戏继续，又或者是，棋盘中没有满并且没有人获胜的时候，游戏继续。

在什么时候判断输赢？

是每下一个棋子，我们都要去判断一下，有没有赢

 

要是赢了，游戏结束。如果没赢，需要重复下棋，因此我们需要用到循环。

 

怎么判断输赢呢？

 

看我们的返回值，如果返回的是‘*’ --->玩家赢， ‘#’--->电脑赢，‘P--->平局

'C'--->游戏继续。 

 

前面两个，是在 玩家下棋，电脑下棋 的函数中，你输入的棋子是什么，我们的返回值就是什么。

 

后面两个就看你想让它返回什么，你就设置成什么。

这是Game()的删改。 

void Game()
{
	char board[ROW][COL] = { 0 };
	Init_board(board, ROW, COL);//初始化数组
	Display_board(board, ROW, COL);//打印棋盘
	char ret = 0;
	while (1)
	{
		Player_Play(board, ROW, COL);//玩家下棋  
		ret = Is_win(board, ROW, COL);//判断输赢
		if (ret != 'C')//只要不是游戏继续，游戏就结束   
			break;
		Computer_Play(board, ROW, COL);//电脑下棋
		ret = Is_win(board, ROW, COL);//判断输赢
		if (ret != 'C') 
			break;
	}
	if ('*' == ret)
	{
		printf("玩家赢\n");
			
	}
	else if ('#' == ret)
	{
		printf("电脑赢\n");

	}
	else 
	{
		printf("平局\n");

	}
	Display_board(board, ROW, COL);//游戏结束的时候在打印下棋盘

}

Is_win()函数的实现 

以下写法比较差，因为我们判断输赢的时候把它写死了，要是换一个4*4的棋盘就行不通了，动态版的稍后就会提到，也是我们能写出五子棋的关键。

// 判断 棋盘是否满了 
//static int Is_Full(char board[ROW][COL], int row, int col)  
//加入 static 使这个函数只能在game.c.存在，增加隐蔽性。
//{
//	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;
//} 

char Is_win(char board[ROW][COL], int row, int col)
{
	int i= 0;
    int j=0;
	//判断 游戏继续 不能放在前面 否则就会出现玩家游戏赢了，游戏仍然继续的bug，
    //又或者是电脑游戏赢了，游戏仍然继续的bug

	//行 三个元素 
	for (i = 0; i < row; i++)  
	{
	     if (board[i][0] == board[i][1] && board[i][1] == 
                        board[i][2] && board[i][0] != ' ')
			{
				return board[i][1];
			}
	}
	//列 三个元素 
 	for (j = 0; j < col; j++)
	{
	
			if (board[0][j] == board[1][j] && board[1][j] == 
                            board[2][j] && board[0][j] != ' ')
			{
				return board[1][j];
			}
	
	}
	//对角线左上到右下
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
		return board[1][1];
    //对角线右上到左下
	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
		return board[1][1];
	//剩下 平局 和 继续 的时候， 这两者顺序随意。
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 'C';
		}
	}

	return 'P';// 可以写一个Is_Full的函数判断是否满了 满了返回1，
	//否则返回0.接收的时候，ret==1，则返回P，else 则返回C 。  上面已经给出来了
}

完整代码：

game.h

#include<stdio.h>
#include<stdlib.h>  //rand(),srand()的头文件
#include<time.h>   //time(NULL)的头文件

#define ROW 3
#define COL 3


//函数声明

//数组初始化
void Init_board(char board[ROW][COL], int row, int col);
//打印棋盘
void Display_board(char board[ROW][COL], int row, int col);
//玩家下棋
void Player_Play(char board[ROW][COL], int row, int col);
//电脑下棋
void Computer_Play(char board[ROW][COL], int row, int col);
//判断能否赢
char Is_win(char board[ROW][COL], int row, int col);

源文件

#include"game.h"
void menu()
{
	printf("************************\n");
	printf("************************\n");
	printf("*******  1.play  *******\n");
	printf("*******  0.exit  *******\n");
	printf("************************\n");
}

void Game()
{
	char board[ROW][COL] = { 0 };
	Init_board(board, ROW, COL);//初始数组
	Display_board(board, ROW, COL);//打印棋盘
	char ret = 0;
	while (1)
	{
		Player_Play(board, ROW, COL);//玩家下棋  
		ret = Is_win(board, ROW, COL);
		if (ret != 'C')//只要不是继续，游戏就结束   
			break;
		Computer_Play(board, ROW, COL);//电脑下棋
		ret = Is_win(board, ROW, COL);
		if (ret != 'C') 
			break;
	}
//出循环后判断游戏结果
	if ('*' == ret)
	{
		printf("玩家赢\n");
			
	}
	else if ('#' == ret)
	{
		printf("电脑赢\n");

	}
	else 
	{
		printf("平局\n");

	}
	Display_board(board, ROW, COL);//结束时在打印一下棋盘

}
int main()
{
	srand((unsigned int)time(NULL));//产生随机种子
	int input = 0;
	do
	{
		menu();
		printf("请选择输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Game();
			break;
		case 0:
			printf("游戏结束\n");
			break;
		default:
				printf("输入错误，请重新输入\n");
				break;
		}
	} while (input);
}

 game.c

#include"game.h"

//初始化
void Init_board(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 Display_board(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++)//     打印的是 %c |
		{
			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 Player_Play(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("玩家走:\n");
	while (1)
	{   
		printf("输入坐标:>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标的合法性  x:1-3 y:1-3
		{
			if (board[x - 1][y - 1] == ' ')//判断坐标处有没有被占用
			{
				board[x - 1][y - 1] = '*';
				Display_board(board, ROW, COL);//打印棋盘
				printf("\n");
				break;
			}
			else
			{
				printf("坐标处已被占用，重新输入\n");
			}
		}
		else
		{
			printf("坐标输入错误，重新输入\n");
		}
	}
}

//电脑下棋
void Computer_Play(char board[ROW][COL], int row, int col)
{
	printf("电脑走:\n");
	while (1)
	{
		int x = rand() % row; //0-2
		int y = rand() % col;
			if (board[x][y] == ' ')//判断坐标处有没有被输入
			{
				board[x][y] = '#';
				Display_board(board, ROW, COL);//打印棋盘
				printf("\n");
				break;
			}
	}
}

//判断棋盘满没满

//static int Is_Full(char board[ROW][COL], int row, int col)  
加入 static 使这个函数只能在game.c.存在，增加隐蔽性。
//{
//	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;
//}   

char Is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//判断 继续 不能放在前面 否则就会出现玩家游戏赢了，游戏仍然继续的bug，
	//又或者是电脑游戏赢了，游戏仍然继续的bug

	//行 三个元素 
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] ==
			board[i][2] && board[i][0] != ' ')
		{
			return board[i][1];
		}
	}
	//列 三个元素 
	for (j = 0; j < col; j++)
	{

		if (board[0][j] == board[1][j] && board[1][j] ==
			board[2][j] && board[0][j] != ' ')
		{
			return board[1][j];
		}

	}
	//对角线左上到右下
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
		return board[1][1];
	//对角线右上到左下
	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
		return board[1][1];
	//剩下 平局 和 继续 的时候， 这两者顺序随意。
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 'C';
		}
	}

	return 'P';// 可以写一个Is_Full的函数判断是否满了 满了返回1，
	//否则返回0.接收的时候，ret==1，则返回P，else 则返回C 。  上面已经给出来了
}

五子棋

五子棋和我们三子棋代码差不多。主要的差别就是判断输赢的时候要判断5个棋子是否相同。

游戏的核心来了：动态匹配输赢

这里我们能够实现的话，n子棋也是能够实现的。

 

我们拿五子棋来举例子：

a6c161d4a0424b7bb193134bb05c6f88.png

 那我们要怎么动态匹配输赢呢？

输赢能有多少种情况？，我们不知道，但是我们可以知道的是，五个连续的棋子，要么是在行连续，要么是在列连续，要么是在对角线上连续。

坐标我们设置成（i,j），棋盘的大小为 row*col 。

我们先来看 行：

378cd393e79a42d981e4c522af35045a.png

每一行：五个连续的坐标它的行坐标没有变，变的是列坐标

 

我们可以这样写连续的五个行坐标：[ i ][ j ],[ i ][ j + 1 ],[ i ][ j + 2 ],[ i ][ j + 3 ],[ i ][ j + 4 ]  

 

一看到这样的形式，是不是很像双循环呢？它就是双层循环

 

设置两个变量i，j，i控制行，j控制列。

 

我们在写循环时候呢，要注意到范围的问题。

 

写的时候最大列坐标不能超过我们的列的总数，即 j+4<col

我们来看代码

for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (j + 4 < col)
			{
				if (board[i][j] == board[i][j + 1] && board[i][j + 1] == board[i][j + 2] 
					&& board[i][j + 2] == board[i][j + 3]
					&& board[i][j + 3] == board[i][j + 4] 
					&& board[i][j] != ' ')
				{
					return board[i][j];
				}
			}
		}
	}

再来看列：

84ed1f609fad467d83765586143877d5.png

 

每一列：五个连续的坐标它的列坐标没有变，变的是行坐标，

 

同样的我们可以这样写出[ i ][ j ],[ i + 1 ][ j ],[ i + 2 ][ j ],[ i + 3 ][ j ],[ i + 4 ][ j ]

 

写的时候，同样的要注意到条件的设置

我们来看代码：

for (j = 0; j < col; j++)
	{
		for (i = 0; i < row; i++)
		{
			if (i + 4 < row)
			{
				if (board[i][j] == board[i + 1][j] && board[i + 1][j] == board[i + 2][j] 
					&& board[i + 2][j] == board[i + 3][j] 
					&& board[i + 3][j] == board[i + 4][j] 
					&& board[i][j] != ' ')
				{
					return board[i][j];
				}
			}
		}
	}

对角线左上-右下

最简单一组是[ 0 ][ 0 ],[ 1 ][ 1 ],[ 2 ][ 2 ],[ 3 ][ 3 ],[ 4 ][ 4 ]我们用它来举例。

 

我们已经知道它是双循环了，我们设想一下

 

j每加一，我们[0][0],[1][1],[2][2],[3][3],[4][4]这一组坐标，列坐标也会加+1，行不变，[0][1],[1][2],[2][3],[3][4],[4][5],[5][6]

0736b8aff4c44ffcab5f59f4971fdeb0.png

 

i每加一，我们[0][0],[1][1],[2][2],[3][3],[4][4]这一组坐标，行坐标也会+1，列坐标不变。

 

[1][0],[2][1],[3][2],[4][3],[5][4]

345365b3f35c44a3ac05723c2c0122db.png

综合上面的两种情况我们可以发现，不管怎么样，五个坐标之间的关系一定是这样的

 

[ i ][ j ],[ i + 1 ][ j + 1 ],[ i + 2 ][ j + 2 ],[ i + 3 ][ j + 3 ],[ i + 4 ][ j + 4]

 

写循环的时候我们同样得注意一下，条件的设置


    for (i = 0; i < row; i++)
	{
		if (i + 4 < row)
		{
			for (j = 0; j < col; j++)
			{
				if (j + 4 < col)
				{
					if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == board[i + 2][j + 2] 
						&& board[i + 3][j + 3] == board[i + 2][j + 2] 
						&& board[i + 3][j + 3] == board[i + 4][j + 4]
						&& board[i][j] != ' ')
					{
						return board[i][j];
					}
				}
			}
		}
	}

对角线右上-左下

先看图：4af7b391d5d1426ab1ea7dee1e447538.png

 我们可以发现，循环的时候，我们外层行是没变，变的是它的列，初始值不一样。

 

那我们设置循环的时候，i=0;j=col-1，去设置。（注意我们代码里j是数组的下标，是比我们列小1的）

69c79fe0f7ad4668b74c5cb5814dc396.png

 65261a0aa3814f1f80393656d2c6b47e.png

 我们也能很快的写出每个坐标的规律 [ i ][ j ]，[ i + 1][ j - 1] ，[i + 2][j - 2]，[i + 3][j - 3]，[i + 4][j - 4] 

 

书写时候条件需要主要到和上面都不同了。

for (i = 0; i < row; i++)
	{
		if (i + 4 < row)
		{
			for (j = col - 1; j >= 0; j--)
			{
				if (j - 4 >= 1)//可以看看图就能够明白了
				{
					if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == 
                           board[i + 2][j - 2] && board[i + 3][j - 3] == 
                           board[i + 2][j - 2] && board[i + 4][j - 4] == 
                           board[i + 3][j - 3] && board[i][j] != ' ')
					{
						return board[i][j];
					}
				}
			}
		}
	}

动态匹配输赢的完整代码

char Is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//行 5个元素 
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (j + 4 < col)
			{
				if (board[i][j] == board[i][j + 1] && board[i][j + 1] == board[i][j + 2] 
					&& board[i][j + 2] == board[i][j + 3]
					&& board[i][j + 3] == board[i][j + 4] 
					&& board[i][j] != ' ')
				{
					return board[i][j];
				}
			}
		}
	}
	//列 三元素
	for (j = 0; j < col; j++)
	{
		for (i = 0; i < row; i++)
		{
			if (i + 4 < row)
			{
				if (board[i][j] == board[i + 1][j] && board[i + 1][j] == board[i + 2][j] 
					&& board[i + 2][j] == board[i + 3][j] 
					&& board[i + 3][j] == board[i + 4][j] 
					&& board[i][j] != ' ')
				{
					return board[i][j];
				}
			}
		}
	}	
	//对角线左上到右下
	for (i = 0; i < row; i++)
	{
		if (i + 4 < row)
		{
			for (j = 0; j < col; j++)
			{
				if (j + 4 < col)
				{
					if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == board[i + 2][j + 2] 
						&& board[i + 3][j + 3] == board[i + 2][j + 2] 
						&& board[i + 3][j + 3] == board[i + 4][j + 4]
						&& board[i][j] != ' ')
					{
						return board[i][j];
					}
				}
			}
		}
	}
	//对角线右上到左下
	for (i = 0; i < row; i++)
	{
		if (i + 4 < row)
		{
			for (j = col - 1; j >= 0; j--)
			{
				if (j - 4 >= 1)
				{
					if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == board[i + 2][j - 2] 
						&& board[i + 3][j - 3] == board[i + 2][j - 2] 
						&& board[i + 4][j - 4] == board[i + 3][j - 3] 
						&& 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] == ' ')
				return 'C';
		}
	}

	return 'P';
}

当我们想要玩五子棋的时候，格子会非常多，要是我们在写的时候，可以有行号和列号的

 

话，游戏感会更好，大家可以试着写写,也是有些繁琐。

c491026cb56d453cb353dd77179671e0.png

棋盘更改后的代码

void Display_board(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//列号
	for(j=0;j<= col;j++)//等于不能少
	{
		if( j >= 10) 
		//这里要写死，不能用col,在宏定义的时候我们改成不是两位数的话打印就有问题
		// 同样的我们行号那里也是得写死
		//if ( j > col)
			printf(" %d|", j);
		else
			printf(" %d |", j);
			
	}
	printf("\n");
	for (j = 0; j <= col; j++)
	{
		printf("---");
			printf("|");
	}
	printf("\n");
	//打印行号

	//打印棋盘
	for (i = 0; i < row; i++)
	{	
			if (i+1 >= 10 )
				printf(" %d|", i+1);
			else
				printf(" %d |", i+1);
		for (j = 0; j < col; j++)//这里没有等于
		{
			printf(" %c ", board[i][j]);
				printf("|");
		}
		printf("\n");
		if (i <= row - 1)
		{
			for (j = 0; j <= col; j++)
			{
				printf("---");
					printf("|");
			}
			printf("\n");
		}
	}
}

玩五子棋的时候呢，和电脑玩肯定没有挑战性，我们可以设置成双人小游戏。

 

在写一个玩家下棋的函数

2242acef38de484f941e7de0ee955c5f.png

 五子棋的代码，和我们三子棋的差不多。

 

只要将我们的Is_win()换成动态的就可以了。

 

如果你想打行号和列号的话，在 打印棋盘  的函数，和原来的是有不同的。

 

有兴趣的可以写一个n子棋出来，大体差不多，最主要的区别在于Is_win()函数的设计

 

如果你看到这里了，很感谢你。头一次上万字，有人能看完，还是非常开心的。

 

 

 

日向晚，声声慢
关注
  • 29
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
PTA 五子棋赢了吗？ C语言
qq_39913187的博客
03-12 1714
五子棋赢了吗？（简易判断） 问题描述 　　假设五子棋的棋盘是N* N的（正整数N&amp;lt;20），黑子用*表示，白子用#表示，空位置用. 表示。 　　 　　现给你一个棋局，请判断黑子是否获胜，如获胜，显示Win，并给出获胜排列的最左边那列的最上方那颗棋子的坐标。（棋盘左上角坐标是 (0, 0) ，右下角坐标是 (N-1, N-1)），如果未获胜，则显示“Not yet”。 注意： 　　不考虑白子是否...
简单使用C语言，判断五子棋输赢
Qiangge180的博客
09-20 5323
使用1代表黑棋，-1代表白棋，0代表空。 采用每次下一颗棋，判断位置是否合法后输出整个棋盘，在调用判断函数看是否有白棋或者黑棋满足获胜条件。若棋子下满也没决出胜负则输出不分胜负。 #include<stdio.h> #include<stdlib.h> int x,y,i,j,n; void output(int a[][10])//输出棋盘 { for(x=0;x<10;x++){ for(y=0;y<10;y++) printf(" %3d",a[x][y
二维数组实现五子棋小游戏
08-08
用java的二维数组实现五子棋小游戏，适合初学者学习二维数组
C语言学会数组就可以做五子棋 - 快来试试吧（包含源码）
qq_70793373的博客
08-12 1392
五子棋玩家对战，并分析源码
稀疏数组——实现五子棋存盘和续上盘功能
heyYouU的博客
08-01 375
当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，避免了存储一些无意义的数据。本篇以五子棋存盘和续上盘的功能，来讲解常规数组和稀疏数组之间的转化。...
易语言三人五子棋客户端-黄棋源码,易语言三人五子棋服务端源码,
07-16
“子程序走棋了”可能是更新棋盘状态和通知其他客户端的函数，“子程序棋盘置空”用于重新开始游戏，“子程序是否走完”检查游戏是否结束，“子程序别人走棋了”可能用于处理对手的行动并更新用户界面。 总的来说，...
一定要看的超基础入门C语言三子五子棋实现方法
King_Cai04的博客
04-08 328
各位读者们好，今天用十大步骤教大家三子棋与五子棋的实现方法，两者逻辑差不多，这里拿三子棋举例；看完此篇章相信你一定可以自己独立完成一项有趣的小游戏。
C++实现简单五子棋游戏
08-19
在五子棋游戏中，函数可以用来实现棋盘的初始化、棋子的下法和判断输赢的条件。 知识点6：C++中的输入输出 在C++中，输入输出是指程序与用户之间的交互。 在五子棋游戏中，输入输出可以用来实现用户的交互，如选择...
pygame单机五子棋实现
08-29
在这个“pygame单机五子棋实现”项目中，我们将深入探讨如何利用pygame库来构建一个五子棋游戏，并实现自动判断输赢的功能。 一、pygame基础知识 1. 初始化与窗口创建：在开始编写游戏之前，首先需要导入pygame模块...
【C语言实现五子棋、三子棋人机对战，包含电脑人工智能对战（可攻可守）】（非标题党）
qq_64318258的博客
08-14 3616
C语言实现的五子棋、三子棋人机对战（通用），包含人工智能，电脑智能应对可攻可守，棋盘大小，游戏规则自由。
五子棋判断输赢
08-27
这个函数我在控制台上运行过.通过改变参数num可以设置多少个棋子连续就赢.
输入五子棋棋盘判断输赢或平局—程序设计（C语言）
输入五子棋棋盘判断输赢—程序设计
06-04 6398
输入五子棋棋盘判断输赢或平局—程序设计（C语言）
c语言五子棋怎么判断五子连珠,五子棋 输赢判断算法
weixin_33985453的博客
05-23 3108
我们以一个二位数组表示五子棋，通过x、y坐标，表示一个棋子的位置。1、基本原理：五子棋判断输赢，其实就是一个二维坐标上，判断上下、左右、两个45度直线，是否有五个相同的直连棋子。2、判断时机：一般情况下，我们可以通过遍历棋盘的每个点，从这个点出发，判断是否有五连子。但是实际上，我们并不需要这样做，因为我们在落子时，肯定当前其他地方没有五连子。我们要做的，就是从当前落子的位置判断，4个方向上是否有五...
用C语言实现三子棋（根据行列数自动判断输赢）
最新发布
Ljiyu0506的博客
05-06 535
三子棋的运行程序。根据给定的行列数，自动判断每行、每列、对角线是否具有相同的棋子，设定不同的返回值判断输赢和平局
c语言五子棋怎么判断五子连珠,分享一个 五子棋 输赢 的 判断逻辑。C#脚本
weixin_36383052的博客
05-23 943
该楼层疑似违规已被系统折叠隐藏此楼查看此楼欢迎指出哪里需要改进。头有点晕，想了半天 实现的。首先棋盘是由二维数组qipan[,]实现。 然后0是没有下子的状态。1是白子，2是黑子。直接每次下完子都调用下这个函数“void Panduan(){int pd_0=0; //判断白子的连续数int pd_1 = 0;//判断黑子的连续数int win = 0;//谁赢//竖向判断是否有五子连珠for ...
C语言n子棋判断输赢,C语言：三子棋小游戏（可拓展为n行n列的n子棋）
weixin_28559803的博客
05-21 623
在写程序之前我们先来理清一下这个游戏需要由哪些功能的函数组成：1.初始化棋盘2.电脑打印出棋盘3.电脑提示玩家先走还是电脑先走4.电脑走5.玩家走6.判断输赢7.判断平局8.判断游戏继续先创建好两个源文件text.c和game.c，一个头文件game.h。 一、test.c1.在主函数中创建一个test函数；int main(){test();return 0;}2.写test函数；test函数包...
五子棋判断输赢C
xb_crazyman
08-07 2969
这是我的五子棋胜负判断 效率一般：/*             5 4 6              /|/            1 - - 3              /|/            7  2  8*/int checkChessWin(Site checkSize){    int i, j ;    int flagDirect = 0 ;        for(i = 1
c语言五子棋判定胜负模块
luyinkkk的博客
12-13 509
& qipan[i - 3][j + 3] == qipan[i - 4][i + 4]） //右上斜。&& qipan[i + 3][i + 3] == qipan[i + 4][i + 4]) //往右下斜。&& qipan[i + 3][j] == qipan[i + 4][j]) //竖着。&& qipan[i][j + 3] == qipan[i][j + 4] //横着检查。
五子棋胜负判定c 语言,【C语言】五子棋胜负判定算法及源代码
weixin_36076701的博客
05-23 3041
五子棋胜负的判定，一般有一下两种算法：1.扫描整个棋盘，分别扫描四个方向是否有5个连子。网上找了很多五子棋源码都是用此算法，这意味着每下一个棋子都要扫描一遍15×15的棋盘，复杂而且低效，代码略。2.每下一字，从该子开始扫描其四个方向(例如：从该子的(x-4，y)坐标开始扫描横向)是否存在5个连子。此算法较为常用，而且不涉及更为复杂的数据结构。另外，为解决扫描越界的问题，在声明棋盘棋子位置时，可声...
C语言二维数组实现三子棋基础教程
在C语言中实现一个简单的三子棋程序，主要涉及到二维数组的运用。程序结构分为三个部分：头文件（game.h）用于声明函数和定义宏，主函数（test.c）调用这些函数，以及函数实现文件（game.c）。 1. 二维数组的创建与...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值