4个10以内的数字的和通过四则运算得到24

4个数24点计算方法与技巧4个数24点计算是一种常见的益智游戏，它要求通过组合数学运算，使用给定的4个数字，通过加减乘除等运算符得出结果为24的算式。

在这个游戏中，玩家需要充分发挥自己的逻辑思维和数学运算能力，以快速找到解题的方法。

下面是一些常用的解题方法和技巧：1. 找到一对数：首先，找到一对数使它们的运算结果等于24，比如12和2的乘积等于24。

这样，我们就可以将问题简化为在剩下的两个数中找到和为12的组合。

2. 利用分数：有时，将一个数拆分为两个数的和或差可以更容易地找到解答。

例如，将8拆分为5和3，然后将5和3与其他数字组合起来进行计算。

3. 利用加法和乘法的交替运算：有时，我们可以通过交替使用加法和乘法运算符来找到解答。

例如，对于数字2、3、4和6，我们可以先将2和3相加得到5，然后将5与4相乘得到20，最后将20与6相加得到24。

4. 利用括号：括号可以改变运算顺序，从而创造更多的计算可能性。

通过合理地使用括号，我们可以将问题简化为更小的子问题。

例如，对于数字1、2、4和6，我们可以通过将1与2和4的乘积相加来得到结果，即1 + (2 * 4) = 9。

此外，解决这个游戏的关键在于灵活运用不同的数学运算规则和技巧。

有时候，解答可能需要多次尝试和调整，但通过不断练习和思考，我们可以提高自己的解题能力，逐渐变得更加熟练。

4个数24点计算游戏不仅仅是一种娱乐方式，它还可以锻炼我们的数学思维能力和逻辑推理能力。

通过挑战这个游戏，我们可以提高自己的数学水平，并培养解决问题的能力。

无论是在学校还是在日常生活中，这些技巧和方法都可以帮助我们更好地解决各种数学难题。

因此，我们应该多多尝试和练习，从中获得乐趣并提升自己的数学能力。

算二十四点较难题目算二十四点是一种经典的数学游戏，规则很简单：给定四个数字，通过四则运算（加、减、乘、除），使最终结果等于 24。

这个游戏看似简单，但当遇到一些较难的题目时，就需要我们充分运用数学思维和技巧来求解。

先来看这样一组数字：3、5、7、8。

乍一看，可能会觉得有些棘手。

但我们可以先从乘法入手，因为 3×8 ＝ 24 是一个比较常见的组合。

那么如何通过剩下的数字 5 和 7 来调整运算呢？我们可以这样思考：5 7 ＝－2，然后 8 ÷（－2) ＝－4，3 （－4) ＝ 7，7×3 ＝ 21，再加上 3就等于 24 了。

整个运算过程为：3×8÷（5 7) ＋ 3 ＝ 24 。

再看这四个数字：2、6、9、9。

这次没有明显能直接得出 24 的乘法组合。

那我们尝试从加法和除法的角度去思考。

先计算 9 ＋ 9 ＝ 18，然后 6 ÷ 2 ＝ 3，18 ＋ 6 ＝ 24 。

即：（9 ＋ 9) ＋ 6 ÷ 2 ＝ 24 。

接下来这组数字：4、4、7、7。

这组数字的难度又有所增加。

如果单纯从四则运算的常规思路出发，可能很难找到答案。

这时候我们可以考虑使用分数运算。

我们知道 4 4/7 ＝ 24/7 ，然后 7×24/7 ＝ 24 。

算式为：7×（4 4/7) ＝ 24 。

还有一组数字：1、5、5、5 。

这组数字也颇具挑战性。

我们可以这样算：5×（5 1÷5) ＝ 5×（5 02) ＝ 5×48 ＝ 24 。

对于算二十四点的较难题目，有时候需要打破常规的思维模式。

比如，当四个数字都较大时，可能要考虑先做减法或除法来缩小数字范围；当数字中有小数时，要灵活运用小数的运算特性。

另外，要善于观察数字之间的关系和特点。

如果有两个数字能够凑成接近 24 的数，那么就重点围绕这两个数字来构建运算式子。

### 三年级数学下册教案：算“24点”（11）-苏教版#### 教学目标1. **知识与技能**：通过“24点”游戏，使学生掌握基本的四则运算，提高计算能力。

2. **过程与方法**：培养学生观察、分析、解决问题的能力，发展逻辑思维。

3. **情感态度价值观**：激发学生学习数学的兴趣，培养合作意识和竞争精神。

