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

汪星人

给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。
1 b, ~# I& [2 N; X' u5 M
3 N: J% D3 X3 j. a2 V0 }6 [) f! n0 }3 \括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
, ^7 F0 _+ i( m; B4 J7 A, D* W
' G1 N5 a$ p/ i8 Y通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。
8 q, j6 I" j" d9 |2 f
在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；

) S4 R" \* b/ _  t以下是java源码：
* ]% o4 i$ U+ B$ L9 M/ R4 R

1. import java.awt.*;
   
2. import javax.swing.*;
   
3. import java.awt.event.*;
   9 I1 g% V' X' {2 L
4. import java.util.*;
   
5. import javax.swing.JOptionPane;
   $ k" Z- K5 L+ h
6. 
   
7. public class  TwentyFourPoke_Game extends JFrame
   , d- Y; z" L$ ?: V
8. {
   9 v5 B  n" e7 S- s: U+ m. ]
9.     private JButton jbsolution = new JButton("Find a Solution");
   
10.     private JButton jbrefresh = new JButton("Refresh");
    
11.     private JButton jbverify = new JButton("Verify");
    $ @& Z5 O1 S2 |
12. 
    , j+ U3 A$ r7 _8 A* c
13.     private JLabel jlmessage = new JLabel("Enter an expression:");
    ) \9 C( ]* E4 S) p, q+ ?! \0 |
14. 
    / ]2 E" F* m+ y
15.     private JTextField jtsolution = new JTextField();
    8 i2 |1 `! f4 a
16.     private JTextField jtexpression = new JTextField();
    
17. 
    
18.     private ImagePanel pp = new ImagePanel();
    ' t: q" l! v$ s" l% E
19. 
    ) @% a5 j6 J$ ]
20.     private int[] card = new int[4];
    
21.     private double[] bcard = new double[4];
    
22. 
    5 G# R8 H2 ]3 x
23.     private double sum;
    
24.     private double[] temp1 = new double[3];
    , P) ]  y$ h# R2 N+ G: h7 Z
25.     private double[] temp2 = new double[2];
    $ T7 z3 |* v5 l9 P
26.     private char[] sign = {'+','-','*','/'};
    
27. 
    
28. 
    ; E% F8 R0 ^) C7 H7 }
29.     public TwentyFourPoke_Game()
    " M, [' U7 s8 X
30.     {
    ( ?5 v1 \% F, p  L( `
31.         JPanel p1 = new JPanel(new GridLayout(1,3));
    5 t; R( o% W* g: P
32.         p1.add(jbsolution);
    
33.         p1.add(jtsolution);
    + r- ?+ I4 r/ y* N  a, @( G( {
34.         p1.add(jbrefresh);
    - m: x( J! l  T# n. G% j: ?
35.         JPanel p3 = new JPanel(new GridLayout(1,3));
    + `. J$ K0 C( g& o" R# g0 r/ a
36.         p3.add(jlmessage);
    
37.         p3.add(jtexpression);
    
38.         p3.add(jbverify);
    % E* V% S2 @& ^, C9 d3 \
39.          
    6 i6 `7 g1 A4 n
40.         add(p1,BorderLayout.NORTH);
    
41.         add(pp,BorderLayout.CENTER);
    ; N5 A$ R8 N! n
42.         add(p3,BorderLayout.SOUTH);
    0 \: W: @1 `% {9 R3 Z
43. 
    5 c/ A/ n7 T1 L  w; F
44.         ButtonListener listener = new ButtonListener();
    
45.         jbsolution.addActionListener(listener);
    
46.         jbrefresh.addActionListener(listener);
    
47.         jbverify.addActionListener(listener);
    2 t& M/ C9 n  @
48.     }
    
49. 
    
50.     class ButtonListener implements ActionListener
    8 Y  A, W9 v9 f( O* o! W
51.     {
    3 Q2 f" N9 Y7 ?
52.         public void actionPerformed(ActionEvent e)
    
53.         {
    
54.             if(e.getSource() == jbsolution)
    + t" z3 t1 `% w. O) t
55.             {
    , M% P% {) D1 d' ]- t7 `
56.                 for(int i = 0;i < 4;i++)
    
57.                 {
    ) H: U7 l# }7 v0 P) p# I" r8 B2 s
58.                     bcard[i] = (double)card[i] % 13;
    / P3 z: B  W, V0 g5 @4 O
59.                     if(card[i] % 13 == 0)
    
60.                         bcard[i] = 13;
    : c& L1 D& {  S" b
61.                 }
    / n# q# c. s' F0 E1 j  V1 \+ o" N
62.                 search();
    
63.             }
    
64.             else if(e.getSource() == jbrefresh)
    
65.             {
    - Y1 p/ K0 L" _+ j6 |( H
66.                 pp.sshow();
    
67. 
    ( T) E5 p) ]% `; I/ {9 p
68.             }
    
69.             else if(e.getSource() == jbverify)
    
70.             {
    ' R( Q+ {% a2 u
71.                 String expression = jtexpression.getText();
    
72.                 int result = evaluateExpression(expression);
    7 S& A/ R# `# W' L8 P! M/ \" l% D5 |
73.                 if(result == 24)
    ! t: e' m7 I, U5 Y* `
74.                 {
    
75.                     JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
    
76.                 }
    : Q, w7 @- h3 e$ ?$ o8 |. c7 X. v% [
77.                 else
    
78.                 {
    1 V& ~$ [; ?/ G5 K5 u0 ~# P
79.                     JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
    & p3 B; g) C9 K# L0 O: [" a
80.                 }
    
81.             }
    
82.         }
    ) D, A4 r1 N2 p- v6 z) Q+ d
