c语言速算24游戏（c语言24点游戏详解）

今天给各位分享c语言速算24游戏的知识，其中也会对c语言24点游戏详解进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、C语言程序设计24点游戏，能算出24的运算法则的代码，很急2、如何用C语言做一个24点游戏的程序？3、编程C语言 24点游戏4、C语言纸牌速算24原理

C语言程序设计24点游戏，能算出24的运算法则的代码，很急

#includeiostream

#includemath.h

using namespace std;

const double MIN=1E-6;

void Print(int *Rank,double *FourNum)

{

for(int i=0;i4;i++)

coutFourNum[Rank[i]]” “;

coutendl;

}

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:

coutFourNum[Rank[0]];

break;

case 3:

coutFourNum[Rank[1]];

break;

case 5:

coutFourNum[Rank[2]];

break;

case 7:

coutFourNum[Rank[3]];

break;

case 2:

coutOper[i];

break;

case 4:

coutOper[j];

break;

case 6:

coutOper[k];

break;

}

}

coutendl;

}

}

void SearchTree(int Depth,int *Rank,int *FourNum,char *Oper,bool def)

{

int i,j,k;

if(Depth==4)

{

for(i=0;i4;i++)

for(j=0;j4;j++)

for(k=0;k4;k++)

Calculate_24(Rank,FourNum,Oper,i,j,k,def);

}

else

{

for(i=0;i4;i++)

{

int Remember=0;

for(j=0;jDepth;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;

cintime;

while(time–)

{

for(int i=0;i4;i++)//输入测试数据

cina[i];

cout”所有可能的结果：”endl;

SearchTree(0,b,a,c,def);

if(def==false)

cout”No”endl;

}

return 0;

}

如何用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;j4;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点游戏

#include “stdio.h”

#include “math.h”

#include “time.h”

void main()

{

void first();

void second();

int third();

time_t t;

int close=0;

char get;

clrscr();

srand((unsigned) time(t));

for(;;)

{

clrscr();

printf(“24 POINTS SYSTEM v2.2\n”);

printf(“MADE BY DANTE WANG\n”);

printf(“Jul.28th 2006\n\n”);

printf(“Please choose mode!\n\n”);

printf(“1. Game Mode\n”);

printf(“2. Count Mode\n”);

printf(“3. Quit\n\n”);

get=getch();

switch(get)

{

case ‘1’: first(); break;

case ‘2’: second();break;

case ‘3’: close=third(); break;

default: printf(“Please input 1, 2 or 3!\n”); getch();

}

if(close)

break;

}

}

void first()

{

int jdgsgn(int a,int b,int c,int d);

int n[4],i;

char ch[100],ch1[100];

int check(char *p);

int exam2(char *p,int a,int b,int c,int d);

void sign(int a,int b,int c,int d);

double figure(char *p);

void draw(int *p);

for(;;)

{

for(i=0;i4;i++)

{

n[i]=rand()%13+1;

}

draw(n);

if(!jdgsgn(n[0],n[1],n[2],n[3]))

{

printf(“No answer!”);

getch();

continue;

}

gets(ch);

if(!strcmp(strlwr(ch),”quit”))

break;

else

{

strcpy(ch1,ch);

if(!check(ch)!exam2(ch,n[0],n[1],n[2],n[3])fabs(figure(ch1)-24)=0.000001)

{

printf(“\nGood job!\n”);

getch();

}

else

{

printf(“\nWrong!\n\nAnswer: “);

sign(n[0],n[1],n[2],n[3]);

getch();

}

}

}

}

void second()

{

int n[4],i;

char c[4][10];

int exam(char *p);

void sign(int a,int b,int c,int d);

double recog(char *p);

clrscr();

printf(“Input 0 to leave.\n\n”);

for(;;)

{

for(i=0;i4;i++)

{

scanf(“%s”,c[i]);

if(exam(c[i]))

{

printf(“GRAMMER ERROR!\n”);

i–;

continue;

}

n[i]=(int)recog(c[i]);

if(n[i]==0)

break;

}

if(n[0]n[1]n[2]n[3])

sign(n[0],n[1],n[2],n[3]);

else

break;

}

}

int third()

{

printf(“Thanks for using this software!\n\n”);

printf(“If you have any advices or suggestions,\n\n”);

printf(“welcome to send email to wyc890618@163.com.\n\n”);

getch();

return(1);

}

void sign(int a,int b,int c,int d)

{

char *change(int x);

double figure(char *p);

int i[4],n,n1,n2,n3,n4,s1,s2,s3,t,flag=0;

char s[4][2]=,p[64]=,p1[64]=;

i[0]=a;

i[1]=b;

i[2]=c;

i[3]=d;

for(n1=0;n14;n1++)

{

for(n2=0;n24;n2++)

{

if(n2==n1)

continue;

for(n3=0;n34;n3++)

{

if(n3==n2||n3==n1)

continue;

for(n4=0;n44;n4++)

{

if(n4==n3||n4==n2||n4==n1)

continue;

for(s1=0;s14;s1++)

{

for(s2=0;s24;s2++)

{

for(s3=0;s34;s3++)

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

作者： wyc890618 2006-8-7 15:46 回复此发言

——————————————————————————–

2 完美的24点运算与游戏程序

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

if(s1/2==1(s2/2==0||s3/2==0))

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,”(“);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcat(p,”)”);

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

}

if(s1/2==0s2/2==1)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,”)”);

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

}

if(s2/2==0s1/2==1)

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,”(“);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,”)”);

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

}

if((s1/2==0||s2/2==0)s3/2==1)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,”)”);

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

}

