㈠ 用c语言编写24点代码分析
#include<stdio.h>
double fun(double a1,double a2,int b) //用于尝试着计算的函数，b为运算控制
{
switch(b)
{
case 0:return (a1+a2);
case 1:return (a1-a2);
case 2:return (a1*a2);
case 3:return (a1/a2);
}
}
void main()
{
int i,j,k,l,n,m,r,save[4];
double num[4]={1,1,1,1},tem1,tem2,tem3,abc=1111;
char sign[5]="+-*/"; //打印时候用的符号，需要和fun函数里的顺序保持一致
printf("input 4 numbers:");
for(i=0;i<4;i++)
{
scanf("%lf",num+i); //输入数据
save[i]=num[i]; //保存原始数据
}
//下面程序的思想，就是利用穷举（其实就是使用的排列组合方法）来计算可能的组合。
//先把输入的4个数进行排列（前4个for语句就这个用途）
//再依次插入三个运算符（后3个for语句就这个用途）
//事实上，从这里看，这个程序是不怎样的。七层循环嵌套，这是编程的大忌。一般循环嵌套最好不要超过两层。
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(j!=i)
{
for(k=0;k<4;k++)
if(k!=i&&k!=j)
{
for(l=0;l<4;l++)
if(l!=i&&l!=j&&l!=k)
{
for(n=0;n<4;n++)
for(m=0;m<4;m++)
for(r=0;r<4;r++)
{
tem1=fun(num[i],num[j],n);
tem2=fun(tem1,num[k],m);
tem3=fun(tem2,num[l],r);
//以下五种处理方法，涵盖了有可能的全部运算顺序
//这也是本程序最精妙的地方。
if(tem3==24.0)//如果直接算得了24，说明次序不变，直接输出就是
printf("{(%d%c%d)%c%d}%c%d=24\n",save[i],sign[n],save[j],sign[m],save[k],sign[r],save[l]);
else if(tem3==-24.0)//如果算得的是负的，说明需要颠倒第二次运算（第三次运算不可能是加减）
printf("{%d%c(%d%c%d)}%c%d=24\n",save[k],sign[m],save[i],sign[n],save[j],sign[r],save[l]);
else if(tem3==1.0/24.0)//如果是倒数，说明需要颠倒最后一次运算（第三次运算同样不可能是加减）
printf("%d%c{(%d%c%d)%c%d}=24\n",save[l],sign[r],save[i],sign[n],save[j],sign[m],save[k]);
else if(tem3==-1.0/24.0)//如果是负倒数，则说明第二次和第三次运算都要颠倒（第三次运算同样不可能是加或减）
printf("%d%c{%d%c(%d%c%d)}=24\n",save[l],sign[r],save[k],sign[n],save[i],sign[m],save[j]);
else
{ //处理（）*/+/-（）的情况
tem1=fun(num[i],num[j],n);
tem2=fun(num[k],num[l],r);
tem3=fun(tem1,tem2,m);
if(tem3==24.0)
printf("(%d%c%d)%c(%d%c%d)=24\n",save[i],sign[n],save[j],sign[m],save[k],sign[r],save[l]);
}
}
}
}
}
}
//后面我再研究了下,发现"第三次不可能是加减法"这种思想是错误的,而程序作者在设计的时候,确实是这么认为的,所以,这个程序是有问题的.
//但程序里的主体思想没有问题,如果需要修改这个错误,程序需要在运算顺序判断上下功夫.结果只能取==24的情况.
㈡ 24点游戏算法
看了N个24点的源码了，虽然都能正确的得到结果，不过从效率和智能上来说都很垃圾。(国内的程序员，大多也就是在源码基础上改改而已，这也是企业追逐经济利益的趋势。真正写底层算法的高手就没多少了。。。如果A*，8皇后和跳马的算法对你来说没什么难度，可以尝试写下。很多人应该可以略过看下面的内容了，或者只看不思考，免得伤脑筋)。 这些算法的通病，也正是我目前想解决的问题是：1 效率性把24点扩展一下，就是要写一个函数。function fun(arr:Array,num):Array{ //arr参数为[a,b,c,d,e....] //N个数字,在24点游戏里，为[a,b,c,d] 4个数 //num //要匹配的结果 24点游戏里，num=24 return Array //输出结果存在数组里，如["(3+3)*(2+2)","(3*2+2)*3".........]}如果是N个数字的计算，用N来计算程序的复杂度。那么24点的很多算法是属于穷举排列，无法扩展，并且重复计算量很多。没效率可言2 结果的正确性这个也能说明为什么连把公式穷举出来，作为类似索引表的这样典型空间换时间的方法，效率还是很低。这里还涉及到一点智能问题。
AI很难识别相同的运算。
如 a+b+c+d 和 a+c+b+d 按游戏规则来说属于同种方法 但是在很多方法里，会得出重复的，如同时会输出 ((a+b)+c)*d 和 ((a+c)+b)*d这样同样的公式。在我们玩24点扑克游戏时，这点明显是不允许的。虽然24点这游戏并不是那么严谨，但是有这样的潜规则 在别人讲他的算法时，如果你马上能想出同样能算出24的不同类的方法，可以视为平手 如 2*4*(4-1) 和 (4+4)*(2+1) 可以视为不同的算法。 特殊情况，当牌有点数相同的，花色不同时， 相同点数的位置替代，也应属于同类运算，但是没有一个代码能够识别这些的。 另外(8-(1+3))*6 和 (8-1-3)*6 理应属于同种算法。在程序中理应执行一遍，并且也只属于(8-1-3)*6这种括号数较少的公式才合理。 程序一次是只能计算两个数的运算的。用递归回溯的思路，可以方便的遍历所有的执行顺序和符号组合。但是实际写起来，在程序中，用条件判断，剔除种种不必要的运算和生成简捷正确的公式，难度非常大。另外就是递归的层级相当多，代码设计难度也很大。 这个程序执行所费的时间，花在公式上的存储读取时间和条件判断所花费的时间也是相当可观的。3 智能性 还是回到24点来说了。拟人的思路。 当我们玩24点的游戏，很多时候，大家都不愿意多看，马上要求换牌。比如说A，A，2，2。在程序里可以这样解释，if(a*b*c*d<24){return} 牌太小了不可能有计算结果。 这时我们换了一张牌，结果大家都抢着报自己的答案了。为什么能这么快呢？这和人工智能里的学习记忆机制挂点钩。人算时，并不会像通常的程序那样去排列组合，直到得到满意的结果为止。而是有很多优先的成分。比如说4张牌里面，有一张牌是3，那么，我们马上会想到的是把其它3张牌组合成8。而如果里面有张牌是4，我们会想到把其它3张牌组合成6。而且24点这游戏一般两人玩，手动出牌也很难保证4张牌同时出。不同人的注意力也集中在不同地方。就生成了一个优先度的问题。 如上所诉，那么在计算24点的程序里，如果a,b,c,d里面，有数字=2，3，4，6，8，12这样的12的因数在里面，我们一般应该将这样的数字放在最后去计算，优先组合其它的3个数字。如果数字在数组的位置和优先计算有关系的话，即是 for(var i in arr){ if(arr[i]==24的因数){ arr.push(arr.splice(i,1)) } } 如果要换其中某一张牌时，这时我们其实已经将其他3张牌的种种排列组合已经计算好了。只能与换的那种牌组合了。如果其他3张牌组合好了与第4张牌在一起并不能得到结果，那么也并不代表无解。只是这种方法行不通。那么应该抛弃这样的组合方式，并重新计算(从效率上来说，等同于这样的算法不需要再计算，程序的表达上，这点也较有难度)。 人脑计算时，如果4张牌里面有相同的牌的话， 如果相同的牌不是24的因数，通常是优先把这样的牌给计算掉，假设4张牌为[a1,b1,c,d](后接数字，数字相同的代表数值相等)，那么一般会先这样拆 (a1?c)?(b1?d) ，把相同的牌尽量和其他的牌组合，生成24的因数。如 5,5,3,2 这样的牌，我们会马上反映出 5+3=8 5-2=3 3*8=24，那么换成程序来说，4张牌的优先顺序可能为[a1,c,b1,d]，当a1,c经过计算得到新值e时，排列为[b1,d,e] 如果相同的牌是24的因数。那么我们可能会保留一个，并计算其他3张能否凑成另一个需要的因数。如牌8，8，2，3 我们会优先计算 8*(8-2-2)。而程序上来说，4个数的优先程度是[a1,c,d,b1]上面只分析了部分常见情况，细分下来非常多，并且在程序里实现起来有点难度。不过如果分得很细了。条件判断所用的时间视为0。而每次拟人的计算过程用setInterval(时间周期模拟人脑的一个计算周期)，而不是简单的for来算的话。可能那个24点的程序就很完善了。输入一些参数，设置能模拟出不同的人在牌放置的位置时，计算所用的时间。如果下一次的4张牌刚好和上盘的4张牌一样或重复了3张优先计算的牌，就会像人一样马上靠回忆而不是计算得出结果。 24点的扑克游戏，一个很简单的游戏，如果想复杂了，也是个不得了的东西。
这样可以么？
㈢ C语言24点的算法
下面是我自己写的一个程序:
我的解法是把这个问题分解成了两个子问题，首先求出4个数字的无重复全排列，放到一个数组里面，再对没一个排列情况，从头到尾穷举所有的四则运算情况。注意到除法是特殊的，我用x/y表示x除以y，用x|y表示x分之y。注意到，如果穷举的解得到-24的话，只需要把有减法的地方调换一下顺序就可以了，代码如下
/***********************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
int index[4]={0,1,2,3};//used to generate subscription collection
int sub[4]; //used in p() only
float f[4]={8.0f,3.0f,3.0f,8.0f};//the 24 point numbers
float fs[24][4];//all possible permutaions of f
float tmp[4]; //used for buf
int g_number=0; //number of permutations
float RES[4];
char op[3];
void p(int idx){//求全排列的函数
if(idx==4){
for(int i=0;i<4;++i){tmp[i]=f[sub[i]];}
for(int g=0;g<g_number;++g){if(memcmp(fs[g],tmp,sizeof(float)*4)==0)return;}
for(int i=0;i<4;++i){fs[g_number][i]=f[sub[i]];}
g_number++;
return;
}
for(int i=0;i<4;++i){//make subscription collections
bool pflag=false;
for(int j=0;j<idx;++j){if(sub[j]==i)pflag=true;}
if(pflag==true)continue;
sub[idx]=index[i];
p(idx+1);
}
}
void solve(int L){//对某个排列，递归求所有四则运算的结果，找到就退出
if(L==3){
if(fabs(fabs(RES[L])-24.0f)<0.01f){
printf("Found solution,RES=%f,((%d%c%d)%c%d)%c%d\n",RES[L],
(int)f[0],op[0],
(int)f[1],op[1],
(int)f[2],op[2],
(int)f[3]);
exit(0);
}
return;
}
for(int j=0;j<5;++j){//j judges for operators
if(j==0){RES[L+1]=RES[L]+tmp[L+1];op[L]='+';solve(L+1);}
if(j==1){RES[L+1]=RES[L]-tmp[L+1];op[L]='-';solve(L+1);}
if(j==2){RES[L+1]=RES[L]*tmp[L+1];op[L]='*';solve(L+1);}
if(j==3&&tmp[L+1]!=0)
{RES[L+1]=RES[L]/tmp[L+1];op[L]='/';solve(L+1);}
if(j==4&&RES[L+1]!=0)
{RES[L+1]=tmp[L+1]/RES[L];op[L]='|';solve(L+1);}
}
}
int main(int argc,char* argv[]){//should avoid 0
f[0]=atoi(argv[1]);
f[1]=atoi(argv[2]);
f[2]=atoi(argv[3]);
f[3]=atoi(argv[4]);
p(0);
for(int i=0;i<g_number;++i){
memcpy(tmp,fs[i],sizeof(float)*4);
RES[0]=tmp[0];
for(int t=0;t<4;++t){ printf("%d,",(int)tmp[t]); }
printf("\n");
solve(0);
}
printf("Found no solution :( \n");
return 0;
}
----------编译运行，运行时的参数就是4个数字
g++ p.cpp && ./a.out 1 5 5 5
1,5,5,5,
Found solution,RES=-24.000000,((1/5)-5)*5
g++ p.cpp && ./a.out 8 3 3 8
8,3,3,8,
Found solution,RES=-24.000006,((8/3)-3)|8
上面这个解写出来就是
8
--------- = 24
3-(8/3)
主程序为了简化，省去了对输入的检查，楼主可以自己添加。
㈣ 编程求计算24点的方法是什么
解法用到的基本思想就是回溯，树的深度为最深为4，树的判断分支为 加减乘除，对不满足条件的解进行剪枝（即当前结果>=24）,当到达递归边界（即树的深度为四时）时，即判断当前的结果是否符合条件（=24），符合即找到解，否则继续进行。
参考代码如下：
#include<iostream>
#include<math.h>
using namespace std;
const double MIN=1E-6;
void Print(int *Rank,double *FourNum)
{
for(int i=0;i<4;i++)
cout<<FourNum[Rank[i]]<<" ";
cout<<endl;
}
void Calculate_24(int *Rank,int *FourNum,char *Oper,int i,int j,int k,bool &def)
{
double res=0;
switch(i)
{
case 0:
res=FourNum[Rank[0]]+FourNum[Rank[1]];
break;
case 1:
res=FourNum[Rank[0]]-FourNum[Rank[1]];
break;
case 2:
res=FourNum[Rank[0]]*FourNum[Rank[1]];
break;
case 3:
res=FourNum[Rank[0]]/FourNum[Rank[1]];
break;
}
switch(j)
{
case 0:
res=res+FourNum[Rank[2]];
break;
case 1:
res=res-FourNum[Rank[2]];
break;
case 2:
res=res*FourNum[Rank[2]];
break;
case 3:
res=res/FourNum[Rank[2]];
break;
}
switch(k)
{
case 0:
res=res+FourNum[Rank[3]];
break;
case 1:
res=res-FourNum[Rank[3]];
break;
case 2:
res=res*FourNum[Rank[3]];
break;
case 3:
res=res/FourNum[Rank[3]];
break;
}
if(fabs(res-24)>MIN)
return;
else
{
def=true;
for(int num=1;num<=7;num++)
{
switch(num)
{
case 1:
cout<<FourNum[Rank[0]];
break;
case 3:
cout<<FourNum[Rank[1]];
break;
case 5:
cout<<FourNum[Rank[2]];
break;
case 7:
cout<<FourNum[Rank[3]];
break;
case 2:
cout<<Oper[i];
break;
case 4:
cout<<Oper[j];
break;
case 6:
cout<<Oper[k];
break;
}
}
cout<<endl;
}
}
void SearchTree(int Depth,int *Rank,int *FourNum,char *Oper,bool &def)
{
int i,j,k;
if(Depth==4)
{
for(i=0;i<4;i++)
for(j=0;j<4;j++)
for(k=0;k<4;k++)
Calculate_24(Rank,FourNum,Oper,i,j,k,def);
}
else
{
for(i=0;i<4;i++)
{
int Remember=0;
for(j=0;j<Depth;j++)
{
if(Rank[j]==i)
Remember=1;
}
if(Remember)
continue;
Rank[Depth]=i;
SearchTree(Depth+1,Rank,FourNum,Oper,def);
}
}
}
int main()
{
int a[4],b[4],time;
char c[4]={'+','-','*','/'};
bool def=false;
cin>>time;
while(time--)
{
for(int i=0;i<4;i++)//输入测试数据
cin>>a[i];
cout<<"所有可能的结果："<<endl;
SearchTree(0,b,a,c,def);
if(def==false)
cout<<"No"<<endl;
}
return 0;
}
㈤ 求教24点游戏的算法（最好用C++)
24点游戏是一个大众化的益智游戏.任意给四张扑克牌(不包括大小王),只能够用加,减,乘,除以及适当的括号连接这四张牌,无论顺序,使计算结果为24,或者宣布根本就是无解的.需要注意的是,每张牌必须运算,并且只能运算一次,J,Q,K可设置为11,12,13.
本程序目的就是算出一组牌的所有解(不同形式的式子算不同解),如没有则输出无解.
算法说明
首先解决图形扑克牌的显示问题.我选择了Qcard.dll.运用其中的DrawCard过程可轻松实现扑克的显示问题,在源程序中会有具体用法.
接下来是24点算法的讨论.首先想到的是用穷举表达式的方法,然后求值.然而,由于括号的存在,使穷举表达式并非易事.实际上,括号的作用仅仅是提高运算的优先级而已,如果我们规定符号的优先级,一样可以达到要求.具体来说,设四张牌为a,b,c,d,运算符为①,②,③,表达式为a ① b ② c ③ .如果强制规定①,②,③的优先顺序,就不必考虑括号问题了.而这3个运算符的运算顺序有3!=6种,分别是:
1.①②③ 2.①③② 3.②①③ 4.②③① 5.③①② 6.③②①
等价的表达式分别是:
1.((a①b②)c③) 2.(a①b)②(c③d) 3.(a①(b②c))③d
4.a①((b②c)③d) 5.(a①b)②(c③d) 6. a①(b②(c③d))
显然,2和5是相同的,因此只考虑5种情况.这样,括号的问题就解决了.
接下来,就是生成a,b,c,d的全排列,注意去掉其中的相同排列.去除的方法很多,比如字典排序等,我用的是另一种方法.
用循环的嵌套生成a,b,c,d的24种全排列,记录在数组中.把每一组数当作一个四位的14进制数,把这24个数全部转化为十进制(如(6529)14=6*143+5*142+2*14+9).这样,如果两个排列完全相同,则得到的十进制数是相等的.这样,通过对这些十进制的比较,就可以比较这些排列的相同情况.一旦遇到相同的排列,就标记上.最后生成一组没有重复的排列.
对这组排列进行以上方法的运算,就可以得到所有的结果了.注意在运算过程中除法的特殊性——除数不能为零.因为可能会用到除法,所以要考虑精度问题,这里通过结果减去24取绝对值与一个接近0的小数比较,如小于它,即可判定结果是24.
附:其他待决的问题:
图形扑克牌的遮挡问题.当窗口中的扑克牌被遮挡后,扑克牌不会重新画上,造成扑克牌遮挡后显示不全问题.应寻找Qcard.dll的有关参数.
形式不同而实质相同的解的问题.有些解虽然形式不同,但其实质是完全相同的.如3*((11+4)-7)和3*(11+(4-7)),实际上只是一种解.去掉这些相同解的问题情况较多,其较为繁琐,有待解决.
多余括号好问题.有些解的括号是多余的,应在输出前去掉.
改进程序的可玩性.增加玩家输入表达式的功能,并判断对错,还可以加上时间限制,使玩家参与到游戏中.
程序框图
VB源程序代码
'需要声明所有用到的变量
Option Explicit
'声明全局变量,数组
Dim cards(1 To 4) As Single, card(1 To 4) As Single
Dim result(1 To 24, 0 To 4) As Integer, final(1 To 24, 1 To 4) As Integer, temp(1 To 24) As Long
Dim nokey As Boolean, total As Integer, n1 As Integer, n2 As Integer, n3 As Integer, n4 As Integer, a As Integer, b As Integer, c As Integer, d As Integer, op1 As Integer, op2 As Integer, op3 As Integer, answer1 As Single, answer2 As Single, answer3 As Single, color As Integer
Dim i As Integer, j As Integer, t As Integer
'声明zero常量,设置0的标准,处理除法的精度问题
Const zero = 0.00001
'初始化QCARD32.DLL
Private Declare Function InitializeDeck Lib "qcard32.dll" (ByVal hwin As Long) As Integer
'DrawCard 子程序,画出扑克牌图样在FORM窗体及 窗体上的图片框
'用法:
'hwnd ---- 需要画图的对象句柄
'nCard --- 扑克牌编号 其编号如下
'1-13 梅花 14-26 方块 27-39 红心 40-52 黑桃 小王-110 大王-111
'x,y 位置
Private Declare Sub DrawCard Lib "qcard32.dll" (ByVal hwnd As Long, ByVal nCard As Integer, ByVal x As Integer, ByVal y As Integer)
'DrawBack 子程序,画出扑克牌的背面图案,共六种 按 1--6 编号
Private Declare Sub DrawBack Lib "qcard32.dll" (ByVal hwnd As Long, ByVal nCard As Long, ByVal x As Long, ByVal y As Long)
'GetCardSuit 函数,求 nCard 的点数 1-13
'Private Declare Function GetCardSuit Lib "qcard32.dll" (ByVal nCard As Long) As Long
'GetCardValue 函数,求 nCard 的花色 0:鬼牌 1:梅花 2:方块 3:红心 4:黑桃
'Private Declare Function GetCardValue Lib "qcard32.dll" (ByVal nCard As Long) As Long
'Form_Load过程,初始化
Private Sub Form_Load()
Randomize Timer
Call InitializeDeck(Me.hwnd)
Command3.Enabled = False
End Sub
'answer函数,返回x与y做operator运算后的值,-100为错误标志
Private Function answer(x As Single, y As Single, operator As Integer) As Single
Select Case operator
Case 1
answer = x + y
Exit Function
Case 2
answer = x - y
Exit Function
Case 3
answer = x * y
Exit Function
Case 4
If y = 0 Then
answer = -100
Exit Function
Else
answer = x / y
Exit Function
End If
End Select
answer = -100
End Function
'operate函数,返回数值op所对应的四则运算符号
Private Function operate(op As Integer) As String
Select Case op
Case 1
operate = "+"
Case 2
operate = "-"
Case 3
operate = "*"
Case 4
operate = "/"
End Select
End Function
'search过程,去掉数组result中相同的元素,存入数组final中
Private Sub search()
For i = 1 To 24
result(i, 0) = 0
temp(i) = result(i, 1) * 14 ^ 3 + result(i, 2) * 14 ^ 2 + result(i, 3) * 14 + result(i, 4)
Next i
For i = 1 To 23
For j = i + 1 To 24
If temp(i) = temp(j) Then result(i, 0) = 1
Next j
Next i
For i = 1 To 24
If result(i, 0) = 1 Then GoTo 1
t = t + 1
For j = 1 To 4
final(t, j) = result(i, j)
Next j
1 Next i
End Sub
'Main过程,用于计算四个数通过不同运算得到24的所有情况,并输出结果
Private Sub Main()
For op1 = 1 To 4
For op2 = 1 To 4
For op3 = 1 To 4
'1·形如( a @ b ) @ c ) @ d 的表达式
answer1 = answer(cards(1), cards(2), op1)
answer2 = answer(answer1, cards(3), op2)
answer3 = answer(answer2, cards(4), op3)
If answer1 -100 And answer2 -100 And answer3 -100 Then
If Abs(answer3 - 24) < zero Then
nokey = False
total = total + 1
Text1.Text = Text1.Text + "((" + Trim$(Str$(cards(1))) + operate(op1) + Trim$(Str$(cards(2))) + ")" + operate(op2) + Trim$(Str$(cards(3))) + ")" + operate(op3) + Trim$(Str$(cards(4))) + " "
'若本行已有三个式子,就换行
If total Mod 3 = 0 Then
Text1.Text = Text1.Text + Chr$(13) + Chr$(10)
End If
End If
End If
'2·形如( a @ b ) @ (c @ d) 的表达式
answer1 = answer(cards(1), cards(2), op1)
answer2 = answer(cards(3), cards(4), op3)
answer3 = answer(answer1, answer2, op2)
If answer1 -100 And answer2 -100 And answer3 -100 Then
If Abs(answer3 - 24) < zero Then
nokey = False
total = total + 1
Text1.Text = Text1.Text + "(" + Trim$(Str$(cards(1))) + operate(op1) + Trim$(Str$(cards(2))) + ")" + operate(op2) + "(" + Trim$(Str$(cards(3))) + operate(op3) + Trim$(Str$(cards(4))) + ")" + " "
'若本行已有三个式子,就换行
If total Mod 3 = 0 Then
Text1.Text = Text1.Text + Chr$(13) + Chr$(10)
End If
End If
End If
'3·形如( a @ ( b @ c ) ) @ d 的表达式
answer1 = answer(cards(2), cards(3), op2)
answer2 = answer(cards(1), answer1, op1)
answer3 = answer(answer2, cards(4), op3)
If answer1 -100 And answer2 -100 And answer3 -100 Then
If Abs(answer3 - 24) < zero Then
nokey = False
total = total + 1
Text1.Text = Text1.Text + "(" + Trim$(Str$(cards(1))) + operate(op1) + "(" + Trim$(Str$(cards(2))) + operate(op2) + Trim$(Str$(cards(3))) + "))" + operate(op3) + Trim$(Str$(cards(4))) + " "
'若本行已有三个式子,就换行
If total Mod 3 = 0 Then
Text1.Text = Text1.Text + Chr$(13) + Chr$(10)
End If
End If
End If
'4·形如 a @ ( ( b @ c ) @ d ) 的表达式
answer1 = answer(cards(2), cards(3), op2)
answer2 = answer(answer1, cards(4), op3)
answer3 = answer(cards(1), answer2, op1)
If answer1 -100 And answer2 -100 And answer3 -100 Then
If Abs(answer3 - 24) < zero Then
nokey = False
total = total + 1
Text1.Text = Text1.Text + Trim$(Str$(cards(1))) + operate(op1) + "((" + Trim$(Str$(cards(2))) + operate(op2) + Trim$(Str$(cards(3))) + ")" + operate(op3) + Trim$(Str$(cards(4))) + ")" + " "
'若本行已有三个式子,就换行
If total Mod 3 = 0 Then
Text1.Text = Text1.Text + Chr$(13) + Chr$(10)
End If
End If
End If
'5·形如 a @ ( b @ ( c @ d ) ) 的表达式
answer1 = answer(cards(3), cards(4), op3)
answer2 = answer(cards(2), answer1, op2)
answer3 = answer(cards(1), answer2, op1)
If answer1 -100 And answer2 -100 And answer3 -100 Then
If Abs(answer3 - 24) < zero Then
nokey = False
total = total + 1
Text1.Text = Text1.Text + Trim$(Str$(cards(1))) + operate(op1) + "(" + Trim$(Str$(cards(2))) + operate(op2) + "(" + Trim$(Str$(cards(3))) + operate(op3) + Trim$(Str$(cards(4))) + "))" + " "
'若本行已有三个式子,就换行
If total Mod 3 = 0 Then
Text1.Text = Text1.Text + Chr$(13) + Chr$(10)
End If
End If
End If
Next op3
Next op2
Next op1
End Sub
'Card1_MouseDown过程,按左键点击纸牌加1,按右键减1
Private Sub Card1_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single)
Select Case Button
'按左键
Case 1
If card(4) = 13 Then
card(4) = 1
Else
card(4) = card(4) + 1
End If
'按右键
Case 2
If card(4) = 1 Then
card(4) = 13
Else
card(4) = card(4) - 1
End If
End Select
'随机产生变化后的花色
color = Int(Rnd() * 4)
'重画纸牌
Call DrawCard(Me.hwnd, color * 13 + card(4), 10, 10)
End Sub
'Card2_MouseDown过程,按左键点击纸牌加1,按右键减1
Private Sub Card2_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single)
Select Case Button
'按左键
Case 1
If card(3) = 13 Then
card(3) = 1
Else
card(3) = card(3) + 1
End If
'按右键
Case 2
If card(3) = 1 Then
card(3) = 13
Else
card(3) = card(3) - 1
End If
End Select
'随机产生变化后的花色
color = Int(Rnd() * 4)
'重画纸牌
Call DrawCard(Me.hwnd, color * 13 + card(3), 10 + 85, 10)
End Sub
'Card3_MouseDown过程,按左键点击纸牌加1,按右键减1
Private Sub Card3_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single)
Select Case Button
'按左键
Case 1
If card(2) = 13 Then
card(2) = 1
Else
card(2) = card(2) + 1
End If
'按右键
Case 2
If card(2) = 1 Then
card(2) = 13
Else
card(2) = card(2) - 1
End If
End Select
'随机产生变化后的花色
color = Int(Rnd() * 4)
'重画纸牌
Call DrawCard(Me.hwnd, color * 13 + card(2), 10 + 2 * 85, 10)
End Sub
'Card4_MouseDown过程,按左键点击纸牌加1,按右键减1
Private Sub Card4_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single)
Select Case Button
'按左键
Case 1
If card(1) = 13 Then
card(1) = 1
Else
card(1) = card(1) + 1
End If
'按右键
Case 2
If card(1) = 1 Then
card(1) = 13
Else
card(1) = card(1) - 1
End If
End Select
'随机产生变化后的花色
color = Int(Rnd() * 4)
'重画纸牌
Call DrawCard(Me.hwnd, color * 13 + card(1), 10 + 3 * 85, 10)
End Sub
'Command1_Click过程,点击洗牌按钮画出纸牌背面
Private Sub Command1_Click()
'随机产生纸牌背面的样式
color = Int(Rnd() * 6 + 1)
'画出纸牌背面
Call DrawBack(Me.hwnd, color, 10, 10)
Call DrawBack(Me.hwnd, color, 95, 10)
Call DrawBack(Me.hwnd, color, 180, 10)
Call DrawBack(Me.hwnd, color, 265, 10)
'禁用答案按钮
Command3.Enabled = False
End Sub
'Command2_Click过程,点击发牌按钮画出随机产生的纸牌
Private Sub Command2_Click()
'清空答案
Text1.Text = ""
'随机产生的纸牌,并画出
For i = 1 To 4
card(i) = Int(Rnd() * 13 + 1)
color = Int(Rnd() * 4)
Call DrawCard(Me.hwnd, color * 13 + card(i), 10 + (4 - i) * 85, 10)
Next i
'开启答案按钮
Command3.Enabled = True
End Sub
'Command3_Click过程,点击答案按钮计算结果
Private Sub Command3_Click()
'清空解的数量
Label1.Caption = ""
'默认设置为无解
nokey = True
'解的计数器清零
total = 0
'临时变量清零
i = 0
j = 0
t = 0
'产生24种全排列
For n1 = 1 To 4
For n2 = 1 To 4
If n2 = n1 Then GoTo 2
For n3 = 1 To 4
If n3 = n1 Or n3 = n2 Then GoTo 3
n4 = 10 - n1 - n2 - n3
i = i + 1
result(i, 1) = card(n1)
result(i, 2) = card(n2)
result(i, 3) = card(n3)
result(i, 4) = card(n4)
3 Next n3
2 Next n2
Next n1
'调用search过程,去掉重复排列
Call search
'调用Main过程,寻找答案
For i = 1 To t
For j = 1 To 4
cards(j) = final(i, j)
Next j
Call Main
Next i
'输出解的情况
If nokey = False Then Label1.Caption = "共有" + Trim$(Str$(total)) + "组解!" Else Label1.Caption = "无解!"
'禁止答案按钮
Command3.Enabled = False
End Sub
五,程序界面
N
Y
比较temp(i)与temp(j)是否相等
For j=i+1 to 24
For i=1 to 23
初始化变量,数组
For i=1 to 24
初始化重复排列的标志result(1..24,0)=0
排列存入数组result(1..24,1..4)
全排列循环终止
3重循环产生24种全排列
随机产生四张扑克牌
将全排列所对应的十进制数存入temp(1..24)
Next i
设置重复排列的标志result(i,0)=1
计数器t=t+1
Next j
Next i
结束
输出解的个数或无解
结束循环final中的排列
计算形如 a @ ( b @ ( c @ d ) ) 的表达式
如等于24则输出
计算形如 a @ ( ( b @ c ) @ d ) 的表达式
如等于24则输出
计算形如( a @ ( b @ c ) ) @ d的表达式
如等于24则输出
计算形如( a @ b ) @ ( c @ d ) 的表达式
如等于24则输出
计算形如( a @ b ) @ c ) @ d 的表达式
如等于24则输出
结束循环3个运算符
循环3个运算符
循环final中的全部排列
Next i
把result存入final
Y
N
检验result(i,0)标志
是否为1
For i=1 to t