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

汪星人

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

* V! o4 U* V* `& D+ }括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
7 d5 y* f; o4 o, n6 Z  E
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。

9 ]5 S9 i5 Q) [/ K4 d# @: W在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；

以下是java源码：

1. import java.awt.*;
   - ^% [. X  x" Y& X, f
2. import javax.swing.*;
   
3. import java.awt.event.*;
   ! u, J% D" v# e* Z  |( Y
4. import java.util.*;
   6 l0 Z$ t9 t. V
5. import javax.swing.JOptionPane;
   
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   
8. {
   
9.     private JButton jbsolution = new JButton("Find a Solution");
   1 D9 Q# |( w+ r/ d1 y( y
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    
12. 
    
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    ' y- L5 F+ t" c4 C& `4 X5 G
14. 
    
15.     private JTextField jtsolution = new JTextField();
      c7 Y  z7 z# X7 @& U6 v6 A4 a
16.     private JTextField jtexpression = new JTextField();
    4 f- {& ^8 r7 ?
17. 
    ( v/ a! y$ p( a; L  C" N6 B; p
18.     private ImagePanel pp = new ImagePanel();
    
19. 
    + x  S! I5 A) Y6 C8 X$ n) W
20.     private int[] card = new int[4];
    - K5 b, N/ b3 Y
21.     private double[] bcard = new double[4];
    
22. 
    " H# v8 Z" V  H8 P+ ~6 A
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    
25.     private double[] temp2 = new double[2];
    / Y" P3 B) w1 |& n4 x, R# q% D5 L6 I: A- u
26.     private char[] sign = {'+','-','*','/'};
    ) K. U; S, _; g( e
27. 
    
28. 
    & y0 J, k7 f. d5 G) f: D
29.     public TwentyFourPoke_Game()
    