if(s1/2==0s2/2==1s3/2==0)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,”)”);

strcat(p,s[s2]);

strcat(p,”(“);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcat(p,”)”);

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

printf(“%s\n”,p);

flag++;

break;

}

*p=’\0′;

}

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag==0)

printf(“No answer!\n”);

}

char *change(int x)

{

static char a[64];

char *c;

c=a+63;

*c=’\0′;

c–;

for(;;c–)

{

if(x=10)

{

*c=x%10+’1′-1;

x=x/10;

}

else

{

*c=x+’1′-1;

break;

}

}

return©;

}

double figure(char *p)

{

int judge(char *p);

int judge2(char *p);

void add(char *p);

void pick(char *p);

double recog(char *p);

char *c=p,*c1,c2[64];

int sign,kuoh=0,flag2=0;

double result,chu;

add(p);

for(sign=0;*c!=’\0′;c++)

{

if(*c==’+’||*c==’-‘||*c==’*’||*c==’/’||*c=='(‘||*c==’)’)

{

sign++;

break;

}

作者： wyc890618 2006-8-7 15:46 回复此发言

——————————————————————————–

3 完美的24点运算与游戏程序

}

if(sign==0)

return(recog(p));

else

{

c=p;

for(;*c!=’\0′;c++)

{

if(*c=='(‘)

kuoh++;

if(*c==’)’)

kuoh–;

if(!judge2©)

{

if(*c==’+’kuoh==0)

{

*c=’\0′;

result=figure(p)+figure(c+1);

flag2++;

break;

}

if(*c==’-‘kuoh==0)

{

*c=’\0′;

result=figure(p)-figure(c+1);

flag2++;

break;

}

}

if(!judge©)

{

if(*c==’*’kuoh==0)

{

*c=’\0′;

result=figure(p)*figure(c+1);

flag2++;

break;

}

if(*c==’/’kuoh==0)

{

*c=’\0′;

chu=figure(c+1);

if(chu==0)

{

result=99999;

}

else

{

result=figure(p)/chu;

}

flag2++;

break;

}

}

}

if(flag2)

return(result+0);

else

{

pick(p);

result=figure(p);

return(result+0);

}

}

}

int judge(char *p)

{

char *c=p;

int kuoh=0,flag=0;

for(c++;*c!=’\0′;c++)

{

if(*c=='(‘)

kuoh++;

if(*c==’)’)

kuoh–;

if(kuoh==0(*c==’+’||*c==’-‘||*c==’*’||*c==’/’))

{

flag++;

break;

}

}

return(flag);

}

int judge2(char *p)

{

char *c=p;

int kuoh=0,flag=0;

for(c++;*c!=’\0′;c++)

{

if(*c=='(‘)

kuoh++;

if(*c==’)’)

kuoh–;

if(kuoh==0(*c==’+’||*c==’-‘))

{

flag++;

break;

}

}

return(flag);

}

void add(char *p)

{

char *c=p,b[64];

int flag=0;

for(;*c!=’\0′;c++)

{

if((*c==’-‘||*c==’+’)(*(c+1)=’0’*(c+1)=’9′))

flag++;

if((*c=’0’*c=’9’||*c==’.’)(*(c+1)==’*’||*(c+1)==’/’||*(c+1)==’+’||*(c+1)==’-‘))

{

flag++;

break;

}

if((*c=’0’*c=’9’||*c==’.’)*(c+1)==’)’)

{

break;

}

}

if(flag==2)

flag=1;

else

flag=0;

if(flag)

{

c=p;

for(;*c!=’\0′;c++)

{

if(*(c+1)=’0’*(c+1)=’9′)

{

if(*c==’+’||*c==’-‘)

{

strcpy(b,c);

*c='(‘;

strcpy(c+1,b);

}

break;

}

}

c+=2;

for(;*c!=’\0′;c++)

{

if((*c’0’||*c’9′)*c!=’.’)

{

strcpy(b,c);

*c=’)’;

strcpy(c+1,b);

break;

}

}

}

}

