作业帮24点游戏算法
来源：学生作业帮助网 编辑：作业帮 时间：2024/09/25 11:21:09 字数作文
篇一：24点算法大全
“24点” 算法技巧
一、游戏内容及规则
一牌中1～9这36张牌任意抽取4张牌，用加、减、乘、除（可加括号）把牌面上的数算成24。每张牌必须用一次且只能用一次。例如：抽出的四张牌是3、8、8、9，那么算式为（9—8）×8×3或3×8÷（9—8）或（9—8÷8）×3等；再例如，抽出的四张牌为3、4、7、11，可以这样计算：（7－4）×（11
－3）＝3×8＝24，或（7＋11）÷3×4＝18÷3×4＝6×4＝24。
“算24点”主要是将四个数字和四种运算符号及括号进行一定的组合、搭配，使计算结果为24，而组合、搭配的形式有很多，有些可以得出24，但有些则不行。因此，我们不能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑，计算时还应掌握一些基本的运算技巧。这里向大家介绍几种常用的、便
于学习掌握的方法：
二、计算方法
要想快速计算，首先要非常清楚24可以由怎样的两个数求得，如2×12＝24，4×6＝24，3×8＝24，这样就可以把问题转化成怎样使用4个数，凑出两个数的问题，其中有一点值得大家注意，就是四个数的顺序可以依据需要?a href="http://www.zw2.cn/zhuanti/guanyuwozuowen/" target="_blank" class="keylink">我獍才拧?/p>
例1 ：利用3×8＝24、4×6＝24求解。
把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。
? 1、2、3、5 可组成（1+2）×（3+5）=24；（5－1）×（2×3）=24； ? 2、3、3、7 可组成（2×3）×（7－3）=24； ? 5、7、7、9 可组成（9－7）×（5＋7）=24
实践证明，利用3×8＝24、4×6＝24来求解的这种方法是利用率最大、命中率最高的一种方法。
练习：（1） 2、4、5、9 可组成（9－5）×（2+4）=24
（2） 2、2、8、8 可组成（8÷2）×（8－2）=24
（3） 3、4、5、8 可组成（5－3）×（4＋8）=24
三、思维方法
在掌握了计算方法的基础上，我们还必须要掌握一定的思维技巧，刚才上面的这些题的思维方法，在数学上我们称为“顺向思维”，除了这种思维方法之外，我们还有一种非常重要的思维方法“逆向思维”。
当四个数中有24的因数时如2、3、4、6、8，先用24除以这些数得到一个商，然后用剩下的3个数计算出这个商。
例如：1、2、3、5，可先用24÷3=8，再用1＋2＋5得8，可组成（1+2+5）×3=24；
2、3、3、7，可先用24÷3=8，再用7＋3—2得8，可组成（7＋3—2）×
3=24；
2、4、5、9，可先用24÷4=6，再用9－5＋2得6，可组成（9－5＋2）×
4=24
2、2、8、8，可先用24÷8=3，再用（8－2）÷2，可组成（8－2）÷2×
8=24；
或24÷2=12，再用8÷2＋8得12，可组成（8÷2＋8）×2=24； 例2：利用24÷2、24÷3、24÷4、24÷6、24÷8求解
? 2、3、4、5 可组成（3＋4＋5）×2＝24；（5＋3－2）×4=24； ? 6、8、9、9 可组成（9＋9）÷6×8=24；9÷（9－6）×8=24；
实践证明，但两两组数的“顺向思维”遇到困难时，采用这种“逆向思维”
的方法是非常有效的。
练习：（1） 4、7、7、7 可组成 4×（7－7÷7）＝24
（2） 5、6、8、8 可组成（5＋6－8）×8＝24
四、熟能生巧
有些数字用乘法关系最后求得“24”就不太容易，应考虑＋、－关系，27－3＝24，25－1＝24，20＋4＝24??先用两个数将计算结果靠近24，再进行适当调整，这是一种非常行之有效的方法，
例3：
? 依据27－3＝24 ，可得3×3×3－3＝24； ? 依据20＋4＝24 ，可得4×4＋4＋4＝24； ? 依据25－1＝24 ；可得5×5－5÷5＝24；
实践证明，要想解决这些问题，必须依据数字的特点，依赖于良好的数感，
而这需要大家经过一定的训练才能获得。
练习：（1）4、5、7、9 可组成 5＋4×7－9； （2）5、5、8、9 可组成
8+5×5－9；
（3）5、5、9、9 可组成5×5－9÷9； （4）5、8、8、8 可组成5
×8－（8＋8）；
五、思维定势
用人们的俗话讲：就是“一根筋碰住了”，犯了一些低级错误。
? 4、5、6、9 可组成9+6+4+5 ? 4、5、7、8 可组成8+7+4+5
人们的思维有时会受到常规思维的影响，将简单的问题想复杂了，往往造成一些非常简单的题目想了半天也无法解决的现象。在数学上，我们称为“思维定
势”，也常常是好生的困惑。
六、特例
1、24点里这六道题是一定要用分数做的：1346 1456 1555 1668 3377 3388 4477
2、经过尝试，我们发现，4个1，4个2，由于数太小，无法算出“24”，而4个7，4个8，4个9由于太大，也无法算出。其余可以实现。当然，这只是通常要求下的无解，如规则不同，有些也还是能计算的，如：1，1，1，5的方法是：
1+1=2，将2作为5的平方得25，再减1得24。
24点算法大全(1) 1 1 1 1 无解 1 1 1 2 无解 1 1 1 3 无解 1 1 1 4 无解 1 1 1 5 无解 1 1 1 6 无解 1 1 1 7 无解
1 1 1 8 (1+1+1)×8 1 1 4 13 无解
1 1 5 5 5×5－1×1 1 1 5 6 5×(6－1)－1 1 1 5 7 (5－1)×(7－1) 1 1 5 8 (5－1－1)×8 1 1 5 9 无解 1 1 5 10 无解 1 1 5 11 无解 1 1 5 12 无解 1 1 5 13 无解
1 2 2 2 无解 1 2 2 3 无解
1 2 2 4 (1+2)×2×4 1 2 2 5 (2+2)×(1+5) 1 2 2 6 1×2×2×6 1 2 2 7 2×2×(7－1) 1 2 2 8 (2+2－1)×8 1 2 2 9 (1+2+9)×2
1 2 2 10 (1+2)×(10－2) 1 2 2 11 2×11+2×1 1 1 1 9 无解 1 1 1 10 无解
1 1 1 11 (1+1)×(1+11) 1 1 1 12 (1+1)×1×12 1 1 1 13 (1+1)×(13－1) 1 1 2 2 无解 1 1 2 3 无解 1 1 2 4 无解 1 1 2 5 无解
1 1 2 6 (1+1+2)×6 1 1 2 7 (1+2)×(1+7) 1 1 2 8 (1+2)×1×8 1 1 2 9 (1+2)×(9－1) 1 1 2 10 (1+1)×(2+10) 1 1 2 11 1×2×(11+1) 1 1 2 12 1×1×2×12 1 1 2 13 1×2×(13－1) 1 1 3 3 无解
1 1 3 4 (1+1)×3×4 1 1 3 5 (1+3)×(1+5) 1 1 3 6 1×(1+3)×6 1 1 3 7 (1+3)×(7－1) 1 1 3 8 1×1×3×8 1 1 3 9 1×3×(9－1) 1 1 3 10 3×(10－1－1) 1 1 3 11 (3－1)×(11+1) 1 1 3 13 (3－1)×(13－1) 1 1 4 4 (1+1+4)×4 1 1 4 5 1×4×(5+1) 1 1 4 6 1×1×4×6 1 1 4 7 1×4×(7－1) 1 1 4 8 1×(4－1)×8 1 1 4 9 (4－1)×(9－1) 1 1 4 10 (1+1)×10+4 1 1 4 11 无解
1 1 4 12 (4－1－1)×12
1 1 6 6 (6－1－1)×6 1 1 6 7 无解
1 1 6 8 6÷(1+1)×8 1 1 6 9 (1+1)×9+6 1 1 6 10 无解 1 1 6 11 无解
1 1 6 12 (1+1)×6+12 1 1 6 13 无解 1 1 7 7 无解 1 1 7 8 无解 1 1 7 9 无解
1 1 7 10 (1+1)×7+10 1 1 7 11 无解 1 1 7 12 无解 1 1 7 13 无解
1 1 8 8 (1+1)×8+8 1 1 8 9 无解 1 1 8 10 无解 1 1 8 11 无解 1 1 8 12 无解 1 1 8 13 无解 1 1 9 9 无解 1 1 9 10 无解 1 1 9 11 无解 1 1 9 12 无解 1 1 9 13 1+1+9+13 1 1 10 10 无解 1 1 10 11 无解
1 1 10 12 1+1+10+12 1 1 10 13 1×(1+10+13) 1 1 11 11 1+1+11+11 1 1 11 12 1×(1+11+12) 1 1 11 13 1×1×(11+13) 1 1 12 12 1×1×(12+12) 1 1 12 13 1×(12+13－1) 1 1 13 13 13+13－1－1
1 2 2 12 (1+2÷2)×12 1 2 2 13 2×13－1×2 1 2 3 3 2×3×(1+3) 1 2 3 4 1×2×3×4 1 2 3 5 2×3×(5－1) 1 2 3 6 (2+3－1)×6 1 2 3 7 1+2+3×7 1 2 3 8 3×(2－1)×8 1 2 3 9 3×9－1－2 1 2 3 10 2×10+1+3 1 2 3 11 2×11+3－1 1 2 3 12 (1+3)÷2×12 1 2 3 13 2×13+1－3 1 2 4 4 1×(2+4)×4 1 2 4 5 (2+4)×(5－1) 1 2 4 6 4×(2－1)×6 1 2 4 7 (7－2+1)×4 1 2 4 8 (1+4－2)×8 1 2 4 9 2×(1+9)+4 1 2 4 10 2×10+4×1 1 2 4 11 (1+11)×(4－2) 1 2 4 12 (4－2)×1×12 1 2 4 13 (13－1)×(4－2) 1 2 5 5 5×5－2+1 1 2 5 6 (1+5－2)×6 1 2 5 7 (7－2)×5－1 1 2 5 8 (5－2)×1×8 1 2 5 9 (5－2)×(9－1) 1 2 5 10 2×10+5－1 1 2 5 11 无解
1 2 5 12 (5－1－2)×12 1 2 5 13 (1+2)×(13－5) 1 2 6 6 (6－2)×1×6 1 2 6 7 (6－2)×(7－1) 1 2 6 8 6÷2×1×8 1 2 6 9 6÷2×(9－1)
1 2 6 10 (1+2)×10－6 1 2 6 11 2×6+1+11 1 2 6 12 6÷(1+2)×12 1 2 6 13 2×6－1+13 1 2 7 7 (7×7－1)÷2 1 2 7 8 2×(1+7)+8 1 2 7 9 2×9－1+7 1 2 7 10 1×2×7+10 1 2 7 11 2×7－1+11 1 2 7 12 2×(7－1)+12 1 3 4 7 3×7+4－1 1 3 4 8 (3－1)×(4+8) 1 3 4 9 3×9+1－4 1 3 4 10 (1+3)×(10－4) 1 3 4 11 (11－3)×(4－1) 1 3 4 12 (1+4－3)×12 1 3 4 13 3×4+13－1 1 3 5 5 无解 1 3 5 6 3×6+1+5 1 3 5 7 (3－1)×(7+5) 1 3 11 11 3－1+11+11 1 3 11 12 3×12－1－11 1 3 11 13 无解
1 3 12 12 12×3－12×1 1 3 12 13 3×12－13+1 1 3 13 13 13+13+1－3 1 4 4 4 (4+4)×(4－1) 1 4 4 5 4×5+4×1 1 4 4 6 (1+6)×4－4 1 4 4 7 7×4－1×4 1 2 7 13 无解 1 2 8 8 1×2×8+8 1 2 8 9 2×8+9－1 1 2 8 10 2×(8－1)+10 1 2 8 11 无解 1 2 8 12 无解 1 2 8 13 1+2+8+13 1 2 9 9 无解 1 2 9 10 无解
1 2 9 11 (1+2)×11－9 1 2 9 12 1+2+9+12 1 2 9 13 1×2+9+13 1 2 10 10 无解
1 2 10 11 1+2+10+11 1 2 10 12 1×2+10+12 1 2 10 13 2－1+10+13 1 2 11 11 1×2+11+11 1 2 11 12 2－1+11+12
1 2 11 13 11+13×(2－1) 1 2 12 12 (2－1)×(12+12) 1 2 12 13 1－2+12+13 1 2 13 13 13+13－2×1 1 3 3 3 (1+3)×(3+3) 1 3 3 4 (3－1)×3×4 1 3 3 5 1×3×(3+5) 1 3 3 6 3×(1+6)+3 1 3 3 7 1×3+3×7 1 3 3 8 3×(8－1)+3 1 3 3 9 3×9－3×1 1 3 3 10 (10－1)×3－3 1 3 3 11 1×3×(11－3) 1 3 3 12 (1+3÷3)×12 1 3 3 13 无解
1 3 4 4 (3+4－1)×4 1 3 4 5 1+3+4×5
1 3 4 6 6÷(1－3÷4) 1 3 5 8 (1+5－3)×8 1 3 5 9 (5－1)×(9－3) 1 3 5 10 3×10－1－5 1 3 5 11 (1+3)×(11－5) 1 3 5 12 (5－3)×1×12 1 3 5 13 (5－3)×(13－1) 1 3 6 6 (1+6－3)×6 1 3 6 7 (6－3)×(7+1) 1 3 6 8 (6－3)×1×8 1 3 6 9 (6－3)×(9－1) 1 3 6 10 3×10×1－6 1 3 6 11 (1+11)÷3×6 1 3 6 12 6÷3×1×12 1 3 6 13 6÷3×(13－1) 1 3 7 7 (7－1)×(7－3) 1 3 7 8 (7－1－3)×8 1 3 7 9 (1+7)×9÷3 1 3 7 10 (3－1)×7+10 1 3 7 11 无解
1 3 7 12 (7－1)÷3×12 1 3 7 13 1+3+7+13 1 3 8 8 (3－1)×8+8 1 3 8 9 1×8×9÷3 1 3 8 10 (10－1)÷3×8 1 3 8 11 3×11－1－8 1 3 8 12 1+3+8+12 1 3 8 13 1×(3+8+13) 1 3 9 9 (9－1)×9÷3 1 3 9 10 3×(1+10)－9 1 3 9 11 1+3+9+11 1 3 9 12 1×3+9+12 1 3 9 13 3+9+13－1 1 3 10 10 1+3+10+10 1 3 10 11 1×3+10+11 1 3 10 12 3－1+10+12 1 3 10 13 无解
1 4 4 8 (8－1)×4－4 1 4 4 9 4×4－1+9
1 4 4 10 (10－4)×4×1 1 4 4 11 (11－4－1)×4 1 4 4 12 (4÷4+1)×12 1 4 4 13 无解 1 4 5 5 4×5+5－1 1 4 5 6 6÷(5÷4－1) 1 4 5 7 4×7+1－5 1 4 5 8 (1+5)×(8－4) 1 4 5 9 (9－4)×5－1 1 4 5 10 (10－4)×(5－1) 1 4 5 11 (11－5)×1×4 1 4 5 12 (5－4+1)×12 1 4 5 13 (13－5)×(4－1) 1 4 6 6 (1+4)×6－6 1 4 6 7 (7+1－4)×6 1 4 6 8 (6+1－4)×8 1 4 6 9 (9－1－4)×6 1 4 6 10 (4－1)×10－6 1 4 6 11 (6－4)×(11+1) 1 4 6 12 (6－4)×1×12 1 4 6 13 (6－4)×(13－1) 1 4 7 7 (1+7)×(7－4) 1 4 7 8 (7－4)×1×8 1 4 7 9 (7－4)×(9－1) 1 4 7 10 无解
1 4 7 11 (1+4)×7－11 1 4 7 12 (7－4－1)×12 1 4 7 13 (13－7)×1×4 1 4 8 8 (8÷4+1)×8 1 4 8 9 4×8+1－9 1 4 8 10 无解 1 4 8 11 1+4+8+11 1 4 8 12 8÷4×1×12 1 4 8 13 8÷4×(13－1)
篇二：24点游戏的算法参考与源程序
一、 任务说明
24点游戏是一个大众化的益智游戏。任意给四张扑克牌（不包括大小王），只能够用加、减、乘、除以及适当的括号连接这四张牌，无论顺序，使计算结果为24，或者宣布根本就是无解的。需要注意的是，每张牌必须运算，并且只能运算一次，J、Q、K可设置为11、12、13。
本程序目的就是算出一组牌的所有解（不同形式的式子算不同解），如没有则输出无解。
二、 算法说明
首先解决图形扑克牌的显示问题。我选择了Qcard.dll。运用其中的DrawCard过程可轻松实现扑克的显示问题，在源程序中会有具体用法。
接下来是24点算法的讨论。首先想到的是用穷举表达式的方法，然后求值。然而，由于括号的存在，使穷举表达式并非易事。实际上，括号的作用仅仅是提高运算的优先级而已，如果我们规定符号的优先级，一样可以达到要求。具体来说，设四张牌为a、b、c、d，运算符为①、②、③，表达式为a ① b ② c ③ 。如果强制规定①、②、③的优先顺序，就不必考虑括号问题了。而这3个运算符的运算顺序有3！=6种，分别是：
1．①②③ 2.①③② 3.②①③ 4.②③① 5.③①② 6.③②① 等价的表达式分别是：
1.((a①b②)c③) 2.(a①b)②(c③d) 3.(a①(b②c))③d
4.a①((b②c)③d) 5.(a①b)②(c③d) 6. a①(b②(c③d)) 显然，2和5是相同的，因此只考虑5种情况。这样，括号的问题就解决了。 接下来，就是生成a、b、c、d的全排列，注意去掉其中的相同排列。去除的方法很多，比如字典排序等，我用的是另一种方法。
用循环的嵌套生成a、b、c、d的24种全排列，记录在数组中。把每一组数当作一个四位的14进制数，把这24个数全部转化为十进制（如（6529）
32。这样，如果两个排列完全相同，则得到的十进制数是14=6*14+5*14+2*14+9）
相等的。这样，通过对这些十进制的比较，就可以比较这些排列的相同情况。一旦遇到相同的排列，就标记上。最后生成一组没有重复的排列。
对这组排列进行以上方法的运算，就可以得到所有的结果了。注意在运算过程中除法的特殊性——除数不能为零。因为可能会用到除法，所以要考虑精度问题，这里通过结果减去24取绝对值与一个接近0的小数比较，如小于它，即可判定结果是24。
附：其他待决的问题：
1、图形扑克牌的遮挡问题。当窗口中的扑克牌被遮挡后，扑克牌不会重新画上，造成扑克牌遮挡后显示不全问题。应寻找Qcard.dll的有关参数。 2、 形式不同而实质相同的解的问题。有些解虽然形式不同，但其实质是完全相同的。如3*((11+4)-7)和3*(11+(4-7))，实际上只是一种解。去掉这些相同解的问题情况较多，其较为繁琐，有待解决。
3、 多余括号好问题。有些解的括号是多余的，应在输出前去掉。
4、改进程序的可玩性。增加玩家输入表达式的功能，并判断对错，还可以加上时间限制，使玩家参与到游戏中。
三、程序框图
四、VB源程序代码
'需要声明所有用到的变量
Option Explicit
'声明全局变量、数组
Dim cards(1 To 4) As Single, card(1 To 4) As Single
Dim result(1 To 24, 0 To 4) As Integer, final(1 To 24, 1 To 4) As Integer, temp(1 To 24) As Long Dim nokey As Boolean, total As Integer, n1 As Integer, n2 As Integer, n3 As Integer, n4 As Integer, a As Integer, b As Integer, c As Integer, d As Integer, op1 As Integer, op2 As Integer, op3 As Integer, answer1 As Single, answer2 As Single, answer3 As Single, color As Integer
Dim i As Integer, j As Integer, t As Integer
'声明zero常量，设置0的标准，处理除法的精度问题
Const zero = 0.00001
'初始化QCARD32.DLL
Private Declare Function InitializeDeck Lib "qcard32.dll" (ByVal hwin As Long) As Integer
'DrawCard 子程序，画出扑克牌图样在FORM窗体及 窗体上的图片框
'用法：
'hwnd ---- 需要画图的对象句柄
'nCard --- 扑克牌编号 其编号如下
'1-13 梅花 14-26 方块 27-39 红心 40-52 黑桃 小王-110 大王-111
'x，y 位置
Private Declare Sub DrawCard Lib "qcard32.dll" (ByVal hwnd As Long, ByVal nCard As Integer, ByVal x As Integer, ByVal y As Integer)
'DrawBack 子程序，画出扑克牌的背面图案，共六种 按 1--6 编号
Private Declare Sub DrawBack Lib "qcard32.dll" (ByVal hwnd As Long, ByVal nCard As Long, ByVal x As Long, ByVal y As Long)
'GetCardSuit 函数，求 nCard 的点数 1-13
'Private Declare Function GetCardSuit Lib "qcard32.dll" (ByVal nCard As Long) As Long
'GetCardValue 函数，求 nCard 的花色 0∶鬼牌 1∶梅花 2∶方块 3∶红心 4∶黑桃 'Private Declare Function GetCardValue Lib "qcard32.dll" (ByVal nCard As Long) As Long
'Form_Load过程，初始化
Private Sub Form_Load()
Randomize Timer
Call InitializeDeck(Me.hwnd)
Command3.Enabled = False
End Sub
'answer函数，返回x与y做operator运算后的值，-100为错误标志
Private Function answer(x As Single, y As Single, operator As Integer) As Single Select Case operator
Case 1
answer = x + y
Exit Function
Case 2
answer = x - y
Exit Function
Case 3
answer = x * y
Exit Function
Case 4
If y = 0 Then
answer = -100
Exit Function
Else
answer = x / y
Exit Function
End If
End Select
answer = -100
End Function
'operate函数，返回数值op所对应的四则运算符号
Private Function operate(op As Integer) As String
Select Case op
Case 1
operate = "+"
Case 2
operate = "-"
Case 3
operate = "*"
Case 4
operate = "/"
End Select
End Function
'search过程，去掉数组result中相同的元素，存入数组final中
Private Sub search()
For i = 1 To 24
result(i, 0) = 0
temp(i) = result(i, 1) * 14 ^ 3 + result(i, 2) * 14 ^ 2 + result(i, 3) * 14 + result(i, 4)
篇三：24点游戏算法
1 1 1 2 : 算不起 1 1 1 3 : 算不起 1 1 1 4 : 算不起 1 1 1 5 : 算不起 1 1 1 6 : 算不起 1 1 1 7 : 算不起
1 1 1 8 : (1+1+1)*8=24 1 1 1 9 : 算不起 1 1 1 10 : 算不起 1 1 2 2 : 算不起 1 1 2 3 : 算不起 1 1 2 4 : 算不起 1 1 2 5 : 算不起
1 1 2 6 : (1+1+2)*6=24 1 1 2 7 : (1+2)*(1+7)=24 1 1 2 8 : (1*1+2)*8=24 1 1 2 9 : (1+2)*(9-1)=24 1 1 2 10 : (1+1)*(2+10)=24 1 1 3 3 : 算不起
1 1 3 4 : (1+1)*3*4=24 1 1 3 5 : (1+3)*(1+5)=24 1 1 3 6 : (1*1+3)*6=24 1 1 3 7 : (1*1+7)*3=24 1 1 3 8 : (1-1+3)*8=24 1 1 3 9 : (1+1)*(3+9)=24 1 1 3 10 : (10-(1+1))*3=24 1 1 4 4 : (1+1+4)*4=24 1 1 4 5 : (1*1+5)*4=24 1 1 4 6 : (1-1+4)*6=24 1 1 4 7 : (7-1*1)*4=24 1 1 4 8 : (1+1)*(4+8)=24 1 1 4 9 : (4-1)*(9-1)=24 1 1 4 10 : (1+1)*10+4=24 1 1 5 5 : 5*5-1*1=24 1 1 5 6 : (5-1*1)*6=24 1 1 5 7 : (1+1)*(5+7)=24 1 1 5 8 : (5-(1+1))*8=24 1 1 5 9 : 算不起 1 1 5 10 : 算不起
1 1 6 6 : (1+1)*(6+6)=24 1 1 6 7 : 算不起
1 1 6 8 : 6*8/(1+1)=24 1 1 6 9 : (1+1)*9+6=24
1 1 7 7 : 算不起 1 1 7 8 : 算不起 1 1 7 9 : 算不起
1 1 7 10 : (1+1)*7+10=24 1 1 8 8 : (1+1)*8+8=24 1 1 8 9 : 算不起 1 1 8 10 : 算不起 1 1 9 9 : 算不起 1 1 9 10 : 算不起 1 1 10 10 : 算不起 1 2 2 2 : 算不起 1 2 2 3 : 算不起
1 2 2 4 : (1+2)*2*4=24 1 2 2 5 : (1+5)*(2+2)=24 1 2 2 6 : (1+2)*(2+6)=24 1 2 2 7 : (7-1)*(2+2)=24 1 2 2 8 : (2-1+2)*8=24 1 2 2 9 : (1+2+9)*2=24 1 2 2 10 : (1+2)*(10-2)=24 1 2 3 3 : (1+3)*2*3=24 1 2 3 4 : (1+2+3)*4=24 1 2 3 5 : (1+2)*(3+5)=24 1 2 3 6 : (3-1+2)*6=24 1 2 3 7 : 1+2+3*7=24 1 2 3 8 : (2-1)*3*8=24 1 2 3 9 : 3*9-(1+2)=24 1 2 3 10 : (10-1*2)*3=24 1 2 4 4 : (1+2)*(4+4)=24 1 2 4 5 : (5-1+2)*4=24 1 2 4 6 : (2-1)*4*6=24 1 2 4 7 : (1-2+7)*4=24 1 2 4 8 : (1-2+4)*8=24 1 2 4 9 : (9-(1+2))*4=24 1 2 4 10 : 1*2*10+4=24 1 2 5 5 : 1-2+5*5=24 1 2 5 6 : (1-2+5)*6=24 1 2 5 7 : 1*2*(5+7)=24 1 2 5 8 : (5-1*2)*8=24 1 2 5 9 : (1+2)*5+9=24 1 2 5 10 : 2*10-1+5=24 1 2 6 6 : (1+2)*6+6=24 1 2 6 7 : (7-(1+2))*6=24 1 2 6 8 : (6-(1+2))*8=24
1 2 6 10 : (1+2)*10-6=24 1 2 7 7 : (7*7-1)/2=24 1 2 7 8 : (1+7)*2+8=24 1 2 7 9 : 2*9-1+7=24 1 2 7 10 : 1*2*7+10=24 1 2 8 8 : 1*2*8+8=24 1 2 8 9 : 8*9/(1+2)=24 1 2 8 10 : 10+(8-1)*2=24 1 2 9 9 : 算不起 1 2 9 10 : 算不起 1 2 10 10 : 算不起 1 3 3 3 : (1+3)*(3+3)=24 1 3 3 4 : (1*3+3)*4=24 1 3 3 5 : 1*3*(3+5)=24 1 3 3 6 : (6-1+3)*3=24 1 3 3 7 : 1*3+3*7=24 1 3 3 8 : (1+8)*3-3=24 1 3 3 9 : (1+3)*(9-3)=24 1 3 3 10 : (1-3+10)*3=24 1 3 4 4 : (4-1+3)*4=24 1 3 4 5 : 1+3+4*5=24 1 3 4 6 : 6/(1-3/4)=24 1 3 4 7 : 4*7-(1+3)=24 1 3 4 8 : (1+3)*4+8=24 1 3 4 9 : (9-1*3)*4=24 1 3 4 10 : (1+3)*(10-4)=24 1 3 5 5 : 算不起
1 3 5 6 : (1+5)*3+6=24 1 3 5 7 : (3-1)*(5+7)=24 1 3 5 8 : (1-3+5)*8=24 1 3 5 9 : 1*3*5+9=24 1 3 5 10 : 3*10-(1+5)=24 1 3 6 6 : (1-3+6)*6=24 1 3 6 7 : (7-1*3)*6=24 1 3 6 8 : (6-1*3)*8=24 1 3 6 9 : 6+(3-1)*9=24 1 3 6 10 : 1*3*10-6=24 1 3 7 7 : (7-1)*(7-3)=24 1 3 7 8 : (7-(1+3))*8=24 1 3 7 9 : (1+7)*9/3=24 1 3 7 10 : 10+(3-1)*7=24 1 3 8 8 : (1+3)*8-8=24 1 3 8 9 : 8*9/1*3=24
1 3 9 9 : (9-1)/3*9=24 1 3 9 10 : (1+10)*3-9=24 1 3 10 10 : 1+3+10+10=24 1 4 4 4 : (1+4)*4+4=24 1 4 4 5 : 1*4+4*5=24 1 4 4 6 : (1+6)*4-4=24 1 4 4 7 : 4*7-1*4=24 1 4 4 8 : 1*4*4+8=24 1 4 4 9 : (1-4+9)*4=24 1 4 4 10 : 1*4*(10-4)=24 1 4 5 5 : 4*5-(1-5)=24 1 4 5 6 : 6/(5/4-1)=24 1 4 5 7 : 1-5+4*7=24 1 4 5 8 : (1+5)*(8-4)=24 1 4 5 9 : 9-(1-4)*5=24 1 4 5 10 : (1-5)*(4-10)=24 1 4 6 6 : (1+4)*6-6=24 1 4 6 7 : (1-4+7)*6=24 1 4 6 8 : (1-4+6)*8=24 1 4 6 9 : (9-(1+4))*6=24 1 4 6 10 : (4-1)*10-6=24 1 4 7 7 : (1+7)*(7-4)=24 1 4 7 8 : (7-1*4)*8=24 1 4 7 9 : (1-9)*(4-7)=24 1 4 7 10 : 算不起
1 4 8 8 : (8-(1+4))*8=24 1 4 8 9 : 8*9/(4-1)=24 1 4 8 10 : 算不起 1 4 9 9 : 算不起
1 4 9 10 : 1+4+9+10=24 1 4 10 10 : 1*4+10+10=24 1 5 5 5 : (5-1/5)*5=24 1 5 5 6 : (1+5)*5-6=24 1 5 5 7 : 算不起 1 5 5 8 : 算不起
1 5 5 9 : (1+5)*(9-5)=24 1 5 5 10 : (10-5)*5-1=24 1 5 6 6 : 1*5*6-6=24 1 5 6 7 : 1-7+5*6=24 1 5 6 8 : (1-5+8)*6=24 1 5 6 9 : (9-1*5)*6=24 1 5 6 10 : (1+5)*(10-6)=24 1 5 7 7 : 算不起
1 5 7 9 : (1-7)*(5-9)=24 1 5 7 10 : 5*7-(1+10)=24 1 5 8 8 : (8-1*5)*8=24 1 5 8 9 : (9-(1+5))*8=24 1 5 8 10 : 1+5+8+10=24 1 5 9 9 : 1+5+9+9=24 1 5 9 10 : 1*5+9+10=24 1 5 10 10 : (10+10)-(1-5)=24 1 6 6 6 : (6-1)*6-6=24 1 6 6 7 : 算不起 1 6 6 8 : 6/(1-6/8)=24 1 6 6 9 : (1-6+9)*6=24 1 6 6 10 : 1*6*(10-6)=24 1 6 7 7 : 算不起 1 6 7 8 : 算不起
1 6 7 9 : (1+7)*(9-6)=24 1 6 7 10 : 1+6+7+10=24 1 6 8 8 : (1-6+8)*8=24 1 6 8 9 : 1+6+8+9=24 1 6 8 10 : 1*6+8+10=24 1 6 9 9 : 1*6+9+9=24 1 6 9 10 : (9+10)-(1-6)=24 1 6 10 10 : 算不起 1 7 7 7 : 算不起 1 7 7 8 : 算不起 1 7 7 9 : 1+7+7+9=24
1 7 7 10 : (1+7)*(10-7)=24 1 7 8 8 : 1+7+8+8=24 1 7 8 9 : 1*7+8+9=24 1 7 8 10 : (8+10)-(1-7)=24 1 7 9 9 : (9+9)-(1-7)=24 1 7 9 10 : (1-9)*(7-10)=24 1 7 10 10 : 算不起 1 8 8 8 : 1*8+8+8=24 1 8 8 9 : (8+9)-(1-8)=24 1 8 8 10 : (1-8+10)*8=24 1 8 9 9 : 算不起 1 8 9 10 : 算不起 1 8 10 10 : 算不起 1 9 9 9 : 算不起 1 9 9 10 : 算不起 1 9 10 10 : 算不起 1 10 10 10 : 算不起
篇四：关于24点游戏的编程思路与基本算法1
关于24点游戏的编程思路与基本算法 设计思路：
在算24点时候，我的第一反应便是穷举法！在算24点时候，我的思路就是列出4个数字加减乘除的各种可能性，包括括号的算法。我们可以将表达式分成以下几种：首先我们将4个数设为a，b，c，d，，其中算术符号有+，-，*，/，。其中有效的表达式有a，ab-cd，等等。列出所有有效的表达式。其中我们用枚举类型将符号定义成数字常量，比如用1表示+，2表示-等。如下是我对穷举法的一种编程语言。在编程的头部要对变量做下定义。
在输入数字前我做了定义，因为题目规定是1-10内不相同的数字。所以我就想到了if的判断语句来写此句话。即if((a==b)||(a==c)||(a==d)||(b==c)||(b==d)||(c==d)||(a<0)||(a>10)||(b<0)||(b>10)||(c<0)||(c>10)||(d<0)||(d>10))则输入非法。当输入合法时，我就在想，4个数都有各自的排列，所以运用数学的排列组合来算的的，分别是A44=24种组合，打个比方，我入、、输入a，b，c，d，那么就有abdc,badc,bacd``````等24种不同的组合，在这里我就不一一列举，在源代码当中我会一一写在程序里。
在运算时，我开始想，得从括号分类起，有零括号的，一个括号的，两个括号的。
以下是表达式，当然，*并不是×，*只是符号的统称。
零个括号的：a*b*c*d。
一个括号的：(a * b * c) * d，a * (b * c) * d。
两个括号的：(a * b) * (c * d)，(a * b) * c) * d，a * (b * c)) * d 接下来就是对每一种进行分析判断。
以上就是穷举法的基本实现算法
首先穷举的可行性问题。我把表达式如下分成三类：
1、 列出四个数的所有排序序列组合（共有A44=24种组合）。
2、 构筑一个函数，列出所有运算表达式。
3、 输入数据计算。
流程图：
源代码：
#include
int main(void)
{
void jisuan(float x,float y,float z,float w);//声明函数
float a,b,c,d;
fanhui: //做标记
printf("请输入4个数据\n");
printf(" 第一个数：");
scanf("%f",&a);
printf(" 第二个数：");
scanf("%f",&b);
printf(" 第三个数：");
scanf("%f",&c);
printf(" 第四个数：");
scanf("%f",&d);
printf("输出所有算法如下：\n");
if((a<0)||(a>10)||(b<0)||(b>10)||(c<0)||(c>10)||(d<0)||(d>10)||(a==b)||(a==c)||(a==d)||(b==c)||(b==d)||(c==d))
{
printf("你输入的输入不对，重新输入\n");
goto fanhui;// 返回标记，重复输入
}
// 以下是a .b.c.d 的所有排列组合情况
jisuan(a,b,c,d); jisuan(a,b,d,c); jisuan(a,c,d,b);
jisuan(a,c,b,d); jisuan(a,d,b,c); jisuan(a,d,c,b);
jisuan(b,a,c,d); jisuan(b,a,d,c); jisuan(b,c,a,d);
jisuan(b,c,d,a); jisuan(b,d,c,a); jisuan(b,d,a,c);
jisuan(c,a,b,d); jisuan(c,a,d,b); jisuan(c,b,d,a);
jisuan(c,b,a,d); jisuan(c,d,a,b); jisuan(c,d,b,a);
jisuan(d,a,b,c); jisuan(d,a,c,b); jisuan(d,b,c,a);
jisuan(d,b,a,c); jisuan(d,c,a,b); jisuan(d,c,b,a);
return 0;
}
void jisuan(float x,float y,float z,float w) //运算表达式的所有情况
{
if (x+y+z+w==24) printf("%.0f+%.0f+%.0f+%.0f=24\n",x,y,z,w);
else if (x+y+z-w==24) printf("%.0f+%.0f+%.0f-%.0f=24\n",x,y,z,w);
else if ((x+y)*(z+w)==24) printf("(%.0f+%.0f)*(%.0f+%.0f)=24\n",x,y,z,w); else if ((x-y)*(z+w)==24) printf("(%.0f-%.0f)*(%.0f+%.0f)=24\n",x,y,z,w); else if ((x-y)*(z-w)==24) printf("(%.0f-%.0f)*(%.0f-%.0f)=24\n",x,y,z,w); else if ((x+y+z)*w==24) printf("(%.0f+%.0f+%.0f)*%.0f=24\n",x,y,z,w); else if ((x-y-z)*w==24) printf("(%.0f-%.0f-%.0f)*%.0f=24\n",x,y,z,w); else if ((x+y-z)*w==24) printf("(%.0f+%.0f-%.0f)*%.0f=24\n",x,y,z,w); else if ((x*y*z)/w==24) printf("(%.0f*%.0f*%.0f)/%.0f=24\n",x,y,z,w); else if ((x*y)*(z+w)==24) printf("(%.0f*%.0f)*(%.0f+%.0f)=24\n",x,y,z,w); else if ((x*y)*(z-w)==24) printf("(%.0f*%.0f)*(%.0f-%.0f)=24\n",x,y,z,w); else if ((x*y)*z-w==24) printf("(%.0f*%.0f)*%.0f-%.0f=24\n",x,y,z,w); else if ((x*y)*z+w==24) printf("(%.0f*%.0f)*%.0f+%.0f=24\n",x,y,z,w); else if (x*y*z*w==24) printf("%.0f*%.0f*%.0f*%.0f=24\n",x,y,z,w);
else if ((x+y)+(z/w)==24) printf("(%.0f+%.0f)+(%.0f/%.0f)=24\n",x,y,z,w); else if ((x+y)*(z/w)==24) printf("(%.0f+%.0f)*(%.0f/%.0f)=24\n",x,y,z,w); else if ((x*y)+z+w==24) printf("(%.0f*%.0f)+%.0f+%.0f=24\n",x,y,z,w); else if ((x*y)+z-w==24) printf("(%.0f*%.0f)+%.0f-%.0f=24\n",x,y,z,w); else if ((x*y)-(z/w)==24) printf("(%.0f*%.0f)-(%.0f/%.0f)=24\n",x,y,z,w); else if ((x*y)+(z/w)==24) printf("(%.0f*%.0f)+(%.0f/%.0f)=24\n",x,y,z,w); else if ((x*y)-z-w==24) printf("(%.0f*%.0f)-%.0f-%.0f=24\n",x,y,z,w);
else if ((x*y)+(z*w)==24) printf("(%.0f*%.0f)+(%.0f*%.0f)=24\n",x,y,z,w); else if ((x*y)-(z*w)==24) printf("(%.0f*%.0f)-(%.0f*%.0f)=24\n",x,y,z,w); else if ((x*y)/(z*w)==24) printf("(%.0f*%.0f)/(%.0f*%.0f)=24\n",x,y,z,w); else if ((x*y)/(z-w)==24) printf("(%.0f*%.0f)/(%.0f-%.0f)=24\n",x,y,z,w); else if ((x*y)/(z+w)==24) printf("(%.0f*%.0f)/(%.0f+%.0f)=24\n",x,y,z,w); else printf("不可以组成24\n");
}
程序调试：
在程序的调试过程中，我遇到了很多问题，刚开始，由于各个函数的关系没有搞好，导致无法运算。而且在运行输出的时候，不能组成24时后打出字“不可以组成24”，并不是直接输出能组成的部分，导致了不美观。不过这样已经实现了函数的功能了。
篇五：24点游戏的核心算法时
24点游戏的核心算法
时间: 2010-10-15 15:10 点击: 873 次
24 点游戏，就是在给定的几个数字之间加入数学运算符号，使最终结果等于 24，如下图所示 算法的思路是： 1. 考虑没有括号的情况 运算符为+/-时将数字入栈，运算符入另一栈; 否则p
24 点游戏，就是在给定的几个数字之间加入数学运算符号，使最终结果等于 24，如下图所示
算法的思路是：
1. 考虑没有括号的情况
运算符为+/-时将数字入栈，运算符入另一栈; 否则pop出栈顶数字与当前数字进行运算，结果入栈
扫描结束后将顺序取出数字和运算符计算
2. 遇到括号时递归，拿到结果进入第一步的运算
结束
具体代码
appdelegate.m
int x[100];
//保存四个数的所有组合
int arrange[100][100];
//保存读入的四个数
int num[100];
//标记该数是否被访问过
int a[100] = {0};
char sym[5]={'0','+','-','*','/'};
//保存使用的算术运算符
int bol[100];
// 标记运算符是否被访问过
int b[100]={0};
//保存四个数的组合总数
int sum = 0;
int n,r;
int ok=1;
//保存所有可能的组合数
void save(int sum)
{
int i;
for(i=0;i<4;++i)
{
arrange[sum][i] = x[i];
}
}
//判断使用该运算符是否合法
int symbollegal(int t,int i,int sum,int layer)
{
switch(i)
{
case 1:
if(arrange[layer][t]+sum>24)
return 0;
else return arrange[layer][t]+sum;
case 2:
if(sum-arrange[layer][t]<0)
return 0;
else return sum-arrange[layer][t];
case 3:
if(arrange[layer][t]*sum>24)
return 0;
else return arrange[layer][t]*sum;
case 4:
if(arrange[layer][t]!=0&&sum%arrange[layer][t]!=0) return 0;
else return sum/arrange[layer][t(来自:www.sMHaiDa.com 海 达范文网:24点游戏算法)];
}
}
// 打印结果
void pri(int layer)
{
int i,temp;
int totle = arrange[layer][0];
for(i= 1;i<=3;++i)
{
if(totle > arrange[layer][i])
{
temp = symbollegal(i,bol[i],totle,layer);
printf("%d %c %d = %d\n",totle,sym[bol[i]],arrange[layer]
[i],temp);
}
else
{
temp = symbollegal(i,bol[i],totle,layer);
printf("%d %c %d = %d\n",arrange[layer][i],sym[bol[i]],totle,temp);
}
totle = temp;
}
printf("\n");
}
//回溯计算四个组合数出现的情况
void backtrack(int t)
{
int i;
//遍历四个数
for(i = 1;i<= 4;++i)
{
x[t] = num[i];
//如果当前这个数没有被选择
if(a[i]==0)
{
//标记该数已经选择
a[i] = 1;
//结束条件：已经找到符合条件的四个数
if(t == 3 )
{
save(sum);
++sum;
}
else
{
backtrack(t+1);
}
//不符合条件，恢复该数的访问权限
a[i] = 0;
}
}
}
// 计算该组合数能得出24的情况
void find(int sum,int t,int layer)
{
int i,temp,sign;
//遍历加、减、乘、除四个符合
for(i=1;i<=4;++i)
{
bol[t] = i;
//如果选择的符号满足条件
if( (temp = symbollegal(t,i,sum,layer)))
{
//标记该符号已经选择并修改sum值
b[i] = 1;
sign = sum;
sum = temp;
//结束条件：四个数都已经完成运算
if(t == 3)
{
//结果是24点，则打印
if(sum==24)
{
ok=0;
pri(layer);
}
}
else
{
find(sum,t+1,layer);
}
//不符合条件，恢复该符号的访问权限与sum的值
b[i] = 0;
sum = sign;
}
}
}
下面原来是int main()里面的,加到- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { 吧:
num[1] = 1;
num[2] = 4;
num[3] = 4;
num[4] = 5;
backtrack(0);
// 遍历所有的组合数
for(int i=0;i { find(arrange[i][0],1,i); } if(ok) { printf("No answer!\n"); } 帖子地址 /bbs/read.php?tid-34874.html，欢迎参与讨论