30.     {
    + [/ ^  V, z/ I3 U  {" i
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    
32.         p1.add(jbsolution);
    + J4 N! b2 v3 e$ v5 h9 {
33.         p1.add(jtsolution);
    " |; M! |' H0 B( w8 g! A
34.         p1.add(jbrefresh);
    
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    ( {/ ]0 @/ s0 \/ P+ H
36.         p3.add(jlmessage);
    
37.         p3.add(jtexpression);
    
38.         p3.add(jbverify);
    
39.          
    
40.         add(p1,BorderLayout.NORTH);
    $ a! w: o: w# P2 p( [7 U' U9 r
41.         add(pp,BorderLayout.CENTER);
    / u0 Q0 w+ b% O& P2 S. w5 i* y. C
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    4 B0 y0 C: X* Z7 V5 c5 z/ K2 d
46.         jbrefresh.addActionListener(listener);
    & W( N5 P/ C" Q# D# E' n8 x
47.         jbverify.addActionListener(listener);
    $ O2 d1 v7 f0 n- F8 U
48.     }
    
49. 
    
50.     class ButtonListener implements ActionListener
    
51.     {
    
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    : g  F! f3 ~" |/ j! M" u) D$ Z
55.             {
    $ _  w2 |( R' U) s
56.                 for(int i = 0;i < 4;i++)
    
57.                 {
    
58.                     bcard[i] = (double)card[i] % 13;
    3 Q, Q# N6 l6 b! {
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
    - P2 d# E' a+ Y1 z$ z/ P
61.                 }
      S& s( C) t3 c7 s9 \- r
62.                 search();
    
63.             }
    3 [  O- f* d1 `
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    
66.                 pp.sshow();
    0 V( M' M* `" a1 T. I# ^& m
67. 
    & X/ q* _8 c& k- F
68.             }
    
69.             else if(e.getSource() == jbverify)
    
70.             {
    
71.                 String expression = jtexpression.getText();
    # j" N7 x1 ?$ X" [2 r5 y, {- O
72.                 int result = evaluateExpression(expression);
    ' p4 U( B( Y) A* p0 B* N
73.                 if(result == 24)
    9 M, y- D. P- x8 F
74.                 {
    $ L; B$ y5 ~# q7 W
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    
77.                 else
    
78.                 {
    
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    
80.                 }
    
81.             }
    
82.         }
    + u( ^- V; _" {' O
83.     }
    " T+ e8 l! d$ `- T5 p  A# C
84. 
    * H" Q# Z9 g- M; W0 s. f
85.     public static double calcute(double a,double b,char c)
    
86.     {
    % f) z# F% p3 }# K- ^& C
87.         if(c == '+')
    
88.             return a+b;
    + k/ i4 e/ b: \* D3 W
89.         else if(c == '-')
    8 Q% H- I( p$ a" Z& g0 h
90.             return  a-b;
    + j0 F' F' q! U! f
91.         else if(c == '*')
    
92.             return a*b;
    $ g9 T, {1 t8 Z  p6 b5 e
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    ' {4 `: Q  b- b1 u+ h- u& e
95.         else
    9 S  q9 j2 Z+ \4 c  H* d* u/ F
96.             return -1;
    9 F7 e" p" C3 t. H2 n2 H
97.     }
    
98. 
    / z/ F9 t, B3 p% S' f. X$ `! L) e4 Q
99.     public  void search()
    
100.     {
     / `( R! p; d4 E- F9 _8 l6 w
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     ' S- I, h/ c9 W: o, N1 @: w
104.         {
     + ~: Q6 G$ n# h( j" l3 P6 @
105.             for(int j=0;j<4;j++)
     
106.             //第二次放置的符号
     2 \6 O! F1 g2 Z: O$ v' p
107.             {
     
108.                 for(int k=0;k<4;k++)
     4 w+ D  e' f5 [7 L8 R& S
109.                 //第三次放置的符号
     7 j2 b8 T9 N4 Z  w9 N; Q
110.                 {
     
111.                     for(int m=0;m<3;m++)
     + s" V  _+ g% |
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     
113.                     {
     
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     % H. I% \; G9 L4 A. i
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     % V% z0 R9 @( D2 d. i) Z
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     
121.                         {
     
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     " g6 {1 g5 m' e5 v, ^" A
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     ) P$ ?& Q6 A6 ^% @# C4 i  m
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     8 L4 p& f: ?+ p( r9 r. k$ U# |
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     6 u2 E; Q; a: P/ H: E9 e
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     8 M4 q, w% z! k' f- _
129.                             if(sum==24)
     
130.                             //若和为24
     4 D+ {# K; u5 H
131.                             {
     4 C4 y/ D  J6 n6 B2 `! m( R
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
     
134.                                     if(m==0 && n==0)
     " h$ g( ~/ c. H; g$ Y9 a! D! b7 R
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);
     
138.                                         return ;
     
139.                                     }
     
140.                                     else if(m==0 && n==1)
     ; r- B1 e. u9 C
141.                                     {
     ! @- j  j7 s+ m5 j+ C3 u; U
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);
     . ~3 T& S9 i! V  m* A) G
144.                                         return ;
     3 e$ p7 K+ c3 E5 l
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;
     
149.                                         jtsolution.setText(sss);
     ; y* X# d% A: Z! e  U9 t7 g7 ?
150.                                         return ;
     - o) x) Y" B* g1 Y3 H& R, x
151.                                     }
     ! F/ d0 C" |, Q7 Z/ T% |* t
152.                                     else if(m==2 && n==0)
     4 l  o. Y7 b+ n- ]0 N. Q
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.                                     }
     
158.                                     else if(m==2 && n==0)
     4 ]; b; p! M6 w4 l. Q: o$ d