void pick(char *p)

{

char *c=p;

if(*c=='(‘*(c+strlen©-1)==’)’)

{

strcpy(c,c+1);

*(c+strlen©-1)=’\0′;

}

}

double recog(char *p)

{

char *c=p;

int flag=0,number;

double quan,ans=0;

for(;;c++)

{

if(*c==’.’)

{

flag++;

number=c-p;

}

if(*c!=’.'(*c’0’||*c’9′))

break;

}

if(flag==0)

{

for(quan=1,c–;c=p;c–,quan*=10)

ans+=(*c-‘1’+1)*quan;

}

else

{

for(c–,quan=pow(10,number-(c-p));c=p;c–)

{

if(*c==’.’)

continue;

else

{

ans+=(*c-‘1’+1)*quan;

quan*=10;

}

}

}

return(ans);

}

int exam(char *p)

{

double recog(char *p);

char *c=p;

int number=0;

for(;*c!=’\0′;c++)

{

if(*c’9’||*c’0′)

number++;

if(number)

break;

}

if(!number)

{

if(recog(p)13||recog(p)0)

作者： wyc890618 2006-8-7 15:46 回复此发言

——————————————————————————–

4 完美的24点运算与游戏程序

number++;

}

return(number);

}

void draw(int *p)

{

time_t t;

int n;

clrscr();

printf(“Press \”quit\” to leave.”);

srand((unsigned) time(t));

for(n=0;n4;n++)

{

gotoxy(1+7*n,3);

printf(“\xda\xc4\xc4\xc4\xc4\xbf”);

gotoxy(1+7*n,4);

printf(“\xb3%c \xb3”,rand()%4+3);

gotoxy(1+7*n,5);

printf(“\xb3 \xb3”);

gotoxy(1+7*n,6);

switch(*(p+n))

{

case 1:

printf(“\xb3 A\xb3”);

break;

case 2:case 3:case 4:case 5:case 6:case 7:case 8:case 9:case 10:

printf(“\xb3%4d\xb3”,*(p+n));

break;

case 11:

printf(“\xb3 J\xb3”);

break;

case 12:

printf(“\xb3 Q\xb3”);

break;

case 13:

printf(“\xb3 K\xb3”);

}

gotoxy(1+7*n,7);

printf(“\xc0\xc4\xc4\xc4\xc4\xd9”);

gotoxy(1,9);

}

}

int jdgsgn(int a,int b,int c,int d)

{

char *change(int x);

double figure(char *p);

int i[4],n,n1,n2,n3,n4,s1,s2,s3,t,flag=0;

char s[4][2]=,p[64]=,p1[64]=;

i[0]=a;

i[1]=b;

i[2]=c;

i[3]=d;

for(n1=0;n14;n1++)

{

for(n2=0;n24;n2++)

{

if(n2==n1)

continue;

for(n3=0;n34;n3++)

{

if(n3==n2||n3==n1)

continue;

for(n4=0;n44;n4++)

{

if(n4==n3||n4==n2||n4==n1)

continue;

for(s1=0;s14;s1++)

{

for(s2=0;s24;s2++)

{

for(s3=0;s34;s3++)

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

if(s1/2==1(s2/2==0||s3/2==0))

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,”(“);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcat(p,”)”);

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

}

if(s1/2==0s2/2==1)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,”)”);

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

}

if(s2/2==0s1/2==1)

{

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,”(“);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,”)”);

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

}

if((s1/2==0||s2/2==0)s3/2==1)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,s[s2]);

strcat(p,change(i[n3]));

strcat(p,”)”);

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

}

