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

汪星人

给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。
& X2 }% J5 `+ |8 B
括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
2 b7 E5 m+ P) `/ M7 c) C" g
# o% x5 V" |5 U( d. d通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。

在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；
, ~& w4 P8 O% u
以下是java源码：

1. import java.awt.*;
   $ c& I0 m, j3 ^- x- x
2. import javax.swing.*;
   
3. import java.awt.event.*;
   2 p% `3 y& |! p( Y
4. import java.util.*;
   
5. import javax.swing.JOptionPane;
   % ]6 B3 z3 ~* V
6. 
   9 s' w3 b2 A9 o% j, U" c
7. public class  TwentyFourPoke_Game extends JFrame
   5 H9 M/ k# `' D9 u2 f. _: E$ j8 Z
8. {
   
9.     private JButton jbsolution = new JButton("Find a Solution");
   
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    4 B5 t& V6 {0 V4 S; n) n1 U3 {9 c
12. 
    
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    ! p0 W3 m$ B1 W
14. 
    " L$ t+ w+ Y$ @. t# j
15.     private JTextField jtsolution = new JTextField();
    
16.     private JTextField jtexpression = new JTextField();
    
17. 
    - S0 k4 T' h- m% X' K
18.     private ImagePanel pp = new ImagePanel();
    
19. 
    8 ~* m( P) q) X4 R: g
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    
22. 
    % ?4 d7 E3 d1 w; e/ \  T. y  w
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    2 u1 U2 v& k- l% S0 B# q
25.     private double[] temp2 = new double[2];
    2 Y9 A1 j- B, F  o0 }. q# K8 ^0 B, |
26.     private char[] sign = {'+','-','*','/'};
    ; z! g9 D/ x' |% G
27. 
    
28. 
    ! e" [  U7 u( J8 b( H
29.     public TwentyFourPoke_Game()
    
30.     {
    9 I, D# F; n4 D
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    
32.         p1.add(jbsolution);
    ( g- k! u4 a& H; Y! ?+ C, i7 V
33.         p1.add(jtsolution);
    
34.         p1.add(jbrefresh);
    
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    
36.         p3.add(jlmessage);
      E7 r8 }! ~- P5 o1 Z# V7 W3 Y
37.         p3.add(jtexpression);
    4 q- G) s+ M% W5 }- ~* o; X! |
38.         p3.add(jbverify);
    . U) b9 M$ h6 ^1 }  H
39.          
    
40.         add(p1,BorderLayout.NORTH);
    0 b2 V; j* w; N, }, r( c; K$ g- F
41.         add(pp,BorderLayout.CENTER);
    0 E! P6 q: _' U$ U5 D& U: d5 v
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    
44.         ButtonListener listener = new ButtonListener();
    $ o/ F& v9 s- J( y1 M  }
45.         jbsolution.addActionListener(listener);
    
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    
48.     }
      ]0 n, U' h' H1 k7 i
49. 
    
50.     class ButtonListener implements ActionListener
    % n6 l+ V, Y. Y% L' m: J7 M
