24點游戲演算法c
計算的情況舉例如下。
1：四個數是A,B,C,D,然後將A,B,C,D的各種預算結果列舉出來。
2：A+B+C+D2、B-C+A*D3、（A+D）*C+B像這樣沒有規律的列舉電腦是無法完成的，只有靠人工來完成，主要是運算的順序，數字的順序相對簡單些。
3：只需要在改變參數位置就可以了，主要是運算要考慮優先順序，而數字沒有優先順序。
4：24點是一種益智游戲，24點是把4個整數（一般是正整數）通過加減乘除以及括弧運算，使最後的計算結果是24的一個數學游戲，24點可以考驗人的智力和數學敏感性，它能在游戲中提高人們的心算能力。
B. 適合初學者的24點游戲C語言源代碼
關於二十四點游戲的編程思路與基本演算法
漫長的假期對於我來說總是枯燥無味的，閑來無聊便和同學玩起童年時經常玩的二十四點牌游戲來。此游戲說來簡單，就是利用加減乘除以及括弧將給出的四張牌組成一個值為24的表達式。但是其中卻不乏一些有趣的題目，這不，我們剛玩了一會兒，便遇到了一個難題——3、6、6、10（其實後來想想，這也不算是個太難的題，只是當時我們的腦筋都沒有轉彎而已，呵呵）。
問題既然出現了，我們當然要解決。冥思苦想之際，我的腦中掠過一絲念頭——何不編個程序來解決這個問題呢？文曲星中不就有這樣的程序嗎？所以這個想法應該是可行。想到這里我立刻開始思索這個程序的演算法，最先想到的自然是窮舉法（後來發現我再也想不到更好的方法了，悲哀呀，呵呵），因為在這學期我曾經寫過一個小程序——計算有括弧的簡單表達式。只要我能編程實現四個數加上運算符號所構成的表達式的窮舉，不就可以利用這個計算程序來完成這個計算二十四點的程序嗎？確定了這個思路之後，我開始想這個問題的細節。
首先窮舉的可行性問題。我把表達式如下分成三類——
1、 無括弧的簡單表達式。
2、 有一個括弧的簡單表達式。
3、 有兩個括弧的較復4、 雜表達式。
窮舉的開始我對給出的四個數進行排列，其可能的種數為4*3*2*1=24。我利用一個嵌套函數實現四個數的排列，演算法如下:
/* ans[] 用來存放各種排列組合的數組 */
/* c[] 存放四張牌的數組 */
/* k[] c[]種四張牌的代號，其中k[I]=I+1。
用它來代替c[]做處理，考慮到c[]中有可能出現相同數的情況 */
/* kans[] 暫存生成的排列組合 */
/* j 嵌套循環的次數 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
{ int i,p,q,r,h,flag,s[4],t[4][4];
for(p=0,q=0;p<4;p++)
{ for(r=0,flag=0;r if(k[p]!=kans[r]) flag++;
if(flag==j) t[j][q++]=k[p];
}
for(s[j]=0;s[j]<4-j;s[j]++)
{ kans[j]=t[j][s[j>;
if(j==3) { for(h=0;h<4;h++)
ans[2*h]=c[kans[h]-1]; /* 調整生成的排列組合在最終的表
達式中的位置 */
for(h=0;h<3;h++)
symbol(ans,h); /* 在表達式中添加運算符號 */
}
else { j++;
fans(c,k,ans,kans,j);
j--;
}
}
}
正如上面函數中提到的，在完成四張牌的排列之後，在表達式中添加運算符號。由於只有四張牌，所以只要添加三個運算符號就可以了。由於每一個運算符號可重復，所以計算出其可能的種數為4*4*4=64種。仍然利用嵌套函數實現添加運算符號的窮舉，演算法如下:
/* ans[],j同上。sy[]存放四個運算符號。h為表達式形式。*/
int sans(ans,sy,j,h)
char ans[],sy[];int j,h;
{ int i,p,k[3],m,n; char ktans[20];
for(k[j]=0;k[j]<4;k[j]++)
{ ans[2*j+1]=sy[k[j>; /* 剛才的四個數分別存放在0、2、4、6位
這里的三個運算符號分別存放在1、3、5位*/
if(j==2)
{ ans[5]=sy[k[j>;
/* 此處根據不同的表達式形式再進行相應的處理 */
}
else { j++; sans(ans,sy,j--,h); }
}
}
好了，接下來我再考慮不同表達式的處理。剛才我已經將表達式分為三類，是因為添加三個括弧對於四張牌來說肯定是重復的。對於第一種，無括弧自然不用另行處理；而第二種情況由以下代碼可以得出其可能性有六種，其中還有一種是多餘的。
for(m=0;m<=4;m+=2)
for(n=m+4;n<=8;n+=2)
這個for循環給出了添加一個括弧的可能性的種數，其中m、n分別為添加在表達式中的左右括弧的位置。我所說的多餘的是指m=0，n=8，也就是放在表達式的兩端。這真是多此一舉，呵呵！最後一種情況是添加兩個括弧，我分析了一下，發現只可能是這種形式才不會是重復的——（a b）(c d)。為什麼不會出現嵌套括弧的情況呢？因為如果是嵌套括弧，那麼外面的括弧肯定是包含三個數字的（四個沒有必要），也就是說這個括弧裡麵包含了兩個運算符號，而這兩個運算符號是被另外一個括弧隔開的。那麼如果這兩個運算符號是同一優先順序的，則肯定可以通過一些轉換去掉括弧（你不妨舉一些例子來試試），也就是說這一個括弧沒有必要；如果這兩個運算符號不是同一優先順序，也必然是這種形式((a+-b)*/c)。而*和/在這幾個運算符號中優先順序最高，自然就沒有必要在它的外面添加括弧了。
綜上所述，所有可能的表達式的種數為24*64*（1+6+1）=12288種。哈哈，只有一萬多種可能性（這其中還有重復），這對於電腦來說可是小case喲！所以，對於窮舉的可行性分析和實現也就完成了。
接下來的問題就是如何對有符號的簡單表達式進行處理。這是棧的一個著名應用，那麼什麼是棧呢？棧的概念是從日常生活中貨物在貨棧種的存取過程抽象出來的，即最後存放入棧的貨物（堆在靠出口處）先被提取出去，符合「先進後出，後進先出」的原則。這種結構猶如子彈夾。
在棧中，元素的插入稱為壓入（push）或入棧，元素的刪除稱為彈出（pop）或退棧。
棧的基本運算有三種，其中包括入棧運算、退棧運算以及讀棧頂元素，這些請參考相關數據結構資料。根據這些基本運算就可以用數組模擬出棧來。
那麼作為棧的著名應用，表達式的計算可以有兩種方法。
第一種方法——
首先建立兩個棧，操作數棧OVS和運算符棧OPS。其中，操作數棧用來記憶表達式中的操作數，其棧頂指針為topv，初始時為空，即topv=0；運算符棧用來記憶表達式中的運算符，其棧頂指針為topp，初始時，棧中只有一個表達式結束符，即topp=1，且OPS（1）=『；』。此處的『；』即表達式結束符。
然後自左至右的掃描待處理的表達式，並假設當前掃描到的符號為W，根據不同的符號W做如下不同的處理：
1、 若W為操作數
2、 則將W壓入操作數棧OVS
3、 且繼續掃描下一個字元
4、 若W為運算符
5、 則根據運算符的性質做相應的處理：
(1)、若運算符為左括弧或者運算符的優先順序大於運算符棧棧頂的運算符(即OPS(top)),則將運算符W壓入運算符棧OPS，並繼續掃描下一個字元。
(2)、若運算符W為表達式結束符『；』且運算符棧棧頂的運算符也為表達式結束符（即OPS(topp)=』;』），則處理過程結束，此時，操作數棧棧頂元素（即OVS（topv））即為表達式的值。
(3)、若運算符W為右括弧且運算符棧棧頂的運算符為左括弧（即OPS（topp）=』(『)，則將左括弧從運算符棧談出，且繼續掃描下一個符號。
(4)、若運算符的右不大於運算符棧棧頂的運算符（即OPS(topp)），則從操作數棧OVS中彈出兩個操作數，設先後彈出的操作數為a、b，再從運算符棧OPS中彈出一個運算符，設為+，然後作運算a+b,並將運算結果壓入操作數棧OVS。本次的運算符下次將重新考慮。
第二種方法——
首先對表達式進行線性化，然後將線性表達式轉換成機器指令序列以便進行求值。
那麼什麼是表達式的線性化呢？人們所習慣的表達式的表達方法稱為中綴表示。中綴表示的特點是運算符位於運算對象的中間。但這種表示方式，有時必須藉助括弧才能將運算順序表達清楚，而且處理也比較復雜。
1929年，波蘭邏輯學家Lukasiewicz提出一種不用括弧的邏輯符號體系，後來人們稱之為波蘭表示法（Polish notation）。波蘭表達式的特點是運算符位於運算對象的後面，因此稱為後綴表示。在對波蘭表達式進行運算，嚴格按照自左至右的順序進行。下面給出一些表達式及其相應的波蘭表達式。
表達式 波蘭表達式
A-B AB-
（A-B）*C+D AB-C*D+
A*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/
OK，所謂表達式的線性化是指將中綴表達的表達式轉化為波蘭表達式。對於每一個表達式，利用棧可以把表達式變換成波蘭表達式，也可以利用棧來計算波蘭表達式的值。
至於轉換和計算的過程和第一種方法大同小異，這里就不再贅述了。
下面給出轉換和計算的具體實現程序——
/* first函數給出各個運算符的優先順序，其中=為表達式結束符 */
int first(char c)
{ int p;
switch(c)
{ case '*': p=2; break;
case '/': p=2; break;
case '+': p=1; break;
case '-': p=1; break;
case '(': p=0; break;
case '=': p=-1; break;
}
return(p);
}
/* 此函數實現中綴到後綴的轉換 */
/* M的值宏定義為20 */
/* sp[]為表達式數組 */
int mid_last()
{ int i=0,j=0; char c,sm[M];
c=s[0]; sm[0]='='; top=0;
while(c!='\0')
{ if(islower(c)) sp[j++]=c;
else switch(c)
{ case '+':
case '-':
case '*':
case '/': while(first(c)<=first(sm[top]))
sp[j++]=sm[top--];
sm[++top]=c; break;
case '(': sm[++top]=c; break;
case ')': while(sm[top]!='(')
sp[j++]=sm[top--];
top--; break;
default :return(1);
}
c=s[++i];
}
while(top>0) sp[j++]=sm[top--];
sp[j]='\0'; return(0);
}
/* 由後綴表達式來計算表達式的值 */
int calc()
{ int i=0,sm[M],tr; char c;
c=sp[0]; top=-1;
while(c!='\0')
{ if(islower(c)) sm[++top]=ver[c-'a'];/*在轉換過程中用abcd等來代替數，
這樣才可以更方便的處理非一位數，
ver數組中存放著這些字母所代替的數*/
else switch(c)
{ case '+': tr=sm[top--]; sm[top]+=tr; break;
case '-': tr=sm[top--]; sm[top]-=tr; break;
case '*': tr=sm[top--]; sm[top]*=tr; break;
case '/': tr=sm[top--];sm[top]/=tr;break;
default : return(1);
}
c=sp[++i];
}
if(top>0) return(1);
else { result=sm[top]; return(0); }
}
這樣這個程序基本上就算解決了，回過頭來拿這個程序來算一算文章開始的那個問題。哈哈，算出來了，原來如此簡單——（6-3）*10-6=24。
最後我總結了一下這其中容易出錯的地方——
1、 排列的時候由於一個數只能出現一次， 所以必然有一個判斷語句。但是用什麼來判斷，用大小顯然不行，因為有可能這四個數中有兩個或者以上的數是相同的。我的方法是給每一個數設置一個代號，在排列結束時，通過這個代號找到這個數。
2、在應用嵌套函數時，需仔細分析程序的執行過程，並對個別變數進行適當的調整（如j的值）,程序才能正確的執行。
3、在分析括弧問題的時候要認真仔細，不要錯過任何一個可能的機會，也要盡量使程序變得簡單一些。不過我的分析可能也有問題，還請高手指點。
4、在用函數對一個數組進行處理的時候，一定要注意如果這個數組還需要再應用，就必須將它先保存起來，否則會出錯，而且是很嚴重的錯誤。
5、在處理用戶輸入的表達式時，由於一個十位數或者更高位數是被分解成各位數存放在數組中，所以需對它們進行處理，將它們轉化成實際的整型變數。另外，在轉化過程中，用一個字母來代替這個數，並將這個數存在一個數組中，且它在數組中的位置和代替它的這個字母有一定的聯系，這樣才能取回這個數。
6、由於在窮舉過程難免會出現計算過程中有除以0的計算，所以我們必須對calc函數種對於除的運算加以處理，否則程序會因為出錯而退出（Divide by 0）。
7、最後一個問題，本程序尚未解決。對於一些比較著名的題目，本程序無法解答。比如說5、5、5、1或者8、8、3、3。這是由於這些題目在計算的過程用到了小數，而本程序並沒有考慮到小數。
C. 編程C語言 24點游戲
{
printf("%-5d%-8s%-6s%-13s%-15s%-15s\n",per[i-1].score,per[i-1].name,per[i-1].age,per[i-1].num,per[i-1].adds,per[i-1].email);
if(i>1&&i%10==0)
{
printf("\t-----------------------------------\n");
printf("\t");
system("pause");
printf("\t-----------------------------------\n");
}
}
D. C語言實訓求：編程實現24點游戲演算法
上面的程序是正確的，這題的解法用到的基本思想就是回溯，樹的深度為最深為4，樹的判斷分支為 加減乘除，對不滿足條件的解進行剪枝（即當前結果>=24）,當到達遞歸邊界（即樹的深度為四時）時，即判斷當前的結果是否符合條件（=24），符合即找到解，否則繼續進行。
E. 24點游戲用c語言怎麼寫
你首先要懂得C語言編寫規則，其次了解24點游戲的玩法及規則，然後就可以選擇一個合適的編譯器，開始編寫24點游戲了
F. 24點游戲演算法 C/C++ 求解釋,要漢語注釋!!!!越詳細越好!!!!!!!!!
#include <iostream>
#include <time.h>
using namespace std;
const int size=9;
class guess
{
public:
void randnum();
void cutnumguess(int);
void done();
bool guessn;
int a;
int b;
private:
int rslt[4];
int guessnum[4];
}game;
void guess::randnum()
{
rslt[0]=rand()%size;
do
rslt[1]=rand()%size;
while(rslt[1]==rslt[0]);
do
rslt[2]=rand()%size;
while(rslt[2]==rslt[0]||rslt[2]==rslt[1]);
do
rslt[3]=rand()%size;
while(rslt[3]==rslt[0]||rslt[3]==rslt[1]||rslt[3]==rslt[2]);
}
void guess::cutnumguess(int n)
{
guessnum[0]=n/1000;
guessnum[1]=n/100-10*guessnum[0];
guessnum[3]=n%10;
guessnum[2]=(n%100-guessnum[3])/10;
guessn=true;
int i,j;
for(i=0;i<3;i++)
for(j=i+1;j<4;j++)
{
if(guessnum[i]==guessnum[j])
{
guessn=false;
break;
}
if(guessn)
;
else
break;
}
}
void guess::done()
{
a=0;
b=0;
int i,j;
for(i=0;i<4;i++)
for(j=0;j<4;j++)
{
if(i==j&&guessnum[i]==rslt[j])
a++;
if(i!=j&&guessnum[i]==rslt[j])
b++;
}
}
void main()
{
char gameexit;
int chance,n;
do
{
chance=10;
game.randnum();
do
{
cout<<"你還有"<<chance<<"次機會"<<endl<<"請輸入你要猜的數字";
cin>>n;
game.cutnumguess(n);
while(!game.guessn||n>9999||n<0)
{
cout<<"數字輸入錯誤，請重新輸入"<<endl<<"你還有"<<chance<<"次機會"<<endl
<<"請輸入你要猜的數字";
cin>>n;
game.cutnumguess(n);
}
game.done();
if(game.a==4)
{
cout<<"你贏了!!!"<<endl<<"按[x]鍵退出,其他鍵繼續";
cin>>gameexit;
break;
}
else
{
cout<<n<<" "<<game.a<<"A"<<game.b<<"B"<<endl;
}
chance--;
}while(chance!=0);
if(chance==0)
{
cout<<"你輸了!!!"<<endl<<"按[x]鍵退出,其他鍵繼續";
cin>>gameexit;
}
}while(gameexit != 'x');
cout<<"感謝您的使用，再見!"<<endl;
}
G. c語言編程24點游戲，由電腦給四個隨機數，用戶輸入含這四個隨機數的演算法，有沒有大神會啊，幫幫忙啊。
//我有一個程序，用戶輸入表達式計算結果的，也許能幫得上忙。
//不過它只能輸入整數，小數可以用(xxx/1000……)代替。
#include<stdio.h>
#include<stdint.h>
#include<stdbool.h>
#defineITEM_LN064
#defineSTR_LN0256
typedefenum//定義條目類型枚舉
{
TYPE_NULL=0,
TYPE_NUMBER,
TYPE_SYMBOL,
}item_type_t;
typedefenum//定義運算符類型枚舉
{
SYM_NULL=0,
SYM_ADD,
SYM_SUB,
SYM_MUL,
SYM_DIV,
}item_symbol_t;
typedefstruct//定義條目結構體
{
//boolisExist;//存在
item_type_titem_type;//條目類型（數字、符號、空）
item_symbol_titem_symbol;//符號類型（加、減、乘、除、空）
intitem_level;//括弧級別
floatnum;//數值
}item_t;
item_titems[ITEM_LN0];//定義條目表
charstr[STR_LN0];//定義臨時字元串
intcurrentLevel;//括弧級別臨時寄存器
intitemsLength;//條目表長度
boolprevIsNum;//上一字元是數字標志
//計算某一個符號及其鄰域
voidcarculate(intIn)
{
inti;
switch(items[In].item_symbol)//計算前後條目
{
caseSYM_ADD:
items[In-1].num+=items[In+1].num;
break;
caseSYM_SUB:
items[In-1].num-=items[In+1].num;
break;
caseSYM_MUL:
items[In-1].num*=items[In+1].num;
break;
caseSYM_DIV:
{
if(items[In+1].num==0.0)
{
printf("除數為零 ");
return;
}
items[In-1].num/=items[In+1].num;
}
break;
}
for(i=In;i<itemsLength;i++)//移動
{
items[i]=items[i+2];
}
itemsLength-=2;
i=items[In-2].item_level;
if(items[In].item_level>i);//獲取新條目兩邊的級別最大值
i=items[In-2].item_level;
//如果該數字兩邊的運算符級別都比該數字低，就降低數字級別
//以兩邊最高的為准。
if(items[In-1].item_level>i)
items[In-1].item_level=i;
}
main()
{
inti;
currentLevel=0;
prevIsNum=false;
//CurrentItem.item_type=TYPE_NULL;
for(i=0;i<ITEM_LN0;i++)//初始化條目數組
{
//items[i].isExist=false;
items[i].item_symbol=SYM_NULL;
items[i].item_type=TYPE_NULL;
items[i].item_level=0;
items[i].num=0;
}
//items[0].isExist=true;//設置首個為空條目
i=0;
while(1)//帶空格掃描字元串
{
str[i]=getchar();
if(str[i]==' '||str[i]==' ')
{
str[i]=' ';
break;
}
i++;
}
i=0;
itemsLength=1;//從1號開始，設置條目信息
while(str[i]!=' ')
{
if(str[i]>='0'&&str[i]<='9')//如果是數字
{
if(prevIsNum)//如果先前是數字，就在原基礎上累加
{
items[itemsLength-1].num=items[itemsLength-1].num*10+str[i]-'0';
}
else
{
items[itemsLength].num=str[i]-'0';//新建數字條目
items[itemsLength].item_level=currentLevel;
items[itemsLength].item_type=TYPE_NUMBER;
prevIsNum=true;
itemsLength++;
}
}
elseif(str[i]=='+')
{
items[itemsLength].item_level=currentLevel;//新建符號條目
items[itemsLength].item_type=TYPE_SYMBOL;
items[itemsLength].item_symbol=SYM_ADD;
prevIsNum=false;
itemsLength++;
}
elseif(str[i]=='-')
{
items[itemsLength].item_level=currentLevel;
items[itemsLength].item_type=TYPE_SYMBOL;
items[itemsLength].item_symbol=SYM_SUB;
prevIsNum=false;
itemsLength++;
}
elseif(str[i]=='*')
{
items[itemsLength].item_level=currentLevel;
items[itemsLength].item_type=TYPE_SYMBOL;
items[itemsLength].item_symbol=SYM_MUL;
prevIsNum=false;
itemsLength++;
}
elseif(str[i]=='/')
{
items[itemsLength].item_level=currentLevel;
items[itemsLength].item_type=TYPE_SYMBOL;
items[itemsLength].item_symbol=SYM_DIV;
prevIsNum=false;
itemsLength++;
}
elseif(str[i]=='(')
{
currentLevel++;//改變括弧級別
}
elseif(str[i]==')')
{
currentLevel--;
if(currentLevel<0)
{
printf("括弧匹配錯誤 ");
return;
}
}
else
{
prevIsNum=false;
}
i++;
}
if(currentLevel!=0)//檢查括弧匹配
{
printf("括弧匹配錯誤 ");
return;
}
if((itemsLength&1)!=0)//檢查條目數
{
printf("表達式格式錯誤 ");
return;
}
//items[itemsLength].isExist=true;
itemsLength++;//設置末尾空條目
for(i=1;i<itemsLength-1;i++)//排除首尾空條目，檢查正確性
{
if(//如果表達式為數字元號交替
(items[i].item_type==TYPE_NUMBER&&(i&1)!=0)||
(items[i].item_type==TYPE_SYMBOL&&(i&1)==0)
)
{
}
else
{
printf("表達式格式錯誤 ");
return;
}
}
do//不斷查找最大級別運算符，先乘除後加減，從前面開始，依次運算
{
currentLevel=0;
for(i=1;i<itemsLength-1;i++)
{
if(items[i].item_level>currentLevel)
currentLevel=items[i].item_level;//尋找最大級別運算符
}
for(i=1;i<itemsLength-1;i++)//鎖定該最大級別乘除運算符的位置
{
if(items[i].item_level==currentLevel&&
items[i].item_type==TYPE_SYMBOL&&
(items[i].item_symbol==SYM_MUL||items[i].item_symbol==SYM_DIV)
)
break;
}
if(i!=itemsLength-1)//如果該運算符存在
carculate(i);
else//否則尋找加減
{
for(i=1;i<itemsLength-1;i++)//鎖定該最大級別加減運算符的位置
{
if(items[i].item_level==currentLevel&&
items[i].item_type==TYPE_SYMBOL&&
(items[i].item_symbol==SYM_ADD||items[i].item_symbol==SYM_SUB)
)
break;
}
if(i!=itemsLength-1)//如果該運算符存在
carculate(i);
}
}while(itemsLength>3);//當不止一個條目時
printf("%f",items[1].num);//
}
H. 求一個24點的演算法，C語言表示。
已發消息給你了，在這里說不清楚
I. 如何用C語言做一個24點游戲的程序
/*6.3.4 源程序*/
#define N 20
#define COL 100
#define ROW 40
#include "stdio.h"
#include "time.h" /*系統時間函數*/
#include "graphics.h" /*圖形函數*/
#include "alloc.h"/*動態地址分配函數*/
#include "stdlib.h" /*庫函數*/
#include "string.h" /*字元串函數*/
#include "ctype.h" /*字元操作函數*/
char p[4][13]={
{'A','2','3','4','5','6','7','8','9','0','J','Q','K'},/*撲克牌，10用0來表示*/
{'A','2','3','4','5','6','7','8','9','0','J','Q','K'},
{'A','2','3','4','5','6','7','8','9','0','J','Q','K'},
{'A','2','3','4','5','6','7','8','9','0','J','Q','K'}};
typedef struct node
{
int data;
struct node *link;
}STACK1; /*棧1*/
typedef struct node2
{
char data;
struct node2 *link;
}STACK2; /*棧2*/
void init(void);/*圖形驅動*/
void close(void);/*圖形關閉*/
void play(void);/*發牌的具體過程*/
void rand1(int j);/*隨機發牌函數*/
void change(char *e,char *a); /*中綴變後綴函數*/
int computer(char *s); /*後綴表達式計算函數*/
STACK1 *initstack1(STACK1 *top); /*棧1初始化*/
STACK1 *push(STACK1 *top,int x); /*棧1入棧運算*/
STACK1 *pop(STACK1 *top); /*棧1刪除棧頂元素*/
int topx(STACK1 *top); /*棧1讀棧頂元素*/
STACK1 *ptop(STACK1 *top,int *x); /*棧1讀出棧頂元素值並刪除棧頂元素*/
int empty(STACK1 *top); /*判棧1是否為空函數*/
STACK2 *initstack2(STACK2 *top); /*棧2初始化*/
STACK2 *push2(STACK2 *top,char x); /*棧2入棧運算*/
STACK2 *pop2(STACK2 *top); /*棧2刪除棧頂元素*/
char topx2(STACK2 *top); /*棧2讀棧頂元素*/
STACK2 *ptop2(STACK2 *top,char *x); /*棧2讀出棧頂元素值並刪除棧頂元素*/
int empty2(STACK2 *top); /*判棧2是否為空函數*
int text1(char *s) ; /*顯示文本*/
main()
{
char s[N],s1[N],ch;
int i,result;
int gdriver, gmode;
clrscr(); /*清屏*/
init(); /*初始化函數*/
while(1)
{
setbkcolor(BLACK); /*設置背景顏色*/
cleardevice();/*清屏*/
play(); /*發牌*/
gotoxy(1,15); /*移動游標*/
printf("--------------------Note-------------------\n");
printf(" Please enter express accroding to above four number\n"); /*提示信息*/
printf(" Format as follows:2.*(5.+7.)\n");/*提示輸入字元串格式*/
printf(" ----------------------------------------------\n");
scanf("%s%c",s1,&ch); /*輸入字元串壓回車鍵*/
change(s1,s); /*調用change函數將中綴表達式s1轉換為後綴表達式s*/
result=computer(s); /*計算後綴表達式的值，返回結果result */
if(result==24) /*如果結果等於24*/
text1("very good"); /*調用函數text1顯示字元串"very good"*/
else
text1("wrong!!!");/*否則函數text1顯示字元串"wrong!!!"*/
printf("Continue (y/n)?\n"); /*提示信息，是否繼續*/
scanf("%c",&ch); /*輸入一字元*/
if(ch=='n'||ch=='N') /*如果該字元等於n或N*/
break; /*跳出循環，程序結束*/
} /*否則，開始下一輪循環*/
close();
return; /*返回*/
}
void rand1(int j)/*隨機發牌函數*/
{
int kind,num;
char str[3],n;
randomize();
while(1)/*循環直到有牌發*/
{
kind=random(4); /*花色隨機數*/
num=random(13); /*大小隨機數*/
if(p[kind][num]!=-1) /*該數未取過*/
{
n=p[kind][num]; /*取相應位置的撲克牌數*/
p[kind][num]=-1; /*牌發好以後相應位置的元素置-1*/
break;
}
}
switch(kind)/*花式的判斷*/
{
case 0:setcolor(RED);sprintf(str,"%c",3);break; /*紅桃*/
case 1:setcolor(BLACK);sprintf(str,"%c",3);break; /*黑桃*/
case 2:setcolor(RED);sprintf(str,"%c",4);break; /*方片*/
case 3:setcolor(BLACK);sprintf(str,"%c",5);break; /*草花*/
}
settextstyle(0,0,2);
outtextxy(COL+j*100-30,ROW+100-46,str);/*顯示左上角花色*/
outtextxy(COL+j*100+16,ROW+100+32,str); /*顯示右下角花色*/
if(n!='0')/*輸出其他牌*/
{
settextstyle(0,0,3);
sprintf(str,"%c",n);
outtextxy(COL+j*100-5,ROW+100-5,str);/*顯示牌的大小*/
}
else/*輸出10的時候*/
{
sprintf(str,"%d",10);
outtextxy(COL+j*100-6,ROW+100-5,str);
}
}
void play(void)/*發牌的具體過程*/
{
int j;
for(j=0;j<4;j++)
{
bar(COL+j*100-35,ROW+100-50,COL+j*100+35,ROW+1*100+50);/*畫空牌*/
setcolor(BLUE);
rectangle(COL+j*100-32,ROW+100-48,COL+j*100+32,ROW+100+48); /*畫矩形框*/
rand1(j); /*隨機取牌*/
delay(10000); /*延時顯示*/
}
}
void init(void)/*圖形驅動*/
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc");
cleardevice();
}
void close(void)/*圖形關閉*/
{
closegraph();
}
void change(char *e,char *a) /*中綴字元串e轉後綴字元串a函數*/
{
STACK2 *top=NULL; /* 定義棧頂指針*/
int i,j;char w;
i=0;
j=0;
while(e[i]!='\0') /*當字元串沒有結束時*/
{
if(isdigit(e[i])) /*如果字元是數字*/
{
do{
a[j]=e[i]; /*將數字原樣拷貝到數組a中*/
i++; /*e數組的下標加1*/
j++; /*a數組的下標加1*/
}while(e[i]!='.'); /*直到字元為數字結束符「.」為止*/
a[j]='.';j++; /*將數字結束符「.」拷貝到a數組依然保持結束標記*/
}
if(e[i]=='(') /*如果字元是「(」時*/
top=push2(top,e[i]); /*將其壓入堆棧*/
if(e[i]==')') /*如果字元是「)」時*/
{
top=ptop2(top,&w); /*取出棧頂元素，並從棧頂刪除該元素*/
while(w!='(') /*如果字元不是「(」時反復循環*/
{
a[j]=w; /*將棧頂元素存入a數組*/
j++; /*下標加1*/
top=ptop2(top,&w) ; /*取出棧頂元素，並從棧頂刪除該元素*/
}
}
if(e[i]=='+'||e[i]=='-') /*如果字元是加或減號時*/
{
if(!empty2(top)) /*如棧不為空*/
{
w=topx2(top);
while(w!='(') /*當棧頂元素不是「(」時反復循環*/
{
a[j]=w;
j++; /*將棧頂元素存入表達式a中，a的下標加1*/
top=pop2(top); /*刪除棧頂元素*/
if(empty2(top)) /*如果棧為空*/
break; /*跳出循環*/
else
w=topx2(top); /*否則讀棧頂元素*/
}
}
top=push2(top,e[i]); /*將當前e的字元元素壓入堆棧*/
}
if(e[i]=='*'||e[i]=='/') /*如果字元是乘或除號時*/
{
if(!empty2(top)) /*如棧不為空*/
{
w=topx2(top); /*讀棧頂元素存入w*/
while(w=='*'||w=='/')/*當棧頂元素是乘或除時反復循環*/
{
a[j]=w;
j++; /*將棧頂元素存入字元串a中，a的下標加1*/
top=pop2(top); /*刪除棧頂元素*/
if(empty2(top)) /*如果棧為空*/
break; /*跳出循環*/
else
w=topx2(top); /*否則讀棧頂元素*/
}
}
top=push2(top,e[i]); /*將當前e字元元素壓入堆棧*/
}
i++; /*e的下標加1*/
}
while(!empty2(top)) /*當不為空時反復循環*/
top=ptop2(top,&a[j++]); /*將棧頂元素存入數組a中*/
a[j]='\0'; /*將字元串結束標記寫入最後一個數組元素中構成字元串*/
}
int computer(char *s) /* 計算函數*/
{
STACK1 *top=NULL;
int i,k,num1,num2,result;
i=0;
while(s[i]!='\0') /*當字元串沒有結束時作以下處理*/
{
if(isdigit(s[i])) /*判字元是否為數字*/
{
k=0; /*k初值為0*/
do{
k=10*k+s[i]-'0'; /*將字元連接為十進制數字*/
i++; /*i加1*/
}while(s[i]!='.'); /*當字元不為『.』時重復循環*/
top=push(top,k); /*將生成的數字壓入堆棧*/
}
if(s[i]=='+') /*如果為'+'號*/
{
top=ptop(top,&num2); /*將棧頂元素取出存入num2中*/
top=ptop(top,&num1); /*將棧頂元素取出存入num1中*/
result=num2+num1; /*將num1和num2相加存入result中*/
top=push(top,result); /*將result壓入堆棧*/
}
if(s[i]=='-') /*如果為'-'號*/
{
top=ptop(top,&num2); /*將棧頂元素取出存入num2中*/
top=ptop(top,&num1); /*將棧頂元素取出存入num1中*/
result=num1-num2; /*將num1減去num2結果存入result中*/
top=push(top,result); /*將result壓入堆棧*/
}
if(s[i]=='*') /*如果為'*'號*/
{
top=ptop(top,&num2); /*將棧頂元素取出存入num2中*/
top=ptop(top,&num1); /*將棧頂元素取出存入num1中*/
result=num1*num2; /*將num1與num2相乘結果存入result中*/
top=push(top,result); /*將result壓入堆棧*/
}
if(s[i]=='/') /*如果為'/'號*/
{
top=ptop(top,&num2); /*將棧頂元素取出存入num2中*/
top=ptop(top,&num1); /*將棧頂元素取出存入num1中*/
result=num1/num2; /*將num1除num2結果存入result中*
top=push(top,result); /*將result壓入堆棧*/
}
i++; /*i加1*/
}
top=ptop(top,&result); /*最後棧頂元素的值為計算的結果*/
return result; /*返回結果*/
}
STACK1 *initstack1(STACK1 *top) /*初始化*/
{
top=NULL; /*棧頂指針置為空*/
return top; /*返回棧頂指針*/
}
STACK1 *push(STACK1 *top,int x) /*入棧函數*/
{
STACK1 *p; /*臨時指針類型為STACK1*/
p=(STACK1 *)malloc(sizeof(STACK1)); /*申請STACK1大小的空間*/
if(p==NULL) /*如果p為空*/
{
printf("memory is overflow\n!!"); /*顯示內存溢出*/
exit(0); /*退出*/
}
p->data=x; /*保存值x到新空間*/
p->link=top; /*新結點的後繼為當前棧頂指針*/
top=p; /*新的棧頂指針為新插入的結點*/
return top; /*返回棧頂指針*/
}
STACK1 *pop(STACK1 *top) /*出棧*/
{
STACK1 *q; /*定義臨時變數*/
q=top; /*保存當前棧頂指針*/
top=top->link; /*棧頂指針後移*/
free(q); /*釋放q*/
return top; /*返回棧頂指針*/
}
int topx(STACK1 *top) /*讀棧頂元素*/
{
if(top==NULL) /*棧是否為空*/
{
printf("Stack is null\n"); /*顯示棧為空信息*/
return 0; /*返回整數0*/
}
return top->data; /*返回棧頂元素*/
}
STACK1 *ptop(STACK1 *top,int *x) /*取棧頂元素，並刪除棧頂元素*/
{
*x=topx(top); /*讀棧頂元素*/
top=pop(top); /*刪除棧頂元素*/
return top; /*返回棧頂指針*/
}
int empty(STACK1 *top) /*判棧是否為空*/
{
if(top==NULL) /*如果為空*/
return 1; /*返回1*/
else
return 0; /*否則返回0*/
}
STACK2 *initstack2(STACK2 *top) /*初始化*/
{
top=NULL; /*棧頂指針置為空*/
return top; /*返回棧頂指針*/
}
STACK2 *push2(STACK2 *top,char x) /*入棧函數*/
{
STACK2 *p; /*臨時指針類型為STACK2*/
p=(STACK2 *)malloc(sizeof(STACK2)); /*申請STACK2大小的空間*/
if(p==NULL) /*如果p為空*/
{
printf("memory is overflow\n!!"); /*顯示內存溢出*/
exit(0); /*退出*/
}
p->data=x; /*保存值x到新空間*/
p->link=top; /*新結點的後繼為當前棧頂指針*/
top=p; /*新的棧頂指針為新插入的結點*/
return top; /*返回棧頂指針*/
}
STACK2 *pop2(STACK2 *top) /*出棧*/
{
STACK2 *q; /*定義臨時變數*/
q=top; /*保存當前棧頂指針*/
top=top->link; /*棧頂指針後移*/
free(q); /*釋放q*/
return top; /*返回棧頂指針*/
}
char topx2(STACK2 *top) /*讀棧頂元素*/
{
if(top==NULL) /*棧是否為空*/
{
printf("Stack is null\n"); /*顯示棧為空信息*/
return ''; /*返回空字元*/
}
return top->data; /*返回棧頂元素*/
}
STACK2 *ptop2(STACK2 *top,char *x) /*取棧頂元素，並刪除棧頂元素*/
{
*x=topx2(top); /*讀棧頂元素*/
top=pop2(top); /*刪除棧頂元素*/
return top; /*返回棧頂指針*/
}
int empty2(STACK2 *top) /*判棧是否為空*/
{
if(top==NULL) /*如果為空*/
return 1; /*返回1*/
else
return 0; /*否則返回0*/
}
int text1(char *s)
{
setbkcolor(BLUE); /*設置背景顏色為藍色*/
cleardevice(); /*清除屏幕*/
setcolor(12); /*設置文本顏色為淡紅色*/
settextstyle(1, 0, 8);/*三重筆劃字體, 放大8倍*/
outtextxy(120, 120, s); /*輸出字元串s*/
setusercharsize(2, 1, 4, 1);/*水平放大2倍, 垂直放大4倍*/
setcolor(15); /*設置文本顏色為*白色/
settextstyle(3, 0, 5); /*無襯字筆劃, 放大5倍*/
outtextxy(220, 220, s); /*輸出字元串s*/
getch(); /*鍵盤輸入任一字元*/
return ; /*返回*/
}
J. 24點游戲C語言編程
{
printf("%-5d%-8s%-6s%-13s%-15s%-15s\n",per[i-1].score,per[i-1].name,per[i-1].age,per[i-1].num,per[i-1].adds,per[i-1].email);
if(i>1&&i%10==0)
{
printf("\t-----------------------------------\n");
printf("\t");
system("pause");
printf("\t-----------------------------------\n");
}
}
希望對你能有所幫助。