if(s1/2==0s2/2==1s3/2==0)

{

strcat(p,”(“);

strcat(p,change(i[n1]));

strcat(p,s[s1]);

strcat(p,change(i[n2]));

strcat(p,”)”);

strcat(p,s[s2]);

strcat(p,”(“);

strcat(p,change(i[n3]));

strcat(p,s[s3]);

strcat(p,change(i[n4]));

strcat(p,”)”);

strcpy(p1,p);

if(fabs(figure(p1)-24)=0.000001)

{

flag++;

break;

}

*p=’\0′;

}

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

if(flag)

break;

}

return(flag);

}

int exam2(char *p,int a,int b,int c,int d)

{

double recog(char *p);

int number=0,num[4],flag=0,n,m;

num[0]=a;

num[1]=b;

num[2]=c;

num[3]=d;

for(m=0;*p!=’\0′;p++,m++)

{

if(*p=’0’*p=’9′(*(p+1)’9’||*(p+1)’0′))

number++;

if(m0*p=’0’*p=’9’*(p-1)=’0’*(p-1)=’9′)

continue;

if(*p=’9’*p=’0′)

{

if(recog(p)13||recog(p)1)

{

flag++;

break;

}

else

{

for(n=0;n4;n++)

{

if(recog(p)==num[n])

{

num[n]=0;

break;

}

}

}

}

}

if(!flag)

{

if(number!=4)

flag++;

else

if(num[1]||num[2]||num[3]||num[0])

flag++;

}

return(flag);

}

int check(char *p)

{

int kuoh=0,flag=0;

for(;*p!=’\0′;p++)

{

if(*p==’ ‘)

{

flag++;

break;

}

if(kuoh0)

{

flag++;

break;

}

if(*p=='(‘)

kuoh++;

if(*p==’)’)

kuoh–;

if((*p==’+’||*p==’-‘||*p==’*’||*p==’/’)(*(p+1)==’*’||*(p+1)==’/’||*(p+1)==’+’||*(p+1)==’-‘))

{

flag++;

break;

}

if(*p=='(‘(*(p+1)’9’||*(p+1)’0’*(p+1)!=’-‘))

{

flag++;

break;

}

if(*p==’)’*(p+1)!=’+’*(p+1)!=’-‘*(p+1)!=’*’*(p+1)!=’/’*(p+1)!=’\0’)

{

flag++;

break;

}

}

if(!flag)

{

if(kuoh!=0)

flag++;

}

return(flag);

}

另外,站长团上有产品团购,便宜有保证

C语言纸牌速算24原理

/* 计算24是流行的扑克游戏。其方法是任意取出4张牌，A J Q K 王牌 算 1，其它牌按点数计算，花色不计。

目标是通过加、减、乘、除和括号最终算出24。设计一个程序，输入4个数字（1~10），则列出所有可能计算

结果为24的方案。要求：

方案不能重复（加法乘法交换律等算不同方案）。

计算中局部可以为分数，结果为整数即可（如 3 3 7 7 算法： (3 + 3/7)*7）

如果没有找到方案输出：无解。

在某些可不用括号的地方不用括号(即去掉括号后等式的解不变)

待完善：

1)除数不能为零没考虑(不用考虑可正常运行)

*/

#includestdio.h

#includemalloc.h

int zuheshu(float s[],int n); // 组合数的函数

float zuhe[4]={0}; // 暂时存放组合

int sum=0; // 用于计数

// 动态分配n个float变量的数组

float * fsz(int n)

{

return (float *)malloc(sizeof(float)*n);

}

int zuhefu(); //符号组合

int yunsuan(float s[],char p[],int k0[],int k1[]); // 算式组合

float qiujie(float suanshi[],int n); // 算式求解

int hefa(float suanshi[],int r); // 算式正确性检查

float jianjie(float suanshi[],int r); // 算式简洁性检查