51.     {
    8 e. K9 w6 Z+ ?- w* [
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    , L- J: X: a6 N
54.             if(e.getSource() == jbsolution)
    
55.             {
    
56.                 for(int i = 0;i < 4;i++)
    
57.                 {
    ! Y/ p0 g- `' x% V8 X) b
58.                     bcard[i] = (double)card[i] % 13;
    
59.                     if(card[i] % 13 == 0)
    ) C$ V! M# g, n+ I# a5 w
60.                         bcard[i] = 13;
    7 N. M% o+ o6 E
61.                 }
    
62.                 search();
    
63.             }
    
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    
66.                 pp.sshow();
    
67. 
    ( b& v5 N4 w2 j. B
68.             }
    ; b: D8 U8 G. q, V
69.             else if(e.getSource() == jbverify)
    
70.             {
    - F5 t$ d( y! R0 ]2 ^8 L0 u
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    
73.                 if(result == 24)
    1 ~1 z+ @: H  V
74.                 {
      u! K5 L& ?8 |1 p, X. i
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    8 s9 b* Z  r) t
76.                 }
    0 l. i% w( J! L- r8 x
77.                 else
    8 W# C2 S$ O- ?5 M- g! z
78.                 {
    / d* J' ]8 e9 d  @$ j- r
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    
80.                 }
    
81.             }
    
82.         }
    
83.     }
    : _1 _; e1 |9 P3 g
84. 
    - U3 ^; s8 B# R8 z
85.     public static double calcute(double a,double b,char c)
    . F4 g# o8 Q  P& i& `) i. E6 o
86.     {
    6 C+ ~+ a4 ?: F1 o8 o6 \
87.         if(c == '+')
    
88.             return a+b;
    . Q9 x3 D. ~+ o+ [
89.         else if(c == '-')
    . P! V6 j( e3 t9 D; P
90.             return  a-b;
    ( ^% X. G% A8 J
91.         else if(c == '*')
    
92.             return a*b;
    
93.         else if(c == '/' && b != 0)
    & V9 G2 S5 _7 o4 A* ?
94.             return a/b;
    , ^/ l9 b; h  l/ G8 {' O: x
95.         else
    4 a. M* ?* @9 J
96.             return -1;
    ( G8 a/ ]  ^" [9 `) A$ I
97.     }
    
98. 
    ( `; O/ f. E0 Y+ N, e0 `* Z
99.     public  void search()
    
100.     {
     ) k# M; K9 Q6 K6 i  j8 m/ r
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     % H6 O. d$ H* g9 H# x0 P
104.         {
     
105.             for(int j=0;j<4;j++)
     
106.             //第二次放置的符号
     
107.             {
     & b- M: d4 E& k3 b% E: W1 j
108.                 for(int k=0;k<4;k++)
     
109.                 //第三次放置的符号
     
110.                 {
     5 }$ i: A/ r  |. w! Z- g! R
111.                     for(int m=0;m<3;m++)
     
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     
113.                     {
     
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     - h6 I, o5 ~: P/ D) S! d$ Y/ @
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     ; t0 g+ W) q8 i$ Q, R
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     " O4 L1 V& F/ F
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     $ }" j/ Y7 S0 J7 J0 h1 O0 G# h
121.                         {
     . g- b5 n: {2 @0 x5 D  O' v0 ]6 g
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     7 D" u5 F6 {$ Q0 n8 X
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     + g" r: g' F+ @5 [
129.                             if(sum==24)
     ' K9 x* n9 [. ^8 d) Z, b% N& e7 J
130.                             //若和为24
     
131.                             {
     : s& r# H0 l/ ^! r- Z6 ]( S3 x
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
     
134.                                     if(m==0 && n==0)
     / ~5 [; [* _; c
135.                                     {
     
136.                                         String sss ="(("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[j]+(int)bcard[2]+")"+sign[k]+(int)bcard[3]+"="+(int)sum;
     ' ~7 h1 E8 ]* U
137.                                         jtsolution.setText(sss);
     
138.                                         return ;
     
139.                                     }
     1 B& Z0 t3 z+ _: ^/ D) _
140.                                     else if(m==0 && n==1)
     % H  \; D% P% Y" S$ y  E
141.                                     {
     
142.                                         String sss ="("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[j]+(int)bcard[3]+")="+(int)sum;
     6 Y/ m+ \+ c% Y- H/ U7 Z9 \- G
143.                                         jtsolution.setText(sss);
     
144.                                         return ;
     . A& i; w5 P6 I3 G
145.                                     }
     : m- y8 A, ]& ]. B2 t
146.                                     else if(m==1 && n==0)
     - f/ R+ t" Y. f$ v6 N* Z7 L
147.                                     {
     
148.                                         String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
     
149.                                         jtsolution.setText(sss);
     
150.                                         return ;
     
151.                                     }
     1 g: @+ s* T* g! s
152.                                     else if(m==2 && n==0)
     
153.                                     {
     
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);
     
156.                                         return ;
     
157.                                     }
     ; ]0 C; \- S7 b  A7 F" f
158.                                     else if(m==2 && n==0)
     4 S+ r1 I; k  O# s5 m! K
159.                                     {
     * O9 ]; T1 M/ i
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);
     1 M& g6 `& K/ G, I3 I0 L
162.                                         return ;
     
163.                                     }
     ( g0 j' E9 ^5 ~1 T9 g0 q
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     7 ^  c( w  q: O& @% v# ~
165.                                  
     
166.                             }
     ' o2 x7 Y- U( Y
167.                         }
     5 q* s8 r' E0 L' l* j9 k8 v' {
168.                     }
     4 R) S! [6 L9 M; E$ a
169.                 }
     5 K1 N+ U. `, T0 O% v( X
170.             }
     , ]! `* w$ P, H0 k6 L  S, u
171.         }
     - a0 e% p" V8 e  q7 i
172.         if(judge==false)
     
173.             jtsolution.setText("No solution!");
     6 ]! x; L) P( i0 W
174.         //如果没有找到结果，符号位为0
     
175.     }
       i5 L( w/ s, u* G; l( T
176. 
     
177. 
     * O+ Y6 ?1 S. O% d  Q
178.     public static int evaluateExpression(String expression)
     
179.     {
     
180.         // Create operandStack to store operands
     
181.         java.util.Stack operandStack = new java.util.Stack();
     ! Z: n* a: K# I
182. 
     
183.         // Create operatorStack to store operators
     # Q1 ?" L  |! n5 M0 _) [9 ~3 p
184.         java.util.Stack operatorStack = new java.util.Stack();
     
185. 
     
186.         // Extract operands and operators
     
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     8 G+ R( j4 p" \( ?
188. 
     
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     
191.         {
     - N+ l/ R- E5 B3 ]
192.             String token = tokens.nextToken().trim(); // Extract a token
     $ k8 |; [7 F: x- o  f* w
193.             if (token.length() == 0) // Blank space
     
194.                 continue; // Back to the while loop to extract the next token
       Q7 [, b. y3 @3 X
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     $ \' M1 d' S1 w; K  E
196.             {
     3 p* L2 p6 a9 T; F% E1 o% h9 p- F
197.                 // Process all +, -, *, / in the top of the operator stack
     * p5 H7 Y6 Y0 `/ s0 h! t/ C  m. K: _
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     - \/ F* j/ {* d" a# ~
199.            operatorStack.peek().equals('/')))
     - P% [4 L. W) y# V1 @: _$ K* q
200.                 {
     " H, O- P8 f) g, P
201.                     processAnOperator(operandStack, operatorStack);
     4 D. U! G3 B9 J6 t# _8 D
202.                 }
     
203.                 // Push the + or - operator into the operator stack
     + L! R1 x6 ?# ~7 ~
204.                 operatorStack.push(new Character(token.charAt(0)));
     
205.             }
     
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     # A7 K& o% O& `5 |% P
207.             {
     0 A4 s1 k% [" s5 t1 N
208.                 // Process all *, / in the top of the operator stack
     
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     
210.                 {
     ; l( X. @+ h7 K
211.                     processAnOperator(operandStack, operatorStack);
     5 p9 {$ J/ c; e5 y# }( g0 \7 a
212.                 }
     
213. 
     6 {" j! s9 I' F9 y( t. n
214.                 // Push the * or / operator into the operator stack
     , n; n# k( E6 Z: I" X, [& X
215.                 operatorStack.push(new Character(token.charAt(0)));
     1 p; w. P6 W/ z- _" j* C+ b6 K/ V
216.             }
     
217.             else if (token.trim().charAt(0) == '(')
     3 }7 ?  B! D% L. [
218.             {
     . o: q  a  u3 d3 l
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     
220.             }
     3 U. D/ q8 @0 w! m
221.             else if (token.trim().charAt(0) == ')')
     6 T' ?# ?. [8 @8 I! T4 i
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     
226.                      processAnOperator(operandStack, operatorStack);
     6 ~% D, ~) ^* ]$ P) C! d' T3 g
227.                 }
     
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     4 k4 X* I* T  \; j, q( P' F
229.             }
     
230.             else
     & u/ o. \5 r. y
231.             {
     
232.                 // An operand scanned
     
233.                 // Push an operand to the stack
     / W  E4 T+ S5 y; m; v
234.                 operandStack.push(new Integer(token));
     
235.             }
     " T3 P; s1 a0 g6 {
236.         }
     1 D. T) j0 t$ {3 j9 V2 i
237. 
     ' f- z; f) m) M" u
238.         // Phase 2: process all the remaining operators in the stack
     
239.         while (!operatorStack.isEmpty())
     
240.         {
     
241.             processAnOperator(operandStack, operatorStack);
     : ]9 J' h6 b& C
242.         }
     + U4 x, x  _. ~$ K. }9 M" D6 a
243. 
     
244.         // Return the result
     4 ]) M# t6 ?. Q, v( m) y
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     7 L5 S. v8 O! v( ], r
247. 
     
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     - Z" ~; x7 I! e8 Q  X
249.     {
     4 ]; C8 i) y3 x8 A' @. l
