来源：蜘蛛抓取(WebSpider)
时间：2015-08-10 07:02
标签：
24点游戏题目
24点游戏题目_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
24点游戏题目
阅读已结束，如果下载本文需要使用
想免费下载本文？
你可能喜欢问一题数学题：一种24点游戏-中国学网-中国IT综合门户网站
> 问一题数学题：一种24点游戏
问一题数学题：一种24点游戏
转载 编辑：李强
为了帮助网友解决“问一题数学题：一种24点游戏”相关的问题，中国学网通过互联网对“问一题数学题：一种24点游戏”相关的解决方案进行了整理,用户详细问题包括:题目给出的数有：3，7，-5，-13这四个数，用加减乘除四种运算使其最后结果为24，并且数字和运算符合不能重复憨旦封秆莩飞凤时脯江。数学高人请解，具体解决方案如下：解决方案1：(7+(-5*-13))/3(7+(-13*-5))&憨旦封秆莩飞凤时脯江#47;3((-5*-13)+7)/3((-13*-5)+7)/3解决方案2：谢谢了通过对数据库的索引,我们还为您准备了：答：(7+(-5*-13))/3 (7+(-13*-5))/3 ((-5*-13)+7)/3 ((-13*-5)+7)/3===========================================问：把3、4、6、10四个数进行加、减、乘、除、平方、立方等混合运算，使其结...答：3×（4+10-6）=24 3×6+10-4=24 6÷3×10+4=24===========================================问：用8.2.4.6四个数和+。-。*。/.( )组成得数是24的算式答：1: 8 × 2 ÷ 4 × 6 2: (8 × 2) ÷ 4 × 6 3: (8 × 2 ÷ 4) × 6 4: ((8 × 2) ÷ 4) × 6 5: (8 × (2 ÷ 4)) × 6 6: 8 × (2 ÷ 4) × 6 7: 8 × (2 ÷ 4 × 6) 8: 8 × ((2 ÷ 4) × 6) 9: 8 × (2 ÷ (4 ÷ 6)) 10: 8 × 2 ÷(4 ÷ 6) 11: (8 × 2) ÷ (4 ÷ 6) 12: 8 + 2...===========================================问：用8.2.4.6四个数和+。-。*。/.( )组成得数是24的算式答：/tool/24.htm希望能帮到你 3、 (1 + 1) × 7 + 10===========================================如抽出的牌是3、8、8、9,那么算式为(9-8)×8×3或3×8+(9-8)或(9-8÷8)×3等。 "算24点"作为一种扑克牌智力游戏,还应注意计算中的技巧问题。计算时,我们不可能把牌面...===========================================24。 四.有待解决的问题: 1、形式不同而实质相同的解的问题。有些解虽然形式不同,但其实质是完全相同的。 如3*((11+4)-7)和3*(11+(4-7)),实际上只是一种解。去掉这些...===========================================3=24==========================================="算24点"是一种数学游戏,正如象棋、围棋一样是一种人们喜闻乐见的娱乐活动。 它始... 或(9-8÷8)×3等。 "算24点"作为一种扑克牌智力游戏,还应注意计算中的技巧问题。计...===========================================一种数学游戏,游戏方式简单易学,能健脑益智,是一项极为有益的活动. "巧算24点"的游... 或(9-8÷8)×3等. "算24点"作为一种扑克牌智力游戏,还应注意计算中的技巧问题.计算...===========================================2的3+1次方×3==========================================="算24点"作为一种扑克牌智力游戏,还应注意计算中的技巧问题。计算时,我们不可能把牌面上的4个数的不同组合形式--去试,更不能瞎碰乱凑。这里向大家介绍几种常用的、便于...===========================================数学试题。 如2007年甘肃省白银等7市新课程数学试题第4小题: 4张扑克牌如图(1)所... 问题和解决问题的能力。 二、扑克牌中的计算问题 有一种"二十四点"的游戏,其游戏...=========================================== 1、 8 ÷ (3 - 8 ÷ 3)=24 这是唯一的,没有其他的了。===========================================积小于24的数亮亮获胜,游戏公平吗? 6,7,8,9,10,12,14,16,18,20,21,24,27,28,30,32,35... 所以游戏不公平 (4)请你设计一种新的游戏方法,并制定公平的游戏21时...===========================================
本文欢迎转载，转载请注明：转载自中国学网： []
用户还关注
可能有帮助1576人阅读
数字游戏题解
by starfish
[说明：此文改编自我写的一篇解题报告，原题是某年国家集训队组队赛题目]
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
((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) }
其中 ( r1 , r2 ) ∈ S1 × S2。
定义2实际上定义了两个集合中的元素两两进行加减乘除运算所能得到的结果集合
定理1：对于有理数组成的多重集合 S ，如果 S 至少有两个元素，则
f(S)=∪ comb( f(S1), f(S - S1) )
其中 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)
if |S| < 2
then return S
else begin
for each (r1, r2) in S do
r ← r1 + r2;
T ← T + f(S – {r1, r2} + {r});
r ← r1 - r2;
T ← T + f(S – {r1, r2} + {r});
r ← r1 * r2;
T ← T + f(S – {r1, r2} + {r});
0) and (r1 mod r2 = 0) then
r ← r1 / r2;
T ← T + f(S – {r1, r2} + {r});
上述伪代码中使用了+, - 来分别表示集合的并和差运算。算法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) 就是所求。
for i ← 0 to 2^n-1
do F[i]←Φ;
for i ← 0 to n-1
do F[2^i]← {x[i]};
for x ← 1 to 2^n-1 do
for i ← 1to x-1 do
if x∧i=i then
then F[x] ← F[x] + comp(F[i],F[j]);
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 y then
T ← T + {(x – y)};
0) and (x mod y = 0)
then T ← T + {(x / y)};
else begin
T ← T + {(y – x)};
0) and (y mod x = 0)
then T ← T + {(y / x)};
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点的代码
const double PRECISION = 1E-6;
const int COUNT_OF_NUMBER
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] <<
for (int i = 0; i < i++) {
for (int j = i + 1; j < j++) {
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] =
void main()
for (int i = 0; i >
number[i] =
itoa(x, buffer, 10);
expression[i] =
if ( Search(COUNT_OF_NUMBER) ) {
cout << "Success." <<
cout << "Fail." <<
2。根据算法2计算解决题目的程序代码：
const char* INPUT_FILE
= "game.in";
const char* OUTPUT_FILE = "game.out";
const int NUMBER_COUNT
const int STATE_COUNT
= (1 << NUMBER_COUNT);
const int MAX_NUMBER
const int MAX_EXPECTION = 1000;
const int MAX_VALUE
= MAX_EXPECTION * MAX_NUMBER;
struct Node {
int leftvalue,
typedef list NodeL
struct State {
int number[NUMBER_COUNT],
State state[STATE_COUNT];
void ReadData()
ifstream fin(INPUT_FILE);
for (int i = 0; i > number[i];
void Init()
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)
NodeList::const_iterator i,
for (i = state[a].nodelist.begin(); i != state[a].nodelist.end();
for (j = state[b].nodelist.begin(); j != state[b].nodelist.en
node.value = (*i).value + (*j).
node.right =
node.leftvalue
node.rightvalue = (*j).
if ( (node.value <= MAX_VALUE) && (!state[x].exist[no
de.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.right =
node.leftvalue
node.rightvalue = (*j).
if ( (node.value = (*j).value) {
node.value = (*i).value - (*j).
node.right =
node.leftvalue
node.rightvalue = (*j).
node.value = (*j).value - (*i).
node.right =
node.leftvalue
node.rightvalue = (*i).
if ( (node.value = (*j).value) &
((*i).value % (*j).value == 0) )
node.value = (*i).value / (*j).
node.right =
node.leftvalue
node.rightvalue = (*j).
} else if ( ((*i).value != 0) && ((*j).value >= (*i).
((*j).value % (*i).value == 0) )
node.value = (*j).value / (*i).
node.right =
node.leftvalue
node.rightvalue = (*i).
if ( (node.value <= MAX_VALUE) && (!state[x].exist[no
de.value]) )
state[x].nodelist.push_back(node);
state[x].exist[node.value] =
/////////////////////////////////////////////////////
void Solve()
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.
NodeList::const_
out << "(";
for (iter = state[node.left].nodelist.begin();
iter != state[node.left].nodelist.end();
if ((*iter).value == node.leftvalue) {
PrintExpression(out, *iter);
out << node.
for (iter = state[node.right].nodelist.begin();
iter != state[node.right].nodelist.end();
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).val
bestValue = (*iter).
fout << bestValue <<
PrintExpression(fout, *bestIter );
int main()
ReadData();
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场谁可以给我20道24点游戏的题目和答案_百度知道
谁可以给我20道24点游戏的题目和答案
提问者采纳
3*(4+(-6)+10)=24
（7+(-5)*(-13)）/3=24
5× (5 - 1 ÷ 5)
7× (3 ÷ 7 + 3)
3) )*(1+7)
5) )*(9-1)
7) )*(1+5)
11) )*(3+9)
15) *(7-1)
16) )*(4+8)
17) )*(9-1)
18) )*(1+5)
20) )*(5+7)
21) +1))*8
22) )*(6+6)
26) *(1+2)
27) )*(1+5)
28) )*(2+6)
29) )*(7-1)
32) *(1+3)
34) )*(3+5)
38) *(3+9)
39) )*(4+4)
43) *(4+8)
44) *(1+9)
47) *(5+7)
59) )*(3+3)
61) *(3+5)
62) *(1+6)
65) )*(9-3)
66) *(4+4)
* 68) -3/4)
其他类似问题
为您推荐：
24点游戏的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁谁可以给我20道24点游戏的题目和答案
谁可以给我20道24点游戏的题目和答案 10
3*(4+(-6)+10)=24 （7+(-5)*(-13)）/3=24 5 × (5 - 1 ÷ 5) 7 × (3 ÷ 7 + 3) 1) +1)*8 2) +2)*6 3) )*(1+7) 4) *2)*8 5) )*(9-1) 6) +1)*3 7) )*(1+5) 8)*3)*6 9) +1*7) 10) +3)*8 11) )*(3+9) 12) +1+4) 13) +1*5) 14) +4)*6 15) *(7-1) 16) )*(4+8) 17) )*(9-1) 18) )*(1+5) 19) -1)*6 20) )*(5+7) 21) +1))*8 22) )*(6+6) 23) +1)*8 24) +1)*9 25) +1)*8 26) *(1+2) 27) )*(1+5) 28) )*(2+6) 29) )*(7-1) 30) +2)*8 31) +2+9) 32) *(1+3) 33) +2+3) 34) )*(3+5) 35) *2+6) 36) +3*7 37) +3+8) 38) *(3+9) 39) )*(4+4) 40) -1+5) 41) )*4*6 42) +4+7) 43) *(4+8) 44) *(1+9) 45) *5-2 46) -2)*6 47) *(5+7) 48) )/2*8 49) +2)*5 50) +2)*6 51) )/2*6 52) /2*8 53) *2*9 54) -1)/2 55) +2*8 56) +2*7 57) *2*8 58) *8-1 59) )*(3+3) 60) *3+3) 61) *(3+5) 62) *(1+6) 63) +3*7 64) +8)-3 65) )*(9-3) 66) *(4+4) 67) +4*5 * 68) -3/4) 69) )*7-4 70) +3)*4
其他回答 (1)
① 3、3、8、8 ② 1、3、5、5 ③ 2、4、4、10 ④ 3、3、7、7 ⑤ 1、5、5、5 ⑥ 4、4、4、4 ⑦ 1、2、7、7 ⑧ 1、3、4、6 ⑨ 1、6、6、8 ⑩ 1、6、11、13 3 3 7 7 4 4 10 10 1 5 5 5 6 6 8 6 ((-6)+10+4)*3=24 (((-6)+10)+4)*3=24 ((-6)+(10+4))*3=24 ((-6)+4+10)*3=24 (((-6)+4)+10)*3=24 ((-6)+(4+10))*3=24 10-((-6)*3+4)=24 10-(((-6)*3)+4)=24 10-(-6)*3-4=24 10-((-6)*3)-4=24 (10-(-6)*3)-4=24 (10-((-6)*3))-4=24 (10+(-6)+4)*3=24 ((10+(-6))+4)*3=24 (10+((-6)+4))*3=24 10-(3*(-6)+4)=24 10-((3*(-6))+4)=24 10-3*(-6)-4=24 10-(3*(-6))-4=24 (10-3*(-6))-4=24 (10-(3*(-6)))-4=24 (10+4+(-6))*3=24 ((10+4)+(-6))*3=24 (10+(4+(-6)))*3=24 10-(4+(-6)*3)=24 10-(4+((-6)*3))=24 10-4-(-6)*3=24 (10-4)-(-6)*3=24 10-4-((-6)*3)=24 (10-4)-((-6)*3)=24 10-(4+3*(-6))=24 10-(4+(3*(-6)))=24 10-4-3*(-6)=24 (10-4)-3*(-6)=24 10-4-(3*(-6))=24 (10-4)-(3*(-6))=24 (10-4)*3-(-6)=24 ((10-4)*3)-(-6)=24 3*((-6)+10+4)=24 3*(((-6)+10)+4)=24 3*((-6)+(10+4))=24 3*((-6)+4+10)=24 3*(((-6)+4)+10)=24 3*((-6)+(4+10))=24 3*(10+(-6)+4)=24 3*((10+(-6))+4)=24 3*(10+((-6)+4))=24 3*(10+4+(-6))=24 3*((10+4)+(-6))=24 3*(10+(4+(-6)))=24 3*(10-4)-(-6)=24 (3*(10-4))-(-6)=24 3*(4+(-6)+10)=24 3*((4+(-6))+10)=24 3*(4+((-6)+10))=24 3*(4+10+(-6))=24 3*((4+10)+(-6))=24 3*(4+(10+(-6)))=24 (4+(-6)+10)*3=24 ((4+(-6))+10)*3=24 (4+((-6)+10))*3=24 4-(-6)*10/3=24 4-((-6)*10)/3=24 4-(-6)*(10/3)=24 4-((-6)*10/3)=24 4-(((-6)*10)/3)=24 4-((-6)*(10/3))=24 4-(-6)/3*10=24 4-((-6)/3)*10=24 4-((-6)/3*10)=24 4-(((-6)/3)*10)=24 4-(-6)/(3/10)=24 4-((-6)/(3/10))=24 (4+10+(-6))*3=24 ((4+10)+(-6))*3=24 (4+(10+(-6)))*3=24 4-10*(-6)/3=24 4-(10*(-6))/3=24 4-10*((-6)/3)=24 4-(10*(-6)/3)=24 4-((10*(-6))/3)=24 4-(10*((-6)/3))=24 4-10/3*(-6)=24 4-(10/3)*(-6)=24 4-(10/3*(-6))=24 4-((10/3)*(-6))=24 4-10/(3/(-6))=24 4-(10/(3/(-6)))=24
相关知识等待您来回答
学习帮助领域专家
& &SOGOU - 京ICP证050897号