83.     }
    9 A( O" ?2 L4 ]* i, |
84. 
    
85.     public static double calcute(double a,double b,char c)
    
86.     {
    0 @9 m6 z/ J; `( P
87.         if(c == '+')
    ! r, s$ R) c* D1 S5 `, A8 K
88.             return a+b;
    
89.         else if(c == '-')
    
90.             return  a-b;
    
91.         else if(c == '*')
    ( B5 g6 N5 p+ l0 I* a6 h9 F; r# w
92.             return a*b;
    ; ?* z' r+ C9 x2 F1 b. {
93.         else if(c == '/' && b != 0)
    
94.             return a/b;
    
95.         else
    6 G: S" `5 \5 Z# T
96.             return -1;
    
97.     }
    . m, f. p, \2 b7 o5 t* i7 V+ y- A
98. 
    ' Q  V) Z+ i2 H+ S7 d) H! l) C
99.     public  void search()
    ; j3 g" E8 w  Z6 _+ `, a0 H
100.     {
     
101.         boolean judge = false;
     
102.         for(int i=0;i<4;i++)
     
103.         //第一次放置的符号
     4 S. M; b+ u( P8 o7 b) w0 f
104.         {
       m& s. l- Q2 g: p& u+ c4 [& h  \
105.             for(int j=0;j<4;j++)
     : q- j" I# g( L
106.             //第二次放置的符号
     , e% J' ?( B2 `2 U
107.             {
     1 c# n8 c0 O% X! c! k$ z* W
108.                 for(int k=0;k<4;k++)
     , c$ ^6 N9 g7 _4 _4 c
109.                 //第三次放置的符号
     2 C/ v9 D- K$ q' d) U6 L
110.                 {
     
111.                     for(int m=0;m<3;m++)
     " ]; u. b% p  o) a! t' {( y2 \, y
112.                     //首先计算的两个相邻数字，共有3种情况，相当于括号的作用
     $ k4 _2 ?; ?! E
113.                     {
     0 n0 F4 e: H& @
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];
     2 H' W1 z7 e9 A1 F
117.                         temp1[(m+2)%3]=bcard[(m+3)%4];
     
118.                         //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
     
119.                         for(int n=0;n<2;n++)
     
120.                         //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
     
121.                         {
     
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];
     / {. E3 I. L- G+ c
125.                             //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
     
126.                             if(temp2[1]==0 && sign[k]=='/') break;
     
127.                             sum=calcute(temp2[0],temp2[1],sign[k]);
     
128.                             //计算和
     & _7 y6 C5 ?* y) Y2 \
129.                             if(sum==24)
     : k0 z( \+ ~3 ~& V5 e1 @
130.                             //若和为24
     5 p% Z. h7 ?/ O& y
131.                             {
     - i& ~; \( G$ o5 \
132.                                 judge=true;
     
133.                                 //判断符为1，表示已求得解
     & D& ?) f! s8 O0 G* L+ h
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);
     + K( `! ?. w; x! B: o" E) M. V9 k
138.                                         return ;
     
139.                                     }
     
140.                                     else if(m==0 && n==1)
     : b# c0 I2 H! u: V* g" }
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);
     " K. [, m$ J! H! J$ f& b
144.                                         return ;
     / N& R4 n8 L' u/ d0 u
145.                                     }
     # i8 t9 W- @5 {# h& l" H# \' `
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);
     6 |1 y' n& Z, k9 P1 v; [& L( c
150.                                         return ;
     
151.                                     }
     
152.                                     else if(m==2 && n==0)
     8 \" |# ?5 X) e7 o' |" j
153.                                     {
     
154.                                         String sss ="("+(int)bcard[0]+sign[j]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+")="+(int)sum;
     2 R, D$ n5 H  e$ X  p0 `
155.                                         jtsolution.setText(sss);
     9 X9 ?3 x6 _3 z1 X1 G3 f) \9 c3 ^
156.                                         return ;
     
157.                                     }
     
158.                                     else if(m==2 && n==0)
     
159.                                     {
     0 y) `# T3 b6 z: E
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);
     1 Z. e+ z2 k: m7 [
162.                                         return ;
     . z+ ^9 T. h6 k" [
163.                                     }
     
164.                                         //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
     
165.                                  
     # ]/ o# e: h- R" z2 E
166.                             }
     1 q6 W# k1 ~( y' t3 [) c5 _) K
167.                         }
     
168.                     }
     
169.                 }
     
170.             }
     
171.         }
     
172.         if(judge==false)
     
173.             jtsolution.setText("No solution!");
     
174.         //如果没有找到结果，符号位为0
     
175.     }
     + N( Z" H% z+ P) S2 u
176. 
     $ t$ G8 c) w( @' |& U4 z' ^
177. 
     
178.     public static int evaluateExpression(String expression)
     2 Q6 @$ k( o. g2 D6 y5 q
179.     {
     
180.         // Create operandStack to store operands
     
181.         java.util.Stack operandStack = new java.util.Stack();
     7 x/ v- t) Q$ L, W  b0 k9 q+ ^/ |, k
182. 
     
183.         // Create operatorStack to store operators
     2 k" [! [; P9 t" i/ Q
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())
     6 o  Z/ l( M+ z5 \4 P1 b
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
     
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('*') ||
     " Z. i" K& c, s5 i- g5 C
199.            operatorStack.peek().equals('/')))
     8 \' f' D( b. H3 Y: ?2 \+ m
200.                 {
     - w" T8 J( w! y. e8 i
201.                     processAnOperator(operandStack, operatorStack);
     / g. X3 A- A) z) f2 ^) I' l3 ]
