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

汪星人

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

括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
. }4 ^& k( J4 j3 n, V; `5 E
* L& h! b. e' U! b5 F通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。
5 z8 [' g3 V/ o; P0 y' R# v; S
3 T9 m( x: k: g  D; A! Y" {. z在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；

以下是java源码：

1. import java.awt.*;
   0 ^- N4 J3 s2 F) \+ L) n
2. import javax.swing.*;
   
3. import java.awt.event.*;
   % `, N$ t0 }/ ~
4. import java.util.*;
   ( E/ \+ s' X' `, u4 {5 Y1 e8 j. d
5. import javax.swing.JOptionPane;
   ' w( E$ d4 \2 V( e1 F0 z) J; v
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   
8. {
   
9.     private JButton jbsolution = new JButton("Find a Solution");
   4 j3 z! G) l. X9 O
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    
12. 
    
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    
14. 
    0 r* Y" r7 m( A; v% T
15.     private JTextField jtsolution = new JTextField();
    4 h8 @4 e5 G, D
16.     private JTextField jtexpression = new JTextField();
    
17. 
    % u8 T7 z) ^2 E8 Z5 _$ V4 Q3 Y- B
18.     private ImagePanel pp = new ImagePanel();
    ' W2 b" U" S! v
19. 
    6 \$ X, [$ g* b" Z
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];
    
25.     private double[] temp2 = new double[2];
    " R+ x, Z& r8 D6 a6 m
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    4 _: e; M$ A( ?  W# z
28. 
    
29.     public TwentyFourPoke_Game()
    
30.     {
    
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    7 _+ C+ k% ^5 e5 s- {" y/ a
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    2 @' t# h/ l5 x
34.         p1.add(jbrefresh);
    
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    2 p2 r! Z$ r; X' s# Q+ W* P9 G/ `! z7 i
36.         p3.add(jlmessage);
    
37.         p3.add(jtexpression);
    8 |' V; a: y0 w/ G% p9 o% l0 g
38.         p3.add(jbverify);
    
39.          
    * J, G% K! i; q. F/ v& U6 E( w
40.         add(p1,BorderLayout.NORTH);
    
41.         add(pp,BorderLayout.CENTER);
    
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    ' [& Y9 N" W+ b( _; \( X
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    
48.     }
    
49. 
    
50.     class ButtonListener implements ActionListener
    
51.     {
    
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    1 o% K) a1 f0 |% z5 b% L* F. n
55.             {
    
56.                 for(int i = 0;i < 4;i++)
    
57.                 {
    
58.                     bcard[i] = (double)card[i] % 13;
    6 _7 v( |3 _6 }5 C) T: H
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
    / y" f7 d8 Y% i3 R3 y+ D1 w
61.                 }
    
62.                 search();
    
63.             }
    
64.             else if(e.getSource() == jbrefresh)
    ' O: k$ p! }% n% F: d* I
65.             {
    4 `- w" I  Y5 P+ T* H, R9 b
66.                 pp.sshow();
    
67. 
    1 s& I% n8 l) X- ^; z
68.             }
    ; {4 [0 m# u* v. j' w- C
69.             else if(e.getSource() == jbverify)
    " A% Z. E1 p" o; i$ I1 j! S
70.             {
    3 }# P% `( \: n
71.                 String expression = jtexpression.getText();
    6 E  ~. ^- m$ R/ L: g" U% [& g, ]* W
72.                 int result = evaluateExpression(expression);
    
73.                 if(result == 24)
    
74.                 {
    7 ^" _3 |4 X' D3 C& o
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    
77.                 else
    
78.                 {
      w4 f' `0 _# z  v
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    9 q5 {6 ~; I$ F+ i, O4 L
80.                 }
    ; Y$ a* P" |, Q* P4 P( p
81.             }
    8 J7 I# J9 w6 x8 u, ~+ t
82.         }
    0 H# l; h+ B2 }: w7 z
83.     }
    2 V, U4 I' f& w* k' u
84. 
    8 V# k) w& v. ~' f& m! h
85.     public static double calcute(double a,double b,char c)
    / j8 c* x8 v" ~4 b# \3 g
86.     {
    $ }0 a* @# A& j/ g  D1 r
87.         if(c == '+')
    
88.             return a+b;
    
89.         else if(c == '-')
    
90.             return  a-b;
    " ^# o6 U& W4 B4 h7 U
91.         else if(c == '*')
    
92.             return a*b;
    $ P) c4 ^) Y5 J1 x
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    0 ^( i/ I; R5 N2 n- y$ P
95.         else
    
96.             return -1;
    
97.     }
    
