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

汪星人

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

, W* k3 }# Y7 y. B括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
; @% F$ u) c. P7 K& r7 ]7 B6 k4 U) R
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。
) c( W& s* A) R$ T
在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；
" K# f. U- }: w3 v7 J" S; o
: w7 ^3 u/ `: T; Z& v4 T2 ]" d1 A以下是java源码：

1. import java.awt.*;
   
2. import javax.swing.*;
   ; W" ]% a+ i0 t" D9 U0 e
3. import java.awt.event.*;
   
4. import java.util.*;
   
5. import javax.swing.JOptionPane;
   
6. 
   0 Q% I  n  i: P( l3 [8 X
7. public class  TwentyFourPoke_Game extends JFrame
   . s) P" X# J" {9 y
8. {
   * O% X9 ^* M* M
9.     private JButton jbsolution = new JButton("Find a Solution");
   + H$ ~& x- O& N3 t& z0 n
10.     private JButton jbrefresh = new JButton("Refresh");
    * j# X1 T, f- u, _! K  }8 y
11.     private JButton jbverify = new JButton("Verify");
    ! i/ o! R8 B- V9 Y7 p
12. 
    
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    / Y( A; b( B6 |- W0 \1 W$ x. G. }
14. 
    
15.     private JTextField jtsolution = new JTextField();
    2 C( g$ j3 R9 E' x2 _5 h7 Y! Z- k9 e
16.     private JTextField jtexpression = new JTextField();
    & L) G: k! w+ T- [! x0 V* W
17. 
    : L- f5 a" y5 j6 O6 E
18.     private ImagePanel pp = new ImagePanel();
    # S; b2 V/ H: K. z) l
19. 
    & D0 L& R) q8 b9 v1 r* e; l
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    & D1 N2 [' U6 W+ g8 j
22. 
    ) n% w3 C  b4 p# {  j
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    
25.     private double[] temp2 = new double[2];
    ( [6 V' I* C6 I! K4 ^8 q
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    " K$ G" A( L5 ~2 j2 _, E( r
28. 
    
29.     public TwentyFourPoke_Game()
    1 b3 b" Y, E8 d
30.     {
    
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    
34.         p1.add(jbrefresh);
      F: S' c9 M! L3 |* \4 Q0 g; n. a
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    6 k8 g# D8 y( r/ g1 |% `
36.         p3.add(jlmessage);
    ' N. E, }( }& Z% `. D; J$ N  _
37.         p3.add(jtexpression);
    # V6 N8 J% |$ ~3 y6 I" t
38.         p3.add(jbverify);
    
39.          
    
40.         add(p1,BorderLayout.NORTH);
    
41.         add(pp,BorderLayout.CENTER);
    3 k. z4 V% y  E# j2 s+ {
42.         add(p3,BorderLayout.SOUTH);
    1 B* B9 q; S' B3 p( g5 d8 T
43. 
    
44.         ButtonListener listener = new ButtonListener();
    # i" |" |1 r2 j! {+ C4 ~: P
45.         jbsolution.addActionListener(listener);
    ' m8 x4 h: [' ]' n9 T  T
46.         jbrefresh.addActionListener(listener);
    " d" |4 S7 L; Q" ~  B0 N9 R
47.         jbverify.addActionListener(listener);
    " Q7 r1 B% i9 G* |) g/ ]9 }
48.     }
    " |. S) e# g8 S& _8 B, R
49. 
    
50.     class ButtonListener implements ActionListener
    
51.     {
    1 }8 z4 ]; A8 i3 ?- i% l
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    
55.             {
    4 b0 _0 C3 v  @" R
56.                 for(int i = 0;i < 4;i++)
    ! M4 H. G6 D& V! X- R  _
57.                 {
    ) _; I4 `2 z  z
58.                     bcard[i] = (double)card[i] % 13;
    
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
    + v" L! R4 n" R
61.                 }
    + v9 Z: [( C0 H' n. O+ o" Q# \# ^
62.                 search();
    $ }/ Y' {" [/ c% |! y  ~+ L
63.             }
    9 m& Q  o% w7 g7 U2 S8 ~
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    
66.                 pp.sshow();
    
67. 
    * N5 V1 |2 v. {" h1 D4 J
68.             }
    & Z6 {' F6 }$ |, J
69.             else if(e.getSource() == jbverify)
    
70.             {
    & Q- n) n- o: L$ H. ?$ _1 B
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    
73.                 if(result == 24)
    % d: Q. G+ M( _" x/ b1 K, @
74.                 {
    4 d; }, d3 I# R0 M+ _0 c
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    # `6 y, r* S5 p, ?  r
76.                 }
    9 N! N8 |4 b% W! x
