三子棋C语言小游戏功能完善

最新推荐文章于 2024-05-01 19:59:18 发布
最新推荐文章于 2024-05-01 19:59:18 发布
阅读量351 收藏 1
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/OddSmurfs/article/details/80931470
本文详细介绍了使用C语言开发井字棋游戏的过程，包括玩家走、电脑走、判断输赢等核心功能，并优化了电脑下棋算法，使其更具挑战性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录：

在前面的博客中已经对游戏的整体框架做出了分析，在这片博客中将会对整个游戏进行功能的完善的改进。
初始化和打印棋盘的功能已经在前面给出，现在还需要实现的功能便是玩家走、电脑走、和判断输赢的函数。

玩家走：PlayerMove（）

在这个函数中通过数组下标确定一个二维数组中的位置，只要该位置没有放入“棋子”，便把该数组空间赋值为'X'，所以确定该函数的返回值为void,需要将对数组通过循环遍历的临界值ROW COL传过去。所以函数的功能实现如下：

void PlayerMove(char arr[ROW][COL], int row, int col)
{
    int r = 0;
    int c = 0;
    while (1)
    {
        printf("玩家走：>\n");
        scanf("%d%d", &r, &c);
        if (r>=1 && r<=row && c>=1 && c<=col)
        {
            if (arr[r-1][c-1] == ' ')
            {
                arr[r-1][c-1] = 'X';
                break;
            }
            else
            {
                printf("已选择过！请重新输入\n");         
            }
        }
        else
        {
            printf("输入有误！请重新输入\n");
        }
    }
}

电脑走：ComputerMove（）

与电脑走的函数方法类似，不同的是电脑随机生成一个坐标，如果该座标没有放入“棋子”，便将该数组空间赋值为'0',返回值同样为void同样需要把ROW COL传过去。

