C语言写24点游戏

⑴ 24点游戏c语言

#include<cstdlib>#include<iostream>#include<ctime>using namespace std;
class CCard{private: int m_Pip[5];//一共五张牌 int m_Number;//发了多少张牌 int m_Dollar;//赌本 int m_Gamble;//赌注 int m_Win;//赢局数 int m_Lose;//输局数 int m_Draw;//平局数public: CCard();//构造函数。 void FirstPlayTwo();//最初的两张牌 int GetNumber();//返回牌张 int GetPip();//返回点数 void DisplayPip();//依次全部显示牌面的点数 void DisplayPip(int);//除了第一张牌，依次显示全部牌面点数（针对计算机牌的显示） void TurnPlay();//出一张牌。 void Win();//赢了计算赌注 void Lose();//输了 void Draw();//平局 int SetGamble(int);//设置赌本，赌本不够返回-1 int GetMoney();//返回钱数 void DisplayInfo();//打印必要的信息 int GetCurrentCard();//返回当前的牌点};
CCard::GetNumber(){ return m_Number;}
CCard::CCard()//构造函数，初始化{ m_Number = 0; m_Dollar = 100;//初始赌注为100美元 for(int i=0;i<5;i++) m_Pip[i] = 0; m_Gamble = 0; m_Win = m_Lose = m_Draw = 0;}
int CCard::GetMoney(){ return m_Dollar;}
void CCard::DisplayInfo()//打印必要的信息{ cout<<"\n\n\n\t\t\t您一共玩了"<<m_Win+m_Lose+m_Draw<<"局 "<<"赢了"<<m_Win<<"局 "<<"输了"<<m_Lose<<"局 "<<"平局"<<m_Draw<<"次。"<<endl; cout<<"\n\t\t\t\t您的赌本共计有$"<<m_Draw<<"。\n"<<endl;}
int CCard::SetGamble(int gamble){ if(gamble<0) { cout<<"\n输入金额有误"<<endl; return -1; } if(m_Dollar-gamble<0) { cout<<"\n金额不足"<<endl; return -1; } else m_Gamble = gamble; m_Dollar -= gamble; return 0;}
void CCard::FirstPlayTwo()//最初两张牌{ m_Pip[0] = rand()%13+1; m_Pip[1] = rand()%13+1; m_Number = 2;}
int CCard::GetPip(){ int SumPip = 0; for(int i=0;i<m_Number;i++) { SumPip += m_Pip[i]; } return SumPip;}
void CCard::DisplayPip(){ int i; for(i=0;i<m_Number;i++) { cout<<m_Pip[i]<<'\t'; } cout<<endl;}
void CCard::TurnPlay(){ m_Number++; m_Pip[m_Number-1] = rand()%13+1;}
void CCard::Win(){ cout<<"赢家牌面："; DisplayPip(); cout<<"\n牌面点数："<<GetPip()<<endl; m_Dollar = m_Dollar + 2 * m_Gamble; m_Win++; cout<<"\n赌本：$"<<m_Dollar<<" 赢了"<<m_Win<<"次 "<<"输了"<<m_Lose<<"次 "<<"平局"<<m_Draw<<"次"<<endl; cout<<endl; cout<<endl;}
void CCard::Lose(){ m_Lose++; cout<<"\n输家的牌面："; DisplayPip(); if(GetPip()>21) cout<<"\t\t\t\t\t\t\t\t暴了！"<<endl; else cout<<"牌面点数："<<GetPip()<<endl; cout<<"\n赌本：$"<<m_Dollar<<" 赢了"<<m_Win<<"次 "<<"输了"<<m_Lose<<"次 "<<"平局"<<m_Draw<<"次"<<endl; cout<<endl<<endl;}
void CCard::Draw(){ m_Draw++; m_Dollar += m_Gamble; cout<<"\n平局牌面："; DisplayPip(); if(GetPip()>21) cout<<"\n暴了！"<<endl; else cout<<"牌面点数："<<GetPip()<<endl; cout<<"赌本：$"<<m_Dollar<<" 赢了"<<m_Win<<"次 "<<"输了"<<m_Lose<<"次 "<<"平局"<<m_Draw<<"次"<<endl; cout<<endl<<endl;}
void DisplayRule(void){ cout<<endl<<endl; cout<<"\t※※※※※※※※※※欢迎进入21点游戏世界!※※※※※※※※※※\n\n"; cout<<"\t\t 游戏规则：\n"; cout<<endl; cout<<"\t\t 1.玩家最多可以要5张牌；\n"; cout<<endl; cout<<"\t\t 2.如果牌点数的总数超过21点则暴点，自动判数；\n"; cout<<endl; cout<<"\t\t 3.赢家可得双倍的赌注；\n"; cout<<endl; cout<<"\t\t 4.计算机方在大于等于16点时不再要牌。\n"; cout<<endl; cout<<"\t※※※※※※※※※※※※※ 祝您好运！ ※※※※※※※※※※\n"; cout<<endl<<endl;}
void Judge(CCard &cpu,CCard &player){ cout<<endl; if((cpu.GetPip()>21&&player.GetPip()>21)||cpu.GetPip()==player.GetPip()) { cout<<"\n\n\t\t\t\t\t\t\t\t平局！\n"; cout<<"计算机数据：\t"; cpu.DisplayPip(); cout<<"牌面点数："<<cpu.GetPip()<<endl; cout<<"\n您的数据：\t"; player.Draw(); cout<<endl; } else if((cpu.GetPip()>21)||(player.GetPip()>cpu.GetPip()&&player.GetPip()<=21)) { cout<<"\n\n\n\t\t\t\t\t\t\t\t恭喜您赢了！\n\n"; cout<<"计算机数据：\t"; cpu.DisplayPip(); cout<<"牌面点数："<<cpu.GetPip()<<endl; cout<<"\n您的数据：\t"; player.Win(); cout<<endl; } else { cout<<"\n\n\t\t\t\t\t\t\t\t很遗憾您输了！\n"; cout<<"计算机数据：\t"; cpu.DisplayPip(); cout<<"牌面点数："<<cpu.GetPip()<<endl; cout<<"\n您的数据：\t"; player.Lose(); cout<<endl; }}void CCard::DisplayPip(int n){ int i; cout<<"[*]"<<'\t'; for(i=1;i<m_Number;i++) cout<<m_Pip[i]<<'\t'; cout<<endl;}
void PlayTurn(CCard &cpu,CCard & player)//玩一局{ char chChoice; int blCpu = 1;//判断是否要牌 int blPlayer = 1; cpu.FirstPlayTwo();//计算机和玩家各要两张牌 player.FirstPlayTwo(); do { cout<<"\n您的牌点为：\t"; player.DisplayPip(); cout<<"\n"; cout<<"您的牌面点数是："<<player.GetPip()<<endl; cout<<"\n计算机的牌点为：\t"; cpu.DisplayPip(1); if(blPlayer) { cout<<"\n\n\t您是否继续要牌（Y/N）?\t\t\t"; cin>>chChoice; if((chChoice == 'Y'||chChoice == 'y')) { if(player.GetNumber()<5) { player.TurnPlay(); cout<<"\n您要的这张牌是："<<player.GetPip()<<endl; if(player.GetPip()>21) blPlayer = 0; } else { cout<<"对不起，您已经要了5张牌，不能再要牌了！"; blPlayer = 0; } } if(chChoice=='n'||chChoice=='N') blPlayer = 0; } if(cpu.GetPip()<16&&cpu.GetNumber()<5) { cpu.TurnPlay(); cout<<"\n计算机要牌，牌点是："<<cpu.GetPip()<<endl; } else blCpu = 0; if(blCpu&&player.GetNumber()<5&&player.GetPip()<21) blPlayer = 1; }while(blCpu||blPlayer); Judge(cpu,player); return ;}
int main(){ srand((unsigned)time(NULL));//初始化随机数种子 CCard cpu,player; int blLogic; int nMoney;// DisplayRule();// char chChoice; cout<<"是否现在开始游戏（Y/N）?\t\t"; cin>>chChoice; while(chChoice=='Y'||chChoice=='y') { do { cout<<endl; cout<<"\t\t\t您现在有的赌本：$"<<player.GetMoney(); cout<<"\n\n请下注（赌注不能超过赌本）；"; cin>>nMoney; blLogic = player.SetGamble(nMoney); if(blLogic) cout<<"您的赌本不够，请重新下注！\n"; }while(blLogic); PlayTurn(cpu,player);// cout<<"是否继续21点游戏（Y/N）?\t\t\t"; cin>>chChoice; } player.DisplayInfo(); cout<<"\t\t\t您的选择是明智的，赌博有碍家庭和睦！\n"; cout<<"\n\n\t\t\t\t欢迎再次使用此程序！"<<endl<<endl<<endl;
return 0;}

⑵ 适合初学者的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语言实训求：编程实现24点游戏算法

上面的程序是正确的，这题的解法用到的基本思想就是回溯，树的深度为最深为4，树的判断分支为 加减乘除，对不满足条件的解进行剪枝（即当前结果>=24）,当到达递归边界（即树的深度为四时）时，即判断当前的结果是否符合条件（=24），符合即找到解，否则继续进行。

⑷ 24点游戏用c语言怎么写

你首先要懂得C语言编写规则，其次了解24点游戏的玩法及规则，然后就可以选择一个合适的编译器，开始编写24点游戏了

⑸ 编程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");
}
}