98. 
    
99.     public  void search()
      Q5 M8 c1 |8 H# t8 I% M7 x4 [% w! t
100.     {
     
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     + u/ P$ P$ _4 }( Y
103.         //第一次放置的符号
     ) q# \) {# E& x- b' g4 F$ j2 P
104.         {
     8 \0 L- ~& S/ c8 A) c
105.             for(int j=0;j<4;j++)
     
106.             //第二次放置的符号
     , o: J% r0 i  b& a) m$ r
107.             {
     
108.                 for(int k=0;k<4;k++)
     7 b& x4 F+ Q( d+ |( b
109.                 //第三次放置的符号
     : z# B, o* x( H1 y2 Y
110.                 {
     
111.                     for(int m=0;m<3;m++)
     : S1 x: E3 h0 ~
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     * Q; U% N9 b# U3 M) N
113.                     {
     5 h2 ^: A! Q, \) |
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     2 c; y7 i! Y6 R/ m$ I$ B' H
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     - N& J1 ]/ E3 ]/ f* e3 v0 g7 e
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     ' T3 C+ p: H0 I' _( e8 g% p3 S. i: k
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     & |5 p8 e9 ?; z* d2 [' A
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     
121.                         {
     
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     * x$ J$ |0 M5 I% t5 {; s
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     2 u) r) _' Y3 j
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     , ?2 K2 ~! M' @% h  d
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     : W2 }7 N$ k! `8 k2 ~( m, \
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     9 |$ q5 x7 o3 ?+ d
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     " b" H# @4 u1 w. Y4 P9 {; x3 D5 `
128.                             //计算和
     + v& D( r" W: X7 @- j
129.                             if(sum==24)
     
130.                             //若和为24
     " B3 {% y6 c9 ~/ O# l/ b) m
131.                             {
     
132.                                 judge=true;
     ! ^5 m/ |- `! T( R
133.                                 //判断符为1，表示已求得解
     
134.                                     if(m==0 && n==0)
     
135.                                     {
     - w7 Z' R2 x, K$ N5 X8 U: L
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 ;
     2 j+ O5 M# M/ u- N6 }: U& c
139.                                     }
     * q+ S% H1 V1 b% s  b5 V2 C
140.                                     else if(m==0 && n==1)
     
141.                                     {
     - b* f1 A4 C5 ?( D
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 ;
     
145.                                     }
     5 p: s* [) |- h) j+ ~+ h) j  d
146.                                     else if(m==1 && n==0)
     
147.                                     {
     ; U% Q7 q; I7 l
148.                                         String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
     7 G* e; S3 R: d' v3 G3 c
149.                                         jtsolution.setText(sss);
     
150.                                         return ;
     
151.                                     }
     9 t8 j5 _$ V2 w0 C% y: n
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;
     + [- I. M( @2 W; n9 P9 `
155.                                         jtsolution.setText(sss);
     
156.                                         return ;
     # _7 `2 f& g/ \0 h
157.                                     }
     + k' ^( m' ?4 m. A) B
158.                                     else if(m==2 && n==0)
     
159.                                     {
     1 J# ]: H) E5 p) ?
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.                                     }
     ' Q4 P; R4 a8 S' U  M) A3 a
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     0 V' q2 O0 ?  Q6 q+ w
165.                                  
       C* q7 }6 V2 T7 n) Q+ P
166.                             }
     1 Y7 w# r3 \" L/ E) S  d0 q
167.                         }
     5 {( |4 M/ ?. [- E8 G% y
168.                     }
     
169.                 }
     6 \7 H: e0 u& E% K" B, X7 v# _
170.             }
     
171.         }
     + r  P* a9 }4 H
