计算24点游戏c++

合集下载

C语言写的24点游戏

else
if((m%4)==0&&newp[j]%newp[q]==0&&c==3&&newp[q+1]%s2==0)
printf("%d%c((%d%c%d)%c%d)=%d\n",p[3],p1[2],p[0],p1[0],p[1],p1[1],p[2],s3);
}
}
}
}
}
}
}
}
for(c=0;c<4;c++)
{
switch(b[c])
{
case 1:s3=s2+newp[q+1];sign='+';break;
case 2:s3=s2-newp[q+1];sign='-';break;
int a[4],newp[4],b[4]={1,2,3,4};//a[4]数组存放随机生成的四个数
char p1[3],sign; //定义存储运算符的字符数组
printf("四个数是:");
for(i=0;i<4;i++)
{
a[i]=rand()%13+1; //获得随机数
printf("(%d%c%d)%c(%d%c%d)=%d\n",p[2],p1[2],p[3],p1[1],p[0],p1[0],p[1],s3);
else
printf("(%d%c%d)%c(%d%c%d)=%d\n",p[0],p1[0],p[1],p1[1],p[2],p1[2],p[3],s3);

24点游戏C++ 代码

print(out,obj.Sign[0]);
out<<"("<<obj.Q[1];
print(out,obj.Sign[1]);
out<<obj.Q[2]<<"))";
out<<obj.Q[3]<<"))";
break;
}
default:out<<"方法代码参数错误!!!";
}
out<<"="<<M;
{
Q[0]=a;
Q[1]=b;
Q[2]=c;
Q[3]=d;
method=m;
Sign[0]=s1;
Sign[1]=s2;
Sign[2]=s3;
}
ostream& operator<<(ostream& out,const Four &obj)
bool judge4(double a1,int b1,double a2,int b2,double a3,int b3,double a4);/*a1@((a2@a3)@a4)*/
bool judge5(double a1,int b1,double a2,int b2,double a3,int b3,double a4);/*a1@(a2@(a3@a4))*/
class Four
{
private:
int Sign[3];/*储存运算符*/
int Q[N2];/*储存原始顺序,即未排序前的顺序,是输出函数的依据*/

经典游戏--24点--c++代码实现和总体思路（简单暴力向）

经典游戏--24点--c++代码实现和总体思路（简单暴⼒向）24点 24点是⼀个⾮常经典的游戏，从扑克牌⾥抽4张牌，其中J=11，Q=12,K=13，然后经过+，-，*，/，（），的计算后，使得计算得值为24，例如抽到1,2,2,5四张牌，那么（1+5）*（2+2）=24；这就是可以凑成24点的⼀种情况，作为⼀个经典题⽬，在leetcode上也有对应的题⽬进⾏练习 PS　看见知乎⼤佬有⼀种必24点的算法，但是要⽤到阶乘和次⽅式⼦为（a0+b0+c0+d0）! =24⼀、总体思路 1.因为是简单暴⼒向的，所以我们的做法就是直接穷举出所有可能的情况，⾸先是考虑四个数a,b,c,d的排列情况如b,a,c,d等等，通过排列组合可以得到 4*3*2*1 = 24 种情况 2.然后考虑a,b,c,d中的三个运算符的情况设⼀个⾃定义的运算符为,可以是+,-,*,/中的任意⼀个则有 a b c$d 这个式⼦，同样，运算符的可能性有 3*4 = 12 种 3.最后考虑（）的情况，我们规定，每次⼀对（）只框住两个数，⽐如a+b+c+d =(((a+b)+c)+d) = ((r1+c)+d)=(r2+d)=r3（其中r1=a+b,r2=r1+c,r3=r2+d) （）的情况其实就是运算优先级的问题，⽆论运算符是什么，都⼀定是先运算括号⾥的内容所以我们可以穷举出情况第⼀种r1=a b,r2=r1c,r3=r2$d; 第⼆种r1=b c,r2=a r1,r3=r2$d; 第三种r1=b c,r2=r1d,r3=a$r2; 第四种r1=c d,r2=b r1,r3=a$r2; 第五种r1=a b,r2=c d,r3=r1$r2; 仔细观察不难发现，我们控制了运算符和数字的绝对顺序从左到右的顺序严格是a b c$d,不论任何情况都不会改变abcd的顺序，是因为我们在上⾯已经排出来了所有的24种情况，所以我们这就可以严格控制abcd的顺序了⼆、代码实现1 #include <iostream>2 #include <string>3using namespace std;4int mark_int[4] = { 1,2,3,4 };5string mark_char = "+-*/";6double cal(double a, int m, double b)7 {8switch (m)9 {10case1: return a + b;11case2: return a - b;12case3: return a * b;13case4: return a / b;14 }15 }1617bool cal1(double a, double b, double c, double d, int m1, int m2, int m3)18 {19double r1;20double r2;21double r3;22 r1 = cal(a, m1, b);25if (r3 == 24)26 {27 cout << "(((" << a << mark_char[m1 - 1] << b << ")" << mark_char[m2 - 1] << c << ")" << mark_char[m3 - 1] << d << ")" << endl;28return1;29 }30return0;31 }3233bool cal2(int a, int b, int c, int d, int m1, int m2, int m3)34 {35double r1;36double r2;37double r3;38 r1 = cal(b, m1, c);39 r2 = cal(a, m2, r1);40 r3 = cal(r2, m3, d);41if (r3 == 24)42 {43 cout << "((" << a << mark_char[m1 - 1] << "(" << b << mark_char[m2 - 1] << c << "))" << mark_char[m3 - 1] << d << ")" << endl;44return1;45 }46return0;47 }4849bool cal3(int a, int b, int c, int d, int m1, int m2, int m3)50 {51double r1;52double r2;53double r3;54 r1 = cal(b, m1, c);55 r2 = cal(r1, m2, d);56 r3 = cal(a, m3, r2);57if (r3 == 24)58 {59 cout << "(" << a << mark_char[m1 - 1] << "((" << b << mark_char[m2 - 1] << c << ")" << mark_char[m3 - 1] << d << "))" << endl;60return1;61 }62return0;63 }6465bool cal4(int a, int b, int c, int d, int m1, int m2, int m3)66 {67double r1;68double r2;69double r3;70 r1 = cal(c, m1, d);71 r2 = cal(b, m2, r1);72 r3 = cal(a, m3, r2);73if (r3 == 24)74 {75 cout << "(" << a << mark_char[m1 - 1] << "(" << b << mark_char[m2 - 1] << "(" << c << mark_char[m3 - 1] << d << ")))" << endl;76return1;77 }78return0;79 }8081bool cal5(int a, int b, int c, int d, int m1, int m2, int m3)82 {83double r1;84double r2;85double r3;86 r1 = cal(a, m1, b);87 r2 = cal(c, m3, d);88 r3 = cal(r1, m2, r2);89if (r3 == 24)90 {91 cout << "((" << a << mark_char[m1 - 1] << b << ")" << mark_char[m2 - 1] << "(" << c << mark_char[m3 - 1] << d << "))" << endl;92return1;93 }94return0;95 }969798bool all_cal(int a, int b, int c, int d)99 {100for (int i = 1; i <= 4; i++)101for (int j = 1; j <= 4; j++)102for (int k = 1; k <= 4; k++)103 {104if (cal1(a, b, c, d, i, j, k) == true || cal2(a, b, c, d, i, j, k) == true || cal3(a, b, c, d, i, j, k) == true || cal4(a, b, c, d, i, j, k) == true || cal5(a, b, c, d, i, j, k) == true) 105return1;106 }107return0;108 }110111bool judge(int a, int b, int c, int d)112 {113int all[24][4] = {114 {a,b,c,d},{a,b,d,c},{a,c,b,d},{a,c,d,b},{a,d,b,c},{a,d,c,b},115 {b,a,c,d},{b,a,d,c},{b,c,a,d},{b,c,d,a},{b,d,a,c},{b,d,c,a},116 {c,a,b,d},{c,a,d,b},{c,b,a,d},{c,b,d,a},{c,d,a,b},{c,d,b,a},117 {d,a,b,d},{d,a,d,b},{d,b,a,c},{d,b,c,a},{d,c,a,b},{d,c,b,a},118 };119for (int i = 0; i < 24; i++)120 {121if (all_cal(all[i][0], all[i][1], all[i][2], all[i][3]))122return1;123 }124return0;125 }126127int main()128 {129int a, b, c, d;130 cin >> a >> b >> c >> d;131if (!judge(a, b, c, d))132 cout << "凑不成24点" << endl;133134 }三、代码解释先做⼀个计算两个数的函数，⽤数组int mark_int[4] = {1,2,3,4}的四个数表⽰+ - * /，string mark_char是⽤来最后显⽰的1int mark_int[4] = { 1,2,3,4 };2string mark_char = "+-*/";3double cal(double a, int m, double b)4 {5switch (m)//⽤switch来进⾏运算符的选择6 {7case1: return a + b;8case2: return a - b;9case3: return a * b;10case4: return a / b;11 }12 }我们在实现五种括号的函数，并且我们规定运算⼀定是 a m1 b m2 c m3 d(m1,m2,m3是三个运算符的代号），意思就是abcd的从左到右顺序不乱，m1m2m3从左到右的顺序也不会乱，⽐较粗暴的理解就是ab之间⼀定是m1，bc之间⼀定是m2，cd之间⼀定其实m3，然后如果成功返回运算的过程和true，否则返回false1bool cal1(double a, double b, double c, double d, int m1, int m2, int m3)2 {3double r1;4double r2;5double r3;6 r1 = cal(a, m1, b);7 r2 = cal(r1, m2, c);8 r3 = cal(r2, m3, d);9if (r3 == 24)10 {11 cout << "(((" << a << mark_char[m1 - 1] << b << ")" << mark_char[m2 - 1] << c << ")" << mark_char[m3 - 1] << d << ")" << endl;12return1;13 }14return0;15 }//第⼀种r1=a$b,r2=r1$c,r3=r2$d;1617bool cal2(int a, int b, int c, int d, int m1, int m2, int m3)18 {19double r1;20double r2;21double r3;22 r1 = cal(b, m1, c);23 r2 = cal(a, m2, r1);24 r3 = cal(r2, m3, d);25if (r3 == 24)26 {27 cout << "((" << a << mark_char[m1 - 1] << "(" << b << mark_char[m2 - 1] << c << "))" << mark_char[m3 - 1] << d << ")" << endl;28return1;29 }30return0;31 }//第⼆种r1=b$c,r2=a$r1,r3=r2$d;33bool cal3(int a, int b, int c, int d, int m1, int m2, int m3)34 {35double r1;36double r2;37double r3;38 r1 = cal(b, m1, c);39 r2 = cal(r1, m2, d);40 r3 = cal(a, m3, r2);41if (r3 == 24)42 {43 cout << "(" << a << mark_char[m1 - 1] << "((" << b << mark_char[m2 - 1] << c << ")" << mark_char[m3 - 1] << d << "))" << endl;44return1;45 }46return0;47 }//第三种r1=b$c,r2=r1$d,r3=a$r2;4849bool cal4(int a, int b, int c, int d, int m1, int m2, int m3)50 {51double r1;52double r2;53double r3;54 r1 = cal(c, m1, d);55 r2 = cal(b, m2, r1);56 r3 = cal(a, m3, r2);57if (r3 == 24)58 {59 cout << "(" << a << mark_char[m1 - 1] << "(" << b << mark_char[m2 - 1] << "(" << c << mark_char[m3 - 1] << d << ")))" << endl;60return1;61 }62return0;63 }//第四种r1=c$d,r2=b$r1,r3=a$r2;6465bool cal5(int a, int b, int c, int d, int m1, int m2, int m3)66 {67double r1;68double r2;69double r3;70 r1 = cal(a, m1, b);71 r2 = cal(c, m3, d);72 r3 = cal(r1, m2, r2);73if (r3 == 24)74 {75 cout << "((" << a << mark_char[m1 - 1] << b << ")" << mark_char[m2 - 1] << "(" << c << mark_char[m3 - 1] << d << "))" << endl;76return1;77 }78return0;79 }//第五种r1=a$b,r2=c$d,r3=r1$r2;接下来是12种的符号的排列情况，如果有⼀种括号情况满⾜，我们就返回true，否则返回false1bool all_cal(int a, int b, int c, int d)2 {3for (int i = 1; i <= 4; i++)4for (int j = 1; j <= 4; j++)5for (int k = 1; k <= 4; k++)6 {7if (cal1(a, b, c, d, i, j, k) == true || cal2(a, b, c, d, i, j, k) == true || cal3(a, b, c, d, i, j, k) == true || cal4(a, b, c, d, i, j, k) == true || cal5(a, b, c, d, i, j, k) == true) 8return1;9 }10return0;11 }最后是在总判断函数中写⼊24种的abcd排列情况1bool judge(int a, int b, int c, int d)2 {3int all[24][4] = {4 {a,b,c,d},{a,b,d,c},{a,c,b,d},{a,c,d,b},{a,d,b,c},{a,d,c,b},5 {b,a,c,d},{b,a,d,c},{b,c,a,d},{b,c,d,a},{b,d,a,c},{b,d,c,a},6 {c,a,b,d},{c,a,d,b},{c,b,a,d},{c,b,d,a},{c,d,a,b},{c,d,b,a},7 {d,a,b,d},{d,a,d,b},{d,b,a,c},{d,b,c,a},{d,c,a,b},{d,c,b,a},8 };9for (int i = 0; i < 24; i++)10 {11if (all_cal(all[i][0], all[i][1], all[i][2], all[i][3]))12return1;13 }14return0;15 }主函数调⽤judge就完成整个算法了✿✿ヽ(°▽°)ノ✿1int main()4 cin >> a >> b >> c >> d;5if (!judge(a, b, c, d))6 cout << "凑不成24点" << endl;78 }失败的话会显⽰“凑不成24点”其实这个算法的话我写的可以说基本没有优化，就是枚举所有情况实现的，csdn上有⼤佬是有更好的思路的，这篇⽂章也是看了csdn的⼤佬的代码然后⾃⼰修修补补写出来的（我原来看的那篇有bug，⼤佬⾃⼰没发现好像。

24点游戏

“算24点”是一种数学游戏，正如象棋、围棋一样是一种人们喜闻乐见的娱乐活动。

它始于何年何月已无从考究，但它以自己独具的数学魅力和丰富的内涵正逐渐被越来越多的人们所接受。

这种游戏方式简单易学，能健脑益智，是一项极为有益的活动。

“算24点”的游戏内容如下：一副牌中抽去大小王剩下52张，（如果初练也可只用1～10这40张牌）任意抽取4张牌（称牌组），用加、减、乘、除（可加括号）把牌面上的数算成24。

每张牌必须用一次且只能用一次，如抽出的牌是3、8、8、9，那么算式为（9—8）×8×3或（9—8÷8）×3等。

“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧问题，不能瞎碰乱凑。

这里向大家介绍几种常用的、便于学习掌握的方法：1．利用3×8＝24、4×6＝24求解。

把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。

如3、3、6、10可组成（10—6÷3）×3＝24等。

又如2、3、3、7可组成（7＋3—2）×3＝24等。

实践证明，这种方法是利用率最大、命中率最高的一种方法。

2．利用0、11的运算特性求解。

如3、4、4、8可组成3×8＋4—4＝24等。

又如4、5、J、K可组成11×（5—4）＋13＝24等。

3．最为广泛的是以下七种解法（我们用a、b、c、d表示牌面上的四个数）①(a—b）×（c＋d）如（10—4）×（2＋2）＝24等。

②（a＋b）÷c×d 如（10＋2）÷2×4＝24等。

③（a－b÷c）×d 如（3—2÷2）×12＝24等。

④（a＋b－c）×d 如（9＋5—2）×2＝24等。

⑤a×b＋c—d 如11×3＋l—10＝24等。

⑥（a－b）×c＋d 如（4—l）×6＋6＝24等。

24点游戏求解算法

24点游戏求解算法24点游戏简介一副牌中抽去大小王，从剩下的52张中任意抽取4张牌，用加、减、乘、除和括号把牌面上的数算成24，每张牌都必须使用，且只能用一次。

举例如下：【1】 1、2、3、4，那么1x2x3x4 = 24，4/(1/(2x3)) = 24，(1+2+3)x4 = 24等等。

【2】 4、6、8、10，那么(8-6)x10+4 = 24，(10-6)x4+8 = 24。

【3】 5、4、3、3，那么(5+4)x3-3 = 24，(5-3)x4x3 = 24，(3/3+5)x4 = 24等等。

求解算法用穷举法列出所有公式，如果结果等于24则输出。

那么如何排气呢？•经过观察，无论什么样的算式，不管运算符顺序怎么样，不管括号怎么加，都可以用如下方法穷举：【1】最开始是4个数，例如 6、7、8、9。

【2】从4个数中选择两个数，例如6和7。

4选2共6中选法。

【3】将两个数进行加减乘除运算，例如加法运算，6+7。

【4】运算结果13和剩余的2个数8和9组成3个数，13、8、9。

【5】从三个数中选择两个数，例如13和8。

3选2共3中选法。

【6】将两个数进行加减乘除运算，例如除法运算，13/8，或者8/13。

【7】运算结果和剩余的1个数组成2个数，例如13/8、9。

【8】最后一步加减乘除运算，例如乘法运算，13/8 x 9。

注意步骤【3】、【6】、【8】，因为加法和乘法符合交换律，不分顺序，所以一共6中四则运算。

对于除法，还要检查除数是否为0。

•例如上面提到的算式(1+2+3)x4 = 24，可以看做：【1】4个数1、2、3、4。

【2】选择1和2。

【3】选择加法。

【4】运算结果3和剩余2个数组成3个数 3、3、4。

【5】选择3和3。

【6】选择加法。

【7】运算结果6和剩余1个数组成2个数 6、4。

【8】选择乘法。

•再举一个例子，例如算式(11-3)/(5-7) = -4，可以看做：【1】4个数3、5、7、11。

c++24点游戏

c++24点游戏正文第一篇：c++24点游戏 c++24点游戏 #include iostream#include stringusing namespace std; //定义Stack类const maxsize=2022 enum Error_code { success, overflow, underflow };templateclass Stack {public:Stack();bool empty() const;bool full() const;int size() const;void clear();Error_code top(T &item) const;Error_code pop();Error_code push(const T &item);private:int count;T entry[maxsize];};templateStack::Stack() {count=0;}templatebool Stack::empty () const { return count==0;}templatebool Stack::full () const { return count==maxsize;}templateint Stack::size() const {return count;}templatevoid Stack::clear() {count=0;}templateError_code Stack::top (T &item) const { if (empty()) return underflow;item= entry[count-1];return success;}templateError_code Stack::pop () {if (empty()) return underflow;count--;return success;}templateError_code Stack::push (const T &item) {if (full()) return overflow;entry[count++]=item;return success;} Stack sign;Stack num;int set; // 判断程序中的异常，以便适时退出？//void process(char c) //计算两个数的 + - * / 运算// { int k=0;double a,b;sign.pop();if (num.top(b)==success) {num.pop();if (num.top(a)==success) {num.pop();k=1;}}if (k) {switch (c) {case '+': num.push(a+b); break; case '-': num.push(a-b); break; case '*': num.push(a*b); break; case '/':if (b==0) { set=4;num.push(-1);}elsenum.push(a/b);break;}}else {set=1;num.push(-1);}}void get_command(string &str) {coutstr;}double do_command(const string &str) {string s=;double outcome=-1;char c;for (int i=0;str[i]!='\0';i++){if (set!=0) break; //例外则停止运行while (1) { //分离数据与运算符if (str[i]='0' || str[i]=='.') {s+=str[i];i++;}else {if(s!=) {if (num.push(atof(s.c_str ()))==overflow)set=3;s=;break;}}char ch= str[i];switch (ch) { //处理运算的优先级，并注意例外抛出case '*':case '/':if (sign.top(c)==success)if(c=='*'||c=='/') process(c);if (sign.push(ch)==overflow)set=3;break;case '+':case '-':while (sign.top(c)==success) {if (c!='(') process(c);else break;if (sign.push(ch)==overflow) set=3;break;case '(':if (sign.push(ch)==overflow) set=3;break;case ')':while (sign.top(c)==success) { if (c!='(') process(c);else break;}sign.pop();break;case '=':while (sign.top(c)==success) { if (c!='(') process(c);else break;}break;default: set=2;break;}}if (num.size()==1 && sign.size()==0)num.top(outcome);else set=1;if (set==0) coutout; cout>jj;cout13 || a[i]!=int(a[i])) 在输出方面，运算结果等于 24就输出，利用调用的参数判断输出形式，有5种：(a+b)*(c+d)，a*(b*(c+d)) ，(a*(b+c))*d ，a*((b+c)*d) ，((a+b)*c)*d。

24点游戏规则和解题方法

24点游戏规则和解题方法“巧算24点”的游戏内容如下：一副牌中抽去大小王剩下52张，（如果初练也可只用1～10这40张牌）任意抽取4张牌（称牌组），用加、减、乘、除（可加括号）把牌面上的数算成24。

每张牌必须用一次且只能用一次，如抽出的牌是3、8、8、9，那么算式为（9—8）×8×3或3×8＋（9—8）或（9—8÷8）×3等。

“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧问题。

计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。

这里向大家介绍几种常用的、便于学习掌握的方法：1．利用3×8＝24、4×6＝24求解。

把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。

如3、3、6、10可组成（10—6÷3）×3＝24等。

又如2、3、3、7可组成（7＋3—2）×3＝24等。

实践证明，这种方法是利用率最大、命中率最高的一种方法。

2．利用0、11的运算特性求解。

如3、4、4、8可组成3×8＋4—4＝24等。

又如4、5、J、K可组成11×（5—4）＋13＝24等。

3．在有解的牌组中，用得最为广泛的是以下六种解法：（我们用a、b、c、d表示牌面上的四个数）①(a—b）×（c＋d）如（10—4）×（2＋2）＝24等。

②（a＋b）÷c×d如（10＋2）÷2×4＝24等。

③（a－b÷c）×d如（3—2÷2）×12＝24等。

④（a＋b－c）×d如（9＋5—2）×2＝24等。

⑤a×b＋c—d如11×3＋l—10＝24等。

⑥（a－b）×c＋d如（4—l）×6＋6＝24等。

游戏时，同学们不妨按照上述方法试一试。

需要说明的是：经计算机准确计算，一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点，如A、A、A、5。

“24点”的玩法

“24点”的玩法介绍“24点”数学游戏，它能把枯燥的基本数字计算变得趣味盎然，能大大提高计算能力和计算速度，使得思维灵活敏捷，是一种寓教于乐的的智力竞赛游戏。

游戏规则：给定4个自然数，通过加、减、乘、除四则运算，可以任意交换数的位置，可以随意的添加括号，但是每个数只能且必须用上一次，连起来组成一个计算式子，得数就是24。

“24点”数学游戏通常是用扑克牌进行的，此时，给定的4个数就被限定在1～13的范围内。

“24点”数学游戏可以是1个人玩，也可以是多人玩，比如4个人玩，把扑克牌中的大、小王拿掉，剩下的52张牌洗好后，每人分给13张，然后就是每人出一张牌，其中J、Q、K分别代表11、12、13，其他的牌就代表相应的1～10的自然数，谁先算出“24点”，谁就把这4张牌赢走，然后继续玩牌，最后谁的牌多谁就获胜。

当如果算不出“24点”的话，各自就拿回来自己的牌，然后洗牌，再次继续进行。

要想算得又快又准，这就要靠平时的基本功了，而要有好的过硬的基本功，就要多练习了，只有多练，才能算得好，而且这又能很好地锻炼自己的反应能力和敏捷的判断能力，对学好数学很有帮助。

而要玩好这个游戏，最重要的有2条：1、熟悉加法口诀和乘法口诀；2、利用括号，因为括号既能改变运算顺序，也可以改变运算符号。

下面通过一些例子来说明“24点”的一些基本算法。

例1．3、3、5、6解法一、根据3×8＝24，3已经有了，只要将其他3个数凑成8，有3×（5+6－3）＝24。

解法二、根据4×6＝24，6已经有了，只要将其他3个数凑成4，有6×（5－3÷3）＝24或者6×（3×3－5）＝24。

解法三、还是根据3×8＝24，要将2个数凑成3，要将另2个数凑成8有（6－3）×（5+3）＝24。

解法四、先把其中两个数相乘，积不足24的用另外2个数补足，有3×5＋3＋6＝24解法五、先把其中两个数相乘，积超过24的用另外2个数割去，有5×6－3－3＝24例2．2、2、4、8解法一、根据3×8＝24，8已经有了，只要将其他3个数凑成8，有8×【（2+4）÷2】＝24或者8×【4－2÷2】＝24。

24点游戏结果大全

24点游戏最绝的是：(0!+0!+0!+0!)!=24 ,0!是0的阶乘，值为1。

先考虑只用1--9,共9个数字的情况：4个都不一样ABCD： C（4，9）=9*8*7*6/（4*3*2*1）=126；4个都一样AAAA： C（1，9）=9；4个中有三个一样ABBB：P（2，9）=9*8=724个中有两对AABB： C（2，9）=9*8/2=364个中有一对AABC： C（3，9）*3=9*8*7/2=252所以共有：C(4,12)=126+9+72+36+252=495 404:91:(56)注：另解可用开平方√及次方，考虑另解的话，仅有35个无解（7%）一。

4个都一样AAAA：C（1，9）=9 4:5无解的有：1111，2222，7777，8888，9999另解(2)：8888：8+8+√8*8 9999Æ33333333: 3X3X3-3 4444: 4X4+4+4 5555: 5X5-5/5 6666: 6+6+6+6若考虑阶乘,1111 : (1+1+1+1)! 2222: (2+2+2-2)!二。

4个中有两对AABB： C（2，9）=9*8/2=36 24:12无解的有: 1122,1133,1177,4466,6677,778899AA除9955,9933外都无解.(9911,9922,9944,9966,9977,9988)另解(8):9911Æ3911 99AAÆ33AA 4466Æ2266 7788: 8x√(8+7/7)若考虑阶乘, 1122: (1-1+2+2)! 1133: (3+3-1-1)!AA55: 5X5-A/A1144: (1+1+4)X4 1166: (6-1-1)X6 1188:(1+1)x8+8 2233: (3+3)X2X22244:(2x4-2)x4 2266: (6+2)X6/2 2277:2x(7+7-2) 2288: 2X2X8-83344: 4x3+4X3 3366:3X(6/3+6) 3377:(3/7+3)x7 3388:8/(3-8/3)3399: 3X9-9/3 4477:(4-4/7)X7 4488: 4+4+8+8 6688:6x8/(8-6)三。

24点程序讲解

24点游戏的编程算法：1、问题描述给定4个整数（1-10之间的正整数），其中每个数字只能使用一次；任意使用+– * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。

这方面的程序很多，一般都是穷举求解。

本文介绍一种典型的算24点的程序算法面向过程的C实现。

2、问题分析及算法描述基本原理是穷举4个整数所有可能的表达式，然后对表达式求值。

表达式的定义： expression = (expression|number) operator (expression|number)因为能使用的4种运算符+ – * / 都是2元运算符，所以本文中只考虑2元运算符。

2元运算符接收两个参数，输出计算结果，输出的结果参与后续的计算。

由上所述，构造所有可能的表达式的算法如下：(1) 将4个整数放入数组中(2) 在数组中取两个数字的排列，共有 P(4,2) 种排列。

对每一个排列，(2.1) 对 +– * / 每一个运算符，(2.1.1) 根据此排列的两个数字和运算符，计算结果(2.1.2) 改数组：将此排列的两个数字从数组中去除掉，将 2.1.1 计算的结果放入数组中(2.1.3) 对新的数组，重复步骤 2(2.1.4) 恢复数组：将此排列的两个数字加入数组中，将 2.1.1 计算的结果从数组中去除掉可见这是一个递归过程。

步骤 2 就是递归函数。

当数组中只剩下一个数字的时候，这就是表达式的最终结果，此时递归结束。

在程序中，一定要注意递归的现场保护和恢复，也就是递归调用之前与之后，现场状态应该保持一致。

在上述算法中，递归现场就是指数组，2.1.2 改变数组以进行下一层递归调用，2.1.4 则恢复数组，以确保当前递归调用获得下一个正确的排列。

括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。

所以在以上算法中，无需考虑括号。

括号只是在输出时需加以考虑。

注意2.1输出的判定和四位数字的类型：在输出的时候对最后结果等于24的判别，因为考虑到有除法，有可能中途结果可能会出现不能整除的情况与小数，所以输出的四个数都设为float型，且输出判定的时候用近似判定法，而不直接写让最后结果等于24。

(终极版)《24点游戏全攻略》

24点游戏简介24点游戏是一个老少咸宜的益智数学游戏，可以训练人们的专注力、敏捷思维、数据思维、逆向思维、发散思维和归纳论证的思维．24点游戏是把4张扑克牌牌面的数字通过加减乘除（包括括号）进行四则运算，使计算结果等于24的一个棋牌数学休闲益智小游戏．这个小游戏能锻炼人的快速反应能力，除了平时的休闲消遣之外，还经常被很多老师用于数学课堂教学或是数学周的小比赛中，因为这能极大地调动学生多种感官的协调能力也非常利于培养学生的心算能力．总的来说24点算法不管是休闲娱乐还是被学校的老师用来用在教学中，都是非常值得玩的益智游戏，喜爱和追捧24点算法的牌友也举不胜举．健脑益智而且又能提升自己心算能力和快速反应能力的小游戏谁不喜欢玩呢？为什么要玩24点游戏？不少小学生家长来都能注意到这个现象——二年级学校要求5分钟完成40道口算题达标，三年级加入了100以内的混合运算，不知道为什么，这就变成孩子的痛苦的事情了．要么孩子总是磨磨蹭蹭的，在规定时间内根本完不成，要么是错误率很高．不少家长也很无奈，只好打印出更多口算题，让孩子反复练习，结果口算这件事情就变成一个应试的、机械的、难受的事情了．对于提升算术能力，要推荐一个压箱底的好办法：24点游戏，把枯燥的练习变成有游戏，让孩子的兴趣飞起来．“巧算24点”不仅能加强孩子的口算能力和反应能力，还能极大限度地调动眼、脑、手、口、耳多种感官的协调活动，且对于培养学生快捷的心算能力和反应能力很有帮助．经常玩24点游戏的好处有哪些？24点是一个益智的数学游戏，根据美国常青藤名校的研究，一些游戏手段比如24点游戏可以训练小朋友的专注力、敏捷思维、数据思维、逆向思维、创新思维等．初级的好处，是提高数学计算的能力，比如提高计算速度和反应能力，到了中后期，通过玩法的不断升级，可以实现提高数据思维、逆向思维等一些影响大脑思维的能力的训练．玩24点游戏还有一个好处，那就是——扩展思维的多样性．实际上，对于很多牌，算出24点的解法不只一个．对多种解法的探索有利于孩子全面熟练乘法口诀，培养发散思维和归纳论证的思维．24点算法游戏是怎么玩呢？这个游戏一般用到的道具是扑克牌．一副牌抽去大小王剩下52张，J、Q、K分别代表11、12、13（初练也可以把J、Q、K、大小王都拿去），剩下1～13这52张牌(A代表1)．任意抽取4张牌称为牌组，用加、减、乘、除(可加括号，高级玩家也可用乘方开方与阶乘运算)把牌面上的数算成24．每张牌必须用且只能用一次．例如抽出的牌是3、8、8、9，那么算式为(9-8)×8×3=24．谁先算出来，四张牌就归谁，如果无解就各自收回自己的牌，哪一方把所有的牌都赢到手中，就获胜了．在实际游戏中，我们可以适当调整规则，取得了很好的效果．第一个变化是去掉了10，J，Q，K，这是在二年级阶段，孩子刚学完乘法口诀表，计算不了那么大的数，牌的点数范围可以和孩子的学习进程进行调整．第二个变化是把大小王加了回去，并且规定，大小王可以代表任何数．这样有大小王的牌局就一定有解，关键看谁算的更快，游戏意味更弄，小朋友很喜欢这个设置．第三个变化是允许三张牌成24点，这么做的主要考虑还是降低难度，为算术能力不足的小朋友准备的，另外确实有些四张牌的组合是无法通过四则运算得到24点的，加了这条规则可以使得游戏更流畅．第四个变化是每次5张牌算60点，“牌多数大”挑战性更大，适合有数学特长小朋友．24点游戏的技巧【技巧1】经典乘法组合3×8、4×6、12×2把牌面上的四个数想办法凑成3和8、4和6，再相乘求解．如3、3、6、10可组成(10-6÷3)×3=24等.又如2、3、3、7可组成(7+3-2)×3=24等.实践证明，这种方法是利用率最大、命中率最高的一种方法．【技巧2】利用0的运算特性如3、4、4、8可组成3×8+4-4=24等．又如4、5、J、K可组成11×(5-4)+13=24等．【技巧3】最常运用的6种公式(我们用a、b、c、d表示牌面上的四个数)①(a-b)×(c+d)例如：(10-4)×(2+2)=24．②(a+b)÷c×d例如：(10+2)÷2×4=24．③(a-b÷c)×d例如：(3-2÷2)×12=24．④(a+b-c)×d例如：(9+5-2)×2=24．⑤a×b+c-d 例如：11×3+1-10=24．⑥(a-b)×c+d例如：(4-1)×6+6=24．【技巧总结】充分了解了玩法规则后再来总结玩24点算法的技巧，玩了一段时间后我们会发现得出24的法方通常都是3×8、4×6、12×2、全部相加、30-6、15+9、19+5、18+6、21+3等等，如4张牌有一张3或者4或者6或者8的话，就要用另外三张快速数算出8或者6或者4或者3来，这样一相乘结果马上就出来了．如果没有就先记12×2或者30-6以及另外几种简单的组合，如果经常玩有牌感的话基本一眼就能看的出．还有一些小技巧也可以借鉴如巧妙利用0和1以及11的运算特性．比如题目3 8 2 2中，就可以用到0和1的技巧，3和8相乘即为24而两个2可以是1也可以是0，这里既用到了这两张牌也能保证24的计算结果．24点游戏一共有多少种情况？我们知道，24点游戏通常会伴随着4张扑克牌，也就是四张点数1~13的牌．通过排列组合的知识，我们能算出，4 个 1至13 的整数一共有C(16,4)＝1820 个不同的组合，再通过简单的编程穷举，可以知道一共有1362个组合是有解的，有解率为74.83%．（如果去掉J、Q、K三张牌，即4个1~10的整数，那么一共有715个组合，其中566个有解，有解率为79.16%．）传统纸牌玩法有哪些缺陷？如何克服？传统纸牌24点游戏至少有三处缺陷——其一，在全部的组合中，大约有四分之一牌组是无解的，但是哪些是无解的呢？家长通常不能很快判断，导致浪费了宝贵的亲子学习时间．其二，存在少数牌组解法很难以想到，实际就当作无解牌丢掉了，丢失了一次学习进步的机会．其三，如果家长都不能比孩子算的好，会不会有那么一丢丢的尴尬呢？针对以上三处缺陷，推荐使用本人精心制作《每天挑战3道24点游戏》系列题单——第一，本系列已经为您提前排除了所有无解的牌组，题单上的牌组全部都是能算出24的．第二，本系列根据牌组解法的难易程度详细划分出了9个星级，每张题单上还给出了完成三道题的参考时长（精确到百分之一秒），家长可带领从最简单的1星级开始挑战，当孩子实际用时稳定低于参考时长后，便可选择挑战更高难度的2星级、3星级题单．第三，每张题单都有参考答案，每道题都列出了所有可能的解法，一来家长可以提前看答案，在聪明的孩子面前挣回面子，二来家长可以带孩子探索某个牌组的多种解法，充分利用机会扩展孩子思维的多样性．24点游戏最难算的题目有多少？我们知道，大部分题目都是很简单的，即使是普通人，也花不了 5 秒钟，但也有一些比较难的题，普通人平均需要花超过 1 分钟的时间才能算出来．根据统计的结果，我们发现，对于90%的有解的题目，人们都能在20秒内解开（1227/1362），但是也有超过3%的题目（43/1362），人们平均要花超过1分钟，其中最难的4道题，人们平均要花超过3分钟！24点游戏的六类难题总结一、4 个数中存在 24 的约数，但实际上需要用分数 + 除法．举例：2 3 5 12二、4 个数存在 24 的约数，虽然没有用到小数或分数，但最后一步是除法举例：3 5 7 13三、4 个数存在 24 的约数，用到了小数或分数，但最后一步是乘法举例：2 5 5 10四、最后一步是减法举例：3 7 9 13五、虽然最后一步是乘以 24 的约数，但是在过程中用到了不常见的减法或除法举例：3 3 5 7六、最后一步是一个不常见的加法举例：2 9 13 13彩蛋1：四个0如何算24点？【方法1】【方法2】(0!+0!+0!+0!)!=(1+1+1+1)!=4!=24【方法3】00∶00（今天的零点就是昨天的24点）【方法4】（cos0+cos0+cos0+cos0）！=4!=24【方法5】ASCII(0)* ASCII(0)/ (ASCII(0)+ ASCII(0))=48*48/(48+48)=24 彩蛋2：任意四个数如何算24点？[(A’)!+(B’)!+(C’)!+(D’)!]!= (0!+0!+0!+0!)!=(1+1+1+1)!=4!=24 彩蛋3：四个π如何算24点？ (|cos π|+|cos π|+|cos π|+|cos π|)!=4!=24。

二十四点游戏规则

二十四点游戏规则二十四点，是一种基于纸牌的数学游戏，其目标是使用给定的四张纸牌来组合运算，使得最后的结果等于24、每张牌都可以使用一次，可以使用加、减、乘、除等运算符，但是最后的结果必须等于24、以下是详细的游戏规则。

材料和准备：1.一副扑克牌，除去大小王，共52张牌。

2.游戏过程中需要使用到纸和笔，以便记录参与者的回答。

游戏过程：1.将一副扑克牌洗混，并将牌堆整齐的放在桌子上，称为扑克牌堆。

2.从扑克牌堆中抽取四张牌，使得这四张牌对所有人可见。

除了大小王之外，所有的牌都有点数，点数为A的牌为1点，点数为J、Q、K的牌为11、12、13点，其他牌的点数与面值相同。

3.所有参与者要在规定的时间内，使用这四张牌进行运算，使最后的结果等于24、每张牌仅能使用一次，可以使用加、减、乘、除等运算符。

4.参与者可以自行选择运算的顺序，但是必须在规定的时间内给出答案。

5.如果一个参与者在规定时间内找到一个等于24的解答，可以立即宣布并胜利。

如果没有人找到解答，可以选择增加答题时间或重新抽取四张牌。

游戏规则的补充说明：1.设定规定的时间限制，以使游戏保持良好的节奏。

2.参与者可以在纸上进行计算，并将所有的计算步骤写下来，以此来防止错误运算或遗漏一些可能的解答。

3.如果有玩家找到了一个等于24的解答，但是其他人对这个解答持怀疑态度，可以要求出示计算步骤进行验证。

4.在游戏过程中，比赛组织者可以随意改变规定的时间限制、增加计分规则或者进行其他的游戏规则调整，以使游戏更加有趣。

5.如果有特别有悬疑性和争议性的解答出现，可以在游戏结束后进行讨论，并改进游戏规则以避免类似问题的发生。

游戏的目的：总结：二十四点游戏是一种基于纸牌的数学游戏，通过使用四张牌进行加减乘除等运算，目标是找到一个等于24的解答。

游戏过程中，参与者可以自行选择运算顺序，并在规定时间内给出答案。

这个游戏能够激发思维和培养数学能力，提高解决问题的能力和灵活性。

24点小游戏

“24”点小游戏
前些日子数学老师教我们学算“24”点，我觉得很有意思。

所以，一有时间就和爸爸妈妈比赛算“24”点。

算“24”其实也有小窍门：
第一步：想清楚得数为24的乘法口诀或加减法算式。

第二步：从给出的现有数字中找出可以组成24的相关数字：如：“3”、“8”、“4”、“6”、“2”、“12”等。

第三步：将其他数字通过运算，得出需要的数字，如：已有“3”，再通过计算得出“8”，然后3×8=24，或已有条件“9”，再将其他数字计算出“15”，然后9+15=24等等。

要将几个简单的数字算出“24”，有时也不止一种方法。

比如：3、4、4、6这四个数字，计算时，可以先用4-3得出1后乘4得4，4×6得出24，或者先用6-4得出2后再乘4得出8，8×3得24。

算“24”点真的很有意思！
二（1）班
杭音贝。

计算24点游戏c++

24点游戏软件的开发1 概述1.1 课程设计目的a、巩固并加深学生对C++语言程序设计知识的理解；b、培养学生面向对象的程序设计思想，使学生认识面向过程和面向对象两种设计方法的区别；c、进一步掌握和应用VC++ 6.0集成开发环境；d、提高运用C++语言解决实际问题的能力；e、初步掌握开发小型实用软件的基本方法，能独立设计、实现基本的MIS系统；f、掌握书写程序设计开发文档的能力（书写课程设计实验报告）。

1.2 课程设计内容课题名称：24点游戏软件的开发说明：24点游戏是一种常见的纸牌游戏说明要求：a）实现随机发牌；b）能进行结果验算；c）计分；d）难度设置。

2 系统需求分析2.1 系统目标24点游戏是个流行的数学运算游戏。

本次课程设计通过24点游戏来加深我们对对话框编程的认识和理解，并介绍Visual C++在数学计算方面的应用，以及在按钮上设置位图和设置计时器的方法。

24点扑克游戏的规则是：由系统发出4张扑克牌，要求用户利用扑克牌上显示的数字（JQKA算10），通过加减乘除运算得出24。

2.2 主体功能a.对游戏设计三个难易级别，分别为低级、中级和高级。

每次开始游戏前可以根据玩家的需要进行难度设置，如若不设置，系统默认难度级别为中级，设置完难度级别之后就可以开始游戏了，单击“发牌”按钮，桌面上出现四张翻开的扑克牌，与此同时，游戏开始计时，进度条开始前进。

b.在规定的时间内，玩家可以在“输入算式”的编辑框中输入自己想好的算式，然后点击“验算”按钮：如果输入的算式经运算后所的答案正确，则会在编辑框中显示“正确！”；如果输入的数字与给出的牌的数字不符或者符号不合法，则会弹出“内部错误！”的窗口；如果输入的数字与四张牌相符、字符亦合法但是答案不正确，则会在编辑框中显示“错误”；如果未输入任何的数字和算符，则会弹出“内部错误！”的窗口。

c.如果在规定的时间内，玩家没有点击验算按钮，则会弹出“内部错误”的窗口。

C语言版24点游戏

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<time.h>#include<windows.h>struct s_node{int date;struct s_node *next;};typedef struct s_node s_list;typedef s_list *link;link OPER=NULL;link OPND=NULL;char m;link creat(link stack) //创建空栈的函数{stack=(link)malloc(sizeof(s_list));if (!stack){printf("\nERROR");return NULL;}return stack;}link push(link stack,int value) //添加新的元素value为stack的栈顶元素{link newnode;newnode=(link)malloc(sizeof(s_list));if (!newnode){printf("\nERROR");return NULL;}newnode->date=value;newnode->next=stack;stack=newnode;return stack;}link pop(link stack) //栈顶出栈的函数,m表示出栈的栈顶元素{link top;if (stack!=NULL){top=stack;stack=stack->next;m=top->date;free(top);return stack;}elsem=-1;}int is_oper(char oper) //判断是否为算符的函数{switch (oper){case'+':case'-':case'*':case'/':case'(':case')':case'#':return 1;default:return 0;}}int compare(char q1,char q2) //比较算符优先程度的函数{if (q1=='+') //‘+’的比较{switch (q2){case '+':return 1;case '-':return 1;return 0;case '/':return 0;case '(':return 0;case ')':return 1;case '#':return 1;}}else if (q1=='-') //‘-’的比较{switch (q2){case '+':return 1;case '-':return 1;case '*':return 0;case '/':return 0;case '(':return 0;case ')':return 1;case '#':return 1;}}else if (q1=='*') //‘*’的比较{switch (q2){case '+':return 1;case '-':return 1;case '*':return 1;case '/':return 1;return 0;case ')':return 1;case '#':return 1;}}else if (q1=='/') //‘/’的比较{switch (q2){case '+':return 1;case '-':return 1;case '*':return 1;case '/':return 1;case '(':return 0;case ')':return 1;case '#':return 1;}}else if (q1=='(') //‘(’的比较{switch (q2){case '+':return 0;case '-':return 0;case '*':return 0;case '/':return 0;case '(':return 0;case ')':return 2;return -1;}}else if (q1==')') //‘)’的比较{switch (q2){case '+':return 1;case '-':return 1;case '*':return 1;case '/':return 1;case '(':return -1;case ')':return 1;case '#':return 1;}}else if (q1=='#') //‘#’的比较{switch (q2){case '+':return 0;case '-':return 0;case '*':return 0;case '/':return 0;case '(':return 0;case ')':return -1;case '#':return 2;}}}int operate(int p1,int p2,char q) //二元运算的函数，q代表运算符，p1为运算符的左边数值，p2为运算符的右边数值{int p;if (q=='+'){p=p1+p2;return p;}else if (q=='-'){p=p1-p2;return p;}else if (q=='*'){p=p1*p2;return p;}else if (q=='/'){p=p1/p2;return p;}}int main(){char c,e,u;int n,a,b,t,v;int i=0;int f1,f2,f3,f4,flag=0;int h[5]={0};OPER=creat(OPER);OPND=creat(OPND);while (1){OPER->date=0;OPND->date=0;printf("------------------------------------------------------------------------------\n\n\n");printf(" 24点游戏系统\n\n");printf(" 您得到的四个随机数\n\n");srand( (unsigned)time( NULL ) );f1=rand()%13+1;f2=rand()%13+1;f3=rand()%13+1;f4=rand()%13+1;printf(" 【%d】【%d】【%d】【%d】\n\n",f1,f2,f3,f4);printf(" 请输入表达式'#'号结束,无法解答请输入? 直接结束请输入* \n\n");printf("------------------------------------------------------------------------------\n\n\n");printf(" ");c=getchar();if (c=='?'){system("cls");getchar();continue;}else if (c=='*')break;while (OPER->date!='#'){if (flag==1)break;if (is_oper(c)){if (OPER->date==0) //判断OPER是否为空{OPER=push(OPER,c); //若为空则为第一次输入，进栈.c=getchar();continue;}else{n=compare(OPER->date,c);switch (n){case 0:{OPER=push(OPER,c);c=getchar();break;}case 1:{OPER=pop(OPER);e=m;OPND=pop(OPND);if((t!=f1)&&(t!=f2)&&(t!=f3)&&(t!=f4)&&(t!=h[0])&&(t!=h[1])&&(t!=h[2])&&(t!=h[3])&&(t!=h[4])& &(t!=h[5])){printf("\n\n-----------------------------没有使用给出的数字!-------------------------------\n\n");flag=1;}b=m;OPND=pop(OPND);if((t!=f1)&&(t!=f2)&&(t!=f3)&&(t!=f4)&&(t!=h[0])&&(t!=h[1])&&(t!=h[2])&&(t!=h[3])&&(t!=h[4])& &(t!=h[5])){printf("\n\n-----------------------------没有使用给出的数字!-------------------------------\n\n");flag=1;}a=m;t=operate(a,b,e);h[i]=t;i++;OPND=push(OPND,t);break;}case 2:{OPER=pop(OPER);c=getchar();break;}}}}else{OPND=push(OPND,c-48);c=getchar();if (is_oper(c))continue;else{OPND=pop(OPND);v=c-'0';t=m*10+v;if((t!=f1)&&(t!=f2)&&(t!=f3)&&(t!=f4)&&(t!=h[0])&&(t!=h[1])&&(t!=h[2])&&(t!=h[3])&&(t!=h[4])& &(t!=h[5])){printf("\n\n-----------------------------没有使用给出的数字!-------------------------------\n\n");flag=1;}OPND=push(OPND,t);h[i]=t;i++;c=getchar();continue;}}}if (OPND->date==24&&flag==0){printf("----------------------------------------------------------------------------\n\n\n");printf(" **【Congratulation!】** \n\n\n");printf("----------------------------------------------------------------------------\n\n\n");}else if (flag==0){printf("----------------------------------------------------------------------------\n\n\n");printf(" **【Incorrect!】** \n\n\n");printf("----------------------------------------------------------------------------\n\n\n");}system("pause");printf(" 是否继续游戏？y:继续.n:结束\n\n\n");flag=0;u=getchar();if (u=='n'){break;}else{c=getchar();system("cls");continue;}}printf("\n\n\n-----------------------------24点游戏系统-------------------------------\n\n\n");printf("\n\n\n **谢谢使用!**\n");system("pause");return 0;}。

C程序设计 24点小游戏

1设计内容有2、3、4、5、6、7、8、9、10、J、Q、K、A共13张牌，编一程序，判断对任意给定的4张牌，能否在进行加、减、乘、除运算后，其运算结果等于24。

其中J按11计算，Q按12计算，K按13计算，A按1计算。

如果能得到结果24，则输出可得到该结果的计算表达式。

若输入数据符合要求，且经过加、减、乘、除运算后，运行结果能得到24，如输入5，5，5，1，则显示可得到该结果的计算表达式，如5*(5-(1/5))。

若输入数据小于1或者大于13或者不是整数时，提示输入错误。

若输入不能运算出24的数据，如1，1，1，1，则显示经过加、减、乘、除运算后，运行结果不能得到24。

2程序设计2.1存储结构设计由于要储存的数据不多，主要是储存所输入的4个整数，所以采用一维数组(a[4])储存。

而计算过程会出现小数，所以数据类型采用浮点型(float)。

2．2主要程序设计程序采用穷举法，对输入的4个数进行排列，有 4！=24种。

用for来循环，if来判断，算法如下。

for (i=0;i<4;i++)for (j=0;j<4;j++)if (j!=i)for (k=0;k<4;k++)if (k!=j && k!=i)for (l=0;l<4;l++)if (l!=i && l!=j && l!=k){ calculate(a[i],a[j],a[k],a[l]);}用if来判断括号的类型，然后作出不同顺序的运算。

括号有两对，主要有两种类型：一种是( ) ( )型，如(a+b)*(c+d) ；另一种是( ( ) )型，继续细分又有4种类型，如下a*(b*(c+d)) ，(a*(b+c))*d ，a*((b+c)*d) ，((a+b)*c)*d。

算法如下if ((!(i==3 && b==0)) && (!(j==3 && c==0)) && (!(k==3 && d==0))) {sum1=arithmetic(i,a,b);sum2=arithmetic(j,sum1,c);sum3=arithmetic(k,sum2,d);}if (k==2){sum1=arithmetic(i,a,b);sum2=arithmetic(j,c,d);sum3=sum1*sum2;}if (k==3){sum1=arithmetic(i,a,b);sum2=arithmetic(j,c,d);if(sum2!=0){sum3=sum1/sum2;}}在输入方面，按要求，数据类型是 1 至13 的整数，符合则进行运算，不符合则重新输入。

C语言计算24点(原创完美版)

#include<stdio.h>char cha[4]="+-*/",c=0;float fun(float a1,float a2,int b){switch(b) //选择四则运算{case 0:return (a1+a2);case 1:return (a1-a2);case 2:return (a1*a2);case 3:return (a1/a2);}}void algebra(int x[4])//计算满足要求的表达式{int i,j,k;float temp1,temp2,temp3;for(i=0;i<4;i++)for(j=0;j<4;j++)for(k=0;k<4;k++){temp1=fun(x[0],x[1],i);temp2=fun(temp1,x[2],j);temp3=fun(temp2,x[3],k);if(temp3==24){printf("\t\t\t\t[(%d%c%d)%c%d]%c%d=24\n",x[0],cha[i],x[1],cha[j],x[2],cha [k],x[3]);c=1;}temp1=fun(x[0],x[1],i);temp2=fun(x[2],x[3],k);temp3=fun(temp1,temp2,j);if(temp3==24){printf("\t\t\t\t(%d%c%d)%c(%d%c%d)=24\n",x[0],cha[i],x[1],cha[j],x[2],cha [k],x[3]);c=1;}temp1=fun(x[1],x[2],j);temp2=fun(temp1,x[0],i);temp3=fun(temp2,x[3],k);if(temp3==24){printf("\t\t\t\t[%d%c(%d%c%d)]%c%d=24\n",x[0],cha[i],x[1],cha[j],x[2],cha [k],x[3]);c=1;}temp1=fun(x[1],x[2],j);temp2=fun(temp1,x[3],k);temp3=fun(temp2,x[0],i);if(temp3==24){printf("\t\t\t\t%d%c[(%d%c%d)%c%d]=24\n",x[0],cha[i],x[1],cha[j],x[2],cha [k],x[3]);c=1;}temp1=fun(x[2],x[3],k);temp2=fun(temp1,x[1],j);temp3=fun(temp2,x[0],i);if(temp3==24){printf("\t\t\t\t%d%c[%d%c(%d%c%d)]=24\n",x[0],cha[i],x[1],cha[j],x[2],cha [k],x[3]);c=1;}}}int arrange(int num[4])//将四个数排列为24种方式{int i,j,k,l;int temp[4];for(i=0;i<4;i++)for(j=0;j<4;j++)for(k=0;k<4;k++)for(l=0;l<4;l++){if(i!=j&&i!=k&&i!=l&&j!=k&&j!=l&&k!=l){temp[0]=num [i];temp[1]=num[j];temp[2]=num[k];temp[3]=num[l];algebra(temp);}}}int main(){int i, num[4];char ch;printf(" **计算24点游戏**\n\n请输入4个整数，然后按“回车”键: \n");for(i=0;i<4;i++)scanf("%d",&num[i]);//将四个数输入到数组中去printf("结果是:\n");arrange(num);if(c==0)printf("无解.\n");printf("是否继续？(y,n): ");fflush(stdin);ch=getchar();fflush(stdin);if(ch=='n'){printf("\t\t\t\t ****再见!****\n\n");return 0;}while(ch!='y'){printf("输入错误,请重输(y或n): ");ch=getchar();fflush(stdin);if(ch=='n')return 0;}while(ch=='y'){printf("请输入四个整数:");for(i=0;i<4;i++)scanf("%d",&num[i]);//将四个数输入到数组中去fflush(stdin);printf("结果是:\n");arrange(num);if(c==0)printf("无解.\n");printf("是否继续？(y,n): ");ch=getchar();fflush(stdin);if(ch=='n'){printf("\t\t\t\t ******再见!****\n\n");return 0;}while(ch!='y'){printf("输入错误，请重输(y或n): ");ch=getchar();fflush(stdin);if(ch=='n'){printf("\t\t\t\t ******再见!****\n\n");return 0;} }}return 0;}。

24点游戏(C#)

24点游戏（C#）游戏描述：输入参数：4个0…9之间的数字（顺序可调）计算方法：加减乘除（括号）计算结果：24程序截图：程序描述：程序的三种模式：1，全部组合（有解）：将有解的组合全部列出（因为数据组合较多，一屏可能显示不下，所以分段显示）。

如下图（第一段）：2，全部组合（无解含）：将所有的组合一一列出，包括无解的组合（同模式一，分屏显示）。

如下图（第一段）：3，手动输入（默认）：手动输入4个数字，程序自动计算，得出结果。

如下图：程序代码用VS创建ConsoleApplication程序，拷贝一下代码覆盖原代码即可。

（有任何问题，可以私密我）using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.IO;namespace Game24{public class Program{///<summary>///計算結果String///</summary>private static Stack<string> stackResult = new Stack<string>();///<summary>///起動方法///</summary>///<param name="args"></param>public static void Main(string[] args){bool reFlg = true;int[] aryInput = new int[4];Console.ForegroundColor = ConsoleColor.Yellow;Console.WriteLine("===================24点Game===================");Console.WriteLine("========================================tpj");while (reFlg){Console.ForegroundColor = ConsoleColor.Yellow;Console.WriteLine(" 1:全部組合（有解）");Console.WriteLine(" 2:全部組合（無解含）");Console.WriteLine(" 3:手動輸入（默認）");Console.WriteLine(" 4:中止");Console.Write("選択：");string select = Console.ReadLine();#region全部組合if (select == "1" || select == "2"){int mukaisu = 0;int youkaisu = 0;int current = 0;for (int i = 0; i < 10; i++){for (int j = i; j < 10; j++){for (int k = j; k < 10; k++){for (int d = k; d < 10; d++){current++;aryInput[0] = i;aryInput[1] = j;aryInput[2] = k;aryInput[3] = d;bool isRight = Keisan(aryInput);if (select == "1"){if (isRight){youkaisu++;Console.ForegroundColor = ConsoleColor.Gray;Console.Write(string.Format("{0}：{1}、{2}、{3}、{4} ", youkaisu, aryInput[0], aryInput[1], aryInput[2], aryInput[3]));Console.ForegroundColor = ConsoleColor.DarkYellow;string allResult =GetAllResult(stackResult.ToList());Console.WriteLine(allResult);}else{mukaisu++;}}else{if (isRight){youkaisu++;Console.ForegroundColor = ConsoleColor.Gray;Console.Write(string.Format("{0}：{1}、{2}、{3}、{4} ", youkaisu + mukaisu, aryInput[0], aryInput[1], aryInput[2], aryInput[3]));Console.ForegroundColor = ConsoleColor.DarkYellow;string allResult =GetAllResult(stackResult.ToList());Console.WriteLine(allResult);}else{mukaisu++;Console.ForegroundColor = ConsoleColor.Gray;Console.Write(string.Format("{0}：{1}、{2}、{3}、{4} ", youkaisu + mukaisu, aryInput[0], aryInput[1], aryInput[2], aryInput[3]));Console.ForegroundColor = ConsoleColor.DarkYellow;Console.WriteLine("無解...");}}if (current != 0 && current % 120 == 0){Console.ForegroundColor = ConsoleColor.Yellow;Console.Write(string.Format("({0},{1},{2},{3})⇒({4},{5},{6},{7})完了。