#### 教学重点与难点1. **重点**：理解“24点”游戏的规则，能熟练运用四则运算得到结果24。

2. **难点**：在限定时间内，灵活运用四则运算，提高解题速度和准确率。

#### 教学准备- 教具：“24点”游戏卡片- 学具：每组一套“24点”游戏卡片#### 教学过程1. **导入新课**（5分钟）- 利用多媒体展示“24点”游戏，激发学生兴趣。

- 邀请几名学生上台尝试，引导学生观察、思考。

2. **探索交流**（10分钟）- 分组讨论，让学生尝试用自己的方式解决问题。

- 引导学生总结规律，掌握解题技巧。

3. **讲解示范**（10分钟）- 教师讲解“24点”游戏的规则，强调四则运算的运用。

- 示范解题过程，强调注意事项。

4. **实践练习**（10分钟）- 学生分组进行“24点”游戏，教师巡回指导。

- 鼓励学生相互交流，分享解题经验。

5. **总结提升**（5分钟）- 教师引导学生总结本节课的学习内容，强化重点知识。

- 鼓励学生在课后继续练习，提高计算能力。

#### 课后作业- 完成《练习册》中关于“24点”的相关题目。

- 尝试在家中与家人一起玩“24点”游戏，提高计算速度。

#### 教学反思- 注重培养学生的观察力和逻辑思维能力，鼓励学生多角度思考问题。

- 在教学过程中，关注学生的个体差异，因材施教，使每个学生都能得到发展。

- 加强课后辅导，帮助学生巩固所学知识，提高计算能力。

#### 教学评价- 通过课堂表现、课后作业和平时练习，评价学生对“24点”游戏规则的理解和四则运算的运用能力。

C语⾔实现24点问题详解⽬录题⽬描述问题分析代码实现运⾏结果题⽬描述在屏幕上输⼊1〜10范围内的4个整数（可以有重复），对它们进⾏加、减、乘、除四则运算后（可以任意的加括号限定计算的优先级），寻找计算结果等于24的表达式。

例如输⼊4个整数4、5、6、7，可得到表达式：4*((5-6)+7)=24。

这只是⼀个解，要求输出全部的解。

要求表达式中数字的顺序不能改变。

问题分析这道题理解起来很简单，就是拼凑加减乘除，使4个数的运算结果等于24。

由于四则运算中，乘除的优先级⾼于加减，所以必须“加括号”来限定4个数之间运算优先级。

例如：A+B*C-D 这个式⼦，通过增加括号，可以产⽣多种结果，⽐如 (A+B)*(C-D) 和 A+(B*C-D)。

那么总共有⼏种加括号的⽅法呢，该如何分类呢？⼀开始我在想是不是能按照括号对数进⾏分类，但后来发现，要想将4个数字的运算优先级细分，必须使⽤两对括号。

可以这么理解：我们的⽬的是将4个数的运算转换成两个“数”的运算（这⾥的“数”包括括号表达式），⽽每两个数运算，就能得出⼀个结果，即每对括号可以减少⼀个要计算的数字（如(A+B)*(C+D)中，A和B运算，使式⼦变成了3个数，C接着和D运算，使式⼦剩下两个数字）。

4-2=2即为需要的括号数。

下⾯列举所有可能的括号表达式：（#表⽰四则运算符）1. ((A#B)#C)#D2. (A#(B#C))#D3. A#((B#C)#D)4. A#(B#(C#D))5. (A#B)#(C#D)具体思路：上⾯5种括号表达式都可以单独写成函数，函数内部按照括号的优先级+从左往右的顺序进⾏运算，最后返回计算结果。

每个表达式中有3个'#'号，它们是四则运算符（+、-、*、/），可以定义⼀个全局字符数组，存放4这四个字符。

char my_oprator[4] = {'+', '-', '*', '/'};主函数使⽤穷举法，对表达式的每个#符号进⾏遍历（4种运算符），使⽤3层 for循环实现（层数对应3个#符号，每层循环4次，对应4种运算符），最后将符合条件的表达式输出。

《高级语言程序设计》课程设计说明书设计题目：算24游戏目录1.课程设计的目的 (1)2.课程设计任务内容 (1)2.1 说明 (1)2.2 算法分析 (1)2.3 用户使用说明 (1)2.4 模块说明 (1)3.系统模块图 (1)4.效果预览 (3)5.经验和体会 (4)6.参考文献 (4)7.附录 (4)一、课程设计的目的《高级语言程序设计》课程设计是电子信息专业集中实践性环节之一，是学习完《高级语言程序设计》课程后进行的一次全面的综合练习，其目的在于加深对程序设计基本知识的理解，掌握使用C语言进行模块化软件设计的基本方法，提高通过编写程序解决实际问题能力，为今后从事设计工作和后续各种编程课程的学习打好基础。