int fuhe=0; // 计数符合算式数

void main()

{

// 输入四个数

//float shu[4]={0};

//printf(“请输入4个数字(1~10):\n”);

//scanf(“%f”,shu[0]);

//scanf(“%f”,shu[1]);

//scanf(“%f”,shu[2]);

//scanf(“%f”,shu[3]);

//float shu[4]={1,2,3,4};

//printf(“输入的4个数字依此是: %.0f %.0f %.0f %.0f\n”,shu[0],shu[1],shu[2],shu[3]);

//float s[4]={3,3,3,3},shu[4]={0};

//printf(“请输入四个数(0-9):\n”);

for(int i=0;i4;i++)

{

scanf(“%f”,s[i]);

for(int j=i;j0;j–)

{

if(s[j]=s[j-1])

{

float s0=s[j-1];

s[j-1]=s[j];

s[j]=s0;

}

}

}

printf(“四个数是:”);

for(i=0;i4;i++)

{

printf(“%.0f “,s[i]);

}

printf(“\n”);

zuheshu(s,4);

printf(“有%d个算式符合\n”,fuhe);

}

// 组合数，并调用yunsuan

int zuheshu(float s[],int n)

{

if(n==1)

{

zuhe[4-n]=s[0];

zuhefu();

return 1;

}

for(int i=0;in;i++)

{

if(i==0)

{

// 直接填入s[0],数组和候选数中去除该数,递归

zuhe[4-n]=s[i];

float *p=fsz(n-1);

int o=0;

for(int k=0;kn;k++)

{

if(k!=i)

p[o++]=s[k];

}

zuheshu(p,n-1);

free(p);

}

else if(s[i]!=s[i-1])

{

// 直接填入s[0],数组和候选数中去除该数,递归

zuhe[4-n]=s[i];

float *p=fsz(n-1);

int o=0;

for(int k=0;kn;k++)

{

if(k!=i)

p[o++]=s[k];

}

zuheshu(p,n-1);

free(p);

}

}

}

// 组合运算符号,并调用yunsuan

int zuhefu()

{

// 对操作符’+’,’—’,’*’,’/’组合

char opter[4]={‘+’,’-‘,’*’,’/’};

for(int h=0;h4;h++) // 第一个操作符

{

for(int i=0;i4;i++) // 第二个操作符

{

for(int j=0;j4;j++) // 第三个操作符

{

char op[3]; // 放置操作符

op[0]=opter[h];

op[1]=opter[i];

op[2]=opter[j];

// 对括号组合

// 0 1 1 1 2 2 2 3

int khzh[8][3]={{0,0,0},{0,0,1},{0,1,0},{1,0,0},{0,1,1},{1,0,1},{1,1,0},{1,1,1}}; // 正或反括号

for(int k=0;k=3;k++)

{

switch(k)

{

case 0: // 有0个括号

{

yunsuan(zuhe,op,khzh[0],khzh[0]);

}

break;

case 1: // 有1个括号

{

for(int m=1;m=3;m++) // 正括号

{

for(int n=1;n=3;n++) //反括号

{//代码将算式组合，并判断正确性;其中(括号)010和100为错误组合,010和010无错误组合,001和100为错误组合,

//同时100和001可视做无括号应过滤（即正括号后接操作数,操作符,不能是操作数,反括号）

//正确组合有六组

if((m==2n==3)||(m==1n==2)||(m==3n==1)||(m==1n==3))

continue;

yunsuan(zuhe,op,khzh[m],khzh[n]);

}

}

}

break;

case 2: // 有2个括号

{

//代码将算式组合，并判断正确性;其中(括号)*1*和1**为错误组合，**1和*1*为错误组合，

//应过滤（即正括号后接操作数，操作符，不能是操作数，反括号）同时出现1**和**1也应视为0**和**0

//正确括法只有一种即101和101

yunsuan(zuhe,op,khzh[5],khzh[5]);

}

break;

case 3: //有3个括号,不可能

//利用khzu[7]代码将算式组合，并判断正确性(不正确)

break;

}

}

}

}

}

return 1;

}

// 对s[]中的四个数按照p[]和k[]中的运算符进行组合并调用qiujie()函数运算判断结果是否为24

int yunsuan(float s[],char p[],int k0[],int k1[])

