一、用C语言设计算法完成24点游戏的计算是什么

计算的情况举例如下。

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点可以考验人的智力和数学敏感性，它能在游戏中提高人们的心算能力。

二、用c语言编写24点代码分析

#include

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的情况.

三、C语言24点的算法

下面是我自己写的一个程序:

我的解法是把这个问题分解成了两个子问题，首先求出4个数字的无重复全排列，放到一个数组里面，再对没一个排列情况，从头到尾穷举所有的四则运算情况。注意到除法是特殊的，我用x/y表示x除以y，用x|y表示x分之y。注意到，如果穷举的解得到-24的话，只需要把有减法的地方调换一下顺序就可以了，代码如下

/***********************************************************************************/

#include

#include

#include

#include

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

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 dupflag=false;

for(int j=0;j

if(dupflag==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

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)

主程序为了简化，省去了对输入的检查，楼主可以自己添加。