C/C++实现算24点小游戏

已于 2023-05-19 14:38:53 修改
阅读量228 收藏 1
点赞数
文章标签： c++ c语言
于 2023-05-18 15:27:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45700350/article/details/130747942
版权

目录

算24点小游戏

说明

分别使用C语言和C++实现算24点小游戏。考虑到会出现相同的数字组合，如果不排除就会产生重复结果，因此，用C语言实现了简单的set功能， C++则可以直接使用STL。

C file struct
 	|----cal24
 		|----cal24.h
 		|----cal24.c
 		|----set.h
 		|----set.c
 	|----main.c
 	|----CMakeLists.txt

C++ file struct
 	|----cal24
 		|----cal24.hpp
 	|----main.cpp
 	|----CMakeLists.txt

C代码

set.h

#ifndef __SET_H__
#define __SET_H__

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct _node;

typedef struct _node{
    void *val;
    struct _node *next;
} node;

typedef struct {
    int size;
    node *begain;
} set;

void set_insert(set *s, void *x, int data_size);
void set_free(set *s);


#endif

set.c

#include "set.h"

void set_insert(set *s, void *x, int data_size)
{
    node *v = (node *)calloc(1, sizeof(node));
    v->val = malloc(data_size);
    memcpy(v->val, x, data_size);
    v->next = NULL;
    if(!s->begain) {
        s->size = 1;
        s->begain = v;
       
    } else {
        node *t = s->begain;
        node *p = NULL;
        char *insertv = (char*)v->val;
        while(t) {
            char *curr = (char *)t->val;
            int countequal = 0;
            for(int i=0; i<data_size; ++i) 
                countequal += (curr[i] == insertv[i]);
            if(countequal == data_size)
                return;
            p = t;
            t = t->next;
        }
        p->next = v;
        ++s->size;
    }
}

void set_free(set *s) 
{
    node *t = s->begain;
    node *x = t;
    while(t) {
        x = t->next;
        free(t->val);
        free(t);
        t = x;
    }
    s->size = 0;
}

cal24.h

#ifndef __CAL24_H__
#define __CAL24_H__

#include "math.h"
#include "set.h"

#ifdef __cplusplus
extern "C" {
#endif
enum oper {add, sub, mul, _div};

void get_number_list(set *s, float a, float b, float c ,float d);
int cal24(set *s);

#ifdef __cplusplus
}
#endif
#endif

cal24.c

#include "cal24.h"

const char operc[5] = {'+', '-', '*', '/'};
int num = 0;

float oper_cal(float x, float y, enum oper c)
{
    float res = 0;
    switch (c) {
        case add: res = x + y; break;
        case sub: res = x - y; break;
        case mul: res = x * y; break;
        case _div: res = x / (y != 0 ? y : 0.01); break; 
    };
    return res;
}

