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

汪星人

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

/ y; v) E8 i, `: B9 Z* x; F6 Z9 \/ G括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
7 m, ^/ F/ Z7 w7 C
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。

' n  p' J& d$ R3 G5 }在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；
; D' A% G7 m5 n6 \+ ]1 z( Q; G
7 `; L$ K5 Z4 s- ~6 c4 q以下是java源码：
5 V% c. h) @: W( G" S

1. import java.awt.*;
   6 T3 b" i9 {2 m
2. import javax.swing.*;
   
3. import java.awt.event.*;
   / G* q8 m$ j; H- F- W% c& M
4. import java.util.*;
   " f  \$ p# b2 L0 h. s$ G5 v
5. import javax.swing.JOptionPane;
   # @( O8 _0 t# I. ^
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   
8. {
   % K" ]4 y8 K  L1 E6 d/ i, d
9.     private JButton jbsolution = new JButton("Find a Solution");
   
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    ( v0 U$ Z" O6 f
12. 
    5 {1 Y3 ?1 L& L( ~; ^  r; g: ~
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    
14. 
    6 z% C1 W' p3 x1 C
15.     private JTextField jtsolution = new JTextField();
    
16.     private JTextField jtexpression = new JTextField();
    
17. 
    * M; H  e$ _( ?) f
18.     private ImagePanel pp = new ImagePanel();
    7 m4 q) e( G; @3 r
19. 
    
20.     private int[] card = new int[4];
    4 ?6 c% L7 J9 |0 a7 m8 @
21.     private double[] bcard = new double[4];
    " t- D+ r+ l4 t* f2 p. Q3 q4 q
22. 
      G" N$ f4 v+ H
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    
25.     private double[] temp2 = new double[2];
    
26.     private char[] sign = {'+','-','*','/'};
    8 z% f7 D. e  F: Z7 r7 w! R( |
27. 
    
28. 
    
29.     public TwentyFourPoke_Game()
    
30.     {
    
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    
34.         p1.add(jbrefresh);
    9 p; Q8 G" X) M8 S+ S
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    . }( h# N$ P1 M& m" I5 U
36.         p3.add(jlmessage);
    
37.         p3.add(jtexpression);
    
38.         p3.add(jbverify);
    
39.          
    
40.         add(p1,BorderLayout.NORTH);
    , |/ a4 _2 P$ N; x
41.         add(pp,BorderLayout.CENTER);
    ) ?4 ]0 k7 j% D; h
42.         add(p3,BorderLayout.SOUTH);
    
43. 
    
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    
46.         jbrefresh.addActionListener(listener);
    " l6 ?6 a' H. @  K* @
47.         jbverify.addActionListener(listener);
    * B" F9 B, K: ]$ h! y% a8 ^" x
48.     }
    
49. 
    % p/ _6 |3 X; c% x+ f1 _
50.     class ButtonListener implements ActionListener
    
51.     {
    - |( ^8 l( l& N( i" ]
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    6 }: v( F" B1 e  I
55.             {
    
56.                 for(int i = 0;i < 4;i++)
    0 s6 w0 F& I: d) U! m) g
57.                 {
    
58.                     bcard[i] = (double)card[i] % 13;
    
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
      r2 z: l% r! g% Q; T1 o" b' i
61.                 }
    " i+ a9 U3 T& T" r
62.                 search();
    $ C. V4 b  F4 O; k. P( s8 _4 X
63.             }
    
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    1 e* g) g% F( L' H% [4 J7 W( _! z  y
66.                 pp.sshow();
    ; A2 c3 }& @: }) B: k7 t3 A+ \0 u
67. 
    
68.             }
    ' Q+ B( }8 A" J5 ^7 ~
69.             else if(e.getSource() == jbverify)
    
70.             {
    
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    $ _+ }* M- f$ f; A, k4 S: s
73.                 if(result == 24)
    
74.                 {
    
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    
77.                 else
    
78.                 {
    7 L6 d0 z! j9 A% Y. a$ u6 e
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    
80.                 }
    
81.             }
    
82.         }
    
83.     }
    
84. 
    1 t. a" f) a6 [0 y4 H# t  T  _
85.     public static double calcute(double a,double b,char c)
    1 O3 U7 l  C3 Q# G: v# [
86.     {
    ' o% `# r7 f/ b+ |. b- F- E5 \
87.         if(c == '+')
    4 X# s$ `4 |3 Q; g1 ?" T4 _( g% o
88.             return a+b;
    ) X5 k; o: c6 v- n
89.         else if(c == '-')
    
90.             return  a-b;
    
91.         else if(c == '*')
    
92.             return a*b;
    
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    4 }* r/ f' I3 P/ ~  V, Y& |
95.         else
    " A' B2 x( F; P
