c语言中24
Ⅰ c语言中24点对运算符的处理
这段程序看得怎么这么别扭。。。
char确定不要用加''?
for循环里面还基本没见人用++i的呢，都是i++,前者会使i从1到4
l = a[1] (c[i]) a[2] (c[j]) a[3] (c[k]) a[4];这句话也看得我菊花一紧。。。还能这么写么？是我out了
上面的l定义的是float ，后面输出的确实%d
Ⅱ c语言这个程序输出结果为什么是24
这是因为编译时存在字节对齐的原因，字节对齐主要是为了提高内存数据读取速度。如果你想要让结果等于实际大小，你可以设置字节对齐大小如
#pragma pack(1)
取消设置
#pragma pack()
字节对齐的规则如下：
结构体的大小等于其最大成员的整数倍；
结构体成员的首地址相对于结构体首地址的偏移量是其类型大小的整数倍。
比如double型成员的首地址相对于结构体首地址的偏移量应该是8的倍数；
满足前两条规则后，编译器会在结构体成员之后进行字节填充。
Ⅲ 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)
主程序为了简化，省去了对输入的检查，楼主可以自己添加。
Ⅳ C语言算24点
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
char op[3], o[5]="+-*/";
float n[4], on[10];
int used[4] = {0}, top=0, tp=0, x;
void chk(float k);
void search24(int d);
float calc(float n1, float n2, char o);
void make(int i, float p, float q, char o, int d);
int main( void )
{
printf("please input 4 card number: ");
scanf("%f%f%f%f", &n[0], &n[1], &n[2], &n[3]);
search24(0);
printf("No answer. ");
return 0;
}
void chk(float k)
{
if( (tp != 3) || ( fabs(k-24.0) > 0.000001 )) //没有用完3个运算符或者结果不为24就退出.
return;
for(x=0; x<5; x+=2) //这样设计是为了使3个选中的符号都可以得到输出.
printf("%g%c%g=%g ", on[x], op[x/2], on[x+1], //分析得到的.
calc(on[x], on[x+1], op[x/2]));
system("pause");
exit(0);
}
float calc(float n1, float n2, char o)
{
switch(o){
case '+': return (n1+n2);
case '-': return (n1-n2);
case '*': return (n1*n2);
case '/': return (n1/n2);
default: exit(0);
}
}
void make(int i, float p, float q, char o, int d)
{
if(fabs(q)>0.000001 || o!='/') //除数不为0,或者为0的时候不能为除数.
n[i] = calc(p, q, o);
op[tp++] = o;
chk(n[i]);
search24(d+1);
tp--; //因为是全是全局变量,所以在做试验性的循环递归问题时,如果失败,要在递归函数后面重新恢复回原来的值
}
void search24(int d)
{
int i, j, k;
float p, q;
if(d>=3) //控制递归深度,就是运算符的输出个数.
return;
for(i=0; i<4; i++)
for(j=0; j<4; j++)
if( (i!=j)&& (used[i]+used[j] == 0) ) //i!=j是防止重复,(used[i]+used[j] == 0)是防止又再匹配已经用过的j,
//但是i可以新来.
{
used[j] = 1; //j得到匹配之后,赋值为1,表示已经使用
p=n[i];
q=n[j];
on[top++] = p;
on[top++] = q;
for(k=0; k<4; k++) //运算符的循环试用.
make(i, p, q, o[k], d);
n[i] = p; //因为是全是全局变量,所以在做试验性的循环递归问题时,
used[j] = 0; //如果失败,要在递归函数后面重新恢复回原来的值
top -= 2; //
}
}
出处:http://blog.sina.com.cn/s/blog_491de9d60100d5er.html
Ⅳ c语言24点
http://..com/question/130189305.html?an=1&si=2
这个是类似的，你去看看。
Ⅵ C语言纸牌速算24原理
/* 计算24是流行的扑克游戏。其方法是任意取出4张牌，A J Q K 王牌 算 1，其它牌按点数计算，花色不计。
目标是通过加、减、乘、除和括号最终算出24。设计一个程序，输入4个数字（1~10），则列出所有可能计算
结果为24的方案。要求：
方案不能重复（加法乘法交换律等算不同方案）。
计算中局部可以为分数，结果为整数即可（如 3 3 7 7 算法： (3 + 3/7)*7）
如果没有找到方案输出：无解。
在某些可不用括号的地方不用括号(即去掉括号后等式的解不变)
待完善：
1)除数不能为零没考虑(不用考虑可正常运行)
*/
#include<stdio.h>
#include<malloc.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;i<4;i++)
{
scanf("%f",&s[i]);
for(int j=i;j>0;j--)
{
if(s[j]<=s[j-1])
{
float s0=s[j-1];
s[j-1]=s[j];
s[j]=s0;
}
}
}
printf("四个数是:");
for(i=0;i<4;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;i<n;i++)
{
if(i==0)
{
// 直接填入s[0],数组和候选数中去除该数,递归
zuhe[4-n]=s[i];
float *p=fsz(n-1);
int o=0;
for(int k=0;k<n;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;k<n;k++)
{
if(k!=i)
p[o++]=s[k];
}
zuheshu(p,n-1);
free(p);
}
}
}
// 组合运算符号,并调用yunsuan
int zuhefu()
{
// 对操作符'+','—','*','/'组合
char opter[4]={'+','-','*','/'};
for(int h=0;h<4;h++) // 第一个操作符
{
for(int i=0;i<4;i++) // 第二个操作符
{
for(int j=0;j<4;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==2&&n==3)||(m==1&&n==2)||(m==3&&n==1)||(m==1&&n==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;q<13;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;i<r;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;t<r;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==')'||((*q>41)&&(*q<48))) // '+','-','*','/'在次范围内
{
p++;
q++;
}
else
{
flag=0;
break;
}
}
if(*p==41) // 判断是否为')'
{
if((p-suanshi)>=(r-1))
{
break;
}
if((*q>41)&&(*q<48)) // '+','-','*','/'在次范围内
{
p++;
q++;
}
else
{
flag=0;
break;
}
}
if((*p>41)&&(*p<48)) // // 判断是否为符号
{
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;i<r;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>=r0&&re>=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;m<n;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进制数 急求！！
//0~9,A~N表示0～23
#include<stdio.h>
#define N 24
void main()
{ int n; char str[256],*p;
printf("请输入一个%d进制数据：",N); scanf("%s",str); p=str; n=0;
while ( *p )
{ n*=N;
if ( ((*p)>='0')&&((*p)<='9') ) n+=(*p)-'0';
elseif (((*p)>='a')&&((*p)<='n') ) n+=(*p)-'a'+10;
elseif (((*p)>='A')&&((*p)<='N') ) n+=(*p)-'A'+10;
p++;
}
printf("你输入的数据转换成十进制为：%d ",n);
}
Ⅷ C语言程序 算24点
#include<iostream>
using namespace std;
struct operation
{
int x;
int y;
int o;
}op[3];
bool co=false;
void g(int a[],int b[],int n,int i,int j)
{
int x,y;
for(x=0,y=1;x<n;x++)
{
if(x==i||x==j)continue;
b[y++]=a[x];
}
op[4-n].x=a[i];
op[4-n].y=a[j];
}
void f(int a[],int n)
{
int i,j,t,b[4];
if(n==1&&a[0]==24)co=true;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
for(t=1;t<=6;t++)
{
switch(t)
{
case 1:g(a,b,n,i,j);
b[0]=a[i]+a[j];
op[4-n].o=t;
f(b,n-1);
if(co)return;
break;
case 2:g(a,b,n,i,j);
b[0]=a[i]-a[j];
op[4-n].o=t;
f(b,n-1);
if(co)return;
break;
case 3:g(a,b,n,i,j);
b[0]=a[i]*a[j];
op[4-n].o=t;
f(b,n-1);
if(co)return;
break;
case 4:
if(a[j]!=0&&a[i]%a[j]==0)
{
g(a,b,n,i,j);
b[0]=a[i]/a[j];
op[4-n].o=t;
f(b,n-1);
if(co)return;
}
break;
case 5:g(a,b,n,i,j);
b[0]=a[j]-a[i];
op[4-n].o=t;
f(b,n-1);
if(co)return;
break;
case 6:
if(a[i]!=0&&a[j]%a[i]==0&&a[j]>a[i])
{
g(a,b,n,i,j);
b[0]=a[j]/a[i];
op[4-n].o=t;
f(b,n-1);
if(co)return;
}
break;
}
}
}
}
}
void h(int a[],int n,int x,int y,int h)
{
int i,j,b[4];
bool bx=false,by=false;
for(i=0,j=0;i<n;i++)
{
if(a[i]==x&&bx==false)
{
bx=true;
continue;
}
if(a[i]==y&&by==false)
{
by=true;
continue;
}
b[j++]=a[i];
}
for(i=0;i<n-1;i++)a[i+1]=b[i];
a[0]=h;
}
void main()
{
int a[4],i,j;
cout<<"输入4个整数:";
for(i=0;i<4;i++)cin>>a[i];
f(a,4);
if(co)
{
for(i=0;i<3;i++)
{
for(j=0;j<4-i;j++)cout<<a[j]<<" ";
cout<<"\n运算 ";
switch(op[i].o)
{
case 1:cout<<op[i].x<<"+"<<op[i].y<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].x+op[i].y);
break;
case 2:cout<<op[i].x<<"-"<<op[i].y<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].x-op[i].y);
break;
case 3:cout<<op[i].x<<"*"<<op[i].y<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].x*op[i].y);
break;
case 4:cout<<op[i].x<<"/"<<op[i].y<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].x/op[i].y);
break;
case 5:cout<<op[i].y<<"-"<<op[i].x<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].y-op[i].x);
break;
case 6:cout<<op[i].y<<"/"<<op[i].x<<endl;
h(a,4-i,op[i].x,op[i].y,op[i].y/op[i].x);
break;
}
}
cout<<"24"<<endl;
}
else cout<<"不能算出24"<<endl;
}
Ⅸ C语言的算24怎么搞啊
#include<stdio.h>
double fun(double a1,double a2,int 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]="+-*/";
printf("input 4 numbers:\n");
for(i=0;i<4;i++)
{scanf("%lf",num+i); save[i]=num[i];}
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)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点分析（穷举法）
//
#include
#include
#include
typedef struct D_NODE
{
int data;
struct D_NODE *left,*right;
} NODE24;
NODE24 head;
int res=24;
int maketree(int *src,int *i, NODE24 *p)
{
int d=src[*i];
(*i)++;
switch (d)
{
case '+':
case '-':
case '*':
case '/':
p->left=new NODE24;
p->right=new NODE24;
p->data=d;
maketree(src,i,p->left);
maketree(src,i,p->right);
break;
default:
p->data=d;
p->left=NULL;
p->right=NULL;
}
return 0;
}
int cmaketree(NODE24 *p)
{
int c;
c=getch();
putchar(c);
switch (c)
{
case '+':
case '-':
case '*':
case '/':
p->left=new NODE24;
p->right=new NODE24;
p->data=c;
cmaketree(p->left);
cmaketree(p->right);
break;
default:
p->data=c-'0';
p->left=NULL;
p->right=NULL;
}
return 0;
}
int work(struct D_NODE *d)
{
int res=0;
if (d->left==NULL&&d->right==NULL)
res=d->data;
else
{
int a,b;
a=work(d->left);
b=work(d->right);
switch (d->data)
{
case '+':
res=a+b;//work(d->left)+work(d->right);
break;
case '-':
res=a-b;//work(d->left)-work(d->right);
break;
case '*':
res=a*b;//work(d->left)*work(d->right);
break;
case '/':
if (b!=0)
res=(a%b==0)?a/b:-79;
else
res=-79;
//res=work(d->right)?work(d->left)/work(d->right):-79;
break;
}
}
return res;
}
int destroy(struct D_NODE *d)
{
if (d->left==NULL&&d->right==NULL)
delete d;
else
{
destroy(d->left);
d->left=NULL;
destroy(d->right);
d->right=NULL;
if (d != &head)
delete d;
}
return 0;
}
int show(struct D_NODE *d)
{
if (d->left==NULL && d->right==NULL)
printf("%d",d->data);
else
{
printf("(");
show(d->left);
printf("%c",d->data);
show(d->right);
printf(")");
}
return 0;
}
/* int input()
{
//int buf[30]=,idx=0;
//maketree(buf,&idx,&head);
int buf[20],idx=0;
printf("\nPlease Input:");
for (idx=0;idx<20;idx++)
{
buf[idx]=getch();
printf("%c",buf[idx]);
}
idx=0;
maketree(buf,&idx,&head);
return 0;
} */
#define test(p1,p2,p3,p4,p5,p6,p7) {exp[0]=(p1),exp[1]=(p2), \
exp[2]=(p3),exp[3]=(p4),exp[4]=(p5),exp[5]=(p6),exp[6]=(p7); \
idx=0; \
maketree(exp,&idx,&head); \
if (work(&head)==res) \
{ \
found++;printf("%5d: ",found);show(&head);\
if (!(found%3)) printf("\n");\
} \
destroy(&head);\
}
// printf("%d,%d,%d,%d,%d,%d,%d\n",p1,p2,p3,p4,p5,p6,p7); \
int test24()
{
int num[4],opc[4]=,exp[20];
int i1,i2,i3,i4,ic1,ic2,ic3,idx,found=0;
char prompt[]="24点游戏分析\n易华卫 12/17/2000\n";
printf("%s",prompt);
for (i1=0;i1<4;i1++)
{
printf("请输入第%d个数字: ",i1+1);
scanf("%d",num+i1);
//num[i1]=num[i1]%13+1;
}
printf("\n你已经输入了:%d,%d,%d,%d四个数字！\n",num[0],num[1],num[2],num[3]);
printf("\n请输入要计算的结果值，(当然二十四点就输入24啦!):");
scanf("%d",&res);
printf("OK! 按任意键就可以开始了!\n");
getch();
for (i1=0;i1<4;i1++)
for (i2=0;i2<4;i2++)
if (i2!=i1)
for (i3=0;i3<4;i3++)
if (i3!=i1&&i3!=i2)
for (i4=0;i4<4;i4++)
if (i4!=i1&&i4!=i2&&i4!=i3)
for (ic1=0;ic1<4;ic1++)
for (ic2=0;ic2<4;ic2++)
for (ic3=0;ic3<4;ic3++)
{
test(opc[ic1],opc[ic2],opc[ic3],num[i1],num[i2],num[i3],num[i4]);
test(opc[ic1],opc[ic2],num[i1],opc[ic3],num[i2],num[i3],num[i4]);
test(opc[ic1],opc[ic2],num[i1],num[i2],opc[ic3],num[i3],num[i4]);
test(opc[ic1],num[i1],opc[ic2],opc[ic3],num[i2],num[i3],num[i4]);
test(opc[ic1],num[i1],opc[ic2],num[i2],opc[ic3],num[i3],num[i4]);
}
printf("\n共找到了 %d 条正确的计算方法!(很抱歉,我没有处理交换率*^_^*)\n",found);
return 0;
}
main()
{
// fflush(stdin);
// input();
// cmaketree(&head);
// printf("\n=%d\n",work(&head));
test24();
return 0;
}