⑹ 如何用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 ; /*返回*/
}

⑺ 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);//

}

⑻ 如何用C语言编写一个24点的游戏

我可以用C++帮你编一个这样的小程序
但不知道C++算不算得上是C语言？
这个程序有些笨，它无法分辨重复的牌，
只能简单进行计算。但结果是没问题的
虽然和你需要的有点出入，但是下面的小程序也算是提供一种思路吧

#include<iostream>
using namespace std;

int main(){
int i1,i2,i3,i4,v,n1,n2;
double t1,t2,t3,t4,choice[4],s1[4],s2[4][4];

cout<<"##########################二十四点全解###################################\n友情提示：A=1,J=11,Q=12,K=13\n";
cout<<"请说出你抽到的第一牌：";
cin>>choice[0];
cout<<"请说出你抽到的第二牌：";
cin>>choice[1];
cout<<"请说出你抽到的第三牌：";
cin>>choice[2];
cout<<"请说出你抽到的第四牌：";
cin>>choice[3];
cout<<"########################## THINKING ###################################\n";
for(i1=0;i1<4;i1++){
t1=choice[i1];
for(i2=0;i2<4;i2++){
if(i2!=i1){
t2=choice[i2];
s1[0]=t1+t2;
s1[1]=t1-t2;
s1[2]=t1*t2;
s1[3]=t1/t2;
for(i3=0;i3<4;i3++){
if(i3!=i1&&i3!=i2){
t3=choice[i3];
for(v=0;v<4;v++)
{s2[v][0]=s1[v]+t3;
s2[v][1]=s1[v]-t3;
s2[v][2]=s1[v]*t3;
s2[v][3]=s1[v]/t3;}
for(i4=0;i4<4;i4++){
if(i4!=i1&&i4!=i2&&i4!=i1){
t4=choice[i4];
for(n1=0;n1<4;n1++)for(n2=0;n2<4;n2++)
if(s2[n1][n2]+t4==24||s2[n1][n2]-t4==24||s2[n1][n2]*t4==24||s2[n1][n2]/t4==24){
cout<<"找到一种组合方案：\n(("<<t1;

if(s1[n1]==t1+t2)cout<<" + ";
if(s1[n1]==t1-t2)cout<<" - ";
if(s1[n1]==t1*t2)cout<<" * ";
if(s1[n1]==t1/t2)cout<<" / ";

if(n2==0)cout<<t2<<") + "<<t3;
if(n2==1)cout<<t2<<") - "<<t3;
if(n2==2)cout<<t2<<") * "<<t3;
if(n2==3)cout<<t2<<") / "<<t3;

if(s2[n1][n2]+t4==24)cout<<") + "<<t4<<" = 24 \n";
if(s2[n1][n2]-t4==24)cout<<") - "<<t4<<" = 24 \n";
if(s2[n1][n2]*t4==24)cout<<") * "<<t4<<" = 24 \n";
if(s2[n1][n2]/t4==24)cout<<") / "<<t4<<" = 24 \n";

}

}}}
}}}}

return 0;
}

⑼ 50分求C语言编写24点游戏

你把题目说的完整点，我就没看明白什么意思。系统自动生成1-13的数，通过什么计算24点啊？程序内部写算法（那也得告诉我怎么计算）还是手动输入算法。最后的输出是什么？是不是两个人玩，然后进行判断最接近24点的赢？

⑽ 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");
}
}
希望对你能有所帮助。