202.                 }
     
203.                 // Push the + or - operator into the operator stack
     
204.                 operatorStack.push(new Character(token.charAt(0)));
     : z* k- k+ v$ r- m2 C
205.             }
     ' O$ m( K2 r" u0 m% b2 h
206.             else if (token.charAt(0) == '*' || token.charAt(0) == '/')
     / @6 I/ B0 k3 b1 \6 M
207.             {
     
208.                 // Process all *, / in the top of the operator stack
     
209.                 while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
     6 J& |2 v& b* `; \+ N+ i# D
210.                 {
     , l2 e7 N2 c" v0 ]7 ^* `5 W  @
211.                     processAnOperator(operandStack, operatorStack);
     
212.                 }
     
213. 
     
214.                 // Push the * or / operator into the operator stack
     
215.                 operatorStack.push(new Character(token.charAt(0)));
     & v5 V% @* }* A7 A5 M& g! V
216.             }
     
217.             else if (token.trim().charAt(0) == '(')
     9 c1 @$ p4 `( {; L! e
218.             {
     
219.                 operatorStack.push(new Character('(')); // Push '(' to stack
     
220.             }
     . n/ C# A( z9 a/ s+ B) L1 ^/ Y
221.             else if (token.trim().charAt(0) == ')')
     
222.             {
     
223.                 // Process all the operators in the stack until seeing '('
     $ a/ Z5 V, G+ D( _4 X
224.                 while (!operatorStack.peek().equals('('))
     
225.                 {
     . A/ n/ g1 u2 Y1 V, ?; N/ m0 x
226.                      processAnOperator(operandStack, operatorStack);
     
227.                 }
     
228.                 operatorStack.pop(); // Pop the '(' symbol from the stack
     8 G) @4 ^6 w+ c) |+ w* W' |/ m9 {
229.             }
     
230.             else
     
231.             {
     , f+ w  R9 N3 d1 y
232.                 // An operand scanned
     ; O/ k  Z+ S5 e
233.                 // Push an operand to the stack
     6 f3 K, O0 n9 d4 u( i# Q2 C
234.                 operandStack.push(new Integer(token));
     
235.             }
     
236.         }
     
237. 
     
238.         // Phase 2: process all the remaining operators in the stack
     
239.         while (!operatorStack.isEmpty())
     ) d% U! R( _7 o; ?/ f" z
240.         {
     * ?: i% D2 h$ D2 G
241.             processAnOperator(operandStack, operatorStack);
     7 A; z# M8 _; S
242.         }
     
243. 
     - k1 ^; {$ F& {: H9 H0 |1 r8 `