{

float suanshi0[13]={‘0’}; // 合成等式

int r=0; // 等式的长度

// 组合等式

for(int q=0;q13;q++)

{

switch(q)

{

case 0:

{

if(k0[0]==1)

suanshi0[r++]='(‘;

}

break;

case 1:

{

suanshi0[r++]=s[0];

}

break;

case 2:

{

suanshi0[r++]=p[0];

}

break;

case 3:

{

if(k0[1]==1)

suanshi0[r++]='(‘;

}

break;

case 4:

{

suanshi0[r++]=s[1];

}

break;

case 5:

{

if(k1[0]==1)

suanshi0[r++]=’)’;

}

break;

case 6:

{

suanshi0[r++]=p[1];

}

break;

case 7:

{

if(k0[2]==1)

suanshi0[r++]='(‘;

}

break;

case 8:

{

suanshi0[r++]=s[2];

}

break;

case 9:

{

if(k1[1]==1)

suanshi0[r++]=’)’;

}

break;

case 10:

{

suanshi0[r++]=p[2];

}

break;

case 11:

{

suanshi0[r++]=s[3];

}

break;

case 12:

{

if(k1[2]==1)

suanshi0[r++]=’)’;

}

break;

}

}

float * suanshi=fsz(r); // 动态空间申请

for(int i=0;ir;i++)

{

suanshi[i]=suanshi0[i];

}

// 组合算式的正确性检查

float f=hefa(suanshi,r);

if(f==0)

{

return 0;

}

// 组合算式的简洁性检查

f=jianjie(suanshi,r);

if(f==0)

{

return 0;

}

// 调用函数求解结果为24则输出等式

float sum0=qiujie(suanshi,r);

if(sum0==24)

{

fuhe++;

for(int t=0;tr;t++)

{

if(suanshi[t]10)

printf(“%c”,char(suanshi[t]));

else

printf(“%0.0f”,suanshi[t]);

}

printf(“=%0.0f\n”,sum0);

}

free(suanshi);

return 1;

}

// 算式正确性检查

int hefa(float suanshi[],int r)

