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

汪星人

给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。
4 ~! ~" y& ^6 j2 r
. k1 F: K0 e2 v( c& f$ C) p6 s8 ]括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。

3 Z' [. |- U# ~; m通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。
! D* {" ~( E' t: f
4 x+ \: G( N3 D在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；

以下是java源码：

1. import java.awt.*;
   
2. import javax.swing.*;
     p) \1 a+ _  X
3. import java.awt.event.*;
   7 u2 O% I5 I! p0 Z
4. import java.util.*;
   
5. import javax.swing.JOptionPane;
   
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   - {+ p6 J* e2 [! `; v  [
8. {
   
9.     private JButton jbsolution = new JButton("Find a Solution");
   ) d5 w: J8 ?- {
10.     private JButton jbrefresh = new JButton("Refresh");
    " T6 H* C. l% j# a& V9 `. V
11.     private JButton jbverify = new JButton("Verify");
    
12. 
    4 r0 L  v" T' C& h& }5 G4 S, X
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    
14. 
    ! b, p5 s* J/ }1 b/ P( D( E
15.     private JTextField jtsolution = new JTextField();
    9 B7 V3 C9 E( R" Z
16.     private JTextField jtexpression = new JTextField();
    
17. 
    
18.     private ImagePanel pp = new ImagePanel();
    
19. 
    * d9 g" n; Z% |/ j
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    
22. 
    
23.     private double sum;
    / n8 f6 _. [$ t
24.     private double[] temp1 = new double[3];
    * `5 v4 |% a- {& l
25.     private double[] temp2 = new double[2];
    
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    , b. r! q# G- I- `4 z, G* N
28. 
    6 O# K: `7 q  l/ B2 F9 i8 u3 e) ^
29.     public TwentyFourPoke_Game()
    
30.     {
    
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    2 b" Q) T) o2 @8 Y, g* m' l
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    , m8 e8 q1 }- Q3 @2 I; V, W( s
34.         p1.add(jbrefresh);
    . A) i" ]% D, v6 Y/ L* d
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    * V5 T1 Q, d7 S$ s( Q* |+ g
36.         p3.add(jlmessage);
    
37.         p3.add(jtexpression);
    ' z% b1 w2 L# d, y5 E! T; u* l
38.         p3.add(jbverify);
    4 ~$ R( o5 q* V; B
39.          
    1 ]- v: [" @0 _. M: Q8 Y( m
40.         add(p1,BorderLayout.NORTH);
    ( R  j& O, I3 q( y2 _0 Z) y
41.         add(pp,BorderLayout.CENTER);
    - W# L- P; Z3 v: U; e6 W
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    9 ]: ~2 A, c" ?4 |0 @3 @
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    ' N6 i/ E; O1 x. V
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    
48.     }
    
49. 
    
50.     class ButtonListener implements ActionListener
    8 e' T/ }9 C8 u8 U1 w
51.     {
    # E! D$ a7 r9 T0 f1 s+ |+ d: s
52.         public void actionPerformed(ActionEvent e)
    ( O& d4 J  N4 T
53.         {
    # f+ a  A/ o% `$ N6 b9 ~' S: Z
54.             if(e.getSource() == jbsolution)
    : X, L" G2 L1 U
55.             {
    
56.                 for(int i = 0;i < 4;i++)
    8 c, A% O% h, O
57.                 {
    ! a% O3 S. y+ j$ \# ~; t1 y
58.                     bcard[i] = (double)card[i] % 13;
    : U& j/ ~. @. x0 A& ]4 [0 M
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
    
61.                 }
    3 M- i) @8 x1 P; W- }% R- f0 L
62.                 search();
    $ w: T1 p/ G& ^/ H( u7 q
63.             }
    ( g# X  w& D3 E: \& \& e: C- {1 i
64.             else if(e.getSource() == jbrefresh)
    - L0 S  k$ G  r' ^
65.             {
    5 F* c. T: n1 G0 b& I
66.                 pp.sshow();
    
67. 
    / k0 [4 h# j" i( g4 b6 K
68.             }
    
69.             else if(e.getSource() == jbverify)
    
70.             {
    4 ?: N; O$ {: ]0 u6 G
71.                 String expression = jtexpression.getText();
    / x. g: ], B  |' ]2 f
72.                 int result = evaluateExpression(expression);
    # f* k- [$ h3 H$ ?! t8 K9 W$ O7 ?
73.                 if(result == 24)
    / t  o" C! |8 V9 O; g. W
74.                 {
    1 O5 i) E+ k; f+ d8 P  b
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    6 i/ U8 A, B5 [
76.                 }
    & {4 n3 i5 s% Z
77.                 else
    , k0 D8 w5 r: W. t3 N' C  Z# s
78.                 {
    0 p9 }, P  U- Y/ \$ y3 E* R
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    
80.                 }
    5 `7 t$ {4 D) Z* b2 i2 T
81.             }
    : k6 H5 e/ M" O" P8 \4 i& P
82.         }
    
83.     }
    
84. 
    
85.     public static double calcute(double a,double b,char c)
    8 [: \8 d) ~& H. n2 t* q" K
86.     {
    ' h7 H' C+ L2 B( \, K( D' e
87.         if(c == '+')
    & v* m7 I2 F( {9 B, r4 G8 M) H
88.             return a+b;
    9 x0 E$ [! k/ P" p/ Y
89.         else if(c == '-')
    - b* ~1 `0 L5 }% s9 ?& }6 f0 z
90.             return  a-b;
    
91.         else if(c == '*')
    
92.             return a*b;
    . A0 M3 `6 c$ w; G6 `) Z
93.         else if(c == '/' && b != 0)
    9 B- K2 R/ P& L( }1 b1 P5 ~
94.             return a/b;
    
95.         else
    
96.             return -1;
    
97.     }
    
98. 
    
99.     public  void search()
    
100.     {
     1 z' L, N# ]+ e' |/ g$ a+ ]$ H
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     ! O( ~2 s( a( Z1 u$ T
104.         {
     
105.             for(int j=0;j<4;j++)
     6 X% e6 e: e3 U% @, |& F
106.             //第二次放置的符号
     % ?8 H9 ?' ^% V3 m* \+ W7 H+ Z
107.             {
     6 W/ G# B& P* }" L! p5 i
108.                 for(int k=0;k<4;k++)
     1 u; ^4 C9 }0 r% z
109.                 //第三次放置的符号
     & i5 _% y- h3 ^; o) _
110.                 {
     7 Q" ~! U' e$ q  c
111.                     for(int m=0;m<3;m++)
     - N5 z! Z9 Z/ Y
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     : R# c5 Q  G4 l/ _+ t
113.                     {
     
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     % X6 _0 y  t9 x5 V) m( m
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     3 r: U4 g" s/ l) @8 H: o
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     $ I7 b/ Y2 @; R
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     2 b0 p  k4 x+ _8 M6 E
121.                         {
     1 o/ q( n# T/ Q" U; x" L2 J: V
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];
     1 M7 A+ o; L2 z6 ^) u
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     1 q( U7 j4 H; L/ ~
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     % Y. z( s  A8 n* N, _
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     . v4 k' }  W% |1 E) E! Q& r: H. B: ^
128.                             //计算和
     ' x- `. D# w0 Z; B  c2 L1 V
129.                             if(sum==24)
     
130.                             //若和为24
     ! J' Z, e! T- H, i: d- E6 L
131.                             {
     ; \2 z- C* x4 [4 X- y
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
     
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;
     
137.                                         jtsolution.setText(sss);
     , j& O* [- _: @, S8 {! R1 c  z* |
138.                                         return ;
     
139.                                     }
     
140.                                     else if(m==0 && n==1)
     
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 ;
     
145.                                     }
     
146.                                     else if(m==1 && n==0)
     / @3 O# A% e5 ~1 h# t
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.                                     }
     , i' V  g7 {) `) B! |* b8 {3 r$ b
152.                                     else if(m==2 && n==0)
     
153.                                     {
     ; |# N, t3 K# h0 r" ~+ I8 H
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 ;
     3 u+ P) p9 g1 s7 d6 h
157.                                     }
     
158.                                     else if(m==2 && n==0)
     
159.                                     {
     " |1 a1 K$ `+ u* U! w' n5 h8 j/ |: \6 ]
160.                                         String sss =(int)bcard[0]+sign[k]+"("+(int)bcard[1]+sign[j]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+"))="+(int)sum;
     ) ?! r: p2 g% O. W
161.                                         jtsolution.setText(sss);
     % w+ H' v0 N7 Q3 h
162.                                         return ;
       U% B# {+ O* D0 G6 a
163.                                     }
     - M1 x% M; {7 @$ ]% b' K) L
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     3 H9 q) r4 G7 N1 ~+ A  x' I
165.                                  
     
166.                             }
     
167.                         }
     
168.                     }
     1 L% }6 g, L( ?* h  f, A$ q* V' a
169.                 }
     ! r* ?6 p) W% {; v* |
170.             }
     
171.         }
     
172.         if(judge==false)
     
173.             jtsolution.setText("No solution!");
     
174.         //如果没有找到结果，符号位为0
     
175.     }
     
176. 
     2 n) _  x. F& u. ]* |( [! l" ~
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();
     
185. 
     
186.         // Extract operands and operators
     
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
     
193.             if (token.length() == 0) // Blank space
     
194.                 continue; // Back to the while loop to extract the next token
     ' U6 l: g; ^3 J" j' U" P
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
     
197.                 // Process all +, -, *, / in the top of the operator stack
     
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     2 w2 V8 H$ {' r$ {$ U/ F4 z
199.            operatorStack.peek().equals('/')))
     ! b6 R2 Z+ q- ?1 D  b! j
200.                 {
     3 O2 v+ Y6 M" v; |8 R! ^
201.                     processAnOperator(operandStack, operatorStack);
     3 _- Q* \; d- X3 ^# O
202.                 }
     
203.                 // Push the + or - operator into the operator stack
     
204.                 operatorStack.push(new Character(token.charAt(0)));
     
205.             }
     
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     
207.             {
     
208.                 // Process all *, / in the top of the operator stack
     ( G' z% h6 n, A- M5 H2 C) |+ [
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     ( i0 x4 r# `8 P/ r7 L" s
210.                 {
     8 Y5 e! ]) Y) I8 t& x' [
211.                     processAnOperator(operandStack, operatorStack);
     % @7 e# P. g9 b' Y/ g
212.                 }
     
213. 
     
214.                 // Push the * or / operator into the operator stack
     + _, E  Z) C8 I0 z0 F  }; c
215.                 operatorStack.push(new Character(token.charAt(0)));
     ! }" r9 X# V8 j
