3,3,5,7算24点怎么算式_百度知道3、5、3、7四个数怎么算24点_百度知道看书、学习、写代码
24点游戏题解
一、问题描述
80年代全世界流行一种数字游戏，在中国我们把这种游戏称为&24点&。现在我们把这个有趣的游戏推广一下：您作为游戏者将得到6个不同的自然数作为操作数，以及另外一个自然数作为理想目标数，而您的任务是对这6个操作数进行适当的算术运算，要求运算结果小于或等于理想目标数，并且我们希望所得结果是最优的，即结果要最接近理想目标数。您可以使用的运算只有：+，-，*，/，您还可以使用（）来改变运算顺序。注意：所有的中间结果必须是整数，所以一些除法运算是不允许的（例如，（2*2）/4是合法的，2*（2/4）是不合法的）
下面我们给出一个游戏的具体例子：若给出的6个操作数是：1，2，3，4，7和25，理想目标数是573；则最优结果是573：（（（4*25-1）*2）-7）*3。输入：输入文件名为game.in。输入文件仅一行，包含7个整数，前6个整数Mi,1&=Mi&=100，表示操作数，最后一个整数T, 1&=T&=1000,表示理想目标数。输出：输出文件名为game.out。输出文件有两行，第一行仅一个整数，表示您的程序计算得到的最优结果；第二行是一个表达式，即您得到的最优结果的运算方案。输入输出示例：输入文件1 2 3 4 7 25 573输出文件573((4*25-1)*2)-7)*3
二、算法分析
首先我们要对这个问题进行数学抽象。定义1：对于有理数组成的多重集合S ，f(S) 定义如下：
如果 S 是空集或只包含一个元素，则 f(S)=S ；
否则 f(S)=& f( ( S-{r1, r2}) & {r} ) ，对于每一个 r=r1+r2 , r1-r2 , r1&r2，r1&r2(r2&0)，且r1, r2取遍 S 中所有元素的组成的二元组。
定义1说明：要计算集合S中的元素通过四则混合运算所能得到的所有值，我们只需要任取 S 中的两个元素 r1 , r2 ，分别计算 r1 , r2 的加减乘除运算，然后用所得的结果与 S 中剩下的其他数字进行四则混合运算。只要取遍所有的 r1 ,r2 ，最后得到的所有结果的并集就是 S 中的元素通过四则混合运算所能得到的所有值的集合。根据上述定义，在本问题中，集合 S 就是由输入中给定的6个正整数组成的集合，题目所求就是找出 f(S) 中小于或等于目标数的最大数。
定义2：给定两个多重集合 S1 , S2，定义&&&&&&& comb( S1, S2 ) = & { r1+r2 , r1-r2, r1&r2, r1&r2(r2&0) }&&&&&& (1.1)其中 ( r1 , r2 ) & S1 & S2。定义2实际上定义了两个集合中的元素两两进行加减乘除运算所能得到的结果集合。
定理1：对于有理数组成的多重集合 S ，如果 S 至少有两个元素，则&&&&&&& f(S)=& comb( f(S1), f(S - S1) )&&&&&&&&&&&&&&&&&&&&& (1.2)其中 S1 取遍 S 的所有非空真子集。
定理1的含义是：要计算 S 中的元素通过四则混合运算所能得到的所有值，可以先将 S 分解为两个子集 S1 和 S- S1 ，分别计算 S1 和 S-S1 中的元素进行四则混合运算所能得到的结果集合，即 f(S1) 和 f(S-S1) ，然后对这两个集合中的元素进行加减乘除运算，即 comb( f(S1), f(S-S1) ) ，最后得到的所有集合的并集就是 f(S) 。限于篇幅，定理1的正确性易用数学归纳法证明。
定义1和定理1实际上分别给出了计算f(S)的两种不同的方法。根据定义1，可以递归地计算f(S) ，其算法伪代码如下：
function f(S) begin 1.& if |S| & 22.&&& then return S 3.&&& else begin 4.&&&&&&&&&& T & &P 5.&&&&&&&&&& for each (r1, r2) in S do6.&&&&&&&&&& begin 7.&&&&&&&&&&&& r & r1 + r2; 8.&&&&&&&&&&&& T & T + f(S & {r1, r2} + {r}); 9.&&&&&&&&&&&& r & r1 - r2; 10.&&&&&&&&&&& T & T + f(S & {r1, r2} + {r}); 11.&&&&&&&&&&& r & r1 * r2; 12.&&&&&&&&&&& T & T + f(S & {r1, r2} + {r}); 13.&&&&&&&&&&& if (r2 && 0) and (r1 mod r2 = 0) then 14.&&&&&&&&&&& begin 15.&&&&&&&&&&&&& r & r1 / r2; 16.&&&&&&&&&&&&& T & T + f(S & {r1, r2} + {r}); 17.&&&&&&&&&&& end 18.&&&&&&&&& end 19.&&&&&&&&& return T; 20.&& end end
上述伪代码中使用了+, - 来分别表示集合的并和差运算。算法1每次选择两个数字进行某种运算，然后将结果与剩下的数字递归地进行运算，最后求得所有数字进行四则混合运算的结果。当然，在具体实现该算法的过程中有很多可以优化的地方，比如根据加法交换律， a+b+c=a+c+b ，因此我们可以规定：如果上一层递归作了加法运算，这一层仅当满足当前的操作数大于上一层的两个操作数的时候才进行加法运算，以确保 a+b+c 这样的式子中的操作数总是从小到大排列，这样就可以避免重复进行等价的加法计算。类似地我们可以对乘法也作此规定。在进行减法的时候，我们可以规定只能计算大数减小数，因为最后所需计算得到的目标数是一个正数，如果计算过程中出现负数，肯定有另外一个较大的正数与其作加法或者有另外一个负数与其做乘除法以消除负号。因此我们总可以调整运算次序使得四则混合运算的每一步的中间结果都是正数。在作除法的时候，因为题目规定中间结果只能是整数，所以也只需要用大数除小数，且仅当能除尽的时候才进行除法。对于本题而言，初始的集合 S 中一共有6个操作数，每次递归都可以合并两个操作数，所以递归到第5层的时候集合 S 中只剩下一个数，这个数就是原先的6个操作数进行四则混合运算所能得到的结果。本题只要求最接近目标值的结果，所以实现上述算法的时候可以只记录当前最优的结果。对于本题也可以利用递归回溯构造出所有的四则混合运算的语法树，但本质上与算法1是没有区别的。
定理1则给出了另一种计算f(S)的方法。我们当然也可以根据(1.2)式直接地递归计算f(S)，但那样的话会有很多冗余计算。
例如对于S={1,2,3,4}，f(S) = comb( f({ 1 }), f({ 2,3,4}) )& ... & comb( f({ 1,2 }), f({3,4 }) ) & ...;
计算f(S)的时候需要计算 f({ 2,3,4 })和f({ 3,4 }) ，又因为&& f({2,3,4}) = comb(f({ 2 }), f({3,4})) & ...;在计算 f({ 2,3,4}) 的时候又要重复地计算 f({ 3,4 }) ，这就产生了冗余的计算。这种情况下直接地递归就不适用。必须按照一定的顺序，递推地进行计算。这种将递归改为递推，以解决冗余的算法设计策略，就叫做动态规划。下面我们具体阐述一下该算法的步骤。设初始时集合 S 中的 n 个数字分别为x[0], x[1],...,x[n-1] ，我们可以用一个二进制数k来表示S 的子集 S[k] ，x[i] & S[k] 当且仅当二进制数k的第i位为1。于是我们用一个数组 F[0..2^n-1]就可以保存函数f对于S的所有子集的函数值（注意，函数f的函数值是一个集合），且 F[2^n-1]=f(S) 就是所求。
1.& for i & 0 to 2^n-12.&&& do F[i]&&P; 3.& for i & 0 to n-14.&&& do F[2^i]& {x[i]}; 5.& for x & 1 to 2^n-1 do6.& begin 7.&&& for i & 1to x-1 do8.&&& begin 9.&&&&& if x&i=i then 10.&&&& begin 11.&&&&&& j & x & 12.&&&&&& if i & j 13.&&&&&&&& then F[x] & F[x] + comp(F[i],F[j]); 14.&&&& 15.&& 16.&&&&&&&&&&&&&&&&& 17. return F[ 2 n ?1] ;
上述伪代码中使用了+表示集合的并运算。算法2的第1～2行将F中所有的集合初始化为空；第3～4行中 2^i 即表示只包含元素 x[i]的子集（因为 2^i 只有第 i 位上是1），根据定义1我们知道当集合中只有一个元素的时候函数 f 的函数值就是那唯一的元素组成的集合，所以3～4行计算出了函数 f 对于所有只有一个元素的子集的函数值；第5～17行按照一定的顺序计算函数 f 对于 S 的所有子集的函数值。对于 S 的两个子集 S[i] 和 S[x] ， S[i]真包含于S[x]的充要条件是 x&i=i ，这里 & 是按位进行与操作，而 x&i=i 的必要条件是 i&x 。因而第7~15行的循环将S[x]拆成两个子集S[i]和S[j]，并在第13行根据(1.2)式计算所有的comp( f(S[i]),f(S[j]) ) 的并。第12行的判断语句是为了优化算法的效率，因为将 S[x]拆成两个子集 S[i]和 S[j]的过程是对称的，所以我们对于 comp(f(S[i]),f(S[j]) ) 和 comp( f(S[j]),f(S[i]) ) 两者只取一个进行计算。下面是函数comp的伪代码：
function comp(S1, S2) 1.& T & &P ; 2.& for each x in S1 do3.& begin 4.&&& for each y in S2 do5.&&& begin 6.&&&&& T & T + {(x + y)}; 7.&&&&& T & T + {(x * y)}; 8.&&&&& if x & y then 9.&&&&& begin 10.&&&&&& T & T + {(x & y)}; 11.&&&&&& if (y && 0) and (x mod y = 0) 12.&&&&&&&&& then T & T + {(x / y)}; 13.&&&& end 14.&&&& else begin 15.&&&&&& T & T + {(y & x)}; 16.&&&&&& if (x && 0) and (y mod x = 0) 17.&&&&&&&& then T & T + {(y / x)}; 18.&&&& 19.&& 20. 21. return T;
comp在进行计算的时候不考虑参数集合S1和S2的顺序，进行减法的时候始终用大数减小数，这样保证运算过程中不出现负数（这样做的理由前文已经阐明）。因为我们只关心最后的f(S)中最接近目标值的数字，并且题目只要求求出任何一组最优解，所以算法2中的集合不需要是多重集合，只要是一般的集合即可。换句话说，集合F[i]中所有的元素互不相同，重复出现元素的我们只保留其中一个。这样可以大大减少计算中的冗余。做了这样的处理后，算法2的效率至少不会比算法1差，因为算法1中所能采用的主要剪枝手段是排除等价的表达式，但因为等价的两个表达式计算出的结果也一定相同，而算法2排除了所有结果相同的表达式，所以算法2的效率至少不会比算法1差，算法2中所进行的计算基本上都是得到最优解所必需的计算。
在实现算法2的过程中，集合可以用一个链表加上一个哈希表来实现。链表中保存每个表达式及其值，哈希表用来记录该集合中是否存在某个特定值的表达式。当向集合中插入一个新的表达式的时候，首先检查哈希表，看看该集合是否已经有和新表达式值相同的表达式，如果有的话就不插入，否则将新的表达式追加到链表末尾。采用这种数据结构，可以在常数时间内完成集合的插入和删除操作。利用链表，集合的并操作也很容易高效地实现。
在实现算法2的过程中，可以不必保存表达式的字符串，只需要记录下当前的值是 由哪两个集合中的元素通过哪种运算得到的，最后再根据最优解递归地计算出最优 解的表达式。
这样只在最后构造最优解的表达式时才进行字符串操作，程序运行效率能提高7～8倍左右。另外，在comb函数中进行乘法运算的时候要注意考虑运算结果超出整数范围的情况经
过以上优化，利用算法2实现的程序对于100个随机生成的测试数据总共只需要5秒左右就可以出解，平均每个数据只需要50毫秒即可出解（测试用的CPU为赛扬1GB）。
这样的效率已经非常令人满意了。
三、附录：
1、根据算法1计算24点的代码 ：
#include &iostream&#include &string&#include &cmath&
const double PRECISION = 1E-6; const int COUNT_OF_NUMBER& = 4; const int NUMBER_TO_CAL = 24;
double number[COUNT_OF_NUMBER]; string expression[COUNT_OF_NUMBER];
bool Search(int n) { &&& if (n == 1) { &&&&&&& if ( fabs(number[0] - NUMBER_TO_CAL) & PRECISION ) { &&&&&&&&&&& cout && expression[0] && &&&&&&&&&&& &&&&&&& } else { &&&&&&&&&&& &&&&&&& }&&& }
&&& for (int i = 0; i & i++) { &&&&&&& for (int j = i + 1; j & j++) { &&&&&&&&&&& double a, &&&&&&&&&&& string expa,
&&&&&&&&&&& a = number[i]; &&&&&&&&&&& b = number[j]; &&&&&&&&&&& number[j] = number[n - 1];
&&&&&&&&&&& expa = expression[i]; &&&&&&&&&&& expb = expression[j]; &&&&&&&&&&& expression[j] = expression[n - 1];
&&&&&&&&&&& expression[i] = '(' + expa + '+' + expb + ')'; &&&&&&&&&&& number[i] = a + &&&&&&&&&&& if ( Search(n - 1) )
&&&&&&&&&&& expression[i] = '(' + expa + '-' + expb + ')'; &&&&&&&&&&& number[i] = a - &&&&&&&&&&& if ( Search(n - 1) )
&&&&&&&&&&& expression[i] = '(' + expb + '-' + expa + ')'; &&&&&&&&&&& number[i] = b - &&&&&&&&&&& if ( Search(n - 1) )
&&&&&&&&&&& expression[i] = '(' + expa + '*' + expb + ')'; &&&&&&&&&&& number[i] = a * &&&&&&&&&&& if ( Search(n - 1) )
&&&&&&&&&&& if (b != 0) { &&&&&&&&&&&&&&& expression[i] = '(' + expa + '/' + expb + ')'; &&&&&&&&&&&&&&& number[i] = a / &&&&&&&&&&&&&&& if ( Search(n - 1) ) &&&&&&&&&&& }&&&&&&&&&&& if (a != 0) { &&&&&&&&&&&&&&& expression[i] = '(' + expb + '/' + expa + ')'; &&&&&&&&&&&&&&& number[i] = b / &&&&&&&&&&&&&&& if ( Search(n - 1) ) &&&&&&&&&&& }
&&&&&&&&&&& number[i] = &&&&&&&&&&& number[j] = &&&&&&&&&&& expression[i] = &&&&&&&&&&& expression[j] = &&&&&&& }&&& }&&& }
int main() { &&& for (int i = 0; i & COUNT_OF_NUMBER; i++) { &&&&&&& char buffer[20]; &&&&&&& int& &&&&&&& cin && &&&&&&& number[i] = &&&&&&& itoa(x, buffer, 10); &&&&&&& expression[i] = &&& }
&&& if ( Search(COUNT_OF_NUMBER) ) { &&&&&&& cout && "Success." && &&& } else { &&&&&&& cout && "Fail." && &&& }}
2、根据算法2计算解决题目的程序代码：
#include &fstream&#include &algorithm&#include &string&#include &sstream&#include &list&#include &cmath&#include &climits&#include &bitset&
const char* INPUT_FILE& = "game.in"; const char* OUTPUT_FILE = "game.out"; const int NUMBER_COUNT& = 7; const int STATE_COUNT&& = (1 && NUMBER_COUNT); const int MAX_NUMBER&&& = 100; const int MAX_EXPECTION = 1000; const int MAX_VALUE&&&& = MAX_EXPECTION * MAX_NUMBER;
struct Node { &&& &&& int left,&&&&&&& &&& int leftvalue, &&& };
typedef list&Node& NodeL
struct State { &&& bitset&MAX_VALUE+10& &&& NodeL };
int number[NUMBER_COUNT], State state[STATE_COUNT];
void ReadData() { &&& ifstream fin(INPUT_FILE);
&&& for (int i = 0; i & NUMBER_COUNT; i++) { &&&&&&& fin && number[i]; &&& }&&& fin && }
void Init() { &&& N &&& for (int i = 0; i & NUMBER_COUNT; i++) { &&&&&&& node.value&&&&&&&&&&&&& = number[i]; &&&&&&& node.left = node.right = -1; &&&&&&& state[(1 && i)].nodelist.push_back(node); &&&&&&& state[(1 && i)].exist[node.value] = &&& }}
void Merge(int a, int b, int x) {&&&&&& &&& N&&&&& &&& NodeList::const_iterator i,
&&& for (i = state[a].nodelist.begin(); i != state[a].nodelist.end(); i++){ &&&&&&& for (j = state[b].nodelist.begin(); j != state[b].nodelist.end(); j++){&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&& node.value = (*i).value + (*j). &&&&&&&&&&& node.left& = &&&&&&&&&&& node.right =&&&&&&&&&&&&&&&& &&&&&&&&&&& node.leftvalue& = (*i). &&&&&&&&&&& node.rightvalue = (*j). &&&&&&&&&&& node.opr&& = '+'; &&&&&&&&&&& if ( (node.value &= MAX_VALUE) && (!state[x].exist[node.value]) ) { &&&&&&&&&&&&&&& state[x].nodelist.push_back(node); &&&&&&&&&&&&&&& state[x].exist[node.value] = &&&&&&&&&&& }
&&&&&&&&&&& /////////////////////////////////////////////////////
&&&&&&&&&&& double tmp = double((*i).value) * double((*j).value);
&&&&&&&&&&& if (tmp & INT_MAX) { &&&&&&&&&&&&&&& node.value = (*i).value * (*j). &&&&&&&&&&&&&&& node.left& = &&&&&&&&&&&&&&& node.right = &&&&&&&&&&&&&&& node.leftvalue& = (*i). &&&&&&&&&&&&&&& node.rightvalue = (*j). &&&&&&&&&&&&&&& node.opr&& = '*'; &&&&&&&&&&&&&&& if ( (node.value &= MAX_VALUE) && (!state[x].exist[node.value]) ){ &&&&&&&&&&&&&&&&&&& state[x].nodelist.push_back(node); &&&&&&&&&&&&&&&&&&& state[x].exist[node.value] = &&&&&&&&&&&&&&& }&&&&&&&&&&& }
&&&&&&&&&&& /////////////////////////////////////////////////////
&&&&&&&&&&& if ((*i).value &= (*j).value) { &&&&&&&&&&&&&&& node.value = (*i).value - (*j). &&&&&&&&&&&&&&& node.left& = &&&&&&&&&&&&&&& node.right = &&&&&&&&&&&&&&& node.leftvalue& = (*i). &&&&&&&&&&&&&&& node.rightvalue = (*j). &&&&&&&&&&&&&&& node.opr&& = '-'; &&&&&&&&&&& } else { &&&&&&&&&&&&&&& node.value = (*j).value - (*i). &&&&&&&&&&&&&&& node.left& = &&&&&&&&&&&&&&& node.right = &&&&&&&&&&&&&&& node.leftvalue& = (*j). &&&&&&&&&&&&&&& node.rightvalue = (*i). &&&&&&&&&&&&&&& node.opr&& = '-'; &&&&&&&&&&& }
&&&&&&&&&&& if ( (node.value &= MAX_VALUE) && (!state[x].exist[node.value]) ) { &&&&&&&&&&&&&&& state[x].nodelist.push_back(node); &&&&&&&&&&&&&&& state[x].exist[node.value] = &&&&&&&&&&& }
&&&&&&&&&&& /////////////////////////////////////////////////////
&&&&&&&&&&& if ( ((*j).value != 0) && ((*i).value &= (*j).value) && ((*i).value % (*j).value == 0) ) &&&&&&&&&&& { &&&&&&&&&&&&&&& node.value = (*i).value / (*j). &&&&&&&&&&&&&&& node.left& = &&&&&&&&&&&&&&& node.right =&&&&&&&& &&&&&&&&&&&&&&& node.leftvalue& = (*i). &&&&&&&&&&&&&&& node.rightvalue = (*j). &&&&&&&&&&&&&&& node.opr&& = '/'; &&&&&&&&&&& } else if ( ((*i).value != 0) && ((*j).value &= (*i).value) && ((*j).value % (*i).value == 0) ) &&&&&&&&&&& { &&&&&&&&&&&&&&& node.value = (*j).value / (*i). &&&&&&&&&&&&&&& node.left& = &&&&&&&&&&&&&&& node.right = &&&&&&&&&&&&&&& node.leftvalue& = (*j). &&&&&&&&&&&&&&& node.rightvalue = (*i). &&&&&&&&&&&&&&& node.opr&& = '/'; &&&&&&&&&&& }
&&&&&&&&&&& if ( (node.value &= MAX_VALUE) && (!state[x].exist[node.value]) ){&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&& state[x].nodelist.push_back(node); &&&&&&&&&&&&&&& state[x].exist[node.value] = &&&&&&&&&&& }&&&&&&&&&&& /////////////////////////////////////////////////////
&&&&&&& }&&& }}
void Solve() { &&& Init();
&&& for (int x = 2; x & STATE_COUNT; x++) { &&&&&&& for (int i = 1; i & i++) {&&&&&&&&&&&&&&&&&& &&&&&&&&&&& if ( (x & i) == i ) { &&&&&&&&&&&&&&& int j = x - &&&&&&&&&&&&&&& if (i &= j) { &&&&&&&&&&&&&&&&&&& Merge(i, j, x);&&&&&&&& &&&&&&&&&&&&&&& }&&&&&&&&&&& }&&&&&&& }&&& }}
void PrintExpression(ostream& out, Node node) { &&& if (node.left == -1) { &&&&&&& out && node. &&& } else { &&&&&&& NodeList::const_
&&&&&&& out && "(";
&&&&&&& for (iter = state[node.left].nodelist.begin(); &&&&&&&&&&& iter != state[node.left].nodelist.end(); &&&&&&&&&&& iter++) &&&&&&& { &&&&&&&&&&& if ((*iter).value == node.leftvalue) { &&&&&&&&&&&&&&& PrintExpression(out, *iter); &&&&&&&&&&&&&&& &&&&&&&&&&& }&&&&&&& }
&&&&&&& out && node.
&&&&&&& for (iter = state[node.right].nodelist.begin(); &&&&&&&&&&& iter != state[node.right].nodelist.end(); &&&&&&&&&&& iter++) &&&&&&& { &&&&&&&&&&& if ((*iter).value == node.rightvalue) { &&&&&&&&&&&&&&& PrintExpression(out, *iter); &&&&&&&&&&&&&&& &&&&&&&&&&& }&&&&&&& }
&&&&&&& out && ")"; &&& }}
void Output() { &&& ofstream fout(OUTPUT_FILE);
&&& int bestValue = -INT_MAX;&&&&&& &&& NodeList::const_iterator iter, bestI
&&& NodeList& nodelist = state[STATE_COUNT-1].
&&& for (iter = nodelist.begin(); iter != nodelist.end(); iter++) &&& {&&&&&& &&&&&&& if ( ((*iter).value &= expection) && (bestValue & (*iter).value) ) { &&&&&&&&&&& bestValue = (*iter). &&&&&&&&&&& bestIter& = &&&&&&& }&&& }&&& fout && bestValue && &&& PrintExpression(fout, *bestIter ); &&& fout && }
int main() { &&& ReadData(); &&& Solve(); &&& Output();&&& system("PAUSE"); &&& return 0; }
可以参考&编程之美&
阅读(...) 评论()免费自助算命
24点在线计算
巧算24点在我国流行了很多年，八十年代中期，一位青年把这种游戏传到美国后，竟很快在美国中小学生中流传起来，并引起了极大的轰动，还举行大型联赛。许多数学很一般的学生在长期做这个游戏之后，数学成绩突发猛进。
人们普遍认为，“巧算24点”数学游戏，它能把枯燥的基本数字计算变得趣味盎然，能极大限度地调动眼、脑、手、口、耳多种感官的协调活动，使得思维灵活敏捷，大大提高计算能力和计算速度，对于培养快捷的心算能力和反应能力很有帮助，是一种寓教于乐的的智力竞赛游戏。
巧算24点是一种使用扑克牌进行的益智类游戏，游戏的方法是：一副扑克牌54张，去掉大小王后剩下52张牌，从中任意取出4张，用加、减、乘、除与括号使牌面数字运算的最终结果为24，每张牌只能用一次。
据说一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点。
请输入4个1-13的整数（注意：每个数字只能用一次！），程序将为你计算24点：
世纪算命网 V7.0 版本说明
　&　&点击导航栏的“算命首页”可以快速选择其它算命项目。
　&　&手机浏览请使用支持HTML5的浏览器。安卓手机推荐使用手机版的Chrome、Firefox浏览本站，以获得更好的显示效果。
　&　&为方便手机用户使用，电脑浏览不再保障IE 8.0以下版本浏览器的可用性，建议您升级到高版本的IE浏览器。推荐使用Edge或IE 11、Chrome、Firefox浏览本站，显示效果更佳。
扫码下载安卓客户端 Ver 2.0
Copyright &
Version 7.0　 All Rights Reserved.
声明：因为涉及个人隐私，所以本算命系统不会对算命结果做任何保存，您可以放心使用！
本算命系统来源于民间流传的一些算命方法，并非科学研究成果，算命结果仅供个人消遣娱乐，切勿迷信！
任何人均不得将本算命系统用于任何非法用途，且必须自行承担因使用本算命系统带来的任何后果和责任！　　当前位置：
＞＞＞把3，-5，7，-13四个数利用“24点”游戏规则，可写成算式______使其..
把3，-5，7，-13四个数利用“24点”游戏规则，可写成算式______使其结果等于24．
题型：填空题难度：中档来源：不详
根据题意可知[7+（-5）×（-13）]÷3=24．
马上分享给同学
据魔方格专家权威分析，试题“把3，-5，7，-13四个数利用“24点”游戏规则，可写成算式______使其..”主要考查你对&&有理数的混合运算&&等考点的理解。关于这些考点的“档案”如下：
现在没空？点击收藏，以后再看。
因为篇幅有限，只列出部分考点，详细请访问。
有理数的混合运算
有理数的混合运算：是一个运算式子中有加有减有乘有除有次方等运算方式的混合运算方式。有理数混合运算的规律：（1）先乘方，再乘除，最后加减； （2）同级运算，从左到右进行； （3）若有括号，先做括号内的运算，按小括号、中括号、大括号依次进行计算。
发现相似题
与“把3，-5，7，-13四个数利用“24点”游戏规则，可写成算式______使其..”考查相似的试题有：
744934209615728470540000724248534895