96.             return -1;
    
97.     }
    
98. 
    ! `4 V* C. ^. a5 ^; }' r
99.     public  void search()
    
100.     {
       m" o5 R8 V8 |
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     ! V; Z5 M+ ~7 o7 x/ s* J) h
103.         //第一次放置的符号
     " [2 ^; N$ S; T! d! N/ D
104.         {
     $ m0 d; u- C. l; v- ~
105.             for(int j=0;j<4;j++)
     * m) G/ T. @" V7 F% @* `; ~
106.             //第二次放置的符号
     
107.             {
     " [. {6 V: M( B* m' j
108.                 for(int k=0;k<4;k++)
     " {# p% V/ [) G6 U2 _
109.                 //第三次放置的符号
     + w# j, j! W& i' F; N( n
110.                 {
     
111.                     for(int m=0;m<3;m++)
     4 x: X% A7 G: D. I0 M6 `. O# D
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     
113.                     {
     
114.                         if(bcard[m+1]==0 && sign[i]=='/') break;
     
115.                         temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
     
116.                         temp1[(m+1)%3]=bcard[(m+2)%4];
     1 _9 E' K! o6 O
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     8 D6 h; |/ k9 o+ C5 h+ f
121.                         {
     
122.                             if(temp1[n+1]==0 && sign[j]=='/') break;
     
123.                             temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
     / S8 @: d1 Z' s- f) c  L
124.                             temp2[(n+1)%2]=temp1[(n+2)%3];
     
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     
129.                             if(sum==24)
     
130.                             //若和为24
     
131.                             {
     ( P  y* \& K9 S5 W. }- i4 O
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
     
134.                                     if(m==0 && n==0)
     
135.                                     {
     $ R% S' Q7 t8 O
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);
     " W2 C4 S/ F2 i; h# w; r7 \
138.                                         return ;
     
139.                                     }
     . M3 X' F" d, Y1 q, d
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;
       z* H6 X3 ^& d8 S6 l  z; T4 y
143.                                         jtsolution.setText(sss);
     
144.                                         return ;
     
145.                                     }
     
146.                                     else if(m==1 && n==0)
     ! h, L1 T( S( P: K! v' t$ W2 M
147.                                     {
     ( Q# I' J' m: p6 n
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 ;
     7 c9 R' _0 j7 o- I7 K; B1 Q4 l
151.                                     }
     
152.                                     else if(m==2 && n==0)
     + h# M9 }$ Q7 y
153.                                     {
     6 V1 b* }, x3 _# D
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);
     / F+ s/ b/ r- V: A* |2 ^; k$ D
156.                                         return ;
     
157.                                     }
     
158.                                     else if(m==2 && n==0)
     
159.                                     {
     ; ]/ }& \- d' |& _) @/ I: M
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);
     ' Q) `. a7 ?5 E- X* e
162.                                         return ;
     . D. D  P+ q' n6 h# Q
163.                                     }
     % j# \9 \2 A( b! Z' V6 q8 I% V
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     
165.                                  
     ; b4 o; N( C& r' T' a5 P" D
166.                             }
     
167.                         }
     % |/ [  ~' q4 l/ h
168.                     }
     + L  ^2 w1 w% W6 j' a
