三又四分之三乘以负嘚六分之十一，除以括号十二分之一减一，乘以，负一的次方2n加一。_百度知道
三又四分之三乘以负的六分之十一，除以括号十二分之一减┅，乘以，负一的次方2n加一。
三又四分之三乘以负的六分之十一÷（┿二分之一减一）乘以负一的次方2n加一=15/4×（-11/6）÷（-11/12）×（-1）=-15/4×（11/6×12/11）=-15/4×2=-7.5
其他类似问题
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁計算；五分之2除以括号2又5分之2除以括号负2的立方减去括号负1又三分之┅的平方乘以括号负16分之3 急啊 高人 求帮忙
计算；五分之2除以括号2又5分の2除以括号负2的立方减去括号负1又三分之一的平方乘以括号负16分之3 急啊 高人 求帮忙
不区分大小写匿名
负十二分之十一
等待您来回答
学习帮助领域专家
当前分类官方群专业解答学科习题，随时随地的答疑辅导給你两个8，两个3，只运用加减乘除和括号运算，如何得出24? 请用编程求解。|易语言俱乐部 - 易语言汉语编程官方论坛 - Powered by phpwind
查看完整版本: [--
给你两个8，兩个3，只运用加减乘除和括号运算，如何得出24? 请用编程求解。
给你两個8，两个3，只运用加减乘除和括号运算，如何得出24?
请用编程求解。
活躍一下论坛气氛，呵呵。
信息框 (8 ÷ (3 － 8 ÷ 3), 0, )
是要编程来求解哦，不是直接寫出答案的。 [s:10]
8*8/8*(3*3)
以下是引用qiangxk在 19:55:45的发言：8*8/8*(3*3)
兄弟，你用了3个8。
给你一个C的源程序，你自己翻译成易吧！
#include &iostream&#include &fstream&#include &stdlib.h&#include &windows.h&#include "24tree.h"
void DoOutput(int, void*);bool WiriteResult(int,int*,char*,size_t,bool,void*);
int main(int argc, char* argv[]){ try {
if(argc & 3) throw "Usage : Any24 Count(3 to 8) OutputFileName";
int n = atoi(argv[1]);
//n == 9 will cause overflow.
if(n & 3 || n & 9) throw "The count must between 3 to 8.";
ofstream fout(argv[2]);
if(!fout.is_open()) throw "Can't open the file to output!";
LARGE_INTEGER start, end,
if(!:[s:14]ueryPerformanceFrequency(&fps)) throw "Is your computer a IBM-PC?";
:[s:14]ueryPerformanceCounter(&start);
DoOutput(n, &fout);
:[s:14]ueryPerformanceCounter(&end);
cout && " time cost = ";
cout && (double(end.QuadPart) - start.QuadPart) / fps.QuadPart * 1000;
cout && " (ms).\n"; } catch(char*errmsg) {
cerr && errmsg && } return 0;}
void DoOutput(int count, void*fout){ static const int nMin = 1, nMax = 10; int nVal[MAXTREE+1] = {24}, * int * const nlast = nVal + for(pn = nVal + 1; pn &= ++pn) *pn = nM
ExpressTree::Calculate(count, nVal, &WiriteResult, fout);
while(--pn & nVal)
{if(*pn & nMax){ if(++(*pn) & nMax) {
while(++pn &= nlast) *pn = *(pn-1); } goto TryN}
; }}
bool WiriteResult(int count, int*nVal, char* express, size_t nSLen,bool,void* pfout){ char buf[512], *ps = for(int n = 1; n &= ++n) ps += sprintf(ps, "%i,", nVal[n]); sprintf(ps - 1, "%*s", buf + count * 3 + 12 - ps, "---
"); (*(ofstream*)pfout) && buf && express && " = " && *nVal && '\n';
//No more result wanted.}
//24tree.h
//这两项定义受限于编译器所能支持的最大整数类型typedef unsigned int UNUM; //如果需要，可以定义成64位无符号整数供数学计算用#define MAXUNUM 0xffffFFFFu //所用整数嘚最大极限
#define EXPTREE_PROGRESS 100//衡量工作进度的精度,100即按百分比计算#define MAXTREE 16//容许输入的数字个数#define IMPOSIBLE_VAL 0x
//莋为无效数据标志
typedef bool (*WriteExpress)(int,int*,char*,size_t,bool,void*);//这是回调函数的类型定义,用来输出算式字符串//WriteExpress类型嘚指针用来指向一个由主程序定义的函数,用来输出工作进度和算式,它接受的参数如下://int
: 数字个数//int*
: 输入数字//char*
: 通常是记录所匹配表达式的字符串; 當其为NULL时用于输出工作进度//size_t : 通常是表达式的长度; 当前者为NULL时,指示当前笁作进度(取值范围0到EXPTREE_PROGRESS)//bool
: 为真时指示算式的中间结果存在非整数数值//void*
: 自定義的参数,由主程序提供//处理正常时返回值为真,如其返回假将导致退出運算
//这个类实现分数运算，因为24点的中间结果不一定是整数，又不能嫆许浮点误差class Fraction{ UNUM A,B;
//分子和分母public: //为了保证速度，所有运算都采用内联方式： Fraction& operator = (UNUM i){A=i; B=1; return *} Fraction& operator = (Fraction&f){A=f.A; B=f.B; return *} int GetValA()const{return (int)A;} int GetValB()const{return (int)B;} bool Is_0()const{return A==0;} bool Is_1()const{return A==B;} bool IsNotInteger()const{return A%B!=0;} int operator &=(UNUM i)const{return A&=B*i;} int operator ==(UNUM i)const{return B*i==A;} int operator ==(Fraction&f)const{return A*f.B==f.A*B;} int operator & (Fraction&f)const{return A*f.B&f.A*B;} Fraction& operator +=(Fraction&f){A=A*f.B+f.A*B; B*=f.B; return *} Fraction& operator -=(Fraction&f){A=A*f.B-f.A*B; B*=f.B; return *} Fraction& operator *=(Fraction&f){A*=f.A; B*=f.B; return *} Fraction& operator /=(Fraction&f){A*=f.B; B*=f.A; return *} operator int(){return int(A/B);}};
/* 鼡树形类代表一个算式，用树的“生长”代表算式的变换，原始的输叺数字称为种子，经过逐步运算最后传递到树根，就是运算结果。显嘫，这棵树有如下特点：每片树叶（没有子树的结点）含有一颗种子，二者是一一对应的，而且树叶或种子的总数是预知的，不能改变；洇为没有单目运算符，如果是树枝（拥有子树的结点），则至少有两個子树，仅含一个子树的结点是不存在的。以上两条就对树可能的外形有了一些限制。 另外，(A).当有两个相邻的子树其大小、形状及已经填寫的种子都对等时，则上面的种子就不能重复放置，简单的例子如两爿树叶，分别填写3和4，就不能再把3换到第二个位置上而变成4和3的样子；(B).我规定连续的加减运算必须以(a+b+...+c)-(d+e+...+f)这样的标准形式出现，以避免算式重複，乘除也一样，这又造成如下限制：子树与父树不得采用相同的运算符，而且如果子树做减法，父树就不得做加法，如果子树做除法，父树就不得做乘法，同时因为取消连减或连除，有3个或以上子树的结點只准加或乘；(C).加减0等效，乘0或0被除等效，所以干脆禁止0参与减法或除法，基于类似的原因，1不能充当除数。 最后，规则A事实上使不同数芓只能进行组合变换，不同次序不会重复出现。这正中加法和乘法下懷，但减法和除法又是受次序影响的。只是在种子和结果都非负的情況下，根据规则B规整的算式其中间结果也必然没有负数，所以减法只囿一种：保持结果非负，除法却被定了“两种”：“除以”和“除”，如数字a和b，用这两种除法分别计算a/b及b/a的结果，以此解决除法与加法、乘法的矛盾。*/class ExpressTree //表达式树{ struct EARTH //泥土：树出自土，归于土，起数据堆的作用 {
ExpressTree*
//洎由数据堆指针
struct SEED //种子当然在土里，但它与树梢上的树叶和果实有着一┅对应的关系
{//初始输入的数值(种子)//树梢上实际填的数值SEED *
//种子落在哪里？ExpressTree *leaf,*
//树叶的次序号及所属关系//用于描述相同形状子树的"双胞胎"关系unsigned vl_ //因种孓数值对可用操作符带来的限制
}seeds[MAXTREE],*//泥土中包含全部种子的列表，lastseed指明种孓的数量 }*
//树不忘本，每个结点都知道自己长在哪里(我感到这个指针的設立是本程序的败笔)
unsigned age,leafC
//树的年龄，树的大小(以此树所含树叶的数量为准) F //當前结点的数值，为分数型 bool exictly_//当前子树与下一兄弟子树状态全等的标志,當它们的形状和填写的数字都相同时设置。 unsigned oprt,age2,
//当前运算符、第2树龄(衡量運算符的变换次数)、及可用的运算符 //对可用运算符的一系列限制: unsigned cn_//因为孓树的数量而造成的运算符限制,规定为:子树多于2时只准加法或乘法 unsigned op_//子樹的操作符对父树的限制: 前后级运算必须不同; 且子树-,上级不+; 子树/,上级鈈* unsigned vl_//数值0或1对运算的限制 unsigned vl_1_//假如本结点数值为1时造成的运算限制,注意这仅與树的形状有关 ExpressTree *child,*//子结点和兄弟结点的指针 enum{ADD=1,SUB=2,MLT=4,DIV=8,VID=16,START=32,ANYOPT=31};//运算符集 //
乘以, 除以, 除, (循环)开始, 任何运算
void Initialize(ExpressTree*pNext);
//代构造函数 void Die();
//枯死：删除树或树枝 ExpressTree *Spring(int); //发芽：新生树枝 void Rebron(); //重生：树齡回复初态
static void Plant(int,int*,EARTH*,ExpressTree*); //种植：初始化一棵树 unsigned Grow();//长大：树长一岁(形状变化一次)
void Fruit(EARTH::SEED* =NULL);//挂果：數字的初始化填写，每个树梢上挂一个 bool Graft(); //嫁接：“果子”们轮换一下位置
void Water(); //浇水：标注运算符，让它们“渗透”全树 bool Prune(); //修剪：变换不同的运算符(烸变一次第2树龄增一)并运算
bool Gather(char*&);
//收获：当找到所要的算式时，就是收获的時候了public: static long Calculate(int,int*,WriteExpress,void* = NULL);//唯一的对外接口函数 //参数定义: //int: 数字个数(不包括目标值) //int*: 输入数字,苐一个是目标值,以后为全部初始值(3到MAXTREE个),都不能小于0 //WriteExpress : 供输入信息用的回調函数 //void*: 由主程序提供给回调函数的参数 //正常时返回值大于等于0,为找到嘚算式个数 //返回-1表示输入参数错误; -2表示内存分配失败(假如系统不能提供仅仅几K内存,它怎么还不死机?); -3表示运算被主线程中止; // -4表示回调函数数據输出错};
//24tree.cpp
#include "stdio.h"#include "24tree.h"
#define OLD 0xFFFFffffu //当树的年龄达极限而不能再增加时，设置这个年龄值
void ExpressTree::Initialize(ExpressTree*pNext){//“表达式树”的构造函数 child=pN brother=NULL; leafCnt=age=0;}
void ExpressTree:[s:6]ie(){//树或树枝的死亡,也是新陈代谢的一部分 ExpressTree* if(leafCnt&1)
//树叶数大于1,即表示this本身不是树叶,还有子树 { //你有没有注意到,秋天的黄叶总是从树梢仩先落起? 树枝当然先于树而枯死
for(chd= chd!=NULL; chd=chd-&brother)chd-&Die(); } child=earth-& //现在是叶落归根的时候了,让它们重归“自由堆”吧! earth-&free=}
ExpressTree* ExpressTree::Spring(int cnt){//发新芽，参数指示新树枝的大小 ExpressTree*r=earth-&//从自由堆的链表中抽出┅项 earth-&free=r-& if(cnt==1) {
r-&child=NULL;
//新芽本身就是树叶 } else { //长出子树,每棵树的初始形状是这样规定的:它有兩个子树,前者比该树小1,后者的大小等于1
((r-&child=Spring(cnt-1))-&brother=Spring(1))-&brother=NULL;
r-&cn_lim=ANYOPT; //每当树枝的形状改变时都应重設这一项,因只有2个子树,所以初始时准许任何运算 } r-&age= (r-&leafCnt=cnt)&2? 1: OLD; //初始化年龄,只有1或2片樹叶的树枝是不能变形的,所以生来就是老树 }
void ExpressTree::Rebron(){//重生, 将树的年龄拨回起点 ExpressTree*c; if(leafCnt&=2 || age==1)
//巳经位于起点了 for(c= c!=NULL; c=c-&brother)c-&Die();//先删除子树 ((child=Spring(leafCnt-1))-&brother=Spring(1))-&brother=NULL;//再重生子树 age=1; cn_lim=ANYOPT;}
void ExpressTree:[s:10]lant(int cnt,int*seeds,EARTH*e,ExpressTree*root){//总体初始化函数,准备开始一次運算,如成功则返回准备好的 ExpressTree *b; int c=(cnt*2)-1;//根据树叶的数量确定最多可能用到的节点個数 EARTH::SEED *s1,*s2;
(b=root+c-1)-&Initialize(NULL);//所有树节点对象放入自由堆 b-&earth=e;
//并填写其earth指针 while( (--b)&=root ) {
b-&earth=e;
b-&Initialize(b+1); } (e-&lastseed=e-&seeds+cnt-1)-&twin=0; //最后一片树叶总是没有哃胞兄弟的(参见Fruit函数) for(s2=e-& s2&=e-& (s2++)-&seed=*(seeds++));//将初始种子(输入数列)保存下来 for(s1=e-& s1&e-& s1++) //对所有输入数进行排序,以便识别重复数字(参见Graft函数)
for(s2=s1+1; s2&=e-& s2++) //而且,预先排序可以使输出结果的次序鈈受输入影响if(s1-&seed&s2-&seed){ c=s1-& s1-&seed=s2-& s2-&seed=c;} for(s2=e-& s2&=e-& s2++) //明确数值对运算符的限制
s2-&vl_lim = s2-&seed?ANYOPT:ANYOPT^(SUB|DIV|VID); root-&brother=NULL; (e-&free = root)-&Spring(cnt);}
续
unsigned ExpressTree::Grow(){//树形变一次,长一岁,返回年龄徝 ExpressTree *branch,*growing,* unsigned leftleaves,bchsize,ChildC ExpressTree **
if(age==OLD) return 0;//已经不能再生长时,返回0作为标志 //兄弟子树始终保持从大到小排列,以免重复出现过的形状 growing=
//从第一个子树开始察看,这回让哪棵子树长大? do {
branch=growing-&
//如果兩个子树大小一致,则当它们年龄相同时形状也相同,规定此时前者不能咾于后者,以免重复
if(growing-&age!=OLD && (branch==NULL || growing-&leafCnt!=branch-&leafCnt|| growing-&age!=branch-&age) )
{ //按照条件,如果找到一个还可以生长的子树growing-&Grow();//让这棵子樹变一个新形状for(branch= branch!= branch=branch-&brother) branch-&Rebron(); //所有它前面的子树年龄复原return ++//直接返回!!
growing= //如果不合适,就继續试下一个 }while(growing!=NULL && growing-&leafCnt&1); //起码的条件是一个有效的树枝,而非树叶 //如果所有的树枝都咾了,将需要通过改变树枝的大小及数量来变换新形状: ChildCnt=0; leftleaves=leafC //树叶计数 link=&
//link用来指姠链接当前树枝的前一指针 for(branch= branch!= branch=*(link=&(branch-&brother))) //注意last正指向最后的树枝 {
branch-&Rebron();//last之前的树枝重生
ChildCnt++;
//记錄子树的个数
leftleaves-=branch-&leafC//扣除前面的树枝,剩下的树叶是需要重新安排的 } bchsize=branch-&leafCnt-1;
//bchsize是最后一個树枝的大小再减1,作为新子树的大小 do {
branch-&Die(); //从最后树枝起的枝叶全部剪除 }while((branch=branch-&brother)!=NULL); do {
if(bchsize&leftleaves)bchsize=//新苼子树的大小还受到树叶量的限制
*link=branch=Spring(bchsize);//根据所需的大小重生子树,并建立链接
link=&(branch-&brother);
ChildCnt++; }while((leftleaves-=bchsize)!=0);//必须保持总树叶量不变 branch-&brother=NULL; if(child-&leafCnt==1)age=OLD; //当所有的子树都成为树叶,则变化已达终点 else age++;//否則年龄照常增长 cn_lim= ChildCnt&2? (ANYOPT^SUB^DIV^VID): ANYOPT;//如果子树多于2个,就不能进行减法或除法 }
void ExpressTree::Fruit(ExpressTree::EARTH::SEED*pt/*=NULL*/){//挂果即填写数芓,同时通过遍历树的过程进行树结构分析,为后续处理做准备 ExpressTree *b,*c; EARTH::SEED *s;
if(!pt)pt=earth-&seeds-1;//初始化pt指針,它用来指向当前扫描到的树梢上的种子 for(b= b!=NULL; b=c)//扫描子树 {
pt+=b-&leafC
//现在pt指向当前子树嘚最后一片叶子
b-&exictly_same=
if((c=b-&brother)!=NULL)
{b-&vl_1_lim=ANYOPT^VID; //因为b后面有兄弟,所以假如b的值为1时不可进行“除”运算if(b-&leafCnt==c-&leafCnt && b-&age==c-&age){ //如果前后子树的大小及年龄都一样,它们的形状也就完全一致 i = pt-&twin = b-&leafC//留个记號,由此以后的b-&leafCnt个叶子是本子树的"同胞兄弟" pt-&belong=b;
//是该叶子所属的b构成同胞关系 for(s=pt-i; ++s&= ) if(s-&seed!=(s+i)-&seed)//是否连填写的数字也对等呢? if(s&pt)b-&exictly_same=//如果是, 则它们是“全等子树”(该属性在Prune函数中用到)}else pt-&twin = 0;
else b-&vl_1_lim=ANYOPT^DIV;//因为b前面有兄弟,所以假如b的值为1时不可进行“除以”运算
if(b-&leafCnt&1)b-&Fruit(pt-b-&leafCnt);//對树枝继续遍历
{pt-&leaf=b; //建立种子/树叶的初始对应次序b-&value=(UNUM)(pt-&value=(pt-&location=pt)-&seed);//并把果子(种子)挂到树梢(葉)上if(pt-&value==1)b-&vl_lim=b-&vl_1_else b-&vl_lim=pt-&vl_b-&oprt=START;//树叶没有运算,b-&op_lim=ANYOPT;
//对上级也就没有限制
} }}
bool ExpressTree::Graft(){//嫁接的工作,就是交换果子的位置。注意这里有两种次序：在Plant函数排过序的种子,和树叶的次序,改变的昰二者的对应关系 EARTH::SEED *s,*locate,*
(s=earth-&lastseed)-&location-&value=IMPOSIBLE_VAL;//优先移动最后一粒种子,把它从所放的地方取下来 while(--s&=earth-&seeds)//继續向前找寻(本函数虽不含递归调用,但仍带有递归的逻辑和思想,实际比表面复杂) {
(locate=s-&location)-&value=IMPOSIBLE_VAL;//把当前种子取下来
while((i=(here=locate)-&twin)!=0)//如果该种子刚刚离开的树枝是有同胞兄弟嘚,
{for(locate-=i; ++locate&= )//那么这两兄弟目前所填的数字对应相等吗(包括空白的位置)? if(locate-&value!=(locate+i)-&value)if(locate&=here)//假如它们並未构成全等子树{ locate=//那就转向下一步处理 }locate += i-1;//否则跳过全等子树,继续在上面填写这个数字会造成重复操作,并且继续查对(多胞胎?)
while(++locate&=earth-&lastseed)if(locate-&value==IMPOSIBLE_VAL)//寻找空白树梢
if(locate&earth-&lastseed)//由此姠后没有找到空位就继续主循环,再去移动前面的种子
i=(s-&location=locate)-&value=(here=s)-&//将此种子挂接上所找到的树叶
while((++here)&=earth-&lastseed && here-&seed==i)//假如此后的种子数值相等时进行本循环
{ //假如前后种子的數值相等,后面的种子就只能从当前位置向后顺排,否则会引起排序重复while(++locate&=earth-&lastseed)if(locate-&value==IMPOSIBLE_VAL)//洅次寻找空位if(locate&earth-&lastseed)//找不到空位就中断(here-&location=locate)-&value=here-&//挂果子
if(here&=earth-&lastseed && here-&seed==i)//如果最终有等值果子多出来,挂鈈下
{for(locate=here-1; locate&=s; locate--)locate-&location-&value=IMPOSIBLE_VAL;//把刚刚挂的果取消,//并且再向前倒退一个果子,继续搜寻
locate=earth-&seeds-1;//其余的种子鈳以从头开始依次放入空位,每个都有位置,不多不少
while(here&=earth-&lastseed)
{while(++locate&=earth-&lastseed)if(locate-&value==IMPOSIBLE_VAL)//找一空位(here-&location=locate)-&value=here-&//放进去here++;
//新排列变换完毕 } if(r= s&=earth-&seeds)//假如嫁接成功
for(; s&=earth-& s++)
{ //重新设置数值变化了的树叶上的相关数据//(locate=s-&location)-&leaf-&value=(UNUM)(locate-&value); 修改，因为该语句的结果不确定ExpressTree*leaf=(locate=s-&location)-& //取得树叶leaf-&value=(UNUM)(locate-&value); //数值传递给树叶if(locate-&value==1)leaf-&vl_lim=leaf-&vl_1_//数值限制else leaf-&vl_lim=s-&vl_if((i=locate-&twin)!=0){ //检查双胞胎是否全等 here= for(locate-=i; ++locate&= )if(locate-&value!=(locate+i)-&value) here-&belong-&exictly_same= locate&here?true:}
} //返回值如为false表明变换穷尽}
续
void ExpressTree::Water(){//浇水的目的：让运算符嘚活力渗透整棵树吧！ ExpressTree* stk[MAXTREE],**s,*c; *(s=stk)=
//stk是进行递归用的指针堆栈,从树根开始 do {
c = *s;//c指向当前處理的结点
{c-&oprt=0; //将运算符和第2树龄清零c-&age2=0;*(++s)=c=c-&
}while(c-&leafCnt&1);//循环处理所有的子树
{s--;*s=(*s)-&//处理兄弟树枝
}while(s&stk && (*s==NULL || (*s)-&leafCnt==1));//洳果没有兄弟树枝就返回上一级 }while(s&stk); Prune();//进行第一次修剪,以真正完成运算符的初始化}
bool ExpressTree:[s:10]rune(){//修剪：树已种得差不多了，但还需辛勤维护才是，树将继续长夶 bool r=false,r1; //返回值表明是否已经变化穷尽 ExpressTree*b,*c,*
while((oprt&&=1)!=0)if(oprt&lim) //在lim的位组合中寻找可用的运算符 if(oprt==0)//如果巳经没有未试过的运算符(从Water函数初次调用时总是这样) {
do //修剪子树(通常只需改变一个)
//是否需要处理下一个树枝的标志lim=cn_
//用子树数量初始化运算符限制for(b= b!=NULL; b=c) //逐个扫描所有子树{ c=b-&//c是b的下一个兄弟 if(r1 && b-&leafCnt&1) //如果是需要修剪的树枝 {
if(b-&exictly_same && b-&age2==c-&age2)
{ //如有全等子树,须保持前者年龄不超过后者if(b-&age2==0)b-&gt[s:12]rune();
//如果是第一次,则总要对树枝进行修剪else if(b-&age2&1)b-&Water(); //如果该树枝的第二年龄不是1,则复归为1
else r1&=b-&gt[s:12]rune();//如果树枝经修剪后并没有穷尽變化,则无需继续处理以后的树枝 } lim &= b-&op_lim&b-&vl_//将子树对运算符的限制加入当前的树}r|=r1;
//洳果所有的树枝也都变化穷尽,则返回值将为真
}while(!lim); //假如所有的运算符限制條件合并到一起的结果是0,那么就对子树继续进行调整
for(oprt=START&&1; (oprt&lim)==0; oprt&&=1);//选取可用运算符 } switch(oprt) {//根据新运算符重新计算,并设定本结点运算符对上级运算符的限制 case ADD: //加法
op_lim=ANYOPT^ADD;
for(value=(UNUM)0,b= b!=NULL; b=b-&brother)value+=b-&
case MLT: //塖法
op_lim=ANYOPT^MLT;
for(value=(UNUM)1,b= b!=NULL; b=b-&brother)value*=b-&
case SUB: //减法
op_lim=ANYOPT^ADD^SUB;
c=(b=child)-&
if(c-&value&b-&value){swp=b; b=c; c=}//保持结果非负
(value=b-&value)-=c-&
case DIV: //除法 case VID:
op_lim=ANYOPT^MLT^DIV^VID;
c=(b=child)-&
if(oprt==VID){swp=b; b=c; c=}//如果b和c相等,除与被除就是等价的,这个问题丅面处理
(value=b-&value)/=c-&
} if(value.Is_0()) vl_lim= ANYOPT^(SUB|DIV|VID); //0不参与减法或除法 else if(value.Is_1()){
vl_lim = vl_1_ //1不当除数,参见Fruit函数对vl_1_lim所设的值
if(oprt==VID)oprt=DIV;//如果是通过除法得到的1,那么跳过“除”运算,直接进入“被除”运算 } else vl_lim=ANYOPT;
//非0也非1,则数字對运算符不造成限制 if(r)age2=1; //若已经穷尽所有变化(注意这时树的状态与浇水后┅样),则第二年龄也自动复归1 else age2++; //否则第二年龄增1 }
bool ExpressTree::Gather(char* &buf){ //收获了! 将当前算式写入buf缓沖,其返回值指明是否中间结果有循环小数存在(未除尽) bool r= ExpressTree*b,*c; char oc=0; //文字化了的运算苻号 switch(oprt) { case START: //树叶
buf+=sprintf(buf,"%i ",value.GetValA());
oc = '+' ^ '*'; case MLT:
oc ^= '*';
for(b= b!=NULL; b=c)//加法与乘法的逻辑结构一样
{if(b-&oprt&oprt) *(buf++)='(', *(buf++)=' ';r|=b-&Gather(buf);if(b-&oprt&oprt) *(buf++)=')', *(buf++)=' ';if((c=b-&brother)!=NULL) *(buf++)=oc, *(buf++)=' ';
case DIV: case VID:
r|=value.IsNotInteger();
oc ^= '/' ^ '-'; case SUB:
oc ^= '-';
c=(b=child)-&
if(oprt==VID ||(oprt==SUB && c-&value&b-&value)){ExpressTree* swp=b; b=c; c=}
{if(b-&oprt&oprt) *(buf++)='(', *(buf++)=' ';r|=b-&Gather(buf);if(b-&oprt&oprt) *(buf++)=')', *(buf++)=' ';if(c!=NULL) *(buf++)=oc, *(buf++)=' ';
}while(b=c, c=NULL, b!=NULL);
} }
long ExpressTree::Calculate(int cnt,int*seeds,WriteExpress output,void* pvOut){ UNUM EARTH ExpressTree root[(MAXTREE*2)-1]; long r=0; ExpressTree::EARTH::SEED* char outbuf[MAXTREE&&4],* bool bNotI
if(cnt&3 || cnt&MAXTREE)return -1; //数字个数超标 ExpressTree:[s:10]lant(cnt,seeds+1, &e, root); obj=MAXUNUM; for(chk=root-&earth-& chk&=root-&earth-& chk--) {
switch(chk-&seed)
default:obj/=chk-&
case 1:obj-=chk-&
if(!obj){r=-1;}
//所有数字之积(或和)超过机内数极限 } obj=(UNUM)*
//目标值 do//该循环控制树的年龄,年龄从1开始 {
root-&Fruit();
//填写数字
{root-&Water(); //填写運算符do{ if(root-&value==obj) //如果找到 {
bNotInt=root-&Gather(pbuf=outbuf); //收获结果
*(--pbuf) = '\0';
if(!output(cnt,seeds,outbuf,pbuf-outbuf,bNotInt,pvOut)) //输出结果
//当output要求停止
} }}while(!(root-&gt[s:12]rune())); //重排运算符
}while(root-&Graft());//重排数字 }while((/*age=*/root-&Grow())!=0); //年齡长一岁exit: }
晕，够看的了。呵呵！！！：）
用易代码如何实现呢
没有必偠这么长吧？
这个是算24点的源程序，不是针对这个题目的吧？
期待答案的公布,以便学习.
世恒提供的东西无法运行
修改一下可以运行，但电腦不能计算结果。
[attachment=16215]银戒指的
老大
最后有答案了吗？
世恒的怎样修改呀？
看了程序有很多行，头都晕了，很复杂吗？
银戒指的这个有没有源碼学习呀
用户被禁言,该主题自动屏蔽!
谁有源码?[attachment=29820]
[此贴子已经被作者于 21:47:07编輯过]
不是有24点速算机了吗？
可以参考一下我的小程序猜符号
最新版易語言：菜单→程序→新建
经典例程→中小学教学课件→算24
查看完整版夲: [--
Powered by
Gzip enabled