void ComputerMove(char arr[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    printf("电脑走：>\n");
    while (1)
    {
        i = rand()%row;
        j = rand()%col;
        if (arr[i][j] == ' ')
        {
            arr[i][j] = '0';
            break;
        }
    }
}

rand（）函数在调用之前，必须先调用srand（）生成随机数起点，因起点生成后不许再变，所以将其放入main（）中之调用一次即可。

判断输赢 IsWin（）

判断输赢要分四种情况讨论，玩家赢、电脑赢、平局、以上三种情况均不是，比赛继续。

  • 玩家赢、电脑赢、都可以通过循环遍历数组，通过if语句判断棋盘的状态来完成。

  • 如果发现棋盘已满，而胜负未定则为平局。

  • 以上情况均不是则继续游戏。

如何实现这个逻辑，可以通过返回值来判断：当玩家赢返回X，电脑赢返回0，平局返回空字符，如果继续不做处理。

char IsWin(char arr[ROW][COL], int row, int col)
{
    int i = 0;

    for (i=0; i<row; i++)
    {
        //判断是否同行
        if (arr[i][0]==arr[i][1] && arr[i][1]==arr[i][2] && arr[i][1] != ' ')
        {
            return arr[i][1];
        }
        //列
        else if (arr[0][i]==arr[1][i] && arr[1][i]==arr[2][i] && arr[1][i] != ' ')
        {
            return arr[1][i];
        }
        //斜
        else if ((arr[0][0]==arr[1][1] && arr[1][1]==arr[2][2] && arr[1][1] != ' ')
            ||(arr[0][2]==arr[1][1] && arr[1][1]==arr[2][0] && arr[1][1] != ' '))
        {
            return arr[1][1];
        }
        else
        {
            ;
        }
    }

    if (IsFull(arr,ROW,COL))
    {
        return ' ';
    }
}
//判断棋满
static int IsFull(char arr[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            if (arr[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}

IsFull（）将返回值设置成1/0可以很好的在调用的if语句中能够做出判断，前面加上static是为这个函数不需要在其他地方调用，只用于本源码，避免命名冲突。

电脑下棋算法优化

标题很高大上，其实实现方法很挫，说白了就是对棋盘当前状态的一种判断，与判断输赢的逻辑方法完全一样，根据判断的结果，电脑给出当下的最优选择。就是将很多种状态提前告知电脑，然后判断符合状态后，接下来的走法也人为规定好了。这就跟现在的电脑下象棋，围棋是一个道理，就是检索内存中的当前棋盘已有最优方案。
整体的逻辑如下：先判断是否抢3，如果有符合当前电脑能赢的方案，则优先抢其。
接着选择是否堵3，如果玩家出现再落一子就赢的情况，要对其进行封堵。
最后一点，在下棋的过程中，由于棋盘限制，中间位置尤为重要，占据它，将占据主动权，如果为空，则选其。

void ComputerMove(char arr[ROW][COL], int row, int col)
{
    int m = 0;
    int i = 0;
    int j = 0;
    printf("电脑走：>\n");
    //抢3
    //抢行
    for (m=0; m<ROW; m++)
    {
        if (arr[m][0]=='0' && arr[m][1]=='0' && arr[m][2]==' ')
        {
            arr[m][2] = '0';
            goto exit;
        }
        if (arr[m][0]=='0' && arr[m][2]=='0' && arr[m][1]==' ')
        {
            arr[m][1] = '0';
            goto exit;
        }
        if (arr[m][1]=='0' && arr[m][2]=='0' && arr[m][0]==' ')
        {
            arr[m][0] = '0';
            goto exit;
        }
    }
    //抢列
    for (m=0; m<COL; m++)
    {
        if (arr[0][m]=='0' && arr[1][m]=='0' && arr[2][m]==' ')
        {
            arr[2][m] = '0';
            goto exit;
        }
        if (arr[0][m]=='0' && arr[2][m]=='0' && arr[1][m]==' ')
        {
            arr[1][m] = '0';
            goto exit;
        }
        if (arr[1][m]=='0' && arr[2][m]=='0' && arr[0][m]==' ')
        {
            arr[0][m] = '0';
            goto exit;
        }
    }
    //抢斜行
    //情况一：斜率为-1的斜行
    if (arr[0][0]=='0' && arr[1][1]=='0' && arr[2][2]==' ')
    {
        arr[2][2] = '0';
        goto exit;
    }
    if (arr[0][0]=='0' && arr[2][2]=='0' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='0' && arr[2][2]=='0' && arr[0][0]==' ')
    {
        arr[0][0] = '0';
        goto exit;
    }
    //情况二：斜率为1的斜行
    if (arr[2][0]=='0' && arr[1][1]=='0' && arr[0][2]==' ')
    {
        arr[0][2] = '0';
        goto exit;
    }
    if (arr[2][0]=='0' && arr[0][2]=='0' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='0' && arr[0][2]=='0' && arr[2][0]==' ')
    {
        arr[2][0] = '0';
        goto exit;
    }

    //堵
    //堵行
    for (m=0; m<ROW; m++)
    {
        if (arr[m][0]=='X' && arr[m][1]=='X' && arr[m][2]==' ')
        {
            arr[m][2] = '0';
            goto exit;
        }
        if (arr[m][0]=='X' && arr[m][2]=='X' && arr[m][1]==' ')
        {
            arr[m][1] = '0';
            goto exit;
        }
        if (arr[m][1]=='X' && arr[m][2]=='X' && arr[m][0]==' ')
        {
            arr[m][0] = '0';
            goto exit;
        }
    }
    //堵列
    for (m=0; m<COL; m++)
    {
        if (arr[0][m]=='X' && arr[1][m]=='X' && arr[2][m]==' ')
        {
            arr[2][m] = '0';
            goto exit;
        }
        if (arr[0][m]=='X' && arr[2][m]=='X' && arr[1][m]==' ')
        {
            arr[1][m] = '0';
            goto exit;
        }
        if (arr[1][m]=='X' && arr[2][m]=='X' && arr[0][m]==' ')
        {
            arr[0][m] = '0';
            goto exit;
        }
    }
    //堵斜行
    //情况一：斜率为-1的斜行
    if (arr[0][0]=='X' && arr[1][1]=='X' && arr[2][2]==' ')
    {
        arr[2][2] = '0';
        goto exit;
    }
    if (arr[0][0]=='X' && arr[2][2]=='X' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='X' && arr[2][2]=='X' && arr[0][0]==' ')
    {
        arr[0][0] = '0';
        goto exit;
    }
    //情况二：斜率为1的斜行
    if (arr[2][0]=='X' && arr[1][1]=='X' && arr[0][2]==' ')
    {
        arr[0][2] = '0';
        goto exit;
    }
    if (arr[2][0]=='X' && arr[0][2]=='X' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='X' && arr[0][2]=='X' && arr[2][0]==' ')
    {
        arr[2][0] = '0';
        goto exit;
    }

    //抢2
    if (arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }


    while (1)
    {
        i = rand()%row;
        j = rand()%col;
        if (arr[i][j] == ' ')
        {
            arr[i][j] = '0';
            break;
        }
    }
exit:;
}

由于前面做出选择后，后面将不再落子，前面未作处理，才来到后面。所以通过goto语句进行跳转，以实现其逻辑。

这样的不算优化的优化，也仅仅是让电脑不再继续傻下去。由于棋盘的限制，如果有可能，可以将其所有的棋盘状态进行穷举，而电脑每一步落子都是对自己最优，对玩家最不利的，这样人想赢就难了，因为人脑的逻辑分析能力和存储记忆能力是远不及计算机的。

礼让电脑

由于棋盘大小限制，和谁先走就有抢中间位置的决定权，如果感觉自己萌萌哒，可以让电脑先走~。~，变化只是game函数的调用顺序问题以及多一步switch语句的选择，将会在后面完整代码中体现。

完整代码展示

  • game.h
#ifndef __GAME_H__
#define __GAME_H__

#define ROW 3
#define COL 3

void InitBoard(char arr[ROW][COL], int row, int col);//初始化棋盘

void PrintBoard(char arr[ROW][COL], int row, int col);//打印棋盘

void PlayerMove(char arr[ROW][COL], int row, int col);//玩家走

char IsWin(char arr[ROW][COL], int row, int col);//判断输赢

void ComputerMove(char arr[ROW][COL], int row, int col);//电脑走

#endif //__GAME_H__
  • game.c
#include <stdio.h>
#include <stdlib.h>
#include "game.h"

void InitBoard(char arr[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            arr[i][j] = ' ';
        }
    }
}

void PrintBoard(char arr[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            printf(" %c ",arr[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 PlayerMove(char arr[ROW][COL], int row, int col)
{
    int r = 0;
    int c = 0;
    while (1)
    {
        printf("玩家走：>\n");
        scanf("%d%d", &r, &c);
        if (r>=1 && r<=row && c>=1 && c<=col)
        {
            if (arr[r-1][c-1] == ' ')
            {
                arr[r-1][c-1] = 'X';
                break;
            }
            else
            {
                printf("已选择过！请重新输入\n");         
            }
        }
        else
        {
            printf("输入有误！请重新输入\n");
        }
    }
}

static int IsFull(char arr[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            if (arr[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}

char IsWin(char arr[ROW][COL], int row, int col)
{
    int i = 0;

    for (i=0; i<row; i++)
    {
        //判断是否同行
        if (arr[i][0]==arr[i][1] && arr[i][1]==arr[i][2] && arr[i][1] != ' ')
        {
            return arr[i][1];
        }
        //列
        else if (arr[0][i]==arr[1][i] && arr[1][i]==arr[2][i] && arr[1][i] != ' ')
        {
            return arr[1][i];
        }
        //斜
        else if ((arr[0][0]==arr[1][1] && arr[1][1]==arr[2][2] && arr[1][1] != ' ')
            ||(arr[0][2]==arr[1][1] && arr[1][1]==arr[2][0] && arr[1][1] != ' '))
        {
            return arr[1][1];
        }
        else
        {
            ;
        }
    }

    if (IsFull(arr,ROW,COL))
    {
        return ' ';
    }
}

void ComputerMove(char arr[ROW][COL], int row, int col)
{
    int m = 0;
    int i = 0;
    int j = 0;
    printf("电脑走：>\n");
    //抢3
    //抢行
    for (m=0; m<ROW; m++)
    {
        if (arr[m][0]=='0' && arr[m][1]=='0' && arr[m][2]==' ')
        {
            arr[m][2] = '0';
            goto exit;
        }
        if (arr[m][0]=='0' && arr[m][2]=='0' && arr[m][1]==' ')
        {
            arr[m][1] = '0';
            goto exit;
        }
        if (arr[m][1]=='0' && arr[m][2]=='0' && arr[m][0]==' ')
        {
            arr[m][0] = '0';
            goto exit;
        }
    }
    //抢列
    for (m=0; m<COL; m++)
    {
        if (arr[0][m]=='0' && arr[1][m]=='0' && arr[2][m]==' ')
        {
            arr[2][m] = '0';
            goto exit;
        }
        if (arr[0][m]=='0' && arr[2][m]=='0' && arr[1][m]==' ')
        {
            arr[1][m] = '0';
            goto exit;
        }
        if (arr[1][m]=='0' && arr[2][m]=='0' && arr[0][m]==' ')
        {
            arr[0][m] = '0';
            goto exit;
        }
    }
    //抢斜行
    //情况一：斜率为-1的斜行
    if (arr[0][0]=='0' && arr[1][1]=='0' && arr[2][2]==' ')
    {
        arr[2][2] = '0';
        goto exit;
    }
    if (arr[0][0]=='0' && arr[2][2]=='0' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='0' && arr[2][2]=='0' && arr[0][0]==' ')
    {
        arr[0][0] = '0';
        goto exit;
    }
    //情况二：斜率为1的斜行
    if (arr[2][0]=='0' && arr[1][1]=='0' && arr[0][2]==' ')
    {
        arr[0][2] = '0';
        goto exit;
    }
    if (arr[2][0]=='0' && arr[0][2]=='0' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='0' && arr[0][2]=='0' && arr[2][0]==' ')
    {
        arr[2][0] = '0';
        goto exit;
    }

    //堵
    //堵行
    for (m=0; m<ROW; m++)
    {
        if (arr[m][0]=='X' && arr[m][1]=='X' && arr[m][2]==' ')
        {
            arr[m][2] = '0';
            goto exit;
        }
        if (arr[m][0]=='X' && arr[m][2]=='X' && arr[m][1]==' ')
        {
            arr[m][1] = '0';
            goto exit;
        }
        if (arr[m][1]=='X' && arr[m][2]=='X' && arr[m][0]==' ')
        {
            arr[m][0] = '0';
            goto exit;
        }
    }
    //堵列
    for (m=0; m<COL; m++)
    {
        if (arr[0][m]=='X' && arr[1][m]=='X' && arr[2][m]==' ')
        {
            arr[2][m] = '0';
            goto exit;
        }
        if (arr[0][m]=='X' && arr[2][m]=='X' && arr[1][m]==' ')
        {
            arr[1][m] = '0';
            goto exit;
        }
        if (arr[1][m]=='X' && arr[2][m]=='X' && arr[0][m]==' ')
        {
            arr[0][m] = '0';
            goto exit;
        }
    }
    //堵斜行
    //情况一：斜率为-1的斜行
    if (arr[0][0]=='X' && arr[1][1]=='X' && arr[2][2]==' ')
    {
        arr[2][2] = '0';
        goto exit;
    }
    if (arr[0][0]=='X' && arr[2][2]=='X' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='X' && arr[2][2]=='X' && arr[0][0]==' ')
    {
        arr[0][0] = '0';
        goto exit;
    }
    //情况二：斜率为1的斜行
    if (arr[2][0]=='X' && arr[1][1]=='X' && arr[0][2]==' ')
    {
        arr[0][2] = '0';
        goto exit;
    }
    if (arr[2][0]=='X' && arr[0][2]=='X' && arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }
    if (arr[1][1]=='X' && arr[0][2]=='X' && arr[2][0]==' ')
    {
        arr[2][0] = '0';
        goto exit;
    }

    //抢2
    if (arr[1][1]==' ')
    {
        arr[1][1] = '0';
        goto exit;
    }


    while (1)
    {
        i = rand()%row;
        j = rand()%col;
        if (arr[i][j] == ' ')
        {
            arr[i][j] = '0';
            break;
        }
    }
exit:;
}
  • test.c
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "game.h"

void menu1()
{
    printf("****************************************\n");
    printf("*******           1.play         *******\n");
    printf("*******           0.exit         *******\n");
    printf("****************************************\n");
}
void menu2()
{
    printf("****************************************\n");
    printf("*******      1.player_first      *******\n");
    printf("*******     2.computer_first     *******\n");
    printf("****************************************\n");
}
void player_first_game()
{
    char arr[ROW][COL];
    InitBoard(arr,ROW,COL);
    PrintBoard(arr,ROW,COL);
    while (1)
    {
        PlayerMove(arr,ROW,COL);
        PrintBoard(arr,ROW,COL);
        //判断输赢，分为四种情况，如果不是以下三种情况游戏继续
        if (IsWin(arr,ROW,COL)==' ')
        {
            printf("很遗憾，平局！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='X')
        {
            printf("玩家赢！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='0')
        {
            printf("电脑赢！\n");
            break;
        }
        ComputerMove(arr,ROW,COL);
        PrintBoard(arr,ROW,COL);
        if (IsWin(arr,ROW,COL)==' ')
        {
            printf("很遗憾，平局！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='X')
        {
            printf("玩家赢！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='0')
        {
            printf("电脑赢！\n");
            break;
        }
    }
}
void computer_first_game()
{
    char arr[ROW][COL];
    InitBoard(arr,ROW,COL);
    while (1)
    {
        ComputerMove(arr,ROW,COL);
        PrintBoard(arr,ROW,COL);
        //判断输赢，分为四种情况，如果不是以下三种情况游戏继续
        if (IsWin(arr,ROW,COL)==' ')
        {
            printf("很遗憾，平局！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='X')
        {
            printf("玩家赢！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='0')
        {
            printf("电脑赢！\n");
            break;
        }
        PlayerMove(arr,ROW,COL);
        PrintBoard(arr,ROW,COL);
        if (IsWin(arr,ROW,COL)==' ')
        {
            printf("很遗憾，平局！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='X')
        {
            printf("玩家赢！\n");
            break;
        }
        if (IsWin(arr,ROW,COL)=='0')
        {
            printf("电脑赢！\n");
            break;
        }
    }
}
int main()
{
    int input1 = 0;
    int input2 = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu1();
        scanf("%d",&input1);
        switch(input1)
        {
        case 1:
//          game(此处可以添加更完整的游戏功能实现);
            menu2();
            printf("请选择谁先走：>\n");
            scanf("%d",&input2);
            switch(input2)
            {
            case 1:
                player_first_game();
                goto flag;
            case 2:
                computer_first_game();
            }
flag:;
            break;
        case 0:
            printf("游戏结束\n");
            return 0;
        default :
            printf("输入错误！请重新输入\n");
            break;
        }
    }while (input1);
    return 0;
}
C语言实现三子棋及优化
dxtianlei的博客
08-19 372
用C语言来实现一个三子棋，我们首先要有一个思维框架。 游戏开始前首先要有一个菜单供玩家选择，选项有进入和退出两种选项。当然，也要考虑玩家不小心按错的情况。退出游戏则直接退出，而进入游戏结束一局游戏后应该再次让玩家进行菜单选择。这样就又回到了开始的选项，形成了死循环，跳出的途径只有选择菜单上的退出选项。 以上的情况就是我们游戏的基本设定，以C语言来实现也十分简单： //三字棋 #inclu...
C语言经典小游戏之三子棋（超详解释＋源码）
qq_73121173的博客
08-04 2228
关于C语言小游戏之三子棋的详解及源码
进阶版三子棋（待改进）
jotaro07的博客
01-10 2354
进阶版三子棋（待改进） Designed By Rossi 仅供记录和参考，转载需经本人同意 有段时间没写blog了，感觉自己快生锈了。2021年是时候该整点狠活了，我决定搬出我用c++写了三个月的小游戏 目录进阶版三子棋（待改进）初衷一、三子棋的介绍二、代码解析1.登录程序2.打印棋盘3.核心代码1：玩家移动，电脑移动与胜负判定4.核心代码2：玩家先走和电脑先走5.成就系统（计分）6.全局变量，定义及部分主函数部分三、小感慨 初衷 学了这么久编程，总觉得自己除了算法还应该弄点别的东西，用c++写个软
【C语言/入门游戏】三子棋及改良思路
白晨的博客
10-07 1052
知识提要（自主编写游戏所需要的知识）： 1.函数的基本实现； 2.二维数组； 好的，话不多说让我们来看今天的分享 三子棋 效果图： 1.初始界面实现 老规矩，先创建三个文件，分别为test.c（用于测试游戏以及运行游戏）,game.c（用于实现游戏内函数）以及game.h（声明game.c中的函数和共同需要的数据） 先在game.h中引用你所需要的文件和必要的定义 #pragma once # define _CRT_SECURE_NO_WARNINGS #include &l
C语言三子棋游戏实现及AI设想、五子棋推广
weixin_54225634的博客
01-24 4758
@Part1： Part 1 三子棋游戏基础实现： 1、操作界面实现： 即实现供用户选择的的菜单：我们定义为menu函数 void menu(){ printf("****************\n"); printf("*****1.play*****\n"); printf("*****0.exit*****\n"); printf("****************\n"); } 我们希望达到的目的是用户可以不断选择，直至按0退出游戏，于是我们在主函数中需要搭建框架
三子棋程序的实现
lly17792230965的博客
04-09 616
``` #pragma once #ifndef _SANZIQI_H_ #define _SANZIQI_H_ #define ROW 3 #define COL 3 void InitBoard(char arr[ROW][COL], int row, int col);//初始化 void Display(char arr[ROW][COL], int row, int col);//...
用C语言实现 三子棋 小游戏
m0_71199350的博客
05-01 239
代码基本和玩家的一样，唯一要考虑的一点是如何实现电脑在合法范围内随机找位置下的功能，这就必须得用到srand()函数、time()函数，利用时间戳在主函数main()中生成随机数，然后在电脑下棋的函数中用rand()函数%上对应范围内行和列，则生成合法范围内随机数，这边就不对此函数进行介绍，可自行百度。最后，就剩下一个判断输赢的程序小游戏就完成了，我们希望玩家、电脑每走一步棋就用Iswin()判断一次输赢，这一过程同样也是对数组进行判断，最后把棋盘的结果再打印在屏幕上一次。
【C语言小游戏】三子棋（井字棋）
青色_忘川的博客
11-18 6284
主要讲解了三子棋的详细实现，为大家熟练的打通了各种思考逻辑，为什么是这样子，常见的错误。同时最终也给出了三子棋的最终代码，分文件和合并为一个文件都给出了具体的代码。
基于C语言的三子棋游戏设计与实现源码
09-24
该项目深入探讨了基于C语言的三子棋游戏设计与实现，涉及多个关键文件和程序模块。首先，源码中包含大量的日志、调试、索引和项目管理文件，确保了游戏开发的完整性和系统的稳定性。核心文件game.c、test.c和game.h...
C语言实现的三子棋小游戏！！完整代码！
10-21
总结，这款三子棋小游戏是学习C语言和数组操作的好实例，涵盖了输入输出、循环、条件判断等基础概念，同时提供了扩展功能的可能，如游戏难度调整和多人对战模式。通过这个项目，初学者可以提升自己的编程技能，体验...
C语言实现简易版三子棋游戏
08-18
C语言实现简易版三子棋...C语言实现简易版三子棋游戏是一个简易的三子棋游戏，使用C语言实现，游戏的逻辑实现简单易懂，游戏的界面友好易于使用，但游戏的实现较为简单，游戏的逻辑实现不够完善，游戏的界面不够美观。
C语言自制小游戏：三子棋（井字棋）智能下棋补充
weixin_55547460的博客
02-13 3633
一.前期准备 这篇博客并不包含三子棋大体的内容设计，只有怎样让计算机下的棋更智能一些的讲解如果想看怎样实现三子棋大体程序设计内容还请跳转：https://blog.youkuaiyun.com/weixin_55547460/article/details/122648554 在进行下面的内容开始前，需要你首先完善好大体的三子棋程序内容设计 二.程序逻辑结构 这次我们要实现的是让计算机能更加智能的判断应该在哪个坐标下下入棋子，从而实现对玩家的“围追堵截” 在思考这个问题前，我们不妨将计算机替换成自己，想象一下，如果是你
电动汽车充电机：900W1Kw双管正激可调电源充电机的设计与实现 · PCB设计
08-08
900W或1Kw，20V-90V 10A双管正激可调电源充电机的研发过程和技术细节。涵盖了硬件设计（如PCB设计、磁性器件选择）、软件实现（如程序代码、保护功能）、通讯功能（如RS232隔离通讯）以及散热设计等方面。此外，还提供了详细的PCB图、程序代码、BOM清单、磁性器件和散热片规格书等源文件，旨在帮助用户快速投入生产。 适合人群：从事电动汽车充电设备研发的技术人员、电子工程师及相关领域的研究人员。 使用场景及目标：适用于需要高效、稳定的充电解决方案的企业和个人开发者。目标是通过详细的技术解析，帮助用户理解和掌握双管正激充电机的设计与实现方法，从而应用于实际产品开发。 其他说明：文中不仅提供了理论知识，还包括具体的实现案例和源文件下载链接，便于读者深入研究和实践。
【人工智能与机器学习】项目介绍 Python实现基于POA-BP鹈鹕优化算法（POA）优化反向传播神经网络（BP）进行多特征分类预测的详细项目实例（含模型描述及部分示例代码）
08-08
内容概要：本文详细介绍了基于Python实现的POA-BP（鹈鹕优化算法优化反向传播神经网络）多特征分类预测项目。项目旨在通过融合POA和BP神经网络，解决传统BP训练中易陷入局部最优、收敛速度慢等问题，从而提升多特征分类预测的精度和效率。POA算法通过模拟鹈鹕捕食行为，增强了全局搜索能力，提高了模型对高维复杂数据的适应性和鲁棒性。项目涵盖输入数据预处理、POA优化模块、BP神经网络训练模块及预测评估模块，提供了完整的算法实现框架和部分示例代码。 适合人群：具备一定编程基础，特别是对机器学习和神经网络有一定了解的研发人员和技术爱好者。 使用场景及目标：① 提升多特征分类预测精度，减少误分类率；② 加速神经网络训练过程，缩短训练时间；③ 克服传统BP训练局限，提高模型稳定性和泛化能力；④ 支持多领域实际应用需求，如金融风险评估、医疗诊断、图像识别等。 其他说明：项目背景强调了新型群智能算法与经典神经网络结合的重要性，为智能化多特征分类提供了坚实的技术基础。通过模块化设计，实现了POA与BP的有效融合，确保代码结构清晰且便于维护。此外，项目还提供了详细的代码示例，帮助读者更好地理解和实践POA-BP算法。
充电桩上位机：全自动报文分析与快慢充智能监控技术解析 快慢充
08-08
充电桩上位机的全自动报文分析功能及其对快充和慢充的支持。文章首先从技术实现角度深入剖析了上位机的工作机制，涵盖技术架构、算法流程和关键代码实现。接着，通过实际开发经验和案例展示了上位机在报文分析中的应用。此外，还从用户体验和技术决策两个角度分别探讨了上位机的功能特点和选择依据，帮助读者全面理解这一技术。 适合人群：对充电桩技术感兴趣的工程师、产品经理及初学者。 使用场景及目标：适用于需要深入了解充电桩上位机工作原理、开发过程及应用场景的专业人士。目标是让读者掌握上位机的关键技术和设计理念，提升相关领域的技术水平。 其他说明：文章不仅提供了技术实现的详细讲解，还包括了丰富的图表和代码片段，便于读者更好地理解和实践。
Simulink If：支持DBC与硬件信号导入自动生成模型及代码的技术解析
08-08
内容概要：本文介绍了Simulink If这款强大工具的功能及其应用。Simulink If不仅支持DBC（数据库容器）文件的自动导入以生成模型和代码，而且兼容ASW（应用软件组件）和BSW（基础软件组件），同时支持硬件信号的导入来创建模型和生成代码。文中详细讲解了这两个主要功能的具体实现方法，并附有Matlab代码片段作为示例，展示了从读取DBC文件或硬件信号到最终生成模型和代码的完整流程。 适用人群：对汽车电子系统开发感兴趣的研发人员和技术爱好者，尤其是那些需要频繁处理DBC文件以及进行硬件接口编程的人士。 使用场景及目标：适用于汽车电子领域的项目开发过程中，当涉及到基于DBC定义的消息通信或者需要快速建立硬件交互原型时，利用Simulink If可以显著提高工作效率，简化开发步骤，缩短产品上市时间。 其他说明：Simulink If的应用有助于提升开发者对于复杂系统的理解和掌控能力，促进团队协作，确保项目的顺利推进。
人工智能学习笔记与课程资料全记录-布里斯托大学机器人专业研究生AI课程完整内容-机器学习算法实现与数学推导详解-神经网络深度学习基础与进阶知识-包含K-means聚类等无监督学习技.zip
最新发布
08-08
python人工智能学习笔记与课程资料全记录_布里斯托大学机器人专业研究生AI课程完整内容_机器学习算法实现与数学推导详解_神经网络深度学习基础与进阶知识_包含K-means聚类等无监督学习技.zip人工智能学习笔记与课程资料全记录_布里斯托大学机器人专业研究生AI课程完整内容_机器学习算法实现与数学推导详解_神经网络深度学习基础与进阶知识_包含K-means聚类等无监督学习技.zip
工业自动化中WinCC通用外部数据库报表的全脚本实现与自定义方法
08-08
在工业自动化领域中，如何利用WinCC（Windows Control Center）实现通用外部数据库报表的全脚本化操作。主要内容涵盖数据连接脚本、数据查询脚本、报表生成脚本的具体实现步骤，以及如何进行全自定义表格的设计和C脚本的存储。文中还强调了该模板的灵活性，即可以通过适当修改适应不同类型的上位机系统。最后，为初学者提供了学习路径和实践建议。 适合人群：具备一定WinCC脚本基础和SQL语言基础的技术人员，尤其是从事工业自动化领域的工程师。 使用场景及目标：① 实现从数据库到报表展示的全流程自动化；② 提升报表设计效率和灵活性；③ 培养工业自动化项目中的数据分析与展示能力。 其他说明：建议读者结合实际案例进行练习，逐步深入理解和掌握WinCC的高级功能。
基于OpenCV的贝塞尔曲线拟合车道线检测
08-08
资源下载链接为： https://pan.quark.cn/s/9648a1f24758 在 Visual Studio 中新建项目，将此程序文件放入源文件目录，随后直接运行程序。运行后，你可以通过鼠标拖动控制点，直观地观察贝塞尔曲线随着控制点位置变化的动态过程。此外，你还可以手动输入四个控制点的坐标，程序将自动根据这些点拟合出新的贝塞尔曲线。稍作修改后，该程序可用于车道线拟合。代码结构清晰简洁，且附有详细的文字说明。编写这样的代码需要花费不少精力，而分享出来更是需要勇气和慷慨。师兄曾建议收取 20 个积分，但我实在不忍心要这么高的价格。
掌握C语言编程技巧：制作三子棋游戏指南
资源摘要信息:"本文将详细介绍如何使用C语言编写一个简单的三子棋（也称为井字棋）游戏。三子棋是一个两人轮流在3x3...通过遵循这个框架，开发者可以进一步实现和完善游戏的功能，最终完成一个完整的C语言三子棋项目。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值