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

汪星人

给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。
+ l5 f  a( P+ W+ I. j* W
% {- n3 ]% i( }, Y* P" b括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
3 D4 w6 V0 v7 g2 n9 O: V9 R
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。

在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；

# x8 @) I( q% _  k+ L. ^! C* |# Z以下是java源码：

1. import java.awt.*;
   3 W* H4 H7 c2 h2 S$ M6 S- ?0 b
2. import javax.swing.*;
   
3. import java.awt.event.*;
   / \7 B: K% Q8 H* u( u$ N* K, C. B
4. import java.util.*;
   
5. import javax.swing.JOptionPane;
   ; l- ^. I4 _2 E" p7 e* o7 [
6. 
   5 ?0 A8 C" q  W! Q
7. public class  TwentyFourPoke_Game extends JFrame
   
8. {
   6 P7 q- e0 e6 p) V+ d7 l- [
9.     private JButton jbsolution = new JButton("Find a Solution");
   
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    5 m8 T" X9 n4 c% q$ R( h1 A! E
12. 
    / d) S4 E$ G& ^# i. \; Y; ]
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    8 t( \8 F" m7 h
14. 
    / w& [% W- T/ z! H# S5 }" k- ~' }
15.     private JTextField jtsolution = new JTextField();
    
16.     private JTextField jtexpression = new JTextField();
    / z' f1 f/ \* X8 ~
17. 
    
18.     private ImagePanel pp = new ImagePanel();
    
19. 
    ! l9 I0 r" _. K+ G& n
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    
22. 
    
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    3 n3 L2 J/ ?+ i1 e  n1 ?) }
25.     private double[] temp2 = new double[2];
    6 q! @+ v" u6 y6 ?
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    % p9 T% b8 z/ C9 T. Y
28. 
    
29.     public TwentyFourPoke_Game()
    
30.     {
    1 S' [  g( I, Z; U* B
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    ! a7 H5 B/ z/ B! ^. ?5 r" H
32.         p1.add(jbsolution);
    4 V1 L9 l! a  ~. N0 ^4 h: M
33.         p1.add(jtsolution);
    1 X" O* Q1 Y7 \3 |& y/ M/ m4 T) |. H
34.         p1.add(jbrefresh);
    - S- }) y. d* k9 D& W( Z
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    9 O+ Y3 H4 V9 @
36.         p3.add(jlmessage);
    / n) s4 a$ P6 x" N3 w
37.         p3.add(jtexpression);
    - G# \# F9 h" @1 I7 @
38.         p3.add(jbverify);
    8 H8 s0 d1 d( f. m2 z/ i- T! S! p
39.          
    
40.         add(p1,BorderLayout.NORTH);
    ) n+ A1 i; L! A- p
41.         add(pp,BorderLayout.CENTER);
    * @$ j1 {2 a9 K, U+ N) k/ D
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    3 W4 ^: j& u. h  x  O. @# o6 j
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    7 j7 E  |- w$ \
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    
48.     }
    ( H6 @- Y( Z, f9 @9 |- L
49. 
    , M7 K- y( V* {( o" a0 k
50.     class ButtonListener implements ActionListener
    
51.     {
    % H4 U) _+ T$ _
52.         public void actionPerformed(ActionEvent e)
    9 g& M6 L( O: E7 E9 I
53.         {
    $ k' |9 `. V/ _
54.             if(e.getSource() == jbsolution)
    4 V& w- Z3 z- z" o  P" [( a, o
55.             {
    ) j9 v* J- S  t
56.                 for(int i = 0;i < 4;i++)
    
57.                 {
    8 B  ?, Y5 E7 W( O
58.                     bcard[i] = (double)card[i] % 13;
    
59.                     if(card[i] % 13 == 0)
    . G% G+ D" r; f( O7 F& ~
60.                         bcard[i] = 13;
    
61.                 }
    
62.                 search();
    
63.             }
    
64.             else if(e.getSource() == jbrefresh)
    " I$ X8 u) @) ?4 n% U4 T# Q) z
65.             {
    
66.                 pp.sshow();
    . Z% ]1 }3 n8 A. ^
67. 
    
68.             }
    7 I' c' J: K" t# f$ [
69.             else if(e.getSource() == jbverify)
    
70.             {
    3 U3 ]- \- z3 a3 O$ K& f( j& p$ A: X
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    
73.                 if(result == 24)
    " L; B* D( b* k: F/ J
74.                 {
    
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    
77.                 else
    " s7 E: c" T$ h* u7 w" R
78.                 {
    9 b5 E# R# {8 q. t( f
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    ; U5 N. k: b3 e3 D! D
80.                 }
    
81.             }
    7 W0 F8 \* I+ P' W1 e
82.         }
    
83.     }
    6 X: K: O7 U& s  D/ }& D# z8 k
84. 
    0 Q3 d9 h% |/ i, P! R! \2 h& f
85.     public static double calcute(double a,double b,char c)
    
86.     {
    
87.         if(c == '+')
    
88.             return a+b;
    * e# Z1 \- V. Y& \* C
89.         else if(c == '-')
    " b/ y: B* Y# l6 Q( a/ A
90.             return  a-b;
    
91.         else if(c == '*')
    
92.             return a*b;
    
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    4 `" R2 m, F3 ?5 w
95.         else
    
96.             return -1;
    
97.     }
    * M. V. q7 F* [' D' K7 i
98. 
    . B  G& C  \# Y( E5 G
99.     public  void search()
    
100.     {
     7 A6 q! M" L! }  x" g9 a
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     6 m' @4 n+ ^) Y8 N
104.         {
     
105.             for(int j=0;j<4;j++)
     
106.             //第二次放置的符号
     
107.             {
     
108.                 for(int k=0;k<4;k++)
     % x& v6 O, C4 W+ B: C! `) b! L6 \# u
109.                 //第三次放置的符号
     
110.                 {
     . Q2 _: u: C- R( W+ u7 e
111.                     for(int m=0;m<3;m++)
     $ p7 m; Y: j. c& @' j, E
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     + G/ U6 X& B% q; q& t
113.                     {
     9 Z) b( V: e* E4 o+ `
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     , o3 m* n: ^. F! s$ J
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     3 F4 K9 u2 w. F( e
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     7 I3 I0 P, w( j3 x
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     & O5 H* }' w5 X: H$ H
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     
121.                         {
       Y: s% r  _  K! ?2 x2 w
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
       E4 G2 j, z( i: T6 O
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     ( ?% H# ^# s: f1 Z0 I4 V
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     . X* L8 |7 q, }- o4 `
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     3 C/ l. b5 P' V+ c
129.                             if(sum==24)
     
130.                             //若和为24
     
131.                             {
     : W, O6 Q/ g- o9 H3 ]
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
       p8 p0 F% T4 y, q; D1 A8 z8 D
134.                                     if(m==0 && n==0)
     
135.                                     {
     
136.                                         String sss ="(("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[j]+(int)bcard[2]+")"+sign[k]+(int)bcard[3]+"="+(int)sum;
     1 w# U1 v3 ?, ~- F2 I
137.                                         jtsolution.setText(sss);
     
138.                                         return ;
     
139.                                     }
     
140.                                     else if(m==0 && n==1)
     
141.                                     {
     5 B2 W0 l( v, W# C! s
142.                                         String sss ="("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[j]+(int)bcard[3]+")="+(int)sum;
     2 V5 ~, O: y+ {
143.                                         jtsolution.setText(sss);
     
144.                                         return ;
     
145.                                     }
     ' _- u- u9 |- I4 K9 M1 |; K
146.                                     else if(m==1 && n==0)
     " V0 s% i  X7 p* F% I
147.                                     {
     
148.                                         String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
     7 w; R! ^# s+ v5 f5 W8 H8 `3 l' \
149.                                         jtsolution.setText(sss);
     
150.                                         return ;
     
151.                                     }
     
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);
     , o1 n- G" `3 F* R6 d2 a
156.                                         return ;
     ; s# s9 H: D/ V4 A& M- Z
157.                                     }
       V! \- a/ T% @  t& R
158.                                     else if(m==2 && n==0)
     
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);
     
162.                                         return ;
     
163.                                     }
     
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     6 d+ P& T# K  x7 W7 p
165.                                  
     
166.                             }
     5 g2 F6 I; F, n) {) L3 S4 E2 Z# L
167.                         }
     
168.                     }
     ) L+ s0 O3 N! U
169.                 }
     9 d$ {) J, ?; ]. g7 i" L: F
170.             }
     & d: K7 T4 H- {, K! Z
171.         }
     
172.         if(judge==false)
     
173.             jtsolution.setText("No solution!");
     % t6 k1 {& m5 A% D% P, R4 H3 D8 [( a4 {
174.         //如果没有找到结果，符号位为0
     * P* y& Q+ R" C7 t5 B
175.     }
     
176. 
     ; T# c1 s* j0 J6 m) j9 t: ]9 G' \  N
177. 
     6 h$ E5 w! }5 j
178.     public static int evaluateExpression(String expression)
     . g2 E" O+ H$ I
179.     {
     : a6 P/ G3 w* U6 q9 w' M/ s+ f
180.         // Create operandStack to store operands
     3 T  S# E9 r0 q( L( n
181.         java.util.Stack operandStack = new java.util.Stack();
     
182. 
     
183.         // Create operatorStack to store operators
     * h4 I; n% K4 V0 L- v# y7 b! u! @
184.         java.util.Stack operatorStack = new java.util.Stack();
     9 x* n/ z$ C6 l" m. f
185. 
     
186.         // Extract operands and operators
     ! L( u3 ?2 ?& g
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     
188. 
     9 W9 S  W5 i2 ?& G7 F. _
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     / Q& M- ]2 I3 ~/ X0 e/ w
191.         {
     
192.             String token = tokens.nextToken().trim(); // Extract a token
     
193.             if (token.length() == 0) // Blank space
     & W$ @( t  y7 G/ n3 \5 i
194.                 continue; // Back to the while loop to extract the next token
     
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
     ( q2 y1 K; `$ v( }) d7 N
197.                 // Process all +, -, *, / in the top of the operator stack
     7 R, {- V; V5 g* j$ w6 B* |
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     5 ^" [; I& @+ T! t+ O7 k
199.            operatorStack.peek().equals('/')))
     6 y2 z7 i  H/ H) Q4 T
200.                 {
     
201.                     processAnOperator(operandStack, operatorStack);
     
202.                 }
     / b. H$ U, w/ p9 U( Q+ H
203.                 // Push the + or - operator into the operator stack
     
204.                 operatorStack.push(new Character(token.charAt(0)));
     : a# `$ w3 p8 `; d: u
205.             }
     5 L" t5 x6 {& j* d
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     / g* U2 {* ?7 ]' T
207.             {
     6 I2 o5 D) ]; @  y6 I1 {
208.                 // Process all *, / in the top of the operator stack
     ' ^4 S0 C6 ^1 |9 `1 R
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     * t2 I1 L( [: M
210.                 {
     8 x( J/ O  b7 ~" c& D# B! `1 D
211.                     processAnOperator(operandStack, operatorStack);
     
212.                 }
     
213. 
     
214.                 // Push the * or / operator into the operator stack
     $ `$ d$ h$ O$ E- `; `! H
215.                 operatorStack.push(new Character(token.charAt(0)));
     5 ^" o0 r) t7 W
216.             }
     
217.             else if (token.trim().charAt(0) == '(')
     
218.             {
     ; X; L: R4 N' [
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     - F. `- [' N4 c3 v# `# c
220.             }
     
221.             else if (token.trim().charAt(0) == ')')
     
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     ; S5 m7 D- H0 a9 {& @0 `+ Z; }; D
224.                 while (!operatorStack.peek().equals('('))
     7 _. }& k5 Q  d
225.                 {
     
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     . p, n' d% ?, y5 Q
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     
230.             else
     
231.             {
     / g# x/ T! D, _8 }; P3 X& B1 M
232.                 // An operand scanned
     9 P" I* c. X% r
233.                 // Push an operand to the stack
     
234.                 operandStack.push(new Integer(token));
     
235.             }
     
236.         }
     
237. 
     
238.         // Phase 2: process all the remaining operators in the stack
     ! z( _$ g1 g* @+ k# Z
239.         while (!operatorStack.isEmpty())
     
240.         {
     . y1 }3 U: j: N0 H4 d: `: g
241.             processAnOperator(operandStack, operatorStack);
     , S7 _! f+ p. M) w
242.         }
     
243. 
     
244.         // Return the result
     ( T9 w  w+ `5 P; L
245.         return ((Integer)(operandStack.pop())).intValue();
     2 t( K. r  A' N* O4 j
246.     }
     ( s: M/ \/ p$ D3 }2 {% ~& j, i! D) {
247. 
       [  Z' O* i) ?+ K) P5 j
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     
251.         {
     
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     " Z- p1 r. E) ~9 W. L5 H
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     6 ~$ |6 b/ v3 S$ w2 M
255.             operandStack.push(new Integer(op2 + op1));
     + ~" k- Y6 S" g% u6 B7 w
256.         }
     
257.         else if (operatorStack.peek().equals('-'))
     
258.         {
     
259.             operatorStack.pop();
     1 f1 O; [4 S9 @0 m  w7 _% P, V
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
262.             operandStack.push(new Integer(op2 - op1));
     3 a0 \; e# w$ [" G
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     ) @9 F, {) Q* m4 q
265.         {
       E5 ]( y/ v! g6 [
266.             operatorStack.pop();
     
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     7 y% r6 S0 }' H2 t
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
       [8 Y- n9 m, z. Z
269.             operandStack.push(new Integer(op2 * op1));
     
270.         }
     ! E5 Y2 k1 b$ Z) o9 k1 H  d* O9 Z
271.         else if (operatorStack.peek().equals('/'))
     5 s% Y) g3 }/ K: V1 M
272.         {
     * [' j( J2 r7 B6 C: R
273.             operatorStack.pop();
     / g& E. [0 A( `8 ~: U4 f; v
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     * e7 m$ C$ f, z$ i( V  c
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
       l* N- S" E& D; P7 s. n; k
278.     }
     - M- z! D" o/ N+ d
279.      
     1 m5 b+ Q+ _) m7 ?2 J4 b* S- O. N% |
280.     class ImagePanel extends JPanel
     6 d# v3 |- M' @" p
281.     {
     . x! E' f. e; M  m
282.         public void sshow()
     ) S. b/ m% D5 V7 a
283.         {
     
284.             int i;
     
285.             for(i = 0;i < 4;i++)
     
286.             {
     
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     8 {$ p# t. S8 l. @/ L! {4 C! R+ G
289.             repaint();
     
290.         }
     * N# K! \+ F+ u1 J# w
291.          
     
292.         protected void paintComponent(Graphics g)
     , t3 L$ j8 z" K4 Y
293.         {
     4 z1 T0 y  \( o
294.             super.paintComponent(g);
     - q8 s( `: l; a0 h2 E0 ]  w1 y
295.             int i;
     % a4 G6 }# C1 c& {" w, ^0 n6 Y/ F
296.             int w = getWidth() / 4;
     4 T" a, o$ p9 H8 u# r6 O
297.             int h = getHeight();
     
298.             int x = 0;
     / M. m5 B' h' Y
299.             int y = 0;
     2 y! d7 g- N' q
300.             for(i = 0;i < 4;i++)
     , U; K4 Q; u# V6 u4 a
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     ) c/ F$ q3 O6 w/ \( d( Y  F6 d8 Q+ @9 ?
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     
305.                 {
     
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     
309.             }
     % Y. r. I9 q7 W. U5 X, H
310.         }
     
311.     }
     ( b$ w- x; f- w6 j' p7 n- \# N
312. 
     
313.     public static void main(String[] args)
     1 D- i7 Z% H3 k( F
314.     {
     ) w0 H$ i2 t( ?! I
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     % R; i4 X+ F7 A! O( T
316.         frame.setTitle("24 Poke Game");
     . p) }! ]2 K( b0 w
317.         frame.setLocationRelativeTo(null);
     : B4 ~" Q5 D0 f2 x. ?! I6 `4 k
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     $ E& X0 S* w' Q
319.         frame.setSize(368,200);
     : R! T% V: ~- R' e
320.         frame.setVisible(true);
     
321.     }
     
322. }

复制代码

' `& ^- T7 o$ u' F: Y+ P( ^+ }, s
" C' D+ y; v* i


: Z% E: R' t- F


9 _) B! q: y/ l+ I

java宫城大师

学习一下。谢谢