77.                 else
    
78.                 {
    " R4 G3 H- p. I% ^5 `  d8 L
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    & j1 e1 Y2 D/ A1 I) w  s
80.                 }
    
81.             }
    
82.         }
    ( G6 M2 o; W% |& L8 ^% G
83.     }
    7 m( P$ w9 o' i0 f
84. 
    
85.     public static double calcute(double a,double b,char c)
    
86.     {
      s0 {% W6 l7 E! ^8 v, m+ I
87.         if(c == '+')
    
88.             return a+b;
    : c7 ~8 p* Q5 y
89.         else if(c == '-')
    : b8 p& \# j9 N" k0 J5 x/ k: o
90.             return  a-b;
    
91.         else if(c == '*')
    # \: R, v8 T- h* |7 C, j
92.             return a*b;
    0 ^; G4 g8 {3 `
93.         else if(c == '/' && b != 0)
    % j1 N+ i. \+ ^
94.             return a/b;
    # ~& r. `3 g& g
95.         else
    . S" `( A/ ~; C4 e' M: i2 l! ~
96.             return -1;
    
97.     }
    & m' t; w  q9 }9 s1 s
98. 
    ) F  K: N8 B* \1 M7 l9 N
99.     public  void search()
    
100.     {
     
101.         boolean judge = false;
     * H8 G0 P' M4 R" U8 C- S
102.         for(int i=0;i<4;i++)
     * f+ J' ~# i* F
103.         //第一次放置的符号
     
104.         {
     
105.             for(int j=0;j<4;j++)
     $ k% r; l% `5 ?& a+ ]3 D/ j5 ]
106.             //第二次放置的符号
     
107.             {
     
108.                 for(int k=0;k<4;k++)
       f5 Q1 T0 m4 ?6 y9 V. ?4 w7 l- |
109.                 //第三次放置的符号
     
110.                 {
     ) o$ j  r# s' T2 w
111.                     for(int m=0;m<3;m++)
       h5 j4 ]$ ^& Y  n/ N8 t+ f/ N3 Y
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     
113.                     {
     % q- W/ U- M7 q% ~, t
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     " y/ j1 w1 k- t9 j. r! o7 F4 w
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     5 L% {7 m6 R: D5 H3 W. |0 P7 m
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     2 k. B9 O$ J; j  \% V  _: T
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     4 J6 U9 m, Q  n
119.                         for(int n=0;n<2;n++)
     8 a+ R  `; q* k* z% R
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     0 l& N6 J6 L& p% V0 y. {6 P9 w# u
121.                         {
     
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     3 R- m7 N& O1 Y
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     1 o& V9 l, e5 h* B0 U( H
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     * ~9 V3 n5 z+ F1 @
129.                             if(sum==24)
     0 h2 h+ N- }" K) I3 w
130.                             //若和为24
     : a. _& a0 m0 @. A) z
131.                             {
     & Q3 t6 v- M3 S% W! ~
132.                                 judge=true;
     3 G: [, {+ m" {5 J- D! x" S$ q6 A
133.                                 //判断符为1，表示已求得解
     
134.                                     if(m==0 && n==0)
     3 E6 ~4 T* T( R' [0 ?5 F& P
135.                                     {
     
136.                                         String sss ="(("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[j]+(int)bcard[2]+")"+sign[k]+(int)bcard[3]+"="+(int)sum;
     & B# H6 J* q# b1 g( m
137.                                         jtsolution.setText(sss);
     ( p% J0 @( Q9 ^" Z8 `% b. e
138.                                         return ;
     4 V1 B  Q& T/ h, g, B5 l( S* F; g
139.                                     }
     
140.                                     else if(m==0 && n==1)
     / b* Q  j& U9 L* C! u
141.                                     {
     
142.                                         String sss ="("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[j]+(int)bcard[3]+")="+(int)sum;
     
143.                                         jtsolution.setText(sss);
     
144.                                         return ;
     + j" N% ?+ }4 D# s  c/ r- D
145.                                     }
     
146.                                     else if(m==1 && n==0)
     , Q1 V) n6 w6 E% ?
147.                                     {
     ! v' K6 E( Q0 J) E3 A, S
148.                                         String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
     # U8 K! u4 z4 F7 c9 f  P" X6 q
149.                                         jtsolution.setText(sss);
     
150.                                         return ;
     
151.                                     }
     
152.                                     else if(m==2 && n==0)
     
153.                                     {
     ( o3 ~# ?# q  b* e
154.                                         String sss ="("+(int)bcard[0]+sign[j]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+")="+(int)sum;
     
155.                                         jtsolution.setText(sss);
     - x1 h  i6 {3 D+ T
156.                                         return ;
     4 K: m& {$ P9 h1 w7 I0 E; {& b2 M
157.                                     }
     
158.                                     else if(m==2 && n==0)
     
159.                                     {
     ( m$ S" J/ c0 p$ a) E
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);
     
162.                                         return ;
     
163.                                     }
     9 N7 ^6 `7 V6 p  h
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     ' k* h3 [( A- F9 b! K5 t. {# a" B9 W
165.                                  
     % L2 `  F. M  k  W# ?9 _
166.                             }
     8 b& m; R! k& j( X
167.                         }
     
168.                     }
     
169.                 }
     6 B8 a( ~5 \/ o1 e& Q# @
170.             }
     
171.         }
     
172.         if(judge==false)
     0 b6 w- m* o2 q, E2 a# w
173.             jtsolution.setText("No solution!");
     
174.         //如果没有找到结果，符号位为0
     " Q! L1 ~/ ~& y, b! t8 v; `+ h4 X
175.     }
     
176. 
     $ g( F5 r1 k( N: L
177. 
     
178.     public static int evaluateExpression(String expression)
     7 b4 v% P: ~& G4 }
179.     {
     
180.         // Create operandStack to store operands
     * K. |3 w8 X6 I! c4 _( Y0 Q4 s) ^
181.         java.util.Stack operandStack = new java.util.Stack();
     
182. 
     
183.         // Create operatorStack to store operators
     * b; x7 R3 s; p& \+ ~8 x( ^
184.         java.util.Stack operatorStack = new java.util.Stack();
     
185. 
     8 J8 Q8 t+ u& D# C% z
186.         // Extract operands and operators
     ' P' i+ ?+ v" N- N  o! s  w, V
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     
188. 
     
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     
191.         {
     
192.             String token = tokens.nextToken().trim(); // Extract a token
       F5 ?" F1 ]! D9 e+ ^: d$ v
193.             if (token.length() == 0) // Blank space
     
194.                 continue; // Back to the while loop to extract the next token
     6 E- A5 Z* @6 }9 e+ y
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
     1 f! G2 g2 t9 d5 A
197.                 // Process all +, -, *, / in the top of the operator stack
     ) W, W9 l% R3 o) C! R
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     7 ~- A1 T, H: T6 p- ]
199.            operatorStack.peek().equals('/')))
     0 B( M( T" D  t' c9 u; \
200.                 {
     5 e: i: w; f/ E6 c# h
201.                     processAnOperator(operandStack, operatorStack);
     
202.                 }
     " j+ ?3 r0 `  @7 W- |) |2 e2 n- I
203.                 // Push the + or - operator into the operator stack
     
204.                 operatorStack.push(new Character(token.charAt(0)));
     ' K  q+ y+ a: T1 P' `2 u
205.             }
     
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     
207.             {
     9 u! C8 o, m+ m7 c2 r$ s" P
208.                 // Process all *, / in the top of the operator stack
     
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     
210.                 {
     
211.                     processAnOperator(operandStack, operatorStack);
     5 {& i* H  e1 ~2 y  ]$ X9 v
212.                 }
     
213. 
     
214.                 // Push the * or / operator into the operator stack
     
215.                 operatorStack.push(new Character(token.charAt(0)));
     
216.             }
     - ]) w' Q, ~4 C2 B# h5 M5 Z
217.             else if (token.trim().charAt(0) == '(')
     # A6 R9 g' p4 D% t' k& x  [5 W5 m  h6 Z
218.             {
     : D3 m( ~6 c- n8 X
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     ! v( q9 K$ |8 D9 m8 }
220.             }
     ( ~! I9 A' N" \
221.             else if (token.trim().charAt(0) == ')')
     4 c/ J5 K! e2 T+ u1 ^3 }% ^, J) a
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     
226.                      processAnOperator(operandStack, operatorStack);
     + c2 ?; o: ?1 Y; x/ l# s/ W& Y
227.                 }
     
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     
230.             else
     
231.             {
     ; K9 `5 U2 Q* a; }# S, M$ t# g
232.                 // An operand scanned
     % r3 L* r4 F0 h& _; F2 x2 f9 s/ X5 ]
233.                 // Push an operand to the stack
     6 d0 H: v4 t6 L0 B) Y  d! X
234.                 operandStack.push(new Integer(token));
     9 U$ Z, D; w2 g* p1 n. v8 I
235.             }
     
236.         }
     
237. 
     ( a* ~6 \/ X6 {: S$ S0 i. c' g3 g4 S7 g
238.         // Phase 2: process all the remaining operators in the stack
     ( t& m3 J: V2 N* e5 X; r8 }
239.         while (!operatorStack.isEmpty())
     
240.         {
     
241.             processAnOperator(operandStack, operatorStack);
     : }; Y3 _0 w: N2 a9 U1 ?' g$ x7 G
242.         }
     ) k! n2 j! E% s8 @0 _3 p
243. 
     . n1 V+ {+ k3 |( I- u3 |: t
244.         // Return the result
     ! P5 ~' S! b& x4 g$ l
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     % t' [5 _: i! [9 f* D
247. 
     
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     ; C! y: ?( r  g1 I
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     5 R% Z8 X& [5 ^+ w2 f8 h' S7 }% _" T
251.         {
     
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     ( L6 \* O: O( |  A4 I
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
255.             operandStack.push(new Integer(op2 + op1));
     ) p/ W+ B8 m( X
256.         }
     & s2 v9 g) T6 D0 y1 c( H" b
257.         else if (operatorStack.peek().equals('-'))
     7 R" i8 X) i, c! I* u
258.         {
     
259.             operatorStack.pop();
       t6 c5 j2 N1 X9 F' [  M, I4 t
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     " q$ J% N1 \( S: m
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     7 P0 a! U2 k) f$ Z2 |: @8 ~3 j
262.             operandStack.push(new Integer(op2 - op1));
     / L8 h& `3 a) c7 n2 N* {
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     7 `) z5 K6 `- p% {: @
265.         {
     
266.             operatorStack.pop();
     
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     6 ~& b' X- {, d
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
269.             operandStack.push(new Integer(op2 * op1));
     
270.         }
     & H2 T  Z7 Z% M9 n' f( E1 r
271.         else if (operatorStack.peek().equals('/'))
     
272.         {
     ' J1 p& o: c' X9 O
273.             operatorStack.pop();
     : N& o' G/ Q, e/ D2 [
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     6 T: E8 E' Y' d
276.             operandStack.push(new Integer(op2 / op1));
     ; {& q9 Z9 Y  z8 \5 M
277.         }
     
278.     }
     7 p3 b* \: C8 ^+ R0 `
279.      
     
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     / r: W) W' n5 f- |; C- }1 l
283.         {
     + @7 Z( L7 f" u
284.             int i;
     
285.             for(i = 0;i < 4;i++)
     
286.             {
     & u6 a& V9 Z' y3 X$ R' R( @& f  X
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     / ^; W  \9 y% J2 d: N# D
289.             repaint();
     6 X6 H7 b, X+ f% ^, k1 r) S; t
290.         }
     
291.          
     
292.         protected void paintComponent(Graphics g)
     7 I, n' p' s' q
293.         {
     " `1 o2 D, Z% ^) C
294.             super.paintComponent(g);
     
295.             int i;
     % W6 ^9 q# J) v# \
296.             int w = getWidth() / 4;
     " s- I& m* |  n( B5 {
297.             int h = getHeight();
     4 A$ V5 n+ r; G2 X6 M+ `2 P
298.             int x = 0;
     
299.             int y = 0;
     ; _2 r9 w9 F+ P+ o7 W8 E
300.             for(i = 0;i < 4;i++)
     
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     
303.                 Image image = imageIcon.getImage();
       d/ g5 t7 D3 r0 S- v) V) l% e
304.                 if(image != null)
     3 ?) ~. b7 @2 T( F) w' J" C
305.                 {
     ; ~; o. Z) |9 Y: x/ Z4 Y
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     2 J/ Y% {( R3 [4 @0 {
309.             }
     8 r5 H& d2 ?9 R( r5 k; Y
310.         }
     
311.     }
     
312. 
     + [- v8 P9 \- Q
313.     public static void main(String[] args)
     
314.     {
     7 L( k" i, j4 s
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     
316.         frame.setTitle("24 Poke Game");
     ; n3 Z; S7 U( H" Z8 r& i- L
317.         frame.setLocationRelativeTo(null);
     
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     " z# f% P2 T2 o( k6 j" p
319.         frame.setSize(368,200);
     
320.         frame.setVisible(true);
       Q( ^$ m' F3 i& e: @* ]
321.     }
     1 j5 D3 {9 }% o7 B& R. |- V$ X
322. }

复制代码

; J0 D/ L' y4 C* d

' p2 H+ d, C6 r4 C/ {( \
  ]6 x+ {, K& b: \* \9 ]
5 R' d% _- q: H( v' R; t

java宫城大师

学习一下。谢谢