二、课程设计任务内容算24游戏【说明】主要功能：（1）能罗列出四张牌用四则运算凑成24的游戏。

（2）凑不成给出提示。

【算法分析】计算24点主要应用四种运算．开始状态有四个操作数，一个运算符对应两个操作数，所以一开始选择两个操作数分别对四个操作符进行循环检测，每一次运算后产生了新的数，两个数运算变成一个数，整体是少了一个操作数，所以四个数最终是三次运算。

由于操作的层数比较少(只有三层)，所以可以用回溯的算法来进行检测，当找到一个解时便结束查找。

以此循环，最终找到所有解。

如果所有的情况都找过后仍然没有，则输出无解的信息。

【用户使用说明】当游戏界面出现时，玩家可以按照系统提示从1到13之间任意选择4个整数，然后可以多人同时进行四则运算快速得出计算出24点的运算方法。

最后可以通过对程序的运行得到所有的解法。

如果所给的数能够得到24点，计算机将会罗列出所有的算法；如果不能构成24点，计算机将会给出提示。

【模块说明】从大的方面讲，本程序可以分为两个大的模块。

一个模块是对使用者所给数字的分析说明以及程序算法；另一个模块是对运算符的分析说明与使用。

本程序主要采用了循环的结构体，通过回溯法对所给数字进行四则运算，然后通过循环体的功能将所有结果输出，以得到所有满足条件的算法。

24点的原理24点的原理什么是24点？24点是一个简单而又富有挑战性的数学游戏，其规则是通过组合给定的四个数字，使用四则运算（加、减、乘、除）和括号等符号，得到结果为24的算式。

游戏玩法1.首先，从一副扑克牌中随机抽出4张，可以是数字牌（A到10）或特殊牌（J、Q、K）。

2.然后，玩家需要使用这4个数字，通过四则运算等方式计算出结果为24的算式。

3.每个数字只能使用一次，但可以对数字进行加减乘除的运算，也可以使用括号。

例如，对于数字2、3、4、5，可以进行如下计算：(2+3) * (4+5) = 45。

关键的思维技巧在玩24点时，有一些关键的思维技巧可以帮助你找到得到结果为24的算式。

1. 顺序无关性首先，要意识到数字的顺序是无关的。

也就是说，对于数字2、3、4、5，可以将它们按照任意顺序组合，得到的结果都是相同的。

2. 优先级规则其次，记住四则运算的优先级规则。

乘除法具有比加减法更高的优先级，可以优先进行运算。

括号可以改变运算的优先级。

3. 算式的性质还有一个有用的思维技巧是利用算式的对称性和性质。

例如，如果你有两个相同的数字，可以尝试将它们相加、相乘或相减得到结果为24的算式。

举例说明我们通过举例来更好地理解24点的原理。

例子1假设我们有以下数字牌：2、3、4、5。

通过尝试不同的组合和运算符，可以得到如下算式： - 2 + 3 +4 +5 = 14 - 2 * 3 * 4 * 5 = 120 - (2 + 3) * (4 + 5) = 45其中，最后一个算式(2+3) * (4+5) = 45符合要求，得到结果为24的算式。

例子2再举一个例子，假设我们有以下数字牌：2、4、6、8。

通过尝试不同的组合和运算符，可以得到如下算式： - 2 * 4 * 6 * 8 = 384 - (2 + 6) * 4 * 8 = 256其中，最后一个算式(2+6) * 4 * 8 = 256符合要求，得到结果为24的算式。

四年级24点题目大全三种方法全文共四篇示例，供读者参考第一篇示例：四年级的学生在学习数学时，常常会遇到一种挑战性的游戏——24点。

这个游戏的规则很简单，就是利用给定的四个数字，通过加减乘除的运算，使得这四个数字得到结果为24。

虽然看起来简单，但是要在规定的时间内找到解答并不容易。

今天就让我们来看看四年级24点题目大全的三种解题方法。

第一种方法是通过暴力枚举。

这种方法可能比较笨拙，但是对于刚刚接触24点游戏的四年级学生来说，是一种很好的练习方法。

学生可以将给定的四个数字按照不同的顺序排列，然后通过加减乘除的运算，计算出所有可能的结果。

如果其中有任何一种解答等于24，那么这道题目就得到了解决。