void bracket_cal(float a, float b, float c, float d, enum oper *cal) 
{
    float y = oper_cal(oper_cal(oper_cal(a, b, cal[0]), c, cal[1]), d, cal[2]);
    if((fabs(y - 24.0) < 0.01)) {
        ++num;
        printf("((%.0f %c %.0f) %c %.0f) %c %.0f = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
    }
    y = oper_cal(oper_cal(a, b, cal[0]), oper_cal(c, d, cal[2]), cal[1]);
    if((fabs(y - 24.0) < 0.01)) {
        ++num;
        printf("(%.0f %c %.0f) %c (%.0f %c %.0f) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
    }
    y = oper_cal(oper_cal(a, oper_cal(b, c, cal[1]), cal[0]), d, cal[2]);
    if((fabs(y - 24.0) < 0.01)) {
        ++num;
        printf("(%.0f %c (%.0f %c %.0f)) %c %.0f = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
    }
    y = oper_cal(a, oper_cal(oper_cal(b, c, cal[1]), d, cal[2]), cal[0]);
    if((fabs(y - 24.0) < 0.01)) {
        ++num;
        printf("%.0f %c ((%.0f %c %.0f) %c %.0f) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
    }
    y = oper_cal(a, oper_cal(b, oper_cal(c, d, cal[2]), cal[1]), cal[0]);
    if((fabs(y - 24.0) < 0.01)) {
        ++num;
        printf("%.0f %c (%.0f %c (%.0f %c %.0f)) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
    }
}

int cal24(set *s)
{
    float a,b,c,d;
    float data[4];
    enum oper cal[3] = {add, add, add};
    node *t = s->begain;
    printf("data has %d group(s) total\n", s->size);
    while(t) {
        memcpy(data, t->val, 4*sizeof(float));
        a = data[0];
        b = data[1];
        c = data[2];
        d = data[3];
        for(enum oper c1 = add; c1 <= _div; ++c1) {
            cal[0] = c1;
            for(enum oper c2 = add; c2 <= _div; ++c2) {
                cal[1] = c2;
                for(enum oper c3 = add; c3 <= _div; ++c3) {
                    cal[2] = c3;
                    bracket_cal(a, b, c, d, cal);
                }
            }
        }      
        t = t->next;
    }
    return num;
}

void  get_number_list(set *s, float a, float b, float c ,float d)
{
    float nums[4] = {a, b, c, d};
    float t1, t2, t3, t4;
    
    for(int i=0; i<4; ++i) {
        t1 = nums[i];
        for(int j=0; j<4; ++j) {
            if(j != i) {
                t2 = nums[j];
                for(int k=0; k<4; ++k) {
                    if((k != i) && (k != j)) {
                        t3 = nums[k];
                        for(int r=0; r<4; ++r) {
                            if((r!=i) && (r !=j) &&(r !=k)) {
                                t4 = nums[r];
                                float insert[4] = {t1, t2, t3, t4};
                                set_insert(s, (void*)insert, 4*sizeof(float));
                            }
                        }
                    }
                }   
            }
        }
    }
}

main.c

#include "cal24.h"
#include "stdio.h"
#define OPER(x,y,op) x op y

int main(void *arg)
{
    float a, b, c, d;
    set *s = (set *)calloc(1, sizeof(set));
    s->size = 0;
    s->begain = NULL;
    
    printf("input 1st numbers:");
    scanf("%f", &a);
    printf("input 2nd numbers:");
    scanf("%f", &b);
    printf("input 3th numbers:");
    scanf("%f", &c);
    printf("input 4th numbers:");
    scanf("%f", &d);
    
    get_number_list(s, a, b, c, d);
    int num = cal24(s);
    printf("input numbers are %.0f, %.0f, %.0f, %.0f\n", a, b, c, d);
    printf("There are %d calculation methods", num);
    set_free(s);
    free(s);
    return 0;
}

CMakeLists.txt

project(test)
cmake_minimum_required(VERSION 3.24)

aux_source_directory(cal24 APP_SRC)
include_directories(cal24)

add_executable(${PROJECT_NAME} main.c ${APP_SRC})

C++代码

cal24.hpp

#ifndef __CAL24_HPP__
#define __CAL24_HPP__
#include <math.h>
#include <stdio.h>
#include <array>
#include <set>

enum oper {add, sub, mul, _div, other};
const char operc[5] = {'+', '-', '*', '/'};

oper &operator++(oper &d) 
{
    return d = (d == other) ? oper::add : oper(d+1);
}

static float oper_cal(float x, float y, enum oper c)
{
    float res = 0;
    switch (c) {
        case add: res = x + y; break;
        case sub: res = x - y; break;
        case mul: res = x * y; break;
        case _div: res = x / (y != 0 ? y : 0.01); break; 
    };
    return res;
}

class Cal24 {
    float a;
    float b;
    float c;
    float d;
    int num;
    std::set<std::array<float, 4>> data;

    void cal_numbers(const float &a, const float &b, const float &c, const float &d, enum oper *cal) 
    {
        float y = oper_cal(oper_cal(oper_cal(a, b, cal[0]), c, cal[1]), d, cal[2]);
        if((fabs(y - 24.0) < 0.01)) {
            ++num;
            printf("((%.0f %c %.0f) %c %.0f) %c %.0f = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
        }
        y = oper_cal(oper_cal(a, b, cal[0]), oper_cal(c, d, cal[2]), cal[1]);
        if((fabs(y - 24.0) < 0.01)) {
            ++num;
            printf("(%.0f %c %.0f) %c (%.0f %c %.0f) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
        }
        y = oper_cal(oper_cal(a, oper_cal(b, c, cal[1]), cal[0]), d, cal[2]);
        if((fabs(y - 24.0) < 0.01)) {
            ++num;
            printf("(%.0f %c (%.0f %c %.0f)) %c %.0f = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
        }
        y = oper_cal(a, oper_cal(oper_cal(b, c, cal[1]), d, cal[2]), cal[0]);
        if((fabs(y - 24.0) < 0.01)) {
            ++num;
            printf("%.0f %c ((%.0f %c %.0f) %c %.0f) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
        }
        y = oper_cal(a, oper_cal(b, oper_cal(c, d, cal[2]), cal[1]), cal[0]);
        if((fabs(y - 24.0) < 0.01)) {
            ++num;
            printf("%.0f %c (%.0f %c (%.0f %c %.0f)) = 24\n",a, operc[cal[0]], b, operc[cal[1]], c, operc[cal[2]], d);
        }
    }

    void cal24(const float &a, const float &b, const float &c, const float &d)
    {
        oper cal[3] = {add, add, add};
        for(oper c1 = add; c1 <= _div; ++c1) {
            cal[0] = (oper)c1;
            for(oper c2 = add; c2 <= _div; ++c2) {
                cal[1] = (oper)c2;
                for(oper c3 = add; c3 <= _div; ++c3) {
                    cal[2] = (oper)c3;
                    cal_numbers(a, b, c, d, cal);
                }
            }
        }
    }
    void init_set()
    {
        num = 0;
        data.swap(std::set<std::array<float, 4>>());
        std::array<float, 4> input({a, b, c, d});
        float t1 = 0., t2 = 0., t3 = 0., t4 = 0.;
        for(int i=0; i<4; ++i) {
            t1 = input[i];
            for(int j=0; j<4; ++j) {
                if(j != i) {
                    t2 = input[j];
                    for(int k=0; k<4; ++k) {
                        if((k != i) && (k != j)) {
                            t3 = input[k];
                            for(int r=0; r<4; ++r) {
                                if((r!=i) && (r !=j) &&(r !=k)) {
                                    t4 = input[r];
                                    std::array<float, 4> tmp({t1, t2, t3, t4});
                                    data.insert(tmp);
                                }
                            }
                        }
                    }   
                }
            }
        }
    }

public:
    Cal24():a(0), b(0), c(0), d(0), num(0), data(){}
    ~Cal24() 
    {
        num = 0;
        data.swap(std::set<std::array<float, 4>>());
        //data.clear();
    }
    void get_numbers(const float &x, const float &y, const float &z, const float &w) 
    {
        a = x;
        b = y;
        c = z;
        d = w;
        init_set();
    }
    void execute()
    {
        for(auto i = data.begin(); i != data.end(); ++i) {
            float x = (*i)[0];
            float y = (*i)[1];
            float w = (*i)[2];
            float z = (*i)[3];
            cal24(x, y, w, z);
        }
        printf("input numbers are %.0f, %.0f, %.0f, %.0f\n", a, b, c, d);
        printf("There are %d calculation methods", num);
    }
};

#endif

main.cpp

#include <iostream>
#include "cal24.hpp"

int main()
{
	float a, b, c, d;
	std::cout<<"input number 1:";
	std::cin >>a;
	std::cout<<"input number 2:";
	std::cin >>b;
	std::cout<<"input number 3:";
	std::cin >>c;
	std::cout<<"input number 4:";
	std::cin >>d;
    Cal24 e;
    e.get_numbers(a,b,c,d);
    e.execute();
    return 0;
}

CMakeLists.txt

project(test)
cmake_minimum_required(VERSION 3.24)

aux_source_directory(cal24 APP_SRC)
include_directories(cal24)

add_executable(${PROJECT_NAME} main.c ${APP_SRC})
青冥浩荡不见底
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
24点游戏C++实现(包括计算器)
03-21
用C++完成24点游戏，其中包括后缀表达式的计算器，算法使用回溯法，并支持玩家信息存储
【2017CS231n】第十一讲：图像分割、定位、识别
热门推荐
poulang5786的博客
06-13 1万+
一.语义分割二.图像分类和定位三.对象识别
C++/Qt 计算24点
读书笔记
09-13 2196
C++/Qt 计算24点 ​ 游戏的算法可描述如下：4个1-10的数字，用加、减、乘、除和括号把数子算成24，每个数字都必须使用到，且只能用一次。 ​ 用C++写会更加的方便： ​ 在这本书中要求了表达式中数字的顺序不能改变，所以在7.7节 中提供的算法不具有普遍适应性，但是算法的思路还是很简单并且清晰。不需要多动脑袋。在他的基础上，可以轻易的扩展成一般的算法。 一些比较难的24点计算 1 3 9 10 1 4 5 6 1 5 5 5 2 7 10 10 3 3 7 7 3 3
C++程序计算24点
gxgdcyy的博客
02-05 1014
本文用C++编写了一个24点程序，对于能算出24点的，输出一种计算表达式，如不能算也说明。
银行家算法课程设计（附源代码）
振华OPPO的博客世界
03-26 1万+
死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验提供了一个系统动态分配资源的简单模拟程序，用于了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生。 Request i 是进程Pi 的请求向量。Request i（j）=k表示进程Pi请求分配Rj类资源k个。当Pi发出资源请求后，系统按下述步骤进行检查： 1．如果Request i≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。 2．如果Request i≤Available，则转向步骤3；否则，表示
咏南CS插件开发框架也可BS方式部署
weixin_30346033的博客
12-31 80
在几分钟的时间内，CS客户端也可以BS方式部署。 转载于:https://www.cnblogs.com/hnxxcxg/p/5091006.html
C++ 实现计算24点
落叶秋风早的博客
02-17 1万+
原理 暴力枚举所有的情况，运算符号4个，加减乘除 + - * / ，整数数字4个。所需要枚举的次数： 数字顺序：4个数的全排列，4! = 24。 运算符号：4个数需要3个符号，每个可选4种，43 = 64。 加括号方式：((AB)C)D、(A(BC))D、(AB)(CD)、A((BC)D)、A(B(CD))，共5种。 枚举次数 24*64*5 实现细节 全排列枚举由库函数 next_perm...
【C++】计算二十四点
weixin_43669259的博客
11-30 694
输入：只有一行，四个1到9之间的自然数。输出：1、如果有解的话，输出计算式子。2、如果没有解则输出“No answer!
C++_24点运算_华为上机笔试
qq_35423344的博客
03-04 657
题目描述 计算24点是一种扑克牌益智游戏，随机抽出4张扑克牌，通过加(+)，减(-)，乘(*), 除(/)四种运算法则计算得到整数24，本问题中，扑克牌通过如下字符或者字符串表示，其中，小写joker表示小王，大写JOKER表示大王： 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER 本程序要求实现：输入4张牌，输出一个算式，算式的结果为24点。 /////////...
蓝桥杯 试题 算法训练 24点 C++ 详解
Lyz_ID的博客
04-06 5079
问题描述： 　　24点游戏是一个非常有意思的游戏，很流行，玩法很简单：给你4张牌，每张牌上有数字（其中A代表1，J代表11，Q代表12，K代表13），你可以利用数学中的加、减、乘、除以及括号想办法得到24，例如： 　　((A*K)-J)*Q等价于((1*13)-11)*12=24 　　加减乘不用多说了，但除法必须满足能整除才能除！这样有一些是得不到24点的，所以这里只要求求出不超过24的最大值。 输入格式： 　　输入第一行N(1<=N<=5)表示有N组测试数据。每组测试数据输入4行，.
【C++】24点游戏
好好学习天天向上✿✿ヽ(°▽°)ノ✿
04-10 1146
提前bb：采用的ide是vc++ 6.0 ，并且是通过24点游戏.cpp包含Judge.h、compute.h、menu.h3个文件 一、题目分析 24点游戏是经典的纸牌益智游戏。 游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决2...
24点计算器(任意4个数计算24点)
04-03
基于STL的可以计算任意4个数如何算24点，原创源码，算法清晰标准，通用。
2048小游戏C/C++实现
06-04
2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 2048小游戏 ...
C/C++实现推箱子小游戏
05-28
C/C++实现推箱子小游戏推箱子小游戏，用菜单选择某一关卡，读取对应关卡的数据文件，并在屏幕上用cmd为图形方式显示出来（详细要求见里面的pdf）
C/C++ 实现贪吃蛇
11-28
贪吃蛇游戏是一款经典的益智游戏，有PC和手机等多平台版本。既简单又耐玩。该游戏通过控制蛇头方向吃蛋，从而使得蛇变得越来越长。用C/C++实现简单贪吃蛇游戏
利用C/C++实现较完整贪吃蛇游戏
08-27
主要为大家详细介绍了利用C/C++实现较完整贪吃蛇游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C/C++实现投骰子游戏
12-16
我们将要模拟一个非常流行的游戏——掷骰子。 骰子的形式多种多样， 最普遍的是使用两个6面骰子。在一些冒险游戏中，会使用5种骰子：4面、6 面、8面、12面和20面。聪明的古希腊人证明了只有5种正多面体，它们的所 有...
【C】 初识C语言
最新发布
努力学习C/C++
04-21 757
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
基于C/C++的人工智能小项目
03-29
以下是一个基于C/C++的人工智能小项目： 项目名称：井字棋人工智能 项目描述：实现一个简单的井字棋游戏，其中包括一个基于MiniMax算法的人工智能玩家。 项目实现： 1. 实现井字棋游戏的基本逻辑，包括棋盘的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值