㈠ 用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