169.                 }
     + m  n3 @  @: e  m  X2 `
170.             }
     & S( x' _+ I8 M$ J, S" {! @
171.         }
     2 T( d! ^* _0 f/ ~
172.         if(judge==false)
     6 a. d* b0 D8 t# ?0 Z
173.             jtsolution.setText("No solution!");
     # D, A+ }  [6 V7 C6 S$ d
174.         //如果没有找到结果，符号位为0
     
175.     }
     - M3 x0 t1 x* b. P( B& d3 F) o' i
176. 
     " a% G+ Y9 B" H4 T: t
177. 
     
178.     public static int evaluateExpression(String expression)
     % e; F8 }& n- v  t1 u9 C1 H
179.     {
     8 H8 R: i3 Z+ Y, G# T
180.         // Create operandStack to store operands
     
181.         java.util.Stack operandStack = new java.util.Stack();
     
182. 
     . r4 }( Y3 _! b# X
183.         // Create operatorStack to store operators
     " @5 l; d1 w; ?1 o, a) J
184.         java.util.Stack operatorStack = new java.util.Stack();
     ) ?6 V! u: q5 }/ V) E$ u
185. 
     
186.         // Extract operands and operators
     7 d; b! p$ z' b/ ?4 W
187.         java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
     
188. 
     
189.         // Phase 1: Scan tokens
     6 Z+ ~5 U" W1 d; d& O' `
190.         while (tokens.hasMoreTokens())
     
191.         {
     ( |, c* u" q/ [* W$ ~2 X
192.             String token = tokens.nextToken().trim(); // Extract a token
     + x+ L# x9 l) j& t/ i
193.             if (token.length() == 0) // Blank space
     7 d* A# W9 C% T" B0 D6 O
194.                 continue; // Back to the while loop to extract the next token
     0 p$ ^+ _, N1 b) }# Y9 k
195.             else if (token.charAt(0) == '+' || token.charAt(0) == '-')
     
196.             {
     
197.                 // Process all +, -, *, / in the top of the operator stack
     ' q8 i' b9 t, ?9 Z6 D0 f3 N$ J' z
198.                 while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
     6 z: S9 b; Q7 R% I- s* [' ^2 n
199.            operatorStack.peek().equals('/')))
     $ s* o& c# d$ T: l
200.                 {
     
201.                     processAnOperator(operandStack, operatorStack);
     
202.                 }
       ?! d/ y8 V. P4 v! f$ z
203.                 // Push the + or - operator into the operator stack
     
204.                 operatorStack.push(new Character(token.charAt(0)));
       K; ~3 S7 T! n2 r" E