{

float * p=suanshi[0]; // 为当前指针

float * q=suanshi[1]; // 为下一指针

int flag=1; // 等式正确标记

while(1)

{

if(*p==40) // 判断是否为'(‘

{

if((*q=0)(*q=9))

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if((*p=0)(*p=9)) // 判断是否为数

{

if((p-suanshi)=(r-1))

{

break;

}

if(*q==’)’||((*q41)(*q48))) // ‘+’,’-‘,’*’,’/’在次范围内

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if(*p==41) // 判断是否为’)’

{

if((p-suanshi)=(r-1))

{

break;

}

if((*q41)(*q48)) // ‘+’,’-‘,’*’,’/’在次范围内

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if((*p41)(*p48)) // // 判断是否为符号

{

if(*q==40||((*q=0)(*q=9)))

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

}

return flag;

}

// 算式简洁性检查

float jianjie(float suanshi[],int r)

{

float re=1; // 是否括号不影响算式求解

float *p=re,*q=re;

int k=0; // 括号数目

int k1=0; // 运算符的个数

float r0=0; // ‘(‘前的运算符优先级

float r2=1; // 算式运算符优先级

float r1=0; // ‘)’后的运算符优先级

int r3=0;

for(int i=0;ir;i++)

{

if(suanshi[i]=='(‘)

{

k++;

if(*p!='(‘||k==1)

{

p=suanshi[i];

if(i!=0)

{

if(*(p-1)==’+’||*(p-1)==’-‘)

{

r0=1;

}

else if(*(p-1)==’*’||*(p-1)==’/’)

{

r0=2;

}

if(*(p-1)==’-‘)

{

r0+=100;

}

else if(*(p-1)==’/’)

{

r0+=1000;

}

}

}

}

else if(suanshi[i]==’)’)

{

if(k–==1)

{

q=suanshi[i];

if(i!=r-1)

{

if(*(q+1)==’+’||*(q+1)==’-‘)

{

r1=1;

}

else if(*(q+1)==’*’||*(q+1)==’/’)

{

r1=2;

}

}

//递归

re=jianjie(p+1,q-p-1); // 返回括号内的优先级

if(int(r0/100)=1) // 括号'(‘外出现减号或除号

{

if((int(r0/100))==1(int(re/100))==1) // 括号'(‘外出现减号,括号内出现+或-

{

continue;

}

else if((int(r0/1000))==1(int(re/1000))==1) // 括号'(‘外出现除号,括号内出现*或/

{

continue;

}

}

if(int(re/100)==1)

re-=100;

if(int(re/1000)==1)

re-=1000;

if(int(r0/100)==1)

r0-=100;

else if(int(r0/1000)==1)

r0-=1000;

if(re==0)

return 0;

if(re=r0re=r1)

return 0;

}

}

else if(k==0)

{

if(suanshi[i]==’+’||suanshi[i]==’-‘)

{

r2=((r2*k1)+1)/(++k1);

r3=r3/10+1;

}

else if(suanshi[i]==’*’||suanshi[i]==’/’)

{

r2=(r2*k1+2)/(++k1);

r3=r3%10+10;

}

}

}

if(r3%10==1)

r2+=100;

if(r3/10==1)

r2+=1000;

return r2;

}

// 调用函数求解结果为24则输出等式

float qiujie(float suanshi[],int n)

{

if(n==3)

{

float a=0;

switch(char(suanshi[1]))

{

case ‘+’:

return (suanshi[0]+suanshi[2]);

case ‘-‘:

return (suanshi[0]-suanshi[2]);

case ‘*’:

return (suanshi[0]*suanshi[2]);

case ‘/’:

return (suanshi[0]/suanshi[2]);

}

}

// 过滤掉括号项

float pq=’0′;

float * p=pq; // 指向算式的第一个正括号

float * q=pq; // 指向算式的与第一个正括号配对的反括号

int k=0;

float suanshi1[7]={‘0’}; // 除去括号后的算式

int s=0; // 用来记录suanshi1数组的长度

float sum=0; // 算式的值

for(int m=0;mn;m++)

{

if(suanshi[m]=='(‘)

{

k++;

if((*p)!='(‘)

{

p=suanshi[m];

}

continue;

}

if(suanshi[m]==’)’)

{

if(k–==1)

{

q=suanshi[m];

suanshi1[s++]=qiujie(p+1,q-p-1);

p=pq;

q=pq;

}

continue;

}

if(k==0)

{

suanshi1[s++]=suanshi[m];

continue;

}

}

if(s==3)

{

sum=qiujie(suanshi1,s);

}

else

{

p=suanshi1[0]; // 指向第一个数

q=suanshi1[2]; // 只想第二个数

for(m=0;m(s-1)/2;m++)

{

switch(char(suanshi1[2*m+1]))

{

case ‘+’:

if((s-1)/2!=1(suanshi1[2*(m+1)+1]==’*’||suanshi1[2*(m+1)+1]==’/’))

{

*q=qiujie(p+2,3);

int ws=suanshi1[s-1]-suanshi1[2*(m+1)];

for(int w=1;w=ws;w++)

{

if(((q+w+2)-(q+ws))0)

{

*(q+w)=-1;

}

else

{

*(q+w)=*(q+w+2);

}

}

s=s-2;

m–;

}

else

{

if(m==0)

{

sum+=*p+*q;

}

else

{

sum+=*q;

}

p=p+2;

q=q+2;

}

break;

case ‘-‘:

if((s-1)/2!=1(suanshi1[2*(m+1)+1]==’*’||suanshi1[2*(m+1)+1]==’/’))

{

*q=qiujie(p+2,3);

int ws=suanshi1[s-1]-suanshi1[2*(m+1)];

for(int w=1;w=ws;w++)

{

if(((q+w+2)-(q+ws))0)

{

*(q+w)=-1;

}

else

{

*(q+w)=*(q+w+2);

}

}

s=s-2;

m=-1;

}

else

{

if(m==0)

sum+=*p-*q;

else

sum-=*q;

p=p+2;

q=q+2;

}

break;

case ‘*’:

if(m==0)

sum+=(*p)*(*q);

else

sum*=*q;

p=p+2;

q=q+2;

break;

case ‘/’:

if(m==0)

{

sum+=(*p)/(*q);

}

else

{

sum/=*q;

}

p=p+2;

q=q+2;

break;

}

}

}

return sum;

}

关于c语言速算24游戏和c语言24点游戏详解的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。