虽然这种方法比较耗时，但是可以帮助学生熟悉各种运算规则，并锻炼他们的计算能力。

第二种方法是通过找规律解题。

这种方法需要学生对数学有一定的了解和思考能力。

学生可以观察给定的四个数字之间是否存在某种数学关系，比如是否有可以相乘或者相加得到24的数字。

如果存在这样的特殊关系，那么就可以很快地找到解答。

学生还可以通过反复尝试找到一种通用的解题思路，比如先进行乘法或者加法运算，再进行除法或者减法运算。

这种方法虽然需要一定的逻辑思维，但对于提高学生的数学思维能力有很大的帮助。

第三种方法是通过利用数学技巧解题。

这种方法较为高级，需要学生在掌握了基本的数学知识之后才能进行。

学生可以尝试利用分数、平方、平方根等数学技巧，来简化复杂的运算。

可以将给定的四个数字用分数形式表示，再进行加减乘除的运算，得到最后的结果。

这种方法需要学生在运用数学技巧的保持逻辑思维的清晰，并且避免犯错。

通过反复练习，学生可以逐渐提高自己的解题速度和准确性。

四年级24点题目大全有三种解题方法：暴力枚举、找规律解题和利用数学技巧解题。

每种方法都有其适用的场景和对学生的要求，帮助学生在数学学习中得到更全面的提升。

通过不断练习和思考，学生可以逐渐提高自己的解题水平，培养数学思维能力，为未来的学习打下坚实的基础。

三年级下册数学教案4.4 算“24点”苏教版教案：三年级下册数学教案4.4 算“24点”苏教版一、教学内容本节课的教学内容来自苏教版三年级下册数学教材第47页，主要包括算“24点”游戏规则的介绍以及如何通过四则运算来找出符合要求的算式。

学生将学习如何利用加、减、乘、除四则运算，找出结果为24的算式。

二、教学目标1. 让学生掌握算“24点”的游戏规则，并能够独立完成游戏。

2. 提高学生的四则运算能力，培养学生的逻辑思维和运算技巧。

3. 培养学生的合作意识和团队协作能力。

三、教学难点与重点1. 教学难点：如何引导学生找出符合要求的算式，培养学生解决问题的能力。

2. 教学重点：让学生掌握算“24点”的游戏规则，并能够灵活运用四则运算。

四、教具与学具准备1. 教具：PPT、黑板、粉笔2. 学具：练习本、笔五、教学过程1. 实践情景引入：讲述一个关于算“24点”的故事，引发学生的兴趣。

如：小明在数学课上听老师讲解了一个有趣的游戏——“24点”，他迫不及待地想回家试试。

2. 讲解游戏规则：介绍算“24点”的游戏规则，包括如何利用加、减、乘、除四则运算，找出结果为24的算式。

如：给定四个数字，通过四则运算，使这四个数字的结果为24。

3. 例题讲解：出示一道典型的例题，讲解解题思路。

如：给出数字1、2、3、4，如何通过四则运算得出结果为24的算式。

引导学生思考，鼓励学生发表自己的观点。

4. 随堂练习：让学生独立完成几道算“24点”的题目，教师巡回指导。

如：给出数字5、6、7、8，请学生找出结果为24的算式。

5. 小组合作：学生分组，每组共同完成一道较难的算“24点”题目，培养学生的合作意识和团队协作能力。

如：给出数字9、10、11、12，请学生找出结果为24的算式。

六、板书设计板书题目：算“24点”板书内容：1. 游戏规则2. 解题思路3. 例题讲解4. 随堂练习5. 小组合作七、作业设计1. 请学生独立完成教材第47页的练习题。

《10以内数的连加连减》教案教学目标1. 让学生理解10以内数的连加连减的概念，掌握计算方法。

2. 培养学生运用10以内数的连加连减解决实际问题的能力。

3. 培养学生良好的数学学习习惯和合作意识。

教学重点1. 10以内数的连加连减的概念。

2. 10以内数的连加连减的计算方法。

教学难点1. 10以内数的连加连减的运算顺序。

2. 10以内数的连加连减在实际问题中的应用。

教学准备1. 教学课件或黑板。

2. 10以内数的连加连减练习题。

教学过程一、导入1. 通过课件或黑板展示一些10以内的数，引导学生回顾已学的数学知识。

2. 提问：同学们，我们已经学过了10以内的数，今天我们要学习10以内数的连加连减。

大家知道什么是连加连减吗？二、新课讲解1. 通过课件或黑板展示10以内数的连加连减的例子，引导学生观察并总结规律。