216.             }
     
217.             else if (token.trim().charAt(0) == '(')
     4 F5 x1 F& L2 [
218.             {
     & K; R' @- o9 n! P
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     7 o6 Q0 T9 x# U$ w+ u/ ^4 P. U' l
220.             }
     8 m2 j( Z+ `5 V# I6 d4 L
221.             else if (token.trim().charAt(0) == ')')
     % W( I9 i4 V! ]3 s& g; d
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     ; t1 o5 Z8 J+ e+ S& T( x0 M; ^
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     , ]: v) ^) Q: D' _: V
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     
229.             }
     ' J1 r, W7 @* h% y/ A3 v& ~9 j
230.             else
     5 W8 P2 f" {! B' c/ ?
231.             {
     
232.                 // An operand scanned
     
233.                 // Push an operand to the stack
     
234.                 operandStack.push(new Integer(token));
     ! S3 B3 m9 w% e" p" _. f0 c
235.             }
     4 Q: P! I( e6 R
236.         }
     
237. 
     . S% D9 j6 N$ y1 i: E9 Z+ f$ E
238.         // Phase 2: process all the remaining operators in the stack
     5 j1 c. m8 ?1 q7 O- G1 h
239.         while (!operatorStack.isEmpty())
     
240.         {
     * Y& k7 V1 g! x
241.             processAnOperator(operandStack, operatorStack);
     
242.         }
     # k# l+ _' N8 f( _* A7 X& ?4 N2 w
243. 
     
244.         // Return the result
     
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     $ G+ `3 h- P+ c9 O7 h  V0 [
247. 
     
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     1 M+ f' L, I  {5 w" c8 T, c
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     
251.         {
     
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     ) @2 n  D1 v& ~$ o, R
255.             operandStack.push(new Integer(op2 + op1));
     
256.         }
     5 ?& d" Q% X$ V8 L( q* W
257.         else if (operatorStack.peek().equals('-'))
     ! T8 K8 |# i/ g
258.         {
     0 }: s9 W  `) F* i$ f6 P# F
259.             operatorStack.pop();
     
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     ' R$ k  S8 z  z1 q' j& v: z4 T
262.             operandStack.push(new Integer(op2 - op1));
     
263.         }
     , K7 G6 m+ G3 Y
264.         else if (operatorStack.peek().equals('*'))
     7 |9 g: A2 y$ L; ?# h
265.         {
     
266.             operatorStack.pop();
     
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     4 z% P' K2 V6 O7 t
269.             operandStack.push(new Integer(op2 * op1));
     
270.         }
     0 ^% ]7 A8 C6 U5 ^
271.         else if (operatorStack.peek().equals('/'))
     ( T. |7 G' y4 V! C' Q+ e% J# G& S$ o
272.         {
     5 S4 ~/ n; S* k4 i' p2 r
273.             operatorStack.pop();
     : Z& p- O' G' g% W
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     9 q& s$ I+ o; x: U+ @1 O
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
       S; J1 g. Y+ J6 `1 O, F% K
278.     }
     
279.      
     % c- o. H8 e! h1 o
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     # m! `) ?6 m5 G* T2 k2 C' H5 E
283.         {
     
284.             int i;
     
285.             for(i = 0;i < 4;i++)
     1 t  k: a0 T( G( o% [3 A
286.             {
     ) [" I) s  P6 c% F
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     3 N# X0 o* `& Z2 h8 J9 K2 G
289.             repaint();
     
290.         }
     4 p1 @3 v  ^% U- H5 p8 B
291.          
     
292.         protected void paintComponent(Graphics g)
     
293.         {
     
294.             super.paintComponent(g);
     ! I* b. A6 @6 ]3 {- O
295.             int i;
     
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     , Y- f* w6 a" L- D
298.             int x = 0;
     
299.             int y = 0;
     
300.             for(i = 0;i < 4;i++)
     
301.             {
     % E, l; Q- Y0 f0 i0 z+ c
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     
303.                 Image image = imageIcon.getImage();
     
304.                 if(image != null)
     
305.                 {
     . Z' O- ?; A# B1 m" T: R; B# f1 v* i0 O
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     9 h9 M$ P: |9 b
309.             }
     
310.         }
     
311.     }
     
312. 
     
313.     public static void main(String[] args)
     6 K7 C$ |2 ~3 O
314.     {
     
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     
316.         frame.setTitle("24 Poke Game");
     
317.         frame.setLocationRelativeTo(null);
     1 Y1 ~. l  n" U3 ?. N1 I  r
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     5 E( c( ], O+ a  Z) e! z
319.         frame.setSize(368,200);
     / q- a5 W1 o' J1 ~+ U. a
320.         frame.setVisible(true);
     
321.     }
     
322. }

复制代码

  E1 p( k$ I7 a4 |
3 y( d, D2 ]$ n" T

java宫城大师

学习一下。谢谢