172.         if(judge==false)
     1 H/ p  X: C3 o: m2 A- O( b
173.             jtsolution.setText("No solution!");
     4 t1 [, F, q: ^3 `
174.         //如果没有找到结果，符号位为0
     ' i0 |2 x8 {7 D. t% s! j: R
175.     }
     0 Q4 `. l. m9 i
176. 
     
177. 
     
178.     public static int evaluateExpression(String expression)
     
179.     {
     
180.         // Create operandStack to store operands
     
181.         java.util.Stack operandStack = new java.util.Stack();
     
182. 
     
183.         // Create operatorStack to store operators
     
184.         java.util.Stack operatorStack = new java.util.Stack();
       g. g7 h3 w& G. E1 j$ w: F3 F2 \0 }1 n
185. 
     # u, a  t8 K3 o8 t$ {/ t
186.         // Extract operands and operators
     ) z7 a! R+ G2 U
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     - x4 H0 R1 L1 \# Y1 l6 J' H) x
188. 
     3 h+ i3 Z( j% ^+ ?) l: q
189.         // Phase 1: Scan tokens
     
190.         while (tokens.hasMoreTokens())
     6 w4 \# n7 R: k( h
191.         {
       Z) y! t6 {' ^; o
192.             String token = tokens.nextToken().trim(); // Extract a token
     
193.             if (token.length() == 0) // Blank space
     6 j1 T1 r1 k( c
194.                 continue; // Back to the while loop to extract the next token
     9 T: o0 @- C/ C% ^6 u' s
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     5 j' `% v" G( _' b- j; h
196.             {
     2 j0 i6 b  u. c) B9 M- C
197.                 // Process all +, -, *, / in the top of the operator stack
     1 E3 D) K' S* G' {# Z8 l/ J
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     
199.            operatorStack.peek().equals('/')))
     2 R/ y& U8 m' |& L1 o" V" ?! I$ i
200.                 {
     % m6 r6 Q& s3 u
201.                     processAnOperator(operandStack, operatorStack);
     % x3 \. ~5 \- m4 F2 n5 J
202.                 }
     ( Z4 ?7 r, T  ^; N: d7 z4 q
203.                 // Push the + or - operator into the operator stack
     ) u/ M: u  X8 d6 j1 a/ F
204.                 operatorStack.push(new Character(token.charAt(0)));
     
205.             }
     ) E5 ^6 p( l. h. d5 a! b
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     
207.             {
     . s6 W$ ~8 d8 d9 f& e  N# Q" a
208.                 // Process all *, / in the top of the operator stack
     % {- _3 P% M, ^/ `+ l& k4 ]% A
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     
210.                 {
     
211.                     processAnOperator(operandStack, operatorStack);
     
212.                 }
     ! K) r+ F1 N! \# W! m6 y0 ^
213. 
     
214.                 // Push the * or / operator into the operator stack
     
215.                 operatorStack.push(new Character(token.charAt(0)));
     ' s6 @& q0 U, C- f' L; {
216.             }
     3 V% H, m4 h! c7 H* G5 q
217.             else if (token.trim().charAt(0) == '(')
     
218.             {
     9 X& v+ T) Q6 W. Y7 j7 [
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     
220.             }
     8 r7 ^# |7 I: z) U7 }
221.             else if (token.trim().charAt(0) == ')')
     , R; t5 i- Y; @( Z. p3 R" u3 D
222.             {
     3 H8 o3 n  I; `* o
223.                 // Process all the operators in the stack until seeing '('
     5 E" ^" m0 [& v* f4 J
224.                 while (!operatorStack.peek().equals('('))
     / @% S" R% |( l( V6 u
225.                 {
     ! U6 j( b# U$ L8 {
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     / V0 y8 i. y, U9 E
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     
230.             else
     5 d/ F* ]8 K2 K# m" T2 `) [
231.             {
     $ P$ n; x+ D8 W# J& q2 E& _- m
232.                 // An operand scanned
     5 _/ {+ k( z# }, o1 [8 u
233.                 // Push an operand to the stack
     
234.                 operandStack.push(new Integer(token));
     
235.             }
     
236.         }
     
237. 
     # R' @0 m/ ?$ S/ `
238.         // Phase 2: process all the remaining operators in the stack
     6 X8 m: i0 Y8 l. T4 s3 J
239.         while (!operatorStack.isEmpty())
     
240.         {
     
241.             processAnOperator(operandStack, operatorStack);
     3 n$ l5 D7 n  a" W- n* z  k
242.         }
     - R* t% ~- e! |8 N: J
243. 
     
244.         // Return the result
     # i6 B1 R+ w( c5 S3 n+ r2 W7 `1 ^9 ]; |
245.         return ((Integer)(operandStack.pop())).intValue();
     $ h+ z& s) g5 k9 w
246.     }
     
247. 
     : D/ X$ e7 X- @5 ~
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     3 ^9 \" o0 c5 u; P, ~3 \
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     
251.         {
     , q( D3 [$ K8 l  T2 W
252.             operatorStack.pop();
     ' b' `1 u8 g+ m9 W% D; c
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
255.             operandStack.push(new Integer(op2 + op1));
     
256.         }
     
257.         else if (operatorStack.peek().equals('-'))
     
258.         {
     
259.             operatorStack.pop();
     
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     ; ^# _, h3 e) O& g) o% L( ^
262.             operandStack.push(new Integer(op2 - op1));
     # J% ?. n* w0 l3 `, i' g' \4 \/ ]
263.         }
     5 V- u3 D1 e# T7 j& |1 C- y! b
264.         else if (operatorStack.peek().equals('*'))
     / d" W6 }& |) t% R" H/ _& ^
265.         {
     " V( P* @( q# R
266.             operatorStack.pop();
     5 p0 N9 F! C9 @' }- D8 @
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     6 S" s, Z# O+ P3 H7 P; n
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     : v  Y- ?! p% W% L
269.             operandStack.push(new Integer(op2 * op1));
     6 z9 S3 d0 s4 A1 g' y: [  J7 ~+ h0 I! h
270.         }
     
271.         else if (operatorStack.peek().equals('/'))
     , s$ j# C  t  [: V- Z
272.         {
     5 h% S5 Y! D, Y! L
273.             operatorStack.pop();
     ; f1 ~% N& s3 `- @/ s5 }0 r
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     : [9 J% a% i, V
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
     ) u2 }1 c# T+ E. l1 r
278.     }
     $ `3 k/ Z' J) H7 {7 M8 n5 V
279.      
     
280.     class ImagePanel extends JPanel
     $ X/ Z& w& b  z
281.     {
     
282.         public void sshow()
     
283.         {
     
284.             int i;
     0 ?9 @- Q" S1 f8 @
285.             for(i = 0;i < 4;i++)
     
286.             {
     
287.                 card[i] = (int)(1 + Math.random() * 52);
     ; h+ k, {+ E$ Z9 Z. ^
288.             }
     & Z% @& ^: Q) q
289.             repaint();
     
290.         }
     
291.          
     . F5 h; h) F5 ~
292.         protected void paintComponent(Graphics g)
     - i" |8 ?; P" y8 Y9 n. I
293.         {
     ( R9 I3 R6 F' X5 m& @- N
294.             super.paintComponent(g);
     / E1 \# K& T% v4 }4 ~
295.             int i;
     
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     
298.             int x = 0;
     - T9 s9 @# @* \6 ?  @* v
299.             int y = 0;
     # ^5 \& J/ h9 _+ F  K8 r
300.             for(i = 0;i < 4;i++)
     6 w8 O7 p6 Z% W
301.             {
     9 p) S: S( h5 {4 N
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     ( G: w4 n. t5 @, t0 d  R: H8 a, b
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     ( F2 o9 ]! G4 I: g
305.                 {
     
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     $ f* n2 p1 `, v7 q
309.             }
       }3 v5 |6 u+ U2 n4 o% [
310.         }
     
311.     }
     1 v+ E5 u' @$ Y$ b* Y. {# Z, {
312. 
     
313.     public static void main(String[] args)
     
314.     {
     4 X4 o, G  K9 @/ o& J
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     
316.         frame.setTitle("24 Poke Game");
     
317.         frame.setLocationRelativeTo(null);
     0 w8 p9 o) I2 ^
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
319.         frame.setSize(368,200);
     7 z0 N8 J6 B9 u8 p$ p" e( A
320.         frame.setVisible(true);
     # p4 i% c5 B% c
321.     }
     
322. }

复制代码

; |" s: o6 q5 j. }$ B7 y


* l: E$ ^+ J2 V$ U# }

) J$ v* t% v# E

java宫城大师

学习一下。谢谢