250.         if (operatorStack.peek().equals('+'))
     , [+ z; L# {! c
251.         {
     
252.             operatorStack.pop();
     3 K0 z2 Z7 G( c4 f
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
255.             operandStack.push(new Integer(op2 + op1));
     7 i$ a0 K1 Q4 W) P5 `. z
256.         }
     ) r3 j$ M7 W: c- A
257.         else if (operatorStack.peek().equals('-'))
     
258.         {
     . E3 q! }$ a+ |  D, [
259.             operatorStack.pop();
     - R2 ]7 J9 ]6 B3 M+ P* }
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     5 \1 h- g/ ]0 ]) D9 U! o
262.             operandStack.push(new Integer(op2 - op1));
     " D; j! F. D. D+ ]: T* n
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     
265.         {
     ! x, g! r$ m% Z2 ?0 w
266.             operatorStack.pop();
     
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
269.             operandStack.push(new Integer(op2 * op1));
     $ y1 Z9 R: z- }$ T/ Z8 h
270.         }
     
271.         else if (operatorStack.peek().equals('/'))
     0 ]: ]/ a5 j4 ~* z" L
272.         {
     + C& q2 q/ F* G+ H. ^" u
273.             operatorStack.pop();
     0 }( P7 ^* A9 I$ H
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     3 [4 {4 R9 ]: D1 D) F- D6 v3 H
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     6 M; V% M8 K0 g! `( B3 r* c! V; }7 W( r' {
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
     3 y+ l' L0 x) E# f: I
278.     }
     
279.      
     # N$ N3 d- j4 N5 k) W* g- w  F& ^
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     
283.         {
     ) M$ ^- j* R& [# j3 T
284.             int i;
     
285.             for(i = 0;i < 4;i++)
       U% {7 S- B( S( ]( b7 ^
286.             {
     
287.                 card[i] = (int)(1 + Math.random() * 52);
     $ Z+ o; A* T* J6 V8 {* T4 ~
288.             }
     
289.             repaint();
     & Q* Y; V" H/ t& R
290.         }
     , X8 g, D* y) ?, f( p: c0 }
291.          
     
292.         protected void paintComponent(Graphics g)
     1 w6 w. P- j# C/ J. h( Y
293.         {
     6 Q; |2 ], d; ]$ [* H2 d7 P! c
294.             super.paintComponent(g);
     + H2 t+ c; q+ \) c" r* U. ?
295.             int i;
       F& G7 O  Z9 A: @5 E% \8 G& D# ]0 l
296.             int w = getWidth() / 4;
     : V1 F2 w, t) E' A! b& V
297.             int h = getHeight();
     " V1 b' J* }0 ?* G" }" W
298.             int x = 0;
     
299.             int y = 0;
     2 d1 J" b9 T  V- H+ o; f
300.             for(i = 0;i < 4;i++)
     9 J! F8 J9 r2 q) z$ A
301.             {
     ! X" o8 [! S# C# c$ V
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     ; o  i, v& M- W0 I5 U, p$ ^
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     
305.                 {
     
306.                     g.drawImage(image,x,y,w,h,this);
     0 a! d' b3 S% Y; M- C4 p
307.                 }
     
308.                 x += w;
     3 [3 q8 g8 i; o. V
309.             }
     
310.         }
     
311.     }
     
312. 
     
313.     public static void main(String[] args)
     
314.     {
     
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     + T3 r! V7 O( \; F
316.         frame.setTitle("24 Poke Game");
     
317.         frame.setLocationRelativeTo(null);
     
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
319.         frame.setSize(368,200);
     
320.         frame.setVisible(true);
     0 ]& m; v0 x7 k% ?- V" {  e
321.     }
     
322. }

复制代码

0 `1 t' d9 Z4 G7 b( W

; d5 A) Z2 S' e/ c1 ]
6 {" P  t7 s, A( f

java宫城大师

学习一下。谢谢