24点扑克牌游戏——（含java源码）（GUI实现）
给出四个数字，要求，在其间添加运算符和括号，使得计算结果等于24。
括号的放置即为决定哪几个数先进行计算。所以，我们先确定首先进行计算的两个相邻的数，计算完成后，就相当于剩下三个数字，仍需要在它们之间添加符号；然后再决定在这三个数中哪两个相邻的数先计算。由此，我们就成功解决了数字的运算次序问题，此时不需要再考虑不同运算符号的优先级问题，因为括号的优先级高于加减乘除。
通过循环，我们可以得到第一第二第三次计算的运算符，再通过计算，就可以得出和，若和等于24，即为所求解。
在输出格式中，由于括号的放置共六种情况，故根据计算先后顺序的不同，输出时在不同地方放置括号；
以下是java源码：
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.JOptionPane;
public class TwentyFourPoke_Game extends JFrame
{
private JButton jbsolution = new JButton("Find a Solution");
private JButton jbrefresh = new JButton("Refresh");
private JButton jbverify = new JButton("Verify");
private JLabel jlmessage = new JLabel("Enter an expression:");
private JTextField jtsolution = new JTextField();
private JTextField jtexpression = new JTextField();
private ImagePanel pp = new ImagePanel();
private int[] card = new int[4];
private double[] bcard = new double[4];
private double sum;
private double[] temp1 = new double[3];
private double[] temp2 = new double[2];
private char[] sign = {'+','-','*','/'};
public TwentyFourPoke_Game()
{
JPanel p1 = new JPanel(new GridLayout(1,3));
p1.add(jbsolution);
p1.add(jtsolution);
p1.add(jbrefresh);
JPanel p3 = new JPanel(new GridLayout(1,3));
p3.add(jlmessage);
p3.add(jtexpression);
p3.add(jbverify);
add(p1,BorderLayout.NORTH);
add(pp,BorderLayout.CENTER);
add(p3,BorderLayout.SOUTH);
ButtonListener listener = new ButtonListener();
jbsolution.addActionListener(listener);
jbrefresh.addActionListener(listener);
jbverify.addActionListener(listener);
}
class ButtonListener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == jbsolution)
{
for(int i = 0;i < 4;i++)
{
bcard[i] = (double)card[i] % 13;
if(card[i] % 13 == 0)
bcard[i] = 13;
}
search();
}
else if(e.getSource() == jbrefresh)
{
pp.sshow();
}
else if(e.getSource() == jbverify)
{
String expression = jtexpression.getText();
int result = evaluateExpression(expression);
if(result == 24)
{
JOptionPane.showMessageDialog(null,"恭喜你！你答对了！","消息框",JOptionPane.INFORMATION_MESSAGE);
}
else
{
JOptionPane.showMessageDialog(null,"抱歉！请再次尝试。","消息框",JOptionPane.INFORMATION_MESSAGE);
}
}
}
}
public static double calcute(double a,double b,char c)
{
if(c == '+')
return a+b;
else if(c == '-')
return a-b;
else if(c == '*')
return a*b;
else if(c == '/' && b != 0)
return a/b;
else
return -1;
}
public void search()
{
boolean judge = false;
for(int i=0;i<4;i++)
//第一次放置的符号
{
for(int j=0;j<4;j++)
//第二次放置的符号
{
for(int k=0;k<4;k++)
//第三次放置的符号
{
for(int m=0;m<3;m++)
//首先计算的两个相邻数字，共有3种情况，相当于括号的作用
{
if(bcard[m+1]==0 && sign[i]=='/') break;
temp1[m]=calcute(bcard[m],bcard[m+1],sign[i]);
temp1[(m+1)%3]=bcard[(m+2)%4];
temp1[(m+2)%3]=bcard[(m+3)%4];
//先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中
for(int n=0;n<2;n++)
//三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号
{
if(temp1[n+1]==0 && sign[j]=='/') break;
temp2[n]=calcute(temp1[n],temp1[n+1],sign[j]);
temp2[(n+1)%2]=temp1[(n+2)%3];
//先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中
if(temp2[1]==0 && sign[k]=='/') break;
sum=calcute(temp2[0],temp2[1],sign[k]);
//计算和
if(sum==24)
//若和为24
{
judge=true;
//判断符为1，表示已求得解
if(m==0 && n==0)
{
String sss ="(("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[j]+(int)bcard[2]+")"+sign[k]+(int)bcard[3]+"="+(int)sum;
jtsolution.setText(sss);
return ;
}
else if(m==0 && n==1)
{
String sss ="("+(int)bcard[0]+sign[i]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[j]+(int)bcard[3]+")="+(int)sum;
jtsolution.setText(sss);
return ;
}
else if(m==1 && n==0)
{
String sss ="("+(int)bcard[0]+sign[j]+"("+(int)bcard[1]+sign[i]+(int)bcard[2]+"))"+sign[k]+(int)bcard[3]+"="+(int)sum;
jtsolution.setText(sss);
return ;
}
else if(m==2 && n==0)
{
String sss ="("+(int)bcard[0]+sign[j]+(int)bcard[1]+")"+sign[k]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+")="+(int)sum;
jtsolution.setText(sss);
return ;
}
else if(m==2 && n==0)
{
String sss =(int)bcard[0]+sign[k]+"("+(int)bcard[1]+sign[j]+"("+(int)bcard[2]+sign[i]+(int)bcard[3]+"))="+(int)sum;
jtsolution.setText(sss);
return ;
}
//m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式
}
}
}
}
}
}
if(judge==false)
jtsolution.setText("No solution!");
//如果没有找到结果，符号位为0
}
public static int evaluateExpression(String expression)
{
// Create operandStack to store operands
java.util.Stack<Integer> operandStack = new java.util.Stack<Integer>();
// Create operatorStack to store operators
java.util.Stack<Character> operatorStack = new java.util.Stack<Character>();
// Extract operands and operators
java.util.StringTokenizer tokens = new java.util.StringTokenizer(expression, "()+-/*", true);
// Phase 1: Scan tokens
while (tokens.hasMoreTokens())
{
String token = tokens.nextToken().trim(); // Extract a token
if (token.length() == 0) // Blank space
continue; // Back to the while loop to extract the next token
else if (token.charAt(0) == '+' || token.charAt(0) == '-')
{
// Process all +, -, *, / in the top of the operator stack
while (!operatorStack.isEmpty() &&(operatorStack.peek().equals('+') ||operatorStack.peek().equals('-') || operatorStack.peek().equals('*') ||
operatorStack.peek().equals('/')))
{
processAnOperator(operandStack, operatorStack);
}
// Push the + or - operator into the operator stack
operatorStack.push(new Character(token.charAt(0)));
}
else if (token.charAt(0) == '*' || token.charAt(0) == '/')
{
// Process all *, / in the top of the operator stack
while (!operatorStack.isEmpty() && (operatorStack.peek().equals('*') || operatorStack.peek().equals('/')))
{
processAnOperator(operandStack, operatorStack);
}
// Push the * or / operator into the operator stack
operatorStack.push(new Character(token.charAt(0)));
}
else if (token.trim().charAt(0) == '(')
{
operatorStack.push(new Character('(')); // Push '(' to stack
}
else if (token.trim().charAt(0) == ')')
{
// Process all the operators in the stack until seeing '('
while (!operatorStack.peek().equals('('))
{
processAnOperator(operandStack, operatorStack);
}
operatorStack.pop(); // Pop the '(' symbol from the stack
}
else
{
// An operand scanned
// Push an operand to the stack
operandStack.push(new Integer(token));
}
}
// Phase 2: process all the remaining operators in the stack
while (!operatorStack.isEmpty())
{
processAnOperator(operandStack, operatorStack);
}
// Return the result
return ((Integer)(operandStack.pop())).intValue();
}
public static void processAnOperator(java.util.Stack<Integer> operandStack,java.util.Stack<Character> operatorStack)
{
if (operatorStack.peek().equals('+'))
{
operatorStack.pop();
int op1 = ((Integer)(operandStack.pop())).intValue();
int op2 = ((Integer)(operandStack.pop())).intValue();
operandStack.push(new Integer(op2 + op1));
}
else if (operatorStack.peek().equals('-'))
{
operatorStack.pop();
int op1 = ((Integer)(operandStack.pop())).intValue();
int op2 = ((Integer)(operandStack.pop())).intValue();
operandStack.push(new Integer(op2 - op1));
}
else if (operatorStack.peek().equals('*'))
{
operatorStack.pop();
int op1 = ((Integer)(operandStack.pop())).intValue();
int op2 = ((Integer)(operandStack.pop())).intValue();
operandStack.push(new Integer(op2 * op1));
}
else if (operatorStack.peek().equals('/'))
{
operatorStack.pop();
int op1 = ((Integer)(operandStack.pop())).intValue();
int op2 = ((Integer)(operandStack.pop())).intValue();
operandStack.push(new Integer(op2 / op1));
}
}
class ImagePanel extends JPanel
{
public void sshow()
{
int i;
for(i = 0;i < 4;i++)
{
card[i] = (int)(1 + Math.random() * 52);
}
repaint();
}
protected void paintComponent(Graphics g)
{
super.paintComponent(g);
int i;
int w = getWidth() / 4;
int h = getHeight();
int x = 0;
int y = 0;
for(i = 0;i < 4;i++)
{
ImageIcon imageIcon = new ImageIcon("image/card/" + card[i] + ".png");
Image image = imageIcon.getImage();
if(image != null)
{
g.drawImage(image,x,y,w,h,this);
}
x += w;
}
}
}
public static void main(String[] args)
{
TwentyFourPoke_Game frame = new TwentyFourPoke_Game();
frame.setTitle("24 Poke Game");
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(368,200);
frame.setVisible(true);
}
}