244.         // Return the result
     6 U( A  W1 q8 `3 N  j2 p/ n7 W; w
245.         return ((Integer)(operandStack.pop())).intValue();
     
246.     }
     " T; V1 p; K/ [/ p+ L9 V+ f' S: q
247. 
     
248.     public static void processAnOperator(java.util.Stack operandStack,java.util.Stack operatorStack)
     " S( ^" f* V* Z+ }
249.     {
     % z$ }# m% D' n  L; J3 U  W
250.         if (operatorStack.peek().equals('+'))
     
251.         {
     
252.             operatorStack.pop();
     
253.             int op1 = ((Integer)(operandStack.pop())).intValue();
     4 R- I6 y- {$ I  b8 \
254.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
255.             operandStack.push(new Integer(op2 + op1));
     2 G2 n: r4 D/ z+ z
256.         }
     ; k% z) Z3 s+ d) R7 G8 {
257.         else if (operatorStack.peek().equals('-'))
     : ]% w: l" I; b/ \2 g
258.         {
     ; G* f  a3 _3 f2 |
259.             operatorStack.pop();
     
260.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
261.             int op2 = ((Integer)(operandStack.pop())).intValue();
       B0 x( v, ^9 c# y' b
262.             operandStack.push(new Integer(op2 - op1));
     
263.         }
     
264.         else if (operatorStack.peek().equals('*'))
     
265.         {
     
266.             operatorStack.pop();
     4 y( R8 U( }0 }$ o* \( A+ i
267.             int op1 = ((Integer)(operandStack.pop())).intValue();
     : g' n9 y/ `& n/ M
268.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
269.             operandStack.push(new Integer(op2 * op1));
     
270.         }
       J9 {7 C( Y$ R5 C* \, H( f' v3 w$ J
271.         else if (operatorStack.peek().equals('/'))
     7 E/ G! X; l" z- e
272.         {
     
273.             operatorStack.pop();
     
274.             int op1 = ((Integer)(operandStack.pop())).intValue();
     
275.             int op2 = ((Integer)(operandStack.pop())).intValue();
     
276.             operandStack.push(new Integer(op2 / op1));
     
277.         }
     0 W; Y" D3 A  e% E# G+ M% p
278.     }
     * {9 Q5 J4 v. v! D7 A) W' |/ y* c
279.      
     
280.     class ImagePanel extends JPanel
     
281.     {
     
282.         public void sshow()
     4 f! w# ]. B5 R! F: \- {
283.         {
     
284.             int i;
     1 b) ]% f; l3 q
285.             for(i = 0;i < 4;i++)
     
286.             {
     
287.                 card[i] = (int)(1 + Math.random() * 52);
     
288.             }
     
289.             repaint();
     
290.         }
     
291.          
     
292.         protected void paintComponent(Graphics g)
     
293.         {
     " M7 |. v" ~+ l( x. n1 J6 L2 C2 v
294.             super.paintComponent(g);
     
295.             int i;
     $ v( E3 S9 I) i7 ?/ `; t9 ?9 K
296.             int w = getWidth() / 4;
     
297.             int h = getHeight();
     3 A/ I. l( k3 M& j
298.             int x = 0;
     , C2 d3 @! W7 e" j! |  T& G
299.             int y = 0;
     
300.             for(i = 0;i < 4;i++)
     
301.             {
     
302.                 ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
     5 d$ n2 `; M7 R( u' q
303.                 Image image = imageIcon.getImage();
     $ }' x4 F7 b% u+ G
304.                 if(image != null)
     
305.                 {
     1 e$ t& o( O3 D6 w" G/ N1 K
306.                     g.drawImage(image,x,y,w,h,this);
     
307.                 }
     
308.                 x += w;
     * Z- C6 D% L4 f. k6 B+ I$ u: B
309.             }
     - n+ x$ P& u2 a
310.         }
     
311.     }
     
312. 
     . r/ b% P( ?% X1 |' O$ ^) [
313.     public static void main(String[] args)
     ! j7 q, ^8 h5 U7 m: W1 o, ?
314.     {
     
315.         TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
     
316.         frame.setTitle("24 Poke Game");
     / ?: t& U! j, l* a& |/ _; c
317.         frame.setLocationRelativeTo(null);
     2 k, r; c% W. J( v, j9 q: Y
318.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
319.         frame.setSize(368,200);
     . w! U7 _1 ?! r* f" \! S  l
320.         frame.setVisible(true);
     
321.     }
     
322. }

复制代码

1 Y- D# q( L  g% L) i0 Y

+ `4 I" m9 i/ D1 ~" b5 d1 N0 `


" Y2 ?! @0 D9 ^/ |+ w/ ]9 h
, j/ e, [( q4 z2 T$ b. q

java宫城大师

学习一下。谢谢