2. 讲解10以内数的连加连减的概念，让学生明确连加连减的含义。

3. 讲解10以内数的连加连减的计算方法，让学生掌握计算规则。

4. 通过例题演示，让学生学会如何运用10以内数的连加连减解决实际问题。

三、课堂练习1. 让学生独立完成一些10以内数的连加连减的练习题。

2. 对学生的练习进行巡回指导，及时发现并纠正错误。

3. 对学生的练习进行评价，鼓励学生积极参与课堂活动。

四、课堂小结1. 让学生回顾本节课所学的内容，总结10以内数的连加连减的概念和计算方法。

2. 强调10以内数的连加连减在实际问题中的应用，让学生明确学习的重要性。

五、课后作业1. 让学生完成一些10以内数的连加连减的练习题。

2. 家长签字确认，加强家校合作。

教学反思本节课通过讲解、演示、练习等方式，让学生掌握了10以内数的连加连减的概念和计算方法。

在教学过程中，要注意引导学生观察、思考、总结，培养学生的数学思维能力。

同时，要加强课堂练习，及时发现并纠正学生的错误，提高学生的学习效果。

在课后作业的布置上，要加强家校合作，让家长了解学生的学习情况，共同促进学生的成长。

任意1-10中的4个数字，使⽤加减乘除计算得出24结果的可能组合（java版），很多⼈⼩时候都玩过⽬录1. 需求；2. 需求该如何分析呢，怎么划分成⼩需求呢？3. 如何把⼩需求编排成完整需求；学有所得1. 学会分析需求，由哪些组成（规则，逻辑等）;2. 能把的需求分解成很多⼦需求、或孙需求、或童孙需求，直到每个需求很清晰可实施地为⽌3. 学会把各种⼦孙需求，通过组合编排，最终成为⼀个完整的⼤需求解决⽅案需求需求：任意1-10中的4个数字，使⽤加减乘除计算得出24结果的可能组合；通过初步分析，我们可以得到如下规则：规则：1、任意1-10中的4个数字；2、使⽤加减乘除计算得出24;3、在任何⼀次计算中不能出现⼩数，⽐如：(4.0 + 8.0) / (3.0 / 6.0) = 24.0，这种是不算的，虽然最终结果是24，因为3/6=0.5;(8.0 / 3.0) * (4.0 + 5.0) = 24.0，虽然最终为24，但是在第⼀步结果却是⼩数，所以不成⽴；代码如下/*** 是否为合法的计算结果* @param result* @return*/public static boolean isValidResult(double result){if (result<1){return false;}return result == Math.floor(result);}View Code4、整个运算中应该使⽤double类型，因为整数相除，使⽤int类型，在计算机中，会把余数抹掉，直接取整，这样就会造成结果不正确；那需求该如何分析呢，怎么划分成⼩需求呢？⼀般来说我们都会通过案例来分析，⽐如：这个需求，我们使⽤传统的计算，假设我们已经有这四个数[3,4,8,6],可能会有如下组合:⽅案：((4.0 + 8.0) * 6.0) / 3.0=24.0;⽅案：((3.0 * 4.0) - 8.0) * 6.0=24.0;⽅案：((8.0 - 6.0) * 3.0) * 4.0=24.0;⽅案：((4.0 + 8.0) / 3.0) * 6.0=24.0;⽅案：(4.0 * 3.0) * (8.0 - 6.0) = 24.0;⽅案：(6.0 / 3.0) * (4.0 + 8.0) = 24.0；我们暂时先分析这个⼏个⽅案，⼤家看到这⾥，可以先思考⼀下有什么规律，有什么规则；....................................................................................................Thinking..............................从这些⽅案中，我们可以得出如下蹊跷之处：1、所有的⽅案中，都在这四个数的所有可能排列组合中（我记忆之中，应该是⾼中数学的知识点）；2、我们可以把计算法则归纳为两种，所有的都可以归纳到⼀下两种中去；第⼀、从左到右的依次计算；第⼆、两两组合，前两个数计算结果和后两个数的计算结果再次计算；第三、每个⽅案都有3个运算符；不知道⼤家是不是和我发现的⼀样不，或者说有更多的发现；我认为不管什么发现都可以先列出来，然后在逐个去去除⼀些太离谱的发现；我们再继续顺藤摸⽠，到此我们可以把需求分解如下：我们继续分析需求，看看是否可以再次分解从上⾯的需求中我们可以进⼀步进⾏分解第⼀、如何获取四个数的所有排列组合？1、举例，我们继续使⽤案列来分析，⽐如 [3,4,8,6][3,4,8,6]（基准）[4,3,8,6]（第⼆和第⼀调换）[3,8,4,6] [8,3,4,6]（第三和第⼆调换，第⼆和第⼀调换）[3,4,6,8] [3,6,4,8] [6,3,4,8] （第四和第三调换，第三和第⼆调换，第⼆和第⼀调换）这样是不是所有的排列组合呢?显然不是？因为还有三种基准进⾏上⾯的排列组合，也就是上⾯每⾏最后⼀列[4,3,8,6]（基准2）[8,3,4,6]（基准3）[6,3,4,8]（基准4）2、通过上⾯的举例，我们就可以先获取所有的基准组合；3、通过上⾯，我们可以知道每种基准的所有组合；4、通过上⾯的⽅法获取的组合会有重复，需要前需要去重；这样我们就能获取4个数的所有排列组合；我感觉这种获取所有排列组合的算法很笨重（有没有感觉有点想冒泡排序），不优雅，肯定有更优的⽅案，只是我不知道⽽已，如果知道的可以留⾔，谢谢；所有排列分析到此，是不是还需要继续分析，可以继续思考；本⼈感觉可以落地了；如果觉得需要继续分析的，可以继续分解，知道⾃⼰很清晰，知道怎么⼲为⽌（这个因⼈⽽异）；请看代码；获取所有基准代码：double[] array = {3, 4, 6, 8};List<double[]> resultAllList = new ArrayList<>();List<double[]> list = new ArrayList<>();list.add(array);list.add(new double[]{array[1], array[2], array[3], array[0]});list.add(new double[]{array[2], array[3], array[0], array[1]});list.add(new double[]{array[3], array[0], array[1], array[2]});View Code获取每个基准的所有排列组合：/*** 获取array的所有可能组合** @param list* @param array*/public static void getAllArray(List<double[]> list, double[] array) {if (!exists(list, array)) {list.add(array);}for (int i = 1; i < 4; i++) {double[] arrayCopy = Arrays.copyOf(array, array.length);List<double[]> newList = getArrayList(arrayCopy, i);Iterator<double[]> iterator = newList.iterator();while (iterator.hasNext()) {double[] temp = iterator.next();if (!exists(list, temp)) {list.add(temp);}}}}/*** 获取array下标遇到i的位置左右组合** @param array* @param i* @return*/public static List<double[]> getArrayList(double[] array, int i) {List<double[]> list = new ArrayList<>();for (int j = i; j > 0; j--) {double temp = array[j];array[j] = array[j - 1];array[j - 1] = temp;list.add(array);array = Arrays.copyOf(array, array.length);}return list;}View Code第⼆，对于算法法则该如何继续分析呢?我们可以继续使⽤举例从上⾯随意获取⼀种排列组合，⽐如：[3,4,8,6]1、从左到右的组合，在上⾯四个数字中，任意两个数中，我们可以有+，- ，*，/这四种算法，这⼜是⼀种计算的所有排列组合，并把结果和24对⽐，如果相等，那就是可⾏⽅案；那我们是不是继续使⽤上⾯获取组合的⽅式呢？显然不是，这⾥关键点在于：任意两个数中都有+-*/的算法，这⾥我们可以使⽤三个for循环解决；举例：((3.0 * 4.0) - 8.0) * 6.0=24.0;/*** 计算array能算24点的所有组合，从左到右的顺序** @param* @throws Exception*/public static int caculate24Point(double[] array) throws Exception {int count = 0;if (array.length != 4) {throw new Exception("不是四个数");}for (String op : operators) {String expressionStr = "";double result = getTwoNumCaculate(array[0], array[1], op);if (!isValidResult(result)){continue;}expressionStr = String.format("(%s %s %s)", array[0], op, array[1]);for (String op2 : operators) {double result1 = getTwoNumCaculate(result, array[2], op2);if (!isValidResult(result1)){continue;}String expressionStr2 = String.format("(%s %s %s)", expressionStr, op2, array[2]);for (String op3 : operators) {double result2 = getTwoNumCaculate(result1, array[3], op3);String expressionStr3 = String.format("%s %s %s", expressionStr2, op3, array[3]);if (result2 == 24.0d) {count++;System.out.println(String.format("⽅案：%s=%s", expressionStr3, result2));}}}}return count;}View Code2、两两组合，思路和上⾯有些相似，前两个数的任意计算结果1，后两个数的任意计算结果2，结果1和结果2的任意计算结果3，结果3和24对⽐，如果相等，那就是可⾏⽅案；举例：(3.0 * 4.0) * (8.0 - 6.0) = 24.0;/*** 计算array能算24点的所有组合 ,两两组合** @param array* @return* @throws Exception*/public static int caculate24Point2(double[] array) throws Exception {int count = 0;if (array.length != 4) {throw new Exception("不是四个数");}for (String op : operators) {double result1 = getTwoNumCaculate(array[0], array[1], op);if (!isValidResult(result1)){continue;}String expressionStr1 = String.format("(%s %s %s)", array[0], op, array[1]);for (String op2 : operators) {double result2 = getTwoNumCaculate(array[2], array[3], op2);if (!isValidResult(result2)){continue;}String expressionStr2 = String.format("(%s %s %s)", array[2], op2, array[3]);for (String op3 : operators) {double result3 = getTwoNumCaculate(result1, result2, op3);String expressionStr3 = String.format("%s %s %s", expressionStr1, op3, expressionStr2);if (result3 == 24.0d) {count++;System.out.println(String.format("⽅案： %s = %s", expressionStr3, result3));}}}}return count;}View Code某⼀种四个数的所有运算排列通过上⾯的⽅式我们可以全部获取，分析到此，我觉得代码可以落地，当然，如果你觉得还不够清晰，可以继续分析，直到⾃⼰清晰为⽌，这⾥我只是提供分解需求的思路⽽已；在软件⼯程中，我们必定先分析需求，然后分解需求，我们有四⾊分析⽅式，我们还有DDD领域的分析⽅式等，都是需要通过逐步分解成更⼩的需求来反复验证的；到⽬前为⽌我们可以得出如下思维导图把各种⼦孙需求，通过组合编排，最终成为⼀个完整的⼤需求解决⽅案最后，我们把每个⼩的需求加上⼀些规则逻辑组合成完整的⼤需求，我们暂时叫做编排吧；这⾥其实也是⼀个难点，很多⼈希望⼀次性把代码写完整，写正确，其实这种思路是不正确的，这样只会增加代码的难度，⼀次性能把代码写的有多完整多正确，这个跟每个⼈的编程经验熟练度有关；不管编程多⽜，从⽆到有的敲代码⽅向不是⼀次性把左右的代码完成，重点⽅向把核⼼逻辑思路编写上，其次才逐步把⼀些细节逻辑规则加上去，这个就和我们⼩时候学画画⼀样，画⼀颗树先画主⼲然后画叶⼦最后添加果⼦和花之类的；到⽬前为⽌是否完整呢？其实还差⼀点，任意的1-10的数字从哪⾥获取，不过需求没有明确，可以是⽤户输⼊，数据库获取，其他接⼝的传⼊，我们这⾥就定位⽤户输⼊吧获取⽤户输⼊代码如下：double[] array = new double[4];int index=0;Scanner scanner=new Scanner(System.in);while (index<4){System.out.println(String.format("请输⼊第%s个1-10的整数",index+1));String tempNumStr=scanner.nextLine();if(!StringUtils.isNumeric(tempNumStr)){System.out.println("你输⼊的不是⼀个整数");continue;}double tmpNum=Double.valueOf(tempNumStr);if (tmpNum<0 || tmpNum>10){System.out.println("你输⼊的数字不是1-10的数字");continue;}array[index++]=tmpNum;}System.out.println(String.format("你输⼊的4个1-10的整数为%s,%s,%s,%s",array[0],array[1],array[2],array[3]));View Code最终完整代码如下：import ng3.StringUtils;import java.util.*;/*** Author:* Date:*/public class Point24Caculator {/*** 计算24点中可以到的操作*/private static String[] operators = {"+", "-", "*", "/"};public static void main(String[] args) throws Exception {double[] array = new double[4];int index=0;Scanner scanner=new Scanner(System.in);while (index<4){System.out.println(String.format("请输⼊第%s个1-10的整数",index+1));String tempNumStr=scanner.nextLine();if(!StringUtils.isNumeric(tempNumStr)){System.out.println("你输⼊的不是⼀个整数");continue;}double tmpNum=Double.valueOf(tempNumStr);if (tmpNum<0 || tmpNum>10){System.out.println("你输⼊的数字不是1-10的数字");continue;}array[index++]=tmpNum;}System.out.println(String.format("你输⼊的4个1-10的整数为%s,%s,%s,%s",array[0],array[1],array[2],array[3]));System.out.println("结果如下：");List<double[]> resultAllList = new ArrayList<>();List<double[]> list = new ArrayList<>();list.add(array);list.add(new double[]{array[1], array[2], array[3], array[0]});list.add(new double[]{array[2], array[3], array[0], array[1]});list.add(new double[]{array[3], array[0], array[1], array[2]});for (int i = 0; i < list.size(); i++) {getAllArray(resultAllList, Arrays.copyOf(list.get(i), list.get(i).length));}int sum = 0;Iterator<double[]> iterator = resultAllList.iterator();while (iterator.hasNext()) {double[] tempArray = iterator.next();sum += caculate24Point(tempArray);sum += caculate24Point2(tempArray);}System.out.println("总共⽅案数量：" + sum);}/*** 获取array的所有可能组合** @param list* @param array*/public static void getAllArray(List<double[]> list, double[] array) {if (!exists(list, array)) {list.add(array);}for (int i = 1; i < 4; i++) {double[] arrayCopy = Arrays.copyOf(array, array.length);List<double[]> newList = getArrayList(arrayCopy, i);Iterator<double[]> iterator = newList.iterator();while (iterator.hasNext()) {double[] temp = iterator.next();if (!exists(list, temp)) {list.add(temp);}}}}/*** 获取array下标遇到i的位置左右组合** @param array* @param i* @return*/public static List<double[]> getArrayList(double[] array, int i) {List<double[]> list = new ArrayList<>();for (int j = i; j > 0; j--) {double temp = array[j];array[j] = array[j - 1];array[j - 1] = temp;list.add(array);array = Arrays.copyOf(array, array.length);}return list;}/*** array是否存啊在list中** @param list* @param array* @return*/public static boolean exists(List<double[]> list, double[] array) {Iterator<double[]> iterator = list.iterator();while (iterator.hasNext()) {double[] tmpArray = iterator.next();if (tmpArray[0] == array[0] && tmpArray[1] == array[1] && tmpArray[2] == array[2] && tmpArray[3] == array[3]) { return true;}}return false;}/*** 计算array能算24点的所有组合，从左到右的顺序** @param* @throws Exception*/public static int caculate24Point(double[] array) throws Exception {int count = 0;if (array.length != 4) {throw new Exception("不是四个数");}for (String op : operators) {String expressionStr = "";double result = getTwoNumCaculate(array[0], array[1], op);if (!isValidResult(result)){continue;}expressionStr = String.format("(%s %s %s)", array[0], op, array[1]);for (String op2 : operators) {double result1 = getTwoNumCaculate(result, array[2], op2);if (!isValidResult(result1)){continue;}String expressionStr2 = String.format("(%s %s %s)", expressionStr, op2, array[2]);for (String op3 : operators) {double result2 = getTwoNumCaculate(result1, array[3], op3);String expressionStr3 = String.format("%s %s %s", expressionStr2, op3, array[3]);if (result2 == 24.0d) {count++;System.out.println(String.format("⽅案：%s=%s", expressionStr3, result2));}}}}return count;}/*** 计算array能算24点的所有组合 ,两两组合** @param array* @return* @throws Exception*/public static int caculate24Point2(double[] array) throws Exception {int count = 0;if (array.length != 4) {throw new Exception("不是四个数");}for (String op : operators) {double result1 = getTwoNumCaculate(array[0], array[1], op);if (!isValidResult(result1)){continue;}String expressionStr1 = String.format("(%s %s %s)", array[0], op, array[1]);for (String op2 : operators) {double result2 = getTwoNumCaculate(array[2], array[3], op2);if (!isValidResult(result2)){continue;}String expressionStr2 = String.format("(%s %s %s)", array[2], op2, array[3]);for (String op3 : operators) {double result3 = getTwoNumCaculate(result1, result2, op3);String expressionStr3 = String.format("%s %s %s", expressionStr1, op3, expressionStr2);if (result3 == 24.0d) {count++;System.out.println(String.format("⽅案： %s = %s", expressionStr3, result3));}}}}return count;}/*** 是否为合法的计算结果* @param result* @return*/public static boolean isValidResult(double result){if (result<1){return false;}return result == Math.floor(result);}private static double getTwoNumCaculate(double num1, double num2, String operator) throws Exception { switch (operator) {case "+":return num1 + num2;case "-":return num1 - num2;case "*":return num1 * num2;case "/":return num1 / num2;default:throw new Exception("运算符不符合规范");}}}View Code学有所得1. 是否学会了这种分析思路2. 是否这种需求分析思路可以运⽤在地⽅？3. 这种把每个原⼦需求编排成⼀个完整⼤需求，是否可以在他地⽅使⽤?最后效果图：。