159.                                     {
     7 I" q2 B% R9 E9 {
160.                                         String sss =(int)bcard[0]+sign[k]+"("+(int)bcard[1]+sign[j]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+"))="+(int)sum;
     * V& s/ E: W. R- N: W+ \' o
161.                                         jtsolution.setText(sss);
     % h' I9 h# o6 c$ a
162.                                         return ;
     
163.                                     }
     % ]. R# \$ Y2 {* Q5 t
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     
165.                                  
     4 D8 P( `& N: k: ?. x
166.                             }
     
167.                         }
     
168.                     }
     
169.                 }
     
170.             }
     ( K' y; f, A# a/ L5 _6 ?
171.         }
     
172.         if(judge==false)
     
173.             jtsolution.setText("No solution!");
     : g( ~. }. m$ ^
174.         //如果没有找到结果，符号位为0
     
175.     }
     
176. 
     + L! i0 k6 l- K* b/ [
177. 
     
178.     public static int evaluateExpression(String expression)
     
179.     {
     0 m6 `# n! f# D( P0 X1 x& r0 h
180.         // Create operandStack to store operands
     $ g( \+ D% O* K' M4 k
181.         java.util.Stack operandStack = new java.util.Stack();
     
182. 
     7 P. n( Z9 O1 R) S( F( y
183.         // Create operatorStack to store operators
     
184.         java.util.Stack operatorStack = new java.util.Stack();
     
185. 
     1 G! \4 B8 z5 r# T/ z
186.         // Extract operands and operators
     ' e' d! j4 h1 _8 M" Z; `
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     $ i/ f& \: \; [# Z9 o8 _# R
188. 
     . w# C' U" |/ q# {% G2 \' y
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     
191.         {
     3 {: K8 Q) z/ P
192.             String token = tokens.nextToken().trim(); // Extract a token
     # A) n- e" G5 y: g% u
193.             if (token.length() == 0) // Blank space
     $ a: }+ g% j! ?4 R
194.                 continue; // Back to the while loop to extract the next token
     
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
       e! R0 G+ a; k- ^
197.                 // Process all +, -, *, / in the top of the operator stack
     ) a; V+ |2 s, V$ o" u" P+ d6 z( A# c3 G
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     
199.            operatorStack.peek().equals('/')))
     
200.                 {
     
201.                     processAnOperator(operandStack, operatorStack);
     7 `- L2 x6 b6 ]+ w& b: ^
202.                 }
     / }+ ]( n( u# P# W$ Q4 W3 D
203.                 // Push the + or - operator into the operator stack
     . x5 \  g3 g0 s4 E
204.                 operatorStack.push(new Character(token.charAt(0)));
     5 X" _( D+ M8 D. E3 r
205.             }
     
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     
207.             {
     - D( B' _1 d2 U  g1 B  I' X
208.                 // Process all *, / in the top of the operator stack
     " U  ^) U# c8 u( p
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     6 V7 P! l# f% ~( Z* V
210.                 {
     * Z5 v% [) }' d$ E
211.                     processAnOperator(operandStack, operatorStack);
     - u! N- r7 l+ m
212.                 }
     * L6 x: J* ]& S* I
213. 
     
214.                 // Push the * or / operator into the operator stack
     0 }! i/ \! ]. L
215.                 operatorStack.push(new Character(token.charAt(0)));
     5 Y9 A% g: k" \6 I- k1 N) f" q
216.             }
     " s- I5 f( g! r$ B
217.             else if (token.trim().charAt(0) == '(')
     
218.             {
     ) C# l& o! T9 K0 X4 i
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     
220.             }
     
221.             else if (token.trim().charAt(0) == ')')
     
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     
224.                 while (!operatorStack.peek().equals('('))
     2 q0 x5 P  n0 M  g! z2 S3 @
225.                 {
     5 _6 z2 [+ g5 g3 Y
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     
230.             else
     4 h& w7 G4 H2 o* U$ {" w! V
231.             {
     
232.                 // An operand scanned
     
233.                 // Push an operand to the stack
     0 r  \. g1 t9 g! x) j! _% k
234.                 operandStack.push(new Integer(token));
     ' ~" H4 g: n- t
235.             }
     
236.         }
     : D) X) U0 @4 `& S' t) @
237. 
     
238.         // Phase 2: process all the remaining operators in the stack
     * r% j- Q+ c7 s1 Y- Y9 B
239.         while (!operatorStack.isEmpty())
     
240.         {
     2 W; D( p# y6 [4 Y" _! k6 ^
241.             processAnOperator(operandStack, operatorStack);
     
242.         }
     
243. 
     + _5 Z+ u' k7 d8 t( Y) d
244.         // Return the result
     ; c/ s% X- i' W# T- T: Z* G
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     6 ^# f. K1 V* u3 [3 l* f
247. 
     & B' E5 H- @% Q
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     9 I% y$ `, H. m! J* H
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     & h' `) k: F% e" u; j- L
251.         {
       s! X8 y7 T* \$ c/ E& F
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     * Z. K) z" I5 j& C0 D0 X
255.             operandStack.push(new Integer(op2 + op1));
     
256.         }
     
257.         else if (operatorStack.peek().equals('-'))
     9 D; K  ?' Z$ T: e3 P9 V" P! G- I
258.         {
     * s/ N* }7 E) m7 t
259.             operatorStack.pop();
     2 |) t4 ]; p% H
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     8 \1 V/ s% G" U) W
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     1 W6 m8 D: B0 T8 y3 v9 u; Y; b! ?
262.             operandStack.push(new Integer(op2 - op1));
     ! \* Y  O. F. z: l& h/ I0 `
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     7 V$ J* a4 j7 E( H
265.         {
     
266.             operatorStack.pop();
     ' N, w" z! ]2 @9 |
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     + e3 e$ h6 Z( r; S; x
269.             operandStack.push(new Integer(op2 * op1));
     $ D8 |2 W* o" a; V8 W9 Q
270.         }
     
271.         else if (operatorStack.peek().equals('/'))
     
272.         {
     6 D" C0 y" ~) a6 m$ R% {
273.             operatorStack.pop();
     
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
276.             operandStack.push(new Integer(op2 / op1));
     ' q- y; J0 P5 P- k- U
277.         }
     
278.     }
     
279.      
     5 y4 g$ B) _3 R; D( F) N
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     
283.         {
     
284.             int i;
     . n/ s# }( ~( ?
285.             for(i = 0;i < 4;i++)
     ; l/ v. a, I9 G# D2 K. ?, M
286.             {
     
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     & b, V5 V6 j7 R
289.             repaint();
     " K, {2 I$ `6 F2 G. h1 K
