#include&cstdio&
#include&iostream&
#include &cmath&
unsigned long int xx[1001];
int f1(int a, int b, int c, int d)
char s1,s2,s3;
for (int j = 1; j &= 4; j++)
for (int k = 1; k &= 4; k++)
for (int l = 1; l &= 4; l++)
switch (j)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%b)
sum = 9999;
switch (k)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%c)
sum = 9999;
switch (l)
case 1:sum +=
case 2:sum -=
case 3:sum *=
if (sum%d)
sum = 9999;
switch (j)
case 1:s1='+';
case 2:s1='-';
case 3:s1='*';
case 4:s1='/';
switch (k)
case 1:s2='+';
case 2:s2='-';
case 3:s2='*';
case 4:s2='/';
switch (l)
case 1:s3='+';
case 2:s3='-';
case 3:s3='*';
case 4:s3='/';
if (sum == 24)
xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
printf("((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
for (int i=1;i&=x;i++)
if ((a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l)==xx[i])
if (pd==0)
xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
printf("((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
int f2(int a, int b, int c, int d)
int sum = 0;
sum = f1(a, b, c, d) + f1(a, b, d, c) + f1(a, c, b, d) + f1(a, c, d, b) + f1(a, d, b, c) + f1(a, d, c, b);
if (sum != 0)
int main()
int a, b, c,
cin && a && b && c &&
sum = f2(a, b, c, d) + f2(b, a, c, d) + f2(c, a, b, d) + f2(d, a, b, c);
if (sum == 0)
cout && 'N' &&
bool RecursiveCalc(double *pArray, int nCount)
bool bRet =
if (1 == nCount)
if (fabs(pArray[0] - 24.0) & 0.0001)
g_Total++;
Output(pArray[0]);
for (int i = 0; i & nC i++)
for (int j = 0; j & nC j++)
if (j == i)
double f1 = pArray[i];
double f2 = pArray[j];
char *p = g_
for (int nop = 1; nop &= 4; nop++, p++)
if ('/' == *p && fabs(f2) & 0.0001)
double f = Operation(f1, f2, *p);
double *pnew = new double[nCount-1];
if (!pnew)
for (int m = 1, n = 0; m & nCount-1; m++)
while (n == i || n == j)
pnew[m] = pArray[n++];
bRet |= RecursiveCalc(pnew, nCount-1);
g_n1 -= 2;
if (g_bOnlyGetOne && bRet)
递归方式的次数分析
在不考虑加法和乘法的交换律的情况下，对于给定的4个数字的递归算法有以下排列：
4个数中取2个数的排列
12种 *4种运算符 = 48种
3个数中取2个数的排列
*4种运算符 = 24种
2个数中取2个数的排列
*4种运算符 = 8种
所以共有48*24*8种 = 9216种情况
【思路三】
后缀表达式方法
后缀表达式又称为逆波兰表达式，是一种把运算符放在要运算的两个数值后面的一种表示方法，后缀表达式的好处是可以不用括号。
例如对于（1-2）/(3-4)这样的表达式，后缀表示法为：12-34-/，在解释后缀表达式时，我们从左到右扫描，遇到运算符就往运算符的左边取最近的两个数值进行运算，运算结束后将这个运算符和对应的两个运算数替换为运算结果，然后重复这个过程，直到算出最终结果。
例如对于3 ,6 5 - 8 + * 这个表达式，我们可以这样计算：
遇到数字先不管，遇到第一个符号是减号，往前找两个数，是6和5，所以就是6-5，结果=1。用1替换掉6 5 - 得到新的表达式：
3 1 8 + * 接下来是加号，1+8 = 9，表达式变为：3 9 *
最后的结果就是3*9 = 27。
而原来的表达式转换为我们平时看到的中缀表示法就是：3*（6-5+8），可以看出后缀表达式避免了括号。
关于这种表达式的更详细说明，读者可以搜索相关介绍。
将后缀表达式看成栈操作是很多教科书和文章中都提到的一种理解方式，其中向栈中加入数值时不进行任何处理，向栈中加入运算符则取栈顶的2个操作数和运算符进行运算，运算结果再放回栈中，所以每加入一个运算符，相当于栈中数值的数量会减少1，这一点从上面的图中也能看出来，每经过一个运算符，后面括号中的数值都比父节点小1。而每加入一个数值，后面括号中的数值都比父节点多1。
void SetNextSortPermutation(int *pIdx, int nLen)//调整到有序全排列的下一个排列
int nCurIdx = nLen-1;
int nFindIdx = nCurI
while (nCurIdx-1 &= 0 && pIdx[nCurIdx-1] & pIdx[nCurIdx])
nCurIdx--;
if (nCurIdx-1 & 0)
while (pIdx[nFindIdx] & pIdx[nCurIdx-1])
nFindIdx--;
int tmp = pIdx[nCurIdx-1];
pIdx[nCurIdx-1] = pIdx[nFindIdx];
pIdx[nFindIdx] =
for (int i = nCurIdx, j = nLen-1; i & i++, j--)
tmp = pIdx[i];
pIdx[i] = pIdx[j];
调整到运算符的下一个排列的算法类似四则运算中的进位处理，我们定义运算符的顺序是+-*/。则+++的下一个排列是++-，只需要将最后一个符号（+1）变成下一个符号，如果符号越界了，比如++/，最后一个符号是除法，加1，就需要回到加号，同时对前面的符号进行进位，在进位的过程中可能产生循环进位，所以要循环处理。++/（加加除）的下一个排列是+-+，+//（加除除）的下一个排列是-++（减加加）。对应的代码如下：void SetNextOpComb(int *nOp, int nLen)//调整到运算符组合的下一个组合，类似运算中的进位处理
int nCurIdx = nLen-1;
while (nCurIdx &= 0 && 4 == ++nOp[nCurIdx])
nOp[nCurIdx] = 0;
nCurIdx--;
具体的模拟栈操作中，我定义了一个结点结构表示数值或者符号：struct Node
在实际的代码中使用list，只操作list的尾部来模拟栈。代码如下：bool CalcStack(Node *node_all, int nLen)
std::list&Node&
char output[200] = {0};
char tmp[30] = {0};
for (int i = 0; i & nL i++)
if (0 == node_all[i].nType)
lst.push_back(node_all[i]);
sprintf_s(tmp, 30, "%2d ", (int)node_all[i].d);
strcat_s(output, 200, tmp);
else if(1 == node_all[i].nType)
sprintf_s(tmp, 30, "%c ", g_op[node_all[i].op]);
strcat_s(output, 200, tmp);
Node f2 = lst.back();
lst.pop_back();
Node f1 = lst.back();
lst.pop_back();
if (abs(f2.d) & 0.0001 && 3 == node_all[i].op)
node.nType = 0;
node.d = Operation(f1.d, f2.d, g_op[node_all[i].op]);
lst.push_back(node);
assert(0);
double f = lst.back().d;
if (abs(f-24.0) & 0.0001)
g_Total++;
printf("%s=%d\r\n", output, (int)f);
后缀表达式方法共有5种合法的后缀表达式,假设abcd为4个数，+代表符号
第一种: abcd+++
第二种: abc+d++
第三种: ab+cd++
第四种: abc++d+
第五种: ab+c+d+
对于每种情况，4个数字的全排列=24，3个符号的可能性是4*4*4，所以每种情况有24*64=1536种
5种情况 共1536*5 = 7680 种排列
虽然从数据比较上来看，后缀表达式方式的情况比递归法的少，但由于我在代码中用到了list来模拟栈，所以实际代码运行的效率，递归法反而比后缀表达式方法更快，消耗的时间大约只有后缀表达式方法的1/10。也就是低一个数量级。
【题解小结】
相对于直接玩扑克牌软件形式的计算24点游戏，有的软件对每道题目仅提供一个答案，而不管实际的解法有多少种。而有的版本刚好相反，提供了答案的所有排列方式。这意味着，对于1、2、3、4这四个数，尽管只有1×2×3×4一种解法，而列出的答案包含4×3×2×1、2×1×4×3等多达24种！
一方面，如果有多种计算方式，我们应该提供所有答案，而不仅是其中一个答案；另一方面，我们应该避免重复提供相同答案的不同形式。给出所有答案是比较容易的，这里我们只讨论如何避免重复提供相同答案的不同形式。比如1、1、3、8这四个数，1×1×3×8与8×3×1×1应该等效的，答案中只需提供其中一个。那么如何认定两个式子是等效的呢？
c++简单24点游戏
c++简单24点游戏
C++实现24点游戏算法
**更新更新内容：
算法本身并没问题，些许小地方有bug，已经修改。如果测试还有问题，请评论告知，非常感谢！！现已上传github：
这里写链接内容#include
24点问题（穷举法/C++）
算24点（point24）
【问题描述】
几十年前全世界就流行一种数字游戏，至今仍有人乐此不疲．在中国我们把这种游戏称为“算24点”。您作为游戏者将得到4个1~9之间的自然数作为操作数，...
C++实现24点游戏
(1)首先穷举的可行性问题。我把表达式如下分成三类
1、 无括号的简单表达式。
2、 有一个括号的简单表达式。
3、 有两个括号的较复4,杂表达式。
穷举的开始我对给出的...
C++ 英雄联盟挑战赛 24点游戏
“24点游戏是一种使用扑克牌来进行的益智类游戏，游戏内容是：从一副扑克牌中抽去大小王剩下52张，任意抽取4张牌，把牌面上的数（A代表1）运用加、减、乘、除和括号进行运算得出24。每张牌都必须使用一次，...
基于C++的&em&24点&/em&游戏实现:选项1:开始游戏 2:退出游戏。开始游戏后,a:进行计算。 b:查看答案提示。
&em&24点&/em&游戏,没有使用浮点运算。
给出4个正整数操作数，你的任务是使用运算符（+，-，*，/）和括号对
操作数进行计算，分析是否能得到24，每个操作数只能使用1次，运算符和
括号可以多次使用，注意所有的中间结果都是整数...
呵呵,用&em&C&/em&语言写的一个很简单的&em&24点&/em&求解程序,欢迎与我交流 综合评分:3 收藏...欧洲能源一哥照样用区块链玩转&em&2B&/em&的生意
未来3 年,什么样的技术人...
24点游戏算法 问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利
输入：4个1-10的数字。[数字允许重复，测试用例保证无异常数字]
输出： true or fa...
没有更多推荐了，有一种“24点”的扑克牌游戏规则是：任抽4张牌，用各张牌上的点数和加、减、乘、除、（可用括号）列一个算式，先得计算结果为“24”者获胜（J，Q，K分别为11，12，13，A表示1），小明，小红，小刚三人玩：（1）小刚抽到的牌为：方块2，梅花3，方块4，黑桃6；（2）小明抽到的牌为：梅花3，方块7，红心9，方块Q；（3）小红抽到的牌为：黑桃10，梅花8，红心8-学库宝有一种“24点”的扑克牌游戏规则是：任抽4张牌，用各张牌上的点数和加、减、乘、除、（可用括号）列一个算式，先得计算结果为“24”者获胜（J，Q，K分别为11，12，13，A表示1），小明，小红，小刚三人玩：（1）小刚抽到的牌为：方块2，梅花3，方块4，黑桃6；（2）小明抽到的牌为：梅花3，方块7，红心9，方块Q；（3）小红抽到的牌为：黑桃10，梅花8，红心8，黑桃3．他们三人都各自计算得到了“24”，请你把他们三人的算式分别写出来好吗（算式中只需写出数字，不需写出花色）例如：抽到的牌是梅花1，方块2，红心4，方块8；可列式（4-2+1）×8．（1）小刚：&&&&；（2）小明：&&&&；（3）小红：&&&&．有理数的混合运算四张扑克牌点数为78910的要怎样运算才能得到24_百度知道
四张扑克牌点数为78910的要怎样运算才能得到24
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
采纳数：140679
获赞数：2180651
﹙9×8﹚÷﹙10－7﹚=72÷3=24
可不可以讲解方法
8*9/（10-7）
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
下载作业帮安装包
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
下面四张扑克牌的数，有6、5、10、2四个数，通过怎样的计算使结果等于24？至少写出2种不同的综合算式
作业帮用户
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
【10-2】除以2乘6=24
你好！用2,5,6,10算24点，共有50种算法。﹙10×2﹚×﹙6÷5﹚10×[﹙6×2﹚÷5][﹙2÷5﹚×10]×62÷[﹙5÷6﹚÷10][6×﹙10÷5﹚]×26×[2÷﹙5÷10﹚]﹙6×10﹚÷﹙5÷2﹚10÷[﹙5÷2﹚÷6][﹙10÷5﹚×6]×2﹙2×10﹚×﹙6÷5﹚...
为您推荐：
扫描下载二维码和多少张牌没关系，等价于只有两张牌，拿出一张随机的给4个人中的一个，概率1/4，拿出第二章牌，再等概率的随机给牌，给到同一个人的概率1/4，因此是1/16。这里是指定的某一人拿到的概率，如果“同时被一个人拿到的概率”，则是4*1/16=1/4。
1/4, 假设红桃A给了某人, 黑桃A再给他的概率就是1/4。从组合的角度来看也是，将牌分为无序的四堆的组合数为A=C(13,52)*C(13,39)*C(13*26)*C(13,13),那么将红A黑A作为一张牌，其组合数为B=C(12,51)*C(13,39)*C(26,13)*C(13,13)，概率为B/A=1/4。
浏览: 86232 次
来自: 天津
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'