205.             }
     + f4 U/ i$ r5 n( s( ^& `
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     
207.             {
     : R: }: K- U/ j  ]2 k3 h5 j
208.                 // Process all *, / in the top of the operator stack
     0 c8 C: x0 x6 P5 f: E# B
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     + ^+ H; L' k9 Y1 W
210.                 {
     # k" G; U  t3 H, ^3 p6 E
211.                     processAnOperator(operandStack, operatorStack);
     7 R# {* t5 G& k1 h1 s4 C% k5 z
212.                 }
     
213. 
     / |8 A" u* j1 K4 L5 ~
214.                 // Push the * or / operator into the operator stack
     / ]' _1 h! f* b' V
215.                 operatorStack.push(new Character(token.charAt(0)));
     , j4 T! l# U; F( H% q2 |0 @
216.             }
     , _) m+ F& h  m' k
217.             else if (token.trim().charAt(0) == '(')
     1 q3 I9 \& v& d5 G7 D
218.             {
     
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     
220.             }
     
221.             else if (token.trim().charAt(0) == ')')
     ! S% ^: K! }$ x1 ^# [) ~
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     6 J& A7 {! M* e1 _
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     : _  n% r# \! x
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     ( z# e  A/ ~" D* Z# Z+ }
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     # Y* C1 t1 e: G% {" ?$ S; K
229.             }
     
230.             else
     7 e% l1 m7 q0 p6 q1 ~4 j
231.             {
     
232.                 // An operand scanned
     : j! @$ o9 U' n, Q7 h
233.                 // Push an operand to the stack
     
234.                 operandStack.push(new Integer(token));
     - Y7 H1 F  A2 i9 C2 ^
235.             }
     3 P8 G/ c  u; y, Q
236.         }
     
237. 
     : e8 x6 X9 g6 X; [2 |
238.         // Phase 2: process all the remaining operators in the stack
     
239.         while (!operatorStack.isEmpty())
     
240.         {
     
241.             processAnOperator(operandStack, operatorStack);
     
242.         }
     
243. 
       Q( Z6 |7 ?: ~9 I- Z2 K
244.         // Return the result
     8 r5 T4 M. v3 f+ ^/ N" z
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     
247. 
     % `' h9 c6 s& E; C2 q4 m( ?
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     
249.     {
     
250.         if (operatorStack.peek().equals('+'))
     
251.         {
     & s, `5 X  s) e0 H9 i6 }0 `
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     & q3 Y) p8 f( w( I9 H6 M
255.             operandStack.push(new Integer(op2 + op1));
     $ ]% b  L, f/ Y7 F  s
256.         }
     7 A  A  V# i; R' R# _% X
257.         else if (operatorStack.peek().equals('-'))
     7 I9 F1 J& N7 v3 v
258.         {
     * f8 q: |1 F; @. l
259.             operatorStack.pop();
     
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
262.             operandStack.push(new Integer(op2 - op1));
     5 w# A8 y3 [4 ?5 v  {7 b) T
263.         }
     " L' L/ o0 U' [3 f
264.         else if (operatorStack.peek().equals('*'))
     
265.         {
     
266.             operatorStack.pop();
     2 Y; U. C) u9 A
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
269.             operandStack.push(new Integer(op2 * op1));
     
270.         }
     % L- D$ W$ ?5 L: U( j3 n
271.         else if (operatorStack.peek().equals('/'))
     
272.         {
     
273.             operatorStack.pop();
     + C7 Y* S$ v' [% s) A8 x9 ^& D6 s% x% O% U
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     # _. m) p+ P" v  ?
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     / s3 m% v; U! g4 e' Z6 f
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
     + D. ^& o) {6 N  M
278.     }
     
279.      
     
280.     class ImagePanel extends JPanel
     5 K" `' b' H) y: w
281.     {
     
282.         public void sshow()
     ! b$ ^, b; a$ }+ Y% {
283.         {
     
284.             int i;
     
285.             for(i = 0;i < 4;i++)
     $ `) a' ^; K9 X
286.             {
     5 h6 |  P  }2 B+ H. m) A: i
287.                 card[i] = (int)(1 + Math.random() * 52);
     - U3 z3 B$ F; P: e& P- P
288.             }
     
289.             repaint();
     ! O3 R+ r, m" @+ D6 E
290.         }
     ) I/ g  _; m1 P7 f9 J
291.          
     
292.         protected void paintComponent(Graphics g)
     ' ~# T( y8 G  P4 l- `
293.         {
     " Q% v, h! @: }' \8 N9 g1 g
294.             super.paintComponent(g);
     / s( d- c" N, o4 `
295.             int i;
     
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     / |0 ?; u$ r8 @7 @/ P
298.             int x = 0;
     
299.             int y = 0;
     
300.             for(i = 0;i < 4;i++)
     
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     ' p, n! k0 n8 m2 W8 D2 B
303.                 Image image = imageIcon.getImage();
     1 B3 t& I3 g: h9 i- l: g9 F
304.                 if(image != null)
     
305.                 {
     
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     ( O* B* o  h0 V! j3 L: ~
309.             }
     
310.         }
     
311.     }
     ' s9 ^* Z1 A& K# I( S. R
312. 
     
313.     public static void main(String[] args)
     
314.     {
     1 t) O* ~! w; s) T2 f0 i0 H
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     / [+ O7 {: }& o+ S4 i; u0 u7 V
316.         frame.setTitle("24 Poke Game");
     
317.         frame.setLocationRelativeTo(null);
     & f; I6 S, o3 v) _* g: n! K& S
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     * k7 H# ~: }2 D) V9 c: u
319.         frame.setSize(368,200);
     $ {# O' B% r1 I, N
320.         frame.setVisible(true);
     
321.     }
     ) `' P( {. a7 p6 f# \
322. }

复制代码

( _: x) ~: n- V# @
! M0 L2 }' T* L) U" o( k% {' h6 W

/ ~$ K' h, X- u

% V/ d2 }7 ~6 m0 y* l4 y' J6 U- M

java宫城大师

学习一下。谢谢