【题目描述】几十年前全世界就流行一种数字游戏，至今仍有人乐此不疲．在中国我们把这种游戏称为“算24点”。
  您作为游戏者将得到4个1~9之间的自然数作为操作数，而您的任务是对这4个操作数进行适当的算术运算，要求运算结果等于24。
  您可以使用的运算只有：+，-，*，/，您还可以使用（）来改变运算顺序。注意：所有的中间结果须是整数，所以一些除法运算是不允许的（例如，(2*2)/4是合法的，2*(2/4)是 不合法的）。下面我们给出一个游戏的具体例子： 若给出的4个操作数是：1、2、3、7，则一种可能的解答是1+2+3*7=24。


【输入】只有一行，四个1到9之间的自然数。

【输出】如果有解的话，只要输出一个解，输出的是三行数据，分别表示运算的步骤。其中第一行是输入的两个数和一个运算符和运算后的结果，第二行是第一行的结果和一个输入的数据、运算符、运算后的结果；第三行是第二行的结果和输入的一个数、运算符和“=24”。如果两个操作数有大小的话则先输出大的。 如果没有解则输出“No answer!”


【输入样例】1 2 3 7



【输出样例】

2+1=3
7*3=21
21+3=24

1+1={:soso__14929679738222025475_3:}

胡生蒙 发表于 2012-3-31 22:52
1+1=

哥们，什么意思？

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. 
   
4. class MathDemo {
   
5. 
   
6.         public int Mjia(int a, int b) {
   
7.                 return a + b;
   
8.         }
   
9. 
   
10.         public int Mjian(int a, int b) {
    
11.                 return a - b;
    
12.         }
    
13. 
    
14.         public int Mcheng(int a, int b) {
    
15.                 return a * b;
    
16.         }
    
17. 
    
18.         public int Mchu(int a, int b) {
    
19.                 return a / b;
    
20.         }
    
21. }
    
22. 
    
23. public class TTF_24 {
    
24.         public static String ttfDemo(List<Integer> numbers) {
    
25.                 MathDemo md = new MathDemo();
    
26. 
    
27.                 for (int num : numbers) {
    
28.                         int[] ynums = new int[4];
    
29.                         int weishu = 1000;
    
30.                         int len = 0;
    
31.                         while (weishu > 0) {
    
32.                                 ynums[len] = num / weishu;
    
33.                                 num = num % weishu;
    
34.                                 weishu = weishu / 10;
    
35.                                 len++;
    
36. 
    
37.                         }
    
38. 
    
39.                         for (int i = 0; i < 4; i++) {
    
40.                                 for (int k = 0; k < 4; k++) {
    
41.                                         for (int j = 0; j < 4; j++) {
    
42.                                                 int a = 0;
    
43.                                                 int b = 0;
    
44.                                                 int c = 0;
    
45.                                                 switch (i) {
    
46.                                                 case 0:
    
47.                                                         a = md.Mjia(ynums[0], ynums[1]);
    
48.                                                         break;
    
49.                                                 case 1:
    
50.                                                         a = md.Mjian(ynums[0], ynums[1]);
    
51.                                                         break;
    
52.                                                 case 2:
    
53.                                                         a = md.Mcheng(ynums[0], ynums[1]);
    
54.                                                         break;
    
55.                                                 case 3:
    
56.                                                         a = md.Mchu(ynums[0], ynums[1]);
    
57.                                                         break;
    
58.                                                 }
    
59.                                                 switch (k) {
    
60.                                                 case 0:
    
61.                                                         b = md.Mjia(a, ynums[2]);
    
62.                                                         break;
    
63.                                                 case 1:
    
64.                                                         b = md.Mjian(a, ynums[2]);
    
65.                                                         break;
    
66.                                                 case 2:
    
67.                                                         b = md.Mcheng(a, ynums[2]);
    
68.                                                         break;
    
69.                                                 case 3:
    
70.                                                         b = md.Mchu(a, ynums[2]);
    
71.                                                         break;
    
72.                                                 }
    
73.                                                 switch (j) {
    
74.                                                 case 0:
    
75.                                                         c = md.Mjia(b, ynums[3]);
    
76.                                                         break;
    
77.                                                 case 1:
    
78.                                                         c = md.Mjian(b, ynums[3]);
    
79.                                                         break;
    
80.                                                 case 2:
    
81.                                                         c = md.Mcheng(b, ynums[3]);
    
82.                                                         break;
    
83.                                                 case 3:
    
84.                                                         c = md.Mchu(b, ynums[3]);
    
85.                                                         break;
    
86.                                                 }
    
87.                                                 if (c == 24) {
    
88.                                                         String f1 = "";
    
89.                                                         String f2 = "";
    
90.                                                         String f3 = "";
    
91.                                                         switch (i) {
    
92.                                                         case 0:
    
93.                                                                 f1 = "+";
    
94.                                                                 break;
    
95.                                                         case 1:
    
96.                                                                 f1 = "-";
    
97.                                                                 break;
    
98.                                                         case 2:
    
99.                                                                 f1 = "*";
    
100.                                                                 break;
     
101.                                                         case 3:
     
102.                                                                 f1 = "/";
     
103.                                                                 break;
     
104.                                                         }
     
105.                                                         switch (k) {
     
106.                                                         case 0:
     
107.                                                                 f2 = "+";
     
108.                                                                 break;
     
109.                                                         case 1:
     
110.                                                                 f2 = "-";
     
111.                                                                 break;
     
112.                                                         case 2:
     
113.                                                                 f2 = "*";
     
114.                                                                 break;
     
115.                                                         case 3:
     
116.                                                                 f2 = "/";
     
117.                                                                 break;
     
118.                                                         }
     
119.                                                         switch (j) {
     
120.                                                         case 0:
     
121.                                                                 f3 = "+";
     
122.                                                                 break;
     
123.                                                         case 1:
     
124.                                                                 f3 = "-";
     
125.                                                                 break;
     
126.                                                         case 2:
     
127.                                                                 f3 = "*";
     
128.                                                                 break;
     
129.                                                         case 3:
     
130.                                                                 f3 = "/";
     
131.                                                                 break;
     
132.                                                         }
     
133. 
     
134.                                                         return "(((" + ynums[0] + f1 + ynums[1] + ")" + f2
     
135.                                                                         + ynums[2] + ")" + f3 + ynums[3] + "=24";
     
136. 
     
137.                                                 }
     
138.                                         }
     
139.                                 }
     
140.                         }
     
141. 
     
142.                 }
     
143. 
     
144.                 return "No answer!";
     
145.         }
     
146. 
     
147.         public static Integer newNum(int nums, int num) throws Exception {
     
148. 
     
149.                 int[] ynums = new int[4];
     
150.                 int[] hnums = new int[4];
     
151.                 int[] nnumber = new int[4];
     
152.                 int weishu = 1000;
     
153.                 int len = 0;
     
154.                 while (weishu > 0) {
     
155.                         ynums[len] = num / weishu;
     
156.                         num = num % weishu;
     
157.                         weishu = weishu / 10;
     
158.                         len++;
     
159.                 }
     
160.                 int weishu1 = 1000;
     
161.                 int len1 = 0;
     
162.                 while (weishu1 > 0) {
     
163.                         hnums[len1] = nums / weishu1;
     
164.                         nums = nums % weishu1;
     
165.                         weishu1 = weishu1 / 10;
     
166.                         len1++;
     
167.                 }
     
168.                 int len2 = 0;
     
169.                 for (int wei : ynums) {
     
170. 
     
171.                         nnumber[len2] = hnums[wei - 1];
     
172.                         len2++;
     
173.                 }
     
174.                 return nnumber[0] * 1000 + nnumber[1] * 100 + nnumber[2] * 10
     
175.                                 + nnumber[3];
     
176. 
     
177.         }
     
178. 
     
179.         public static List<Integer> arrayNum(int nums) throws Exception {
     
180.                 List<Integer> arrayNumber = new ArrayList<Integer>();
     
181.                 int[] xulie = new int[] { 1234, 1243, 1324, 1342, 1423, 1432, 2134,
     
182.                                 2143, 2314, 2341, 2413, 2431, 3124, 3142, 3214, 3241, 3412,
     
183.                                 3421, 4123, 4132, 4213, 4231, 4312, 4321 };
     
184.                 for (int i : xulie) {
     
185.                         arrayNumber.add(newNum(nums, i));
     
186.                 }
     
187.                 return arrayNumber;
     
188.         }
     
189. 
     
190.         public static void main(String[] args) throws Exception {
     
191. 
     
192.                 int[] num = new int[4];
     
193. 
     
194.                 int nums = Integer.parseInt(javax.swing.JOptionPane
     
195.                                 .showInputDialog("请输入四个1-9的整数"));
     
196.                 System.out.println(ttfDemo(arrayNum(nums)));
     
197.         }
     
198. }

复制代码

输入：1259
结果：(((1+2)*5)+9=24

写的有点粗糙对付着看吧！~