java实现的24点扑克牌游戏源码

汪星人

给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。

# s& K( i# @* S. R6 \括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
& q( B8 Q! ]" t7 F5 P! ~
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。

6 y" B/ c- S& \在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；
; q$ t+ b, E, T
以下是java源码：
& C% t) N; V4 Z6 `) n8 B# L

1. import java.awt.*;
   + R( ?: t4 U- I7 H! r/ A6 E& q! t
2. import javax.swing.*;
   8 @. K7 A# D; E& ^) |  X8 M
3. import java.awt.event.*;
   
4. import java.util.*;
   * t. s' p" i- l
5. import javax.swing.JOptionPane;
   
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   
8. {
   3 W2 D6 r) ~3 C* ~8 U
9.     private JButton jbsolution = new JButton("Find a Solution");
   . D9 s5 _" }* S% C: c% X" f
10.     private JButton jbrefresh = new JButton("Refresh");
    & ~  g# `' l2 B
11.     private JButton jbverify = new JButton("Verify");
    
12. 
    
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    9 z& Y# k* [7 r( X5 n9 }0 P
14. 
    + @: p" L& |8 }6 K* N+ a
15.     private JTextField jtsolution = new JTextField();
    
16.     private JTextField jtexpression = new JTextField();
    
17. 
    7 s, U1 C9 h# s, e$ _
18.     private ImagePanel pp = new ImagePanel();
    
19. 
    
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    ! |6 [0 }& d% s6 _
22. 
    / D1 I7 y, {6 ~# x$ ]8 h
23.     private double sum;
    1 T) ]1 f0 U* j5 F; T, o
24.     private double[] temp1 = new double[3];
    
25.     private double[] temp2 = new double[2];
    
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    & u5 U- ?& l1 p" f' P
28. 
    
29.     public TwentyFourPoke_Game()
    $ p2 ?# i6 }# M- p
30.     {
    ) M' E6 H* ]- G
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    * _" n/ y5 X7 C6 `2 \( ]
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    
34.         p1.add(jbrefresh);
    
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    
36.         p3.add(jlmessage);
    $ l" R) ^8 }( k2 a
37.         p3.add(jtexpression);
    
38.         p3.add(jbverify);
    
39.          
    
40.         add(p1,BorderLayout.NORTH);
    
41.         add(pp,BorderLayout.CENTER);
    ! ~6 _& ^1 ?' K. h& O! o9 W
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    
44.         ButtonListener listener = new ButtonListener();
    8 ^6 L  Z1 S; k0 E
45.         jbsolution.addActionListener(listener);
    ( I0 ]4 k: o. {" o  |& V3 K4 H6 U
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    
48.     }
    
49. 
    
50.     class ButtonListener implements ActionListener
    1 f! G  w+ M' X
