用c语言如何编写五子棋的大小和数量，用c语言编写个五子棋的棋盘代码

用c语言如何编写五子棋的大小和数量？

# includestdio.h

# includestring.h

# includestdlib.h

# define SPA 0

# define MAN 1

# define COM 2/* 空位置设为0 ，玩家下的位置设为1 ，电脑下的位置设为2 */

int qipan[15][15];/* 15*15的棋盘 */

int a,b,c,d,x; /* a b为玩家下子坐标 ，c d为电脑下子坐标 x为剩下空位置*/

void start(); /* 程序的主要控制函数 */

void draw(); /* 画棋盘 */

int win(int p,int q); /* 判断成功 p q为判断点坐标 */

void AI(int *p,int *q); /* 电脑下子 p q返回下子坐标 */

int value(int p,int q); /* 计算空点p q的价值 */

int qixing(int n,int p,int q);/* 返回空点p q在n方向上的棋型 n为1-8方向 从右顺时针启动数 */

void yiwei(int n,int *i,int *j); /* 在n方向上对坐标 i j 移位 n为1-8方向 从右顺时针启动数 */

void main()

{

char k;

do{

x=225;

start();

printf("还需要再来一把吗?输入y或n："); getchar(); scanf("%c",k);

while(k!='y'k!='n'){ printf("输入错误,请重新输入\"); scanf("%c",k); }

system("cls");

}while(k=='y');

printf("谢谢使用!\");

}

void start()

{

int i,j,a1,b1,c1,d1,choice;/* a1 b1储存玩家上手坐标 c1 d1储存电脑上手坐标 */

char ch;

printf("\╔═══════════════════════════════╗\");

printf("\║ ║\");

printf("\║ 欢迎使用五子棋对战程序 祝您玩的愉快挑战无极限 ║\");

printf("\║ ║\");

printf("\║ ._______________________.║\");

printf("\║ | _____________________ |║\");

printf("\║ | I I |║\");

printf("\║ | I 五 子 棋 I | ║\");

printf("\║ | I I |║\");

printf("\║ | I made by XXX I | ║\");

printf("\║ | I___________________I |║\");

printf("\║ !_______________________!║\");

printf("\║ ._[__________]_. ║\");

printf("\║ .___|_______________|___.║\");

printf("\║ |::: ____ | ║\");

printf("\║ |~~~~ [CD-ROM]| ║\");

printf("\║ !_____________________! ║\");

printf("\║ ║\");

printf("\║ ║\");

printf("\║ 寒 星 溪 月 疏 星 首，花 残 二 月 并 白 莲。 ║\");

printf("\║ 雨 月 金 星 追 黑 玉，松 丘 新 宵 瑞 山 腥。 ║\");

printf("\║ 星 月 长 峡 恒 水 流，白 莲 垂 俏 云 浦 岚。 ║\");

printf("\║ 黑 玉 银 月 倚 明 星，斜 月 明 月 堪 称 朋。 ║\");

printf("\║ 二 十 六 局 先 弃 二，直 指 游 星 斜 彗 星。 ║\");

printf("\║ ║\");

printf("\║ ║\");

printf("\║ 1.人机对战 2.人人对战 ║\");

printf("\║ ║\");

printf("\╚═══════════════════════════════╝\");

printf("\\\请输入1或2：");

scanf("%d",choice); /* 选择模式:人机或人人 */

while(choice!=1choice!=2) { printf("输入错误，请重新输入："); scanf("%d",choice); }

if(choice==1){/* 人机模式 */

system("cls");

printf("欢迎使用五子棋人机对战！下子请输入坐标（如13 6）。悔棋请输入15 15。\\\");

for(j=0;j15;j++)

for(i=0;i15;i++)

qipan[j][i]=SPA; /* 置棋盘全为空 */

draw();

printf("先下请按1，后下请按2：");

scanf("%d",i);

while(i!=1i!=2) { printf("输入错误，请重新输入："); scanf("%d",i); }

if(i==1) { /* 假设玩家先手下子 */

printf("请下子："); scanf("%d%d",a,b);

while((a0||a14)||(b0||b14)) { printf("坐标错误!请重新输入："); scanf("%d%d",a,b); }

a1=a; b1=b; x-; qipan[a]=MAN; system("cls"); draw();

}

while(x!=0){

if(x==225) { c=7; d=7; qipan[d][c]=COM; x-; system("cls"); draw(); } /* 电脑先下就下在7 7 */

else { AI(c,d); qipan[d][c]=COM; x-; system("cls"); draw(); } /* 电脑下子 */

c1=c; d1=d; /* 储存电脑上手棋型 */

if(win(c,d)){ /* 电脑赢 */

printf("要悔棋吗？请输入y或n："); getchar(); scanf("%c",ch);

while(ch!='y'ch!='n') { printf("输入错误，请重新输入："); scanf("%c",ch); }

if(ch=='n') { printf("下不过电脑很正常，请不要因为这次的失败而丧失斗志!!!\"); return; }

else { x+=2; qipan[d][c]=SPA; qipan[a1]=SPA; system("cls"); draw(); } /* 悔棋 */

}

printf("电脑下在%d %d\请输入：",c,d); scanf("%d%d",a,b); /* 玩家下子 */

if(a==15b==15) { x+=2; qipan[d][c]=SPA; qipan[a1]=SPA; system("cls"); draw(); printf("请输入："); scanf("%d%d",a,b); } /* 悔棋 */

while((a0||a14)||(b0||b14)||qipan[a]!=SPA) { printf("坐标错误或该位置已有子!请重新输入："); scanf("%d%d",a,b); }

a1=a; b1=b; x-; qipan[a]=MAN; system("cls"); draw();

if(win(a,b)){ printf("电脑神马的都是浮云!!!\"); return; } /* 玩家赢 */

}

printf("和局\");

}

if(choice==2){

system("cls");

printf("欢迎使用五子棋人人对战！下子请输入坐标(如13 6)。悔棋请输入15 15。\\\");

for(j=0;j15;j++)

for(i=0;i15;i++)

qipan[j][i]=SPA; /* 置棋盘全为空 */

draw();

while(x!=0){

printf("1P请输入："); scanf("%d%d",a,b);

if(a==15b==15) { x+=2; qipan[d][c]=SPA; qipan[a1]=SPA; system("cls"); draw(); printf("1P请输入："); scanf("%d%d",a,b); }

while((a0||a14)||(b0||b14)||qipan[a]!=SPA) { printf("坐标错误或该位置已有子!请重新输入："); scanf("%d%d",a,b); }

a1=a; b1=b; x-; qipan[a]=MAN; system("cls"); draw();

printf("1P下在%d %d。\",a,b);

if(win(a,b)){ printf("你真棒!!!\"); return; }/* 玩家1赢 */

printf("2P请输入："); scanf("%d%d",c,d);

if(c==15d==15) { x+=2; qipan[a]=SPA; qipan[d1][c1]=SPA; system("cls"); draw(); printf("2P请输入："); scanf("%d%d",c,d); }

while((c0||c14)||(d0||d14)||qipan[d][c]!=SPA) { printf("坐标错误或该位置已有子!请重新输入："); scanf("%d%d",c,d); }

c1=c; d1=d; x-; qipan[d][c]=COM; system("cls"); draw();

printf("2P下在%d %d。\",c,d);

if(win(c,d)){ printf("你真棒!!!\"); return; }/* 玩家2赢 */

}

printf("和局\");

}

}

void draw() /* 画棋盘 */

{

int i,j;

char p[15][15][4];

for(j=0;j15;j++)

for(i=0;i15;i++){

if(qipan[j][i]==SPA) strcpy(p[j][i]," \\0");

if(qipan[j][i]==MAN) strcpy(p[j][i],"●\\0");

if(qipan[j][i]==COM) strcpy(p[j][i],"◎\\0");

}

printf(" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 \");

printf(" ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐\");

for(i=0,j=0;i14;i++,j++){

printf(" %2d│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%d\",j,p[i][0],p[i][1],p[i][2],p[i][3],p[i][4],p[i][5],p[i][6],p[i][7],p[i][8],p[i][9],p[i][10],p[i][11],p[i][12],p[i][13],p[i][14],j);

printf(" ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤\");

}

printf(" 14│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│%s│0\",p[14][0],p[14][1],p[14][2],p[14][3],p[14][4],p[14][5],p[14][6],p[14][7],p[14][8],p[14][9],p[14][10],p[14][11],p[14][12],p[14][13],p[14][14]);

printf(" └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘\");

printf(" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 \");

}

int win(int p,int q) /* 判断成功 p q为判断点坐标，成功返回1，不然返回0 */

{

int k,n=1,m,P,Q; /* k储存判断点p q的状态COM或MAN。P Q储存判断点坐标。n为判断方向。m为个数。 */

P=p; Q=q;

k=qipan[q][p];

while(n!=5){

m=0;

while(k==qipan[q][p]){

m++;

if(m==5) return 1;

yiwei(n,p,q); if(p0||p14||q0||q14) break;

}

n+=4; m-=1; p=P; q=Q; /* 转向判断 */

while(k==qipan[q][p]){

m++;

if(m==5) return 1;

yiwei(n,p,q); if(p0||p14||q0||q14) break;

}

n-=3; p=P; q=Q; /* 不成功则判断下一组方向 */

}

return 0;

}

void AI(int *p,int *q) /* 电脑下子 *p *q返回下子坐标 */

{

int i,j,k,max=0,I,J;/* I J为下点坐标 */

for(j=0;j15;j++)

for(i=0;i15;i++)

if(qipan[j][i]==SPA){ /* 历遍棋盘，碰见空点则计算价值，取最大价值点下子。 */

k=value(i,j);

if(k=max) { I=i; J=j; max=k; }

}

*p=I; *q=J;

}

int value(int p,int q) /* 计算空点p q的价值 以k返回 */

{

int n=1,k=0,k1,k2,K1,K2,X1,Y1,Z1,X2,Y2,Z2,temp;

int a[2][4][4]={40,400,3000,10000,6,10,600,10000,20,120,200,0,6,10,500,0,30,300,2500,5000,2,8,300,8000,26,160,0,0,4,20,300,0};

/* 数组a中储存己方和对方共32种棋型的值 己方0对方1活0冲1空活2空冲3子数0-3（0表示1个子，3表示4个子） */

while(n!=5){

k1=qixing(n,p,q); n+=4;/* k1,k2为2个反方向的棋型编号 */

k2=qixing(n,p,q); n-=3;

if(k1k2) { temp=k1; k1=k2; k2=temp; } /* 使编号小的为k1,大的为k2 */

K1=k1; K2=k2; /* K1 K2储存k1 k2的编号 */

Z1=k1%10; Z2=k2%10; k1/=10; k2/=10; Y1=k1%10; Y2=k2%10; k1/=10; k2/=10; X1=k1%10; X2=k2%10;

/* X Y Z分别表示 己方0对方1活0冲1空活2空冲3子数0-3（0表示1个子，3表示4个子） */

if(K1==-1) { if(K20) { k+=0; continue; } else k+=a[X2][Y2][Z2]+5; continue; };/* 空棋型and其他 */

if(K1==-2) { if(K20) { k+=0; continue; } else k+=a[X2][Y2][Z2]/2; continue; }; /* 边界冲棋型and其他 */

if(K1==-3) { if(K20) { k+=0; continue; } else k+=a[X2][Y2][Z2]/3; continue; };/* 边界空冲棋型and其他 */

if(((K1-1K14)((K2-1K24)||(K29K214)))||((K199K1104)((K299K2104)||(K2109K2114)))){

/* 己活己活 己活己冲 对活对活 对活对冲 的棋型赋值*/

if(Z1+Z2=2) { k+=a[X2][Y2][3]; continue; }

else { k+=a[X2][Y2][Z1+Z2+1]; continue; }

}

if(((K19K114)(K29K214))||((K1109K1114)(K2109K2114))){

/* 己冲己冲 对冲对冲 的棋型赋值*/

if(Z1+Z2=2) { k+=10000; continue; }

else { k+=0; continue; }

}

if(((K1-1K14)((K299K2104)||(K2109K2114)))||((K19K114)((K299K2104)||(K2109K2114)))){

/* 己活对活 己活对冲 己冲对活 己冲对冲 的棋型赋值*/

if(Z1==3||Z2==3) { k+=10000; continue; }

else { k+=a[X2][Y2][Z2]+a[X1][Y1][Z1]/4; continue; }

}

else { k+=a[X1][Y1][Z1]+a[X2][Y2][Z2]; continue; }/* 其他棋型的赋值 */

}

return k;

}

int qixing(int n,int p,int q)/* 返回空点p q在n方向上的棋型号 n为1-8方向 从右顺时针启动数 */

{

int k,m=0; /* 棋型号注解: 己活000-003 己冲010-013 对活100-103 对冲110-113 己空活020-023 己空冲030-033 对空活120-123 对空冲130-133 空-1 边界冲-2 边界空冲-3*/

yiwei(n,p,q);

if(p0||p14||q0||q14) k=-2; /* 边界冲棋型 */

switch(qipan[q][p]){

case COM:{

m++; yiwei(n,p,q);

if(p0||p14||q0||q14) { k=m+9; return k; }

while(qipan[q][p]==COM) { m++; yiwei(n,p,q); if(p0||p14||q0||q14) { k=m+9; return k; } }

if(qipan[q][p]==SPA) k=m-1; /* 己方活棋型 */

else k=m+9;/* 己方冲棋型 */

}break;

case MAN:{

m++; yiwei(n,p,q);

if(p0||p14||q0||q14) { k=m+109; return k; }

while(qipan[q][p]==MAN) { m++; yiwei(n,p,q); if(p0||p14||q0||q14) { k=m+109; return k; } }

if(qipan[q][p]==SPA) k=m+99;/* 对方活棋型 */

else k=m+109; /* 对方冲棋型 */

}break;

case SPA:{

yiwei(n,p,q);

if(p0||p14||q0||q14) { k=-3; return k; }/* 边界空冲棋型 */

switch(qipan[q][p]){

case COM:{

m++; yiwei(n,p,q);

if(p0||p14||q0||q14) { k=m+29; return k; }

while(qipan[q][p]==COM) { m++; yiwei(n,p,q); if(p0||p14||q0||q14) { k=m+29; return k; } }

if(qipan[q][p]==SPA) k=m+19;/* 己方空活棋型 */

else k=m+29;/* 己方空冲棋型 */

}break;

case MAN:{

m++; yiwei(n,p,q);

if(p0||p14||q0||q14) { k=m+129; return k; }

while(qipan[q][p]==MAN) { m++; yiwei(n,p,q); if(p0||p14||q0||q14) { k=m+129; return k; } }

if(qipan[q][p]==SPA) k=m+119; /* 对方空活棋型 */

else k=m+129; /* 对方空冲棋型 */

}break;

case SPA: k=-1; break; /* 空棋型 */

}

}break;

}

return k;

}

void yiwei(int n,int *i,int *j)/* 在n方向上对坐标 i j 移位 n为1-8方向 从右顺时针启动数 */

{

switch(n){

case 1: *i+=1; break;

case 2: *i+=1; *j+=1; break;

case 3: *j+=1; break;

case 4: *i-=1; *j+=1; break;

case 5: *i-=1; break;

case 6: *i-=1; *j-=1; break;

case 7: *j-=1; break;

case 8: *i+=1; *j-=1; break;

}

}

用C语言编写个五子棋的棋盘？

1.先独立完成 数据结构， 最简单的办法就用一个二维数组表来模拟五子棋的棋盘 2.用MFC做界面，或者是 用OPENCV（个人推荐这个，这个比MFC简单) 里面针对做界面 有 一部分函数，肯定绘制直线，绘制圆，绘制 矩形~ 不过得先配置 OPENCV的文件~3.综合测试

如何用c语言定义五子棋的大小和数量？

在C语言中，可以通过定义常量来表示五子棋的大小和数量。比如，可以定义一个常量BOARD_SIZE表示棋盘的大小，另一个常量PIECE_NUM表示每个玩家的棋子数量。这样，在程序中需使用这些值时，完全就能够直接使用这些常量，而不用在多个地方重复定义。

同时，也可通过变量来表示现目前棋盘上已经下了多少个棋子，以此控制游戏的结束条件。

在 C 语言中，可以使用二维数组表示五子棋盘，还可以通过定义常量来设置棋盘的大小和数量。

下面是一部分示例代码，演示如何定义五子棋盘的大小和数量：

```

#define BOARD_SIZE 15 // 定义棋盘大小为15*15

#define MAX_COUNT 5 // 定义获胜所需棋子数量为5

int board[BOARD_SIZE][BOARD_SIZE]; //定义战盘，形成二维数组

```

在这个例子中，通过 `#define` 重要字来定义了战棋盘的大小为 15x15，还有获胜所需的棋子数量为5个。这样一来，整个程序中都可以通过 BOARD_SIZE 和 MAX_COUNT 两个常量来引用这些值。

然后，可以使用二维数组来表示战盘，这当中数组的每个元素代表棋盘上一个点的状态，比如：

```

board[5][8] = 1; // 代表白棋在第6行第9列落子

```

在这个例子中，将第6行第9列上的位置标记为1，表示该位置上落了一个白棋。可按照需使用另一个值（比如2）代表黑子。

期望这些示例代码能有效的帮您启动定义自己的五子棋程序。

你好，请见以下c语言定义五子棋大小和数量代码：1. 定义五子棋大小int chessSize = 15; // 定义棋盘大小为15*152. 定义五子棋数量int winChessNum = 5; // 定义成功条件为连续5子即为成功以上是c语言定义五子棋大小和数量的基本达到代码。

在C语言中，可以使用各种方法定义五子棋的大小和数量。下面这些内容就是两种常见的方式：

1. 使用常量定义：

```c

#include stdio.h

#define BOARD_SIZE 15

#define WIN_COUNT 5

int main() {

printf(五子棋棋盘大小：%d × %d\, BOARD_SIZE, BOARD_SIZE);

printf(获胜条件：连续%d子\, WIN_COUNT);

return 0;

}

```

在这样的方式中，通过使用`#define`预处理指令定义常量`BOARD_SIZE`和`WIN_COUNT`来表示棋盘的大小和获胜条件。这样可在代码的其他地方直接使用这些常量。

2. 使用变量定义：

```c

#include stdio.h

int main() {

int boardSize = 15;

int winCount = 5;

printf(五子棋棋盘大小：%d × %d\, boardSize, boardSize);

printf(获胜条件：连续%d子\, winCount);

return 0;

}

```

在这样的方式中，使用变量`boardSize`和`winCount`来表示棋盘的大小和获胜条件。这样可以按照一定要在程序中变动更改这些值。

您可以按照自己的需求选择合适的方式来定义五子棋的大小和数量。不管哪种方式，都需按照详细的游戏规则来定义一定程度上的数值。以上示例只是简单展示了如何定义和输出五子棋的大小和数量，实质上应用中还要有结合其他的逻辑和算法来完成游戏的达到。

1. 在C语言中，可以使用二维数组来定义五子棋的大小和数量。2. 二维数组可以定义为int类型，比如int chessboard[15][15]，表示棋盘大小为15*15。这当中，数组下标从0启动，故此，其实棋盘的行列数为16。3. 可以使用循环语句来初始化棋盘，比如for循环可以用来遍历每一个数组元素，故将他初始化为0表示空位。4. 可以使用常量来定义棋子的数量，比如#define CHESS_NUM 5，表示需连成5个棋子才可以获胜。5. 在编写五子棋程序时，还要有考虑如何判断胜负、下棋、悔棋等功能的达到。

#include "stdio.h"

#include "math.h"

#include "windows.h"

#include "time.h"//使用现目前时钟做种子

#define N 15 //定义棋盘大小 1黑2白

#define M N+8 //定义数据棋盘大小

int chess[N][N];//棋盘，用于储存下子位置

int count[M][M];//数据棋盘，用于储存下子位置，和盘外数据

char buffer[N*2-1][N*4-3];//缓冲器，用于储存下子位置，盘外数据，和棋盘符号

long sum[M][M] = {{0}};//成绩棋盘，储存成绩情况

int p[20][5];//存储该位置的全部可能的五连珠情况

int player = 1, ai = 2, error = -1;

int num;//双方回合总数

int now;//设置下棋标志

int flag0;//确定己方已下子

int gs;//游戏结束标志

//基础函数

void RunGame();//进行整个对局

int Menu();//设置启动菜单

void Initialize();//初始化棋盘，数据棋盘，和缓冲器

void Print(int x, int y);//将数据写入数据棋盘，和缓冲器

void Display();//将缓冲器数据输出到屏幕

void Buf_Display();//利用双缓冲将缓冲器数据输出到屏幕

int Judge_Display();//输出胜负情况

//双方对局函数

void PGame();//玩家对局函数

void CGame();//电脑对局函数

//输入函数

void Input(int *x, int *y);//键盘方向键控制，空格键输入

void Mark(int x0, int y0, int x, int y);//标记下子位置

//电脑判断函数

int Basic_condition(int x, int y);//判断下子位置是不是出界

void Find_point(int *pp, int *qq);//找到最好性最优的下子位置

int JUDGE(int x, int y);//判断胜负

void Grade();//计算全部位置的成绩

int Base(int i, int j);//坐标为(i-4,j-4)的全部五连珠情况

long Assessment(int num1, int num2);//评分标准

//主程序

int main()

{

system("title 简易五子棋");//设置标题

system("mode con cols=58 lines=29");//设置窗口大小

system("color E0");//设置颜色

Initialize();//初始化棋盘，数据棋盘，和缓冲器

RunGame();//进行整个对局*/

return 0;

}

/***********************************************************************************************************************************************************/

void RunGame()//进行整个对局

{

switch(Menu())

{

case 1:

while(1)

{

PGame();//玩家对局函数

if(Judge_Display())

{

break;//对局结束

}

CGame();//电脑对局函数

if(Judge_Display())

{

break;//对局结束

}

}//while

break;

case 2:

now=ai;

count[N/2+4][N/2+4] = now; chess[N/2][N/2] = now;

Print(N/2, N/2);//将数据写入数据棋盘，和缓冲器

num++;

while(1)

{

PGame();//玩家对局函数

if(Judge_Display())//玩家对局函数

{

break;//对局结束

}

CGame();//电脑对局函数

if(Judge_Display())

{

break;//对局结束

}

}//while

break;

case 3:

now=1;

count[N/2+4][N/2+4] = now; chess[N/2][N/2] = now;

Print(N/2, N/2);//将数据写入数据棋盘，和缓冲器

num++;

while(1)

{

CGame();//电脑对局函数

if(Judge_Display())

{

break;//对局结束

}

}

break;

default:;

}

}

/***********************************************************************************************************************************************************/

int Menu()//设置启动菜单

{

int x;

printf("1、玩家先手\");

printf("2、玩家后手\");

printf("3、电脑自对弈\");

scanf("%d", x);

return x;

}

void Initialize()//初始化棋盘，数据棋盘，和缓冲器

{

int i, j;

//初始化数据棋盘

for(i = 0; i M; i++)

{

for(j = 0; j M; j++)

{

if((i 4 || i = M - 4)(j 4 || j= M - 4))

{

count[i][j] = error;

}

}

}

//初始化缓冲器

for(i = 0; i N*2-1; i++)

{

for(j = 0; j N*4-3; j++)

{

if(i == 0 j == 0)//以下为边缘棋盘样式

buffer[i][j]='a';//"┏";

else if(i == 0 j == (N*4-3)-1)

buffer[i][j] = 'b';//"┓";

else if(i == (N*2-1)-1 j == (N*4-3)-1)

buffer[i][j] = 'c';//"┛";

else if(i == (N*2-1)-1j == 0)

buffer[i][j]='d';//"┗";

else if(i == 0 j % 4 == 0)

buffer[i][j]='e';//"┯";

else if(i == (N*2-1)-1 j % 4 == 0)

buffer[i][j] = 'f';//"┷";

else if(i % 2 == 0 j == 0)

buffer[i][j] = 'g';//"┠";

else if(i % 2 == 0 j == (N*4-3)-1)

buffer[i][j] = 'h';//"┨";

else if((i == 0 || i == (N*2-1)-1) (j/2) % 2 != 0)

buffer[i][j] = 'i';//"━";

else if(i != 0 i != (N*2-1)-1 i % 2 == 0 (j/2) % 2 != 0)

buffer[i][j] = 'j';//"—";

else if(i % 2 != 0 (j == 0 || j == (N*4-3)-1))

buffer[i][j] = 'k';//"┃";

else if(i % 2 != 0 j != 0 j != (N*4-3)-1 j % 4 == 0)

buffer[i][j] = 'l';//"│";

else if(i != 0 j != 0 i != (N*2-1)-1 j != (N*4-3)-1 i % 2 == 0 j % 4 == 0)

buffer[i][j] = 'm';//中间的空位"┼"

}

}

}

void Print(int x, int y)//将数据写入数据棋盘，和缓冲器

{

count[x+4][y+4] = chess[x][y];

buffer[x*2][y*4] = chess[x][y] + 48;//将整型数据转化为字符型数据

}

void Display()//将缓冲器数据输出到屏幕

{

int i, j;

system("cls");//清理屏幕，准备写入

for(i = 0; i N*2-1; i++)

{

for(j = 0; j N*4-3; j++)

{

//printf("%c", buffer[i][j]);

switch(buffer[i][j])

{

case '1' : printf("●"); j++; break;//j++不可省

case '2' : printf("○"); j++; break;//j++不可省

case 'a' : printf("┏"); break;

case 'b' : printf("┓"); break;

case 'c' : printf("┛"); break;

case 'd' : printf("┗"); break;

case 'e' : printf("┯"); break;

case 'f' : printf("┷"); break;

case 'g' : printf("┠"); break;

case 'h' : printf("┨"); break;

case 'i' : printf("━"); break;//上下的横线更粗

case 'j' : printf("—"); j++; break;//中间的横线更细//j++;因为输出"—"时占两个字符，j++可以规避输出下一个的空格

case 'k' : printf("┃"); break;//左右的竖线更粗

case 'l' : printf("│"); break;//中间的竖线更粗

case 'm' : printf("┼"); break;

case ' ' : printf(" "); break;

default : printf("%c", buffer[i][j]);

}//switch

}//for

printf("\");

}//for

Sleep(100);

/*

//调试

printf("%d\", num);

for(i = 4; i M-4; i++)

{

for( j = 4; j M-4; j++)

printf("%8d", sum[i][j]);

printf("\");

}

*/

}

void PGame()//玩家对局函数

{

static int Px0 = N/2, Py0 = N/2, Px = N/2, Py = N/2;

now = 1;

do{

Mark(Px0, Py0, Px, Py);//标记下子位置

Buf_Display();//将缓冲器数据输出到屏幕

Px0 = Px; Py0 = Py;

Input(Px, Py);

}while(!(chess[Px][Py] flag0 == 1));

Print(Px, Py);//将数据写入数据棋盘，和缓冲器

num++;

gs = JUDGE(Px + 4,Py + 4);

}

void CGame()//电脑对局函数

{

static int Cp = N/2, Cq = N/2, Cp0, Cq0;

Buf_Display();//将缓冲器数据输出到屏幕

Grade();//计算全部位置的成绩

Cp0 = Cp; Cq0 = Cq;//记录上一次电脑下子位置

Find_point(Cp, Cq);//找到最好性最优的下子位置

now = 3 - now;

chess[Cp - 4][Cq - 4] = now;

Mark(Cp0 - 4, Cq0 - 4, Cp - 4, Cq - 4);//标记下子位置

Print(Cp - 4, Cq - 4);//将数据写入数据棋盘，和缓冲器

num++;

gs = JUDGE(Cp, Cq);

}

void Input(int *x, int *y)//键盘方向键控制，空格键输入

{

int input;

flag0 = 0;

input = getch();//取得首次输入信息

if(input == 0x20 !chess[*x][*y])//判断移动光标后，玩家是不是下子

{

chess[*x][*y] = player;

flag0 = 1;

}

else if(input == 0xE0)//假设按下的是方向键，会填充两次输入，首次为0xE0表示按下的是控制键

{

input = getch();//取得第二次输入信息

switch(input)//判断方向键方向并移动光标位置

{

case 0x48 : (*x)-; break;

case 0x4B : (*y)-; break;

case 0x50 : (*x)++; break;

case 0x4D : (*y)++; break;

}//switch

if(*x0) (*x) = N - 1;//假设光标位置越界则移动到对侧

if(*y0) (*y) = N - 1;

if(*xN-1) (*x) = 0;

if(*yN-1) (*y) = 0;

}

}

void Mark(int x0,int y0,int x,int y)//标记己方下子位置

{

x0 = x0*2; y0 = y0*4;

buffer[x0 - 1][y0 - 2] = ' ';

buffer[x0 - 1][y0 + 2] = ' ';

buffer[x0 + 1][y0 + 2] = ' ';

buffer[x0 + 1][y0 - 2] = ' ';

x = x*2; y = y*4;

buffer[x - 1][y - 2] = 'a';

buffer[x - 1][y + 2] = 'b';

buffer[x + 1][y + 2] = 'c';

buffer[x + 1][y - 2] = 'd';

if(y == (N*4-3)-1)//处理“当光标移动到最右侧时，光标出现错位”

{

buffer[x - 1][y + 2] = ' ';

buffer[x + 1][y + 2] = ' ';

}

}

int Basic_condition(int x,int y)//判断下子位置是不是出界

{

if(x = 4 x M - 4 y = 4 y M - 4)

{

return 1;

}

else

{

return 0;

}

}

void Find_point(int *pp, int *qq)//找到最好性最优的下子位置

{

int i, j, flag = 0;//flag为结束标志

long t = 0;

int r, c=0, sumed[N*N][2];

//找寻第一个未下子位置对应的sum值

for(i = 4; i M - 4 flag == 0; i++)

{

for(j = 4; j M - 4 flag == 0; j++)

{

if(!chess[i - 4][j - 4])

{

t = sum[i][j];

flag = 1;

}

}

}//for

//找寻最大的sum值

for(i = 4; i M - 4; i++)

{

for(j = 4; j M - 4 ; j++)

{

if(!chess[i - 4][j - 4] sum[i][j] t)

{

t = sum[i][j];

}

}

}//for

//等于咋办，应该如何处理

//存储全部的最大sum值

for(i = 4; i M - 4; i++)

{

for(j = 4; j M - 4 ; j++)

{

if(!chess[i - 4][j - 4] sum[i][j] == t)

{

sumed[c][0] = i;

sumed[c][1] = j;

c++;

}

}

}//for

srand((unsigned)time(NULL)); //初始化随机数

//随机选用最大sum值中的一组数据

r = rand()%c;

*pp = sumed[r][0];

*qq = sumed[r][1];

}

int JUDGE(int x, int y)//判断胜负，返回1赢，返回0无

{

int a = 1, b = 1, c = 1, d = 1, i;//累计横竖正斜反斜四个方向的连续一样棋子数目

for(i=1;i5;i++)if(y+iM-4count[x][y+i]==now)a++;else break;//向下检查

for(i=1;i5;i++)if(y-i=4count[x][y-i]==now)a++;else break;//向上检查

if(a=5)return now;//若达到5个则判断现目前走子玩家为赢家

for(i=1;i5;i++)if(x+iM-4count[x+i][y]==now)b++;else break;//向右检查

for(i=1;i5;i++)if(x-i=4count[x-i][y]==now)b++;else break;//向左检查

if(b=5)return now;//若达到5个则判断现目前走子玩家为赢家

for(i=1;i5;i++)if(x+iM-4y+iM-4count[x+i][y+i]==now)c++;else break;//向右下检查

for(i=1;i5;i++)if(x-i=4y-i=4count[x-i][y-i]==now)c++;else break;//向左上检查

if(c=5)return now;//若达到5个则判断现目前走子玩家为赢家

for(i=1;i5;i++)if(x+iM-4y-i=4count[x+i][y-i]==now)d++;else break;//向右上检查

for(i=1;i5;i++)if(x-i=4y+iM-4count[x-i][y+i]==now)d++;else break;//向左下检查

if(d=5)return now;//若达到5个则判断现目前走子玩家为赢家

return 0;//若没有检查到五连珠，则返回0表示还没有玩家达成成功

}

void Grade()//计算全部位置的成绩

{

int i, j, m, n;

int num1, num2;

for(i = 4; i M - 4; i++)

{

for(j = 4; j M - 4; j++)

{

if(!chess[i - 4][j - 4])

{

sum[i][j] = 0;//循环初始化sum[i][j]

Base(i, j);//坐标为(i-4,j-4)的全部五连珠情况

for(m = 0; m 20; m++)

{

num1 = 0; num2 = 0;

for(n = 0; n 5; n++)

{

if(p[m][n] == now)

num1++;

else if(p[m][n] == 3 - now)

num2++;

else if(p[m][n] == error)

{

num1 = error; num2 = error;

break;

}

}

sum[i][j] += Assessment(num1, num2);

}

}

}

}

}

int Base(int i,int j)//坐标为(i-4,j-4)的全部五连珠情况

{

//左上-右下

p[0][0]=count[i-4][j-4];p[0][1]=count[i-3][j-3];p[0][2]=count[i-2][j-2];p[0][3]=count[i-1][j-1];p[0][4]=count[i][j];

p[1][0]=count[i-3][j-3];p[1][1]=count[i-2][j-2];p[1][2]=count[i-1][j-1];p[1][3]=count[i][j];p[1][4]=count[i+1][j+1];

p[2][0]=count[i-2][j-2];p[2][1]=count[i-1][j-1];p[2][2]=count[i][j];p[2][3]=count[i+1][j+1];p[2][4]=count[i+2][j+2];

p[3][0]=count[i-1][j-1];p[3][1]=count[i][j];p[3][2]=count[i+1][j+1];p[3][3]=count[i+2][j+2];p[3][4]=count[i+3][j+3];

p[4][0]=count[i][j];p[4][1]=count[i+1][j+1];p[4][2]=count[i+2][j+2];p[4][3]=count[i+3][j+3];p[4][4]=count[i+4][j+4];

//上-下

p[5][0]=count[i-4][j];p[5][1]=count[i-3][j];p[5][2]=count[i-2][j];p[5][3]=count[i-1][j];p[5][4]=count[i][j];

p[6][0]=count[i-3][j];p[6][1]=count[i-2][j];p[6][2]=count[i-1][j];p[6][3]=count[i][j];p[6][4]=count[i+1][j];

p[7][0]=count[i-2][j];p[7][1]=count[i-1][j];p[7][2]=count[i][j];p[7][3]=count[i+1][j];p[7][4]=count[i+2][j];

p[8][0]=count[i-1][j];p[8][1]=count[i][j];p[8][2]=count[i+1][j];p[8][3]=count[i+2][j];p[8][4]=count[i+3][j];

p[9][0]=count[i][j];p[9][1]=count[i+1][j];p[9][2]=count[i+2][j];p[9][3]=count[i+3][j];p[9][4]=count[i+4][j];

//右上-左下

p[10][0]=count[i-4][j+4];p[10][1]=count[i-3][j+3];p[10][2]=count[i-2][j+2];p[10][3]=count[i-1][j+1];p[10][4]=count[i][j];

p[11][0]=count[i-3][j+3];p[11][1]=count[i-2][j+2];p[11][2]=count[i-1][j+1];p[11][3]=count[i][j];p[11][4]=count[i+1][j-1];

p[12][0]=count[i-2][j+2];p[12][1]=count[i-1][j+1];p[12][2]=count[i][j];p[12][3]=count[i+1][j-1];p[112][4]=count[i+2][j-2];

p[13][0]=count[i-1][j+1];p[13][1]=count[i][j];p[13][2]=count[i+1][j-1];p[13][3]=count[i+2][j-2];p[13][4]=count[i+3][j-3];

p[14][0]=count[i][j];p[14][1]=count[i+1][j-1];p[14][2]=count[i+2][j-2];p[14][3]=count[i+3][j-3];p[14][4]=count[i+4][j-4];

//左-右

p[15][0]=count[i][j-4];p[15][1]=count[i][j-3];p[15][2]=count[i][j-2];p[15][3]=count[i][j-1];p[15][4]=count[i][j];

p[16][0]=count[i][j-3];p[16][1]=count[i][j-2];p[16][2]=count[i][j-1];p[16][3]=count[i][j];p[16][4]=count[i][j+1];

p[17][0]=count[i][j-2];p[17][1]=count[i][j-1];p[17][2]=count[i][j];p[17][3]=count[i][j+1];p[17][4]=count[i][j+2];

p[18][0]=count[i][j-1];p[18][1]=count[i][j];p[18][2]=count[i][j+1];p[18][3]=count[i][j+2];p[18][4]=count[i][j+3];

p[19][0]=count[i][j];p[19][1]=count[i][j+1];p[19][2]=count[i][j+2];p[19][3]=count[i][j+3];p[19][4]=count[i][j+4];

}

long Assessment(int num1,int num2)//评分标准

{

if(num2 == 0)//判断电脑五元组成绩

{

switch(num1)

{

case 0 : return 7;

case 1 : return 35;

case 2 : return 800;

case 3 : return 15000;

case 4 : return 800000;

}

}

if(num2 != 0 num1 == 0)//判断玩家五元组成绩

{

switch(num2)

{

case 1 : return 15;

case 2 : return 400;

case 3 : return 1800;

case 4 : return 100000;

}

}

return 0;

}

void Buf_Display()//利用双缓冲将缓冲器数据输出到屏幕

{

int i, j;

//创建屏幕缓冲区

HANDLE hNewConsole = CreateConsoleScreenBuffer(GENERIC_WRITE | GENERIC_READ,

0,

NULL,

CONSOLE_TEXTMODE_BUFFER,

NULL);

//隐藏光标

CONSOLE_CURSOR_INFO cci = {1, 0};

SetConsoleCursorInfo(hNewConsole, cci);

//设置窗口的缓冲区大小

COORD cdBufferSize = {58, 29};

SetConsoleScreenBufferSize(hNewConsole, cdBufferSize);

//然后我们输出这个数组看看

for(i = 0; i N*2-1; i++)

{

for(j = 0; j N*4-3; j++)

{

COORD cdCursorPos = {j, i};

char *p = NULL;

// printf("%c", buffer[i][j]);

switch(buffer[i][j])

{

case '1' : p = "●"; j++; break;//j++可省

case '2' : p = "○"; j++; break;//j++可省

case 'a' : p = "┏"; break;

case 'b' : p = "┓"; break;

case 'c' : p = "┛"; break;

case 'd' : p = "┗"; break;

case 'e' : p = "┯"; break;

case 'f' : p = "┷"; break;

case 'g' : p = "┠"; break;

case 'h' : p = "┨"; break;

case 'i' : p = "━"; break;//上下的横线更粗

case 'j' : p = "—"; j++; break;//中间的横线更细//j++;因为输出"—"时占两个字符，j++可以规避输出下一个的空格

case 'k' : p = "┃"; break;//左右的竖线更粗

case 'l' : p = "│"; break;//中间的竖线更粗

case 'm' : p = "┼"; break;

case ' ' : p = " "; break;

default : p = buffer[i][j];

}//switch,for

if( ! p) continue;

SetConsoleCursorPosition(hNewConsole, cdCursorPos);

WriteConsole(hNewConsole, p, strlen(p), NULL, NULL);

}

// printf("\");

}//for

//把绘制好的东西都显示出来

SetConsoleActiveScreenBuffer(hNewConsole);

//假设游戏结束，返回正常模式

/*if(gs)

{

SetConsoleActiveScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE));

}*/

}

int Judge_Display()//输出胜负情况

{

if(num == N*N)

{

Buf_Display();//将缓冲器数据输出到屏幕

printf("平局！\");

return 1;//对局结束

}

if(gs == 1)

{

Buf_Display();//将缓冲器数据输出到屏幕

printf("黑棋赢！\");

return 1;//对局结束

}

if(gs == 2)

{

Buf_Display();//将缓冲器数据输出到屏幕

printf("白棋赢！\");

return 1;//对局结束

}

return 0;

}

c语言中五子棋棋子怎么打？

一、构建棋盘

第一可以用一个二维数组来构建棋盘，下标表示位置，内容表示黑子白子或者空位。当数组内容为1时，该位置为白字，当数组为0时，该位置为白子，空位输出+

int w[11][11], flag = 0;

int a, b;

for (int k = 0; k 11; k++)

printf(第%d列\, k);

printf(\);

for (int i = 0; i 11; i++) {

for (int j = 0; j 11; j++) {

if (w[i][j] == 0) printf(黑\);

else if (w[i][j] == 1) printf(白\);

else printf(+\);

}

printf(第%d行\\, i);

}

用c语言如何定义五子棋的大小和数量？

，我们使用一个15*15的二维数组 Table[15][15] (15*15是五子棋棋盘的大小)，数组的每一个元素对应棋盘上的一个交叉点，用‘0’表示空位、‘1’代表己方的子、‘2’代表对方的子

合适win10系统的c语言五子棋代码？

在 C 语言中，可以使用二维数组表示五子棋盘，还可以通过定义常量来设置棋盘的大小和数量。

下面是一部分示例代码，演示如何定义五子棋盘的大小和数量：

```

#define BOARD_SIZE 15 // 定义棋盘大小为15*15

#define MAX_COUNT 5 // 定义获胜所需棋子数量为5

int board[BOARD_SIZE][BOARD_SIZE]; //定义战盘，形成二维数组

```

在这个例子中，通过 `#define` 重要字来定义了战棋盘的大小为 15x15，还有获胜所需的棋子数量为5个。这样一来，整个程序中都可以通过 BOARD_SIZE 和 MAX_COUNT 两个常量来引用这些值。

然后，可以使用二维数组来表示战盘，这当中数组的每个元素代表棋盘上一个点的状态，比如：

```

board[5][8] = 1; // 代表白棋在第6行第9列落子

```

在这个例子中，将第6行第9列上的位置标记为1，表示该位置上落了一个白棋。可按照需使用另一个值（比如2）代表黑子。

期望这些示例代码能有效的帮您启动定义自己的五子棋程序

#include stdio.h

#define N 16

//显示五子棋棋盘

void wzq_show(char (*GAME)[N])

{

int i=0,j=0;

printf(五子棋棋盘请看下方具体内容：\);

for(i=0;iN;i++)

{

for(j=0;jN;j++)

{

printf(%c ,GAME[i][j]);

}

printf(\);

}

}

//初始化五子棋棋盘

void wzq_init(char (*GAME)[N])

{

int i=0,j=0;

for(i=0;iN;i++)

{

for(j=0;jN;j++)

{

GAME[i][j]=+;

}

}

//memset(GAME,+,N*N);

}

//游戏是不是成功的运算,但凡是有人成功则返回1

int wzq_play(int a,int b,char (*GAME)[N])

{

int i=0,j=0,k=0;

//方向-上的

for(j=b-4;jb+4;j++)

{

if(j0 || jN-1)

{

continue;

}

for(i=0;i5;i++)

{

if(@==GAME[a][j+i] ||+==GAME[a][j+i])

{

break;

}

if(O==GAME[a][j+i] 4==i)

{

printf(\祝贺你，白家－方向上获胜!\);

return 1;

}

}

}

//方向|上的

for(i=a-4;ia+4;i++)

{

if(i0 || iN-1)

{

continue;

}

for(j=0;j5;j++)

{

if(@==GAME[i+j][b] ||+==GAME[i+j][b])

{

break;

}

if(O==GAME[i+j][b] 4==j)

{

printf(\祝贺你，白家｜方向上获胜!\);

return 1;

}

}

}

//方向\\上的

for(i=a-4,j=b-4;ia+4 jb+4;i++,j++)

{

if(i0 || iN-1 || j0 || jN-1)

{

continue;

}

for(k=0;k5;k++)

{

if(@==GAME[i+k][j+k] ||+==GAME[i+k][j+k])

{

break;

}

if(O==GAME[i+k][j+k] 4==k)

{

printf(\祝贺你，白家＼方向上获胜!\);

return 1;

}

}

}

//方向/上的

for(i=a+4,j=b-4;ia-4 jb+4;i-,j++)

{

if(i0 || iN-1 || j0 || jN-1)

{

continue;

}

for(k=0;k5;k++)

{

if(@==GAME[i-k][j+k] ||+==GAME[i-k][j+k])

{

break;

}

if(O==GAME[i-k][j+k] 4==k)

{

printf(\祝贺你，白家/方向上获胜!\);

return 1;

}

}

}

return 0;

}

int main()

{

char GAME[N][N]={0};

int count=0;//轮换落子计算

int m=0,n=0;//白家

int x=0,y=0;//黑家

int res=0;

int k=0;

wzq_init(GAME);

wzq_show(GAME);

while(1)

{

//当棋盘格子被下满了时

if(N*N==count)

{

printf(棋盘已经下满了，平局!\);

return 0;

}

if(0==count%2)

{

printf(请白家落子（比如0 3或1 3）：);

scanf(%d%d,m,n);

while(m0 || mN-1 || n0 || nN-1)

{

printf(输入的坐标超过范围，请重新输入：);

scanf(%d%d,m,n);

}

while(+!=GAME[m][n])

{

printf(这个方向已经落过子，请重新落子：);

scanf(%d%d,m,n);

}

GAME[m][n]=O;

res=wzq_play(m,n,GAME);

if(1==res)

{

wzq_show(GAME);

printf(程序结束\);

return 0;

}

}else

{

printf(请黑家落子（比如0 3或1 3）：);

scanf(%d%d,x,y);

while(m0 || mN-1 || n0 || nN-1)

{

printf(输入的坐标超过范围，请重新输入：);

scanf(%d%d,m,n);

}

while(+!=GAME[x][y])

{

printf(这个方向已经落过子，请重新落子：);

scanf(%d%d,x,y);

}

GAME[x][y]=@;

res=wzq_play(x,y,GAME);

if(1==res)

{

wzq_show(GAME);

printf(程序结束\);

return 0;

}

}

count++;

wzq_show(GAME);

}

}

一级造价工程师备考资料及辅导课程

一级造价工程师培训班-名师辅导课程