290.         }
     ! B( ]! `; z0 D9 U# U& t/ }
291.          
     - A4 u* p$ P# J2 v* s) u
292.         protected void paintComponent(Graphics g)
     - l" z' U9 b  y
293.         {
     % o6 g. m& v8 ]3 M7 A9 q8 G; n
294.             super.paintComponent(g);
     
295.             int i;
     
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     % M' m3 A$ {4 e* a0 }$ Y
298.             int x = 0;
     
299.             int y = 0;
     
300.             for(i = 0;i < 4;i++)
     2 `" e0 \* t8 K6 x9 u
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     2 k# b9 l: C# W+ `0 o, L' Y
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     
305.                 {
     
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     
309.             }
     
310.         }
     8 j# d# _3 y* K) f
311.     }
     
312. 
     ) x4 n; w) @5 R: Q$ N& L& H
313.     public static void main(String[] args)
     2 p; ?# c/ u- f9 H( q3 ~) l8 R
314.     {
     
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     6 B" e* Q8 K+ l$ g) Z% s
316.         frame.setTitle("24 Poke Game");
     0 v3 z8 O- e9 e6 [, L
317.         frame.setLocationRelativeTo(null);
     
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
319.         frame.setSize(368,200);
     
320.         frame.setVisible(true);
     % s3 j6 }3 P, [; X1 q; F/ K3 N2 R
321.     }
     5 q) K% L% s, u' j# k
322. }

复制代码

" e5 {/ z/ F+ O# |+ n5 N; c



; s( x+ I+ D0 D2 I/ g! y3 d
# {' G- ^% I. j" g
+ ?( i/ S7 X1 B* j, {

java宫城大师

学习一下。谢谢