51.     {
    # _$ h$ G- S5 I6 f& C
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    6 w. L, _. G" m3 g/ }
55.             {
    
56.                 for(int i = 0;i < 4;i++)
    . m: ]: T$ s4 v, a+ I7 O, q9 |/ N# w
57.                 {
    5 P6 A4 ^7 g# w) L- I
58.                     bcard[i] = (double)card[i] % 13;
    0 B) V' [2 D7 e7 S0 P0 I$ E7 S
59.                     if(card[i] % 13 == 0)
    9 w8 g9 {- W5 q% b3 x8 `
60.                         bcard[i] = 13;
    ( G1 r7 u8 Z* x8 b
61.                 }
    # N3 p) I3 v2 I; Y& J6 B5 T" Y
62.                 search();
    
63.             }
    7 q; D3 H" k8 s
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    : |& R6 Y5 v6 X
66.                 pp.sshow();
    2 F0 G0 ?! M8 o2 D
67. 
    
68.             }
    
69.             else if(e.getSource() == jbverify)
    ' D/ W; S: ?+ Z' n( b* h- {
70.             {
    , L( X4 z" R- }$ q* c; B0 S7 ]
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    
73.                 if(result == 24)
    1 T: r. q* v% G; A7 n) i# {- {
74.                 {
    
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    : t8 J. I( O2 D8 a  P
77.                 else
    
78.                 {
    
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    
80.                 }
    
81.             }
    
82.         }
    ! t5 j( p  l# c  \. _! M/ [
83.     }
    ) I  x( G0 l- H
84. 
    
85.     public static double calcute(double a,double b,char c)
    
86.     {
    ' a) n8 o3 ^' K5 n6 x* u) [4 s
87.         if(c == '+')
    
88.             return a+b;
    
89.         else if(c == '-')
    
90.             return  a-b;
    , f: H4 W& F$ u# j8 Q
91.         else if(c == '*')
    ' d& i8 c, l. P' h! y
92.             return a*b;
      d  Z' `$ T5 A5 b! w
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    
95.         else
    
96.             return -1;
    
97.     }
    4 I( C9 i5 T7 P, F. b
98. 
    0 b. g, K0 y( b2 p  a; N1 f
99.     public  void search()
    " W7 F# U7 {0 _3 p6 e3 ]5 K
100.     {
     0 t: l5 L. p1 e& T
101.         boolean judge = false;
     " h3 ^! u8 B2 z# ?9 T$ T# J, P
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     
104.         {
     
105.             for(int j=0;j<4;j++)
     
106.             //第二次放置的符号
     
107.             {
     / d' y0 L! ]9 Q' `. }0 c
108.                 for(int k=0;k<4;k++)
     2 B. G* Z# y5 P0 G' n7 @
109.                 //第三次放置的符号
     
110.                 {
     
111.                     for(int m=0;m<3;m++)
     ) \' f6 a$ \* k- D1 B  X
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     
113.                     {
     0 Y9 |( B' x7 |( Y; Y5 s* T
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     8 a+ M& K( C3 Y* Y, t5 E
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     " B$ ?) d5 C( ]- H
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     # R4 T' K& ~5 O8 @7 Y2 `
121.                         {
     ! j& f4 ~/ k0 q- y& l+ C- L
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     ! `% c+ z& Y8 ]7 l
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     7 u" y% Z% ?/ c1 [0 n  s; G
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     6 h0 v8 q, y. \9 S/ S. b
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     / {: q/ J. P; m" }& d' [. V' I
128.                             //计算和
     
129.                             if(sum==24)
     7 [- {- A6 q* h$ z. y) F) I. Y) w! ]
130.                             //若和为24
     
131.                             {
     8 E6 I- V. a0 j& y
132.                                 judge=true;
     & d+ `% j  U+ b! Y! `
133.                                 //判断符为1，表示已求得解
     # G5 H' d4 d: O$ i. U
134.                                     if(m==0 && n==0)
     , L& f$ O4 Q9 @& o9 g
135.                                     {
     
136.                                         String sss ="(("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[j]+(int)bcard[2]+")"+sign[k]+(int)bcard[3]+"="+(int)sum;
     
137.                                         jtsolution.setText(sss);
     5 G$ g7 m9 |. a6 F
138.                                         return ;
     
139.                                     }
     + i  N# `  |0 `9 m' u
140.                                     else if(m==0 && n==1)
     
141.                                     {
     
142.                                         String sss ="("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[j]+(int)bcard[3]+")="+(int)sum;
     & l  s; |" \1 I/ i% U/ k( t
143.                                         jtsolution.setText(sss);
     ) c/ k% S* L; u
144.                                         return ;
     : {( l" O7 q/ z( r
145.                                     }
     
146.                                     else if(m==1 && n==0)
     
147.                                     {
     
148.                                         String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
     ( G& p5 w) s: O+ ~. k6 M! q. O7 {
149.                                         jtsolution.setText(sss);
     
150.                                         return ;
     6 M9 V5 n' d6 j; D1 S
151.                                     }
     
152.                                     else if(m==2 && n==0)
     
153.                                     {
     : D3 b! B8 r4 j
154.                                         String sss ="("+(int)bcard[0]+sign[j]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+")="+(int)sum;
     ; F5 t9 P7 ?! Y7 q, O. n/ t
155.                                         jtsolution.setText(sss);
     
156.                                         return ;
     
157.                                     }
     
158.                                     else if(m==2 && n==0)
     # I3 K; @& J: s
159.                                     {
     
160.                                         String sss =(int)bcard[0]+sign[k]+"("+(int)bcard[1]+sign[j]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+"))="+(int)sum;
     
161.                                         jtsolution.setText(sss);
     ; H, u( H7 K* K7 c, X
162.                                         return ;
     
163.                                     }
     
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     
165.                                  
     / [& ?/ w9 y6 n
166.                             }
     ) C' a* Q9 ^3 ^# z
167.                         }
     
168.                     }
     - [9 x! `9 r1 X0 c/ z% j  N
169.                 }
     
170.             }
       i. J* v! h8 H0 w. e% @
171.         }
     ) q6 t' {- ?& d: D" M- ?
172.         if(judge==false)
     - E0 \' i1 V! J2 L0 C
173.             jtsolution.setText("No solution!");
     
174.         //如果没有找到结果，符号位为0
     
175.     }
     * F- i% _1 ]- G% x: G! \
176. 
     
177. 
     , p' O* {/ V8 ?4 d4 {8 ^3 W
178.     public static int evaluateExpression(String expression)
     
179.     {
     
180.         // Create operandStack to store operands
     
181.         java.util.Stack operandStack = new java.util.Stack();
     4 i% P/ B7 ^- N! }6 T8 Y) l
182. 
     
183.         // Create operatorStack to store operators
     
184.         java.util.Stack operatorStack = new java.util.Stack();
     ) n( u  Z; w1 u; |; A) [4 a
185. 
     
186.         // Extract operands and operators
     
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     - ]. a9 _9 U2 F! o1 e2 F+ m
188. 
     2 \3 Y% i7 i; a
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     
191.         {
     
192.             String token = tokens.nextToken().trim(); // Extract a token
     
193.             if (token.length() == 0) // Blank space
     3 F7 Q; w. q4 A! B, n% H9 q
194.                 continue; // Back to the while loop to extract the next token
     
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
     
197.                 // Process all +, -, *, / in the top of the operator stack
     5 C" n9 ]6 p+ V: T, p4 l: U0 G
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     
199.            operatorStack.peek().equals('/')))
     " B; ]7 i1 u+ A( r; {& U7 A
200.                 {
     
201.                     processAnOperator(operandStack, operatorStack);
     2 j7 u3 g) B. D7 R) w1 @3 ]* b' L
202.                 }
     
203.                 // Push the + or - operator into the operator stack
     # I! e/ O, I9 J9 F: q2 I4 y
204.                 operatorStack.push(new Character(token.charAt(0)));
     
205.             }
     5 @6 X$ K$ Z! }6 m
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     9 j/ i& @& i7 @5 T9 w7 b
207.             {
     
208.                 // Process all *, / in the top of the operator stack
     $ z, k' x. p" V- C1 U
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     
210.                 {
     
211.                     processAnOperator(operandStack, operatorStack);
     
212.                 }
     
213. 
     9 g4 H  m! R  N) R, y$ t+ B' t
214.                 // Push the * or / operator into the operator stack
     " f, s  V6 o* U+ N2 j4 [
215.                 operatorStack.push(new Character(token.charAt(0)));
     & ~2 Q+ o# B6 M$ G9 i: Z
216.             }
     
217.             else if (token.trim().charAt(0) == '(')
     6 F/ g8 ?/ e4 Q$ j7 t8 S! X( r7 j" G
218.             {
     & @1 Z& X$ N' x
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     6 o: E$ ?! N0 B+ w" f8 @
220.             }
     
221.             else if (token.trim().charAt(0) == ')')
     " ~& p, g; c, H7 W( T1 G- G, @
222.             {
     3 t) _* @2 k" @
223.                 // Process all the operators in the stack until seeing '('
     / D! b4 `$ V' m4 C7 k
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     , Q# F8 y5 m) {' L
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     # O1 [) e+ D/ o$ _1 t4 n
230.             else
     
231.             {
     
232.                 // An operand scanned
     
233.                 // Push an operand to the stack
     
234.                 operandStack.push(new Integer(token));
     
235.             }
     
236.         }
     2 o& d9 q# B$ T7 M5 h
237. 
     " ]# v# k3 ?5 x* O1 r
238.         // Phase 2: process all the remaining operators in the stack
     4 j# u: L% \+ u
239.         while (!operatorStack.isEmpty())
     - Q* h/ @$ [* b! N
240.         {
     % ]3 X. j5 o; x" l4 v* X5 T
241.             processAnOperator(operandStack, operatorStack);
     
242.         }
     
243. 
     / {/ j8 m6 O6 c6 P% Y* N0 D
244.         // Return the result
     
245.         return ((Integer)(operandStack.pop())).intValue();
       f8 h: b  m1 P" ^% ]' f8 L8 ]
246.     }
     
247. 
     ; O7 E" ?" H' H
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     0 ~( `" g# e9 @. _
251.         {
     
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     $ R3 @8 Q$ }, z0 C7 _
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
255.             operandStack.push(new Integer(op2 + op1));
     
256.         }
       }6 O  u" M% a
257.         else if (operatorStack.peek().equals('-'))
     # c  e( V% ]" B% M
258.         {
     
259.             operatorStack.pop();
     " Z, V- q4 L' C; k' I% {
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
262.             operandStack.push(new Integer(op2 - op1));
     & n+ P$ @! C8 G% Y8 z. z
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     # }! [/ l8 l- q7 }5 n- A) Z& A$ l
265.         {
     1 _5 C# m/ ~7 l  `8 w
266.             operatorStack.pop();
     
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     7 k! t* V" s) X& I( p1 D
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     , u+ i% [# f& a$ f3 g# t8 i" y. D
269.             operandStack.push(new Integer(op2 * op1));
     0 W' Z1 p8 @3 Y# q2 h0 h* j
270.         }
     
271.         else if (operatorStack.peek().equals('/'))
     , O3 b1 F1 `: g2 ~
272.         {
     
273.             operatorStack.pop();
     
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
     9 t5 r6 [9 ^, h! \  e4 N
278.     }
     
279.      
     2 I; e: s- w' C. S9 q& L4 g. X9 L0 X. O
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     4 C2 w& Q8 v- ]$ d& J  x
283.         {
     0 S' w5 ~' m, S3 a
284.             int i;
     
285.             for(i = 0;i < 4;i++)
     
286.             {
     ! {5 G+ H# ?* H! W( p" Q6 Q
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     / d7 C2 \9 Y. S% z$ h, G
289.             repaint();
     
290.         }
     
291.          
     
292.         protected void paintComponent(Graphics g)
     7 {+ ]$ y7 D( \+ `
293.         {
     
294.             super.paintComponent(g);
     
295.             int i;
     
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     6 d/ H: k  U; j( \' u
298.             int x = 0;
     * a4 A& d# m, }
299.             int y = 0;
     
300.             for(i = 0;i < 4;i++)
     
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     : r: l, G! `4 y  K" g
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     $ U# W9 i* ?  ]4 J" z3 N& c
305.                 {
     . E  M$ b2 z1 q7 Y# Y$ k8 u) c
306.                     g.drawImage(image,x,y,w,h,this);
     ' e* \( O! f9 l) M0 h3 j
307.                 }
     2 k; g; s( G6 u8 @* }" o
308.                 x += w;
     3 P3 p1 g9 s3 _
309.             }
     
310.         }
     $ q2 T. ^. r2 X# g$ C- B* _2 `1 a4 l
311.     }
     8 P' P$ `0 |( C2 O
312. 
     
313.     public static void main(String[] args)
     % N2 J6 Y* M5 o5 j
314.     {
     7 X" Y5 p3 S2 ]
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     
316.         frame.setTitle("24 Poke Game");
     / c- G. Q2 a1 i6 B4 M( U
317.         frame.setLocationRelativeTo(null);
     
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
319.         frame.setSize(368,200);
     
320.         frame.setVisible(true);
     ( t. o* U3 z9 Z
321.     }
     3 J( P" m0 N9 B" l  _6 k7 l7 Q
322. }

复制代码

, x9 T* M9 O9 |* Q2 v5 |6 }

. o& x4 s! l% N* [1 ?3 J) V0 \

  m$ c9 t9 h# @$ X' g1 ^1 v" a7 b
2 n) v3 f4 S& X( L4 O2 v0 d+ K. B

java宫城大师

学习一下。谢谢