java实现24点

一．题目分析

从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。

1.基本要求：

随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。
1.程序风格良好(使用自定义注释模板)
2.列出表达式无重复。

2. 提高要求：

用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运算表达式（可包含括号），如果表达式计算结果为24则代表用户赢了此局。
1. 程序风格良好(使用自定义注释模板)
2.使用计时器要求用户在规定时间内输入表达式，如果规定时间内运算正确则加分，超时或运算错误则进入下一题并减少生命值（不扣分）。
3.所有成绩均可记录在TopList.txt文件中。

二. 关键算法构造

1. 基本要求
   一般24点均采用降维的方法来实现，所谓降维就是将原本四个数的计算通过递归的方式变成两两计算，即将前两个数的运算结果当做下一步计算的数据，以达到求表达式结果的目的。而表达式的去重则涉及到Java 中集合的应用即通过HashSet踢除重复元素。生成（calculateSet）来存放所有表达式，使用calculateSet.add(filterCalculate(t.getCul_str()))来实现集合元素的去重。
   此代码即集合去重的基本思想

2. 提高要求
   为实现表达式24点的判断，采用双栈操作将操作符及运算数据分别入栈，无视左括号，当遇到右括号时，根据表达式从操作符栈中取出操作符，并从操作数栈中取出相应的操作数进行计算，并将计算结果压入操作数栈。在压栈操作完成后，取出栈顶元素，即表达式的运算结果。
   如(1 + ( ( 2 + 3 ) * ( 4 * 5 ) ) )的双栈算法演示
   
   为了实现在输入的同时倒计时的目的，程序必须采用多线程，上周刚接触到 Java多线程，想到自己写一个线程可能会出现问题，于是想有没有现成的Java类来实现倒计时功能，而Java中Timer 和 Timertask 就可以实现这样的功能。

   三. 程序实现

import java.util.Date;//统计用时
import java.util.Random;

import java.util.ArrayList;
import java.util.Arrays;

import java.util.HashSet;
 
import java.util.List;
import java.util.Set;
 
public class pointGame {
    static List<Node> result = new ArrayList<Node>();    //实例化集合对象，用来存放结果
    static Set<String> calculateSet = new HashSet<String>();//表达式放入集合并去重
    public static void main(String[] args) {
        Date now = new Date();
        int[] values = new int[4];//存放随机数
        Random random = new Random();
        for(int i=0;i<4;i++)//生成随机数
        {
        	int x=random.nextInt(13)+1;
        	values[i]=x;
        }
        System.out.println(Arrays.toString(values)); //打印随机数组
        traverse(values); 
        System.out.println("共耗时: "+(System.currentTimeMillis()-now.getTime())+" 毫秒");//当前时间减去程序开始运行时间
    }
    
    public static void traverse(int[] a){
        if(a.length!=4){
            System.out.println("不得多于或少于4个数");
            return;
        }
        Double[] dArrays = new Double[4];
        dArrays[0] = a[0]+0D;
        dArrays[1] = a[1]+0D;
        dArrays[2] = a[2]+0D;
        dArrays[3] = a[3]+0D;
        List<Node> headerList = null;//初始化集合
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if(j==i){
                    continue;
                }
                for(int k=0;k<4;k++){
                    if(k==i || k==j){
                        continue;
                    }
                    headerList = createHeaderList(dArrays[i],dArrays[j]);
                    List<Node> chooseThreeNum = null;
                    for(Node t:headerList){
                        chooseThreeNum = chooseThreeOrFourNum(t, dArrays[k]);
                        List<Node> chooseFourNum = null;
                        for(Node temp:chooseThreeNum ){
                            chooseFourNum = chooseThreeOrFourNum(temp,dArrays[6-(i+j+k)]);
                            pickNode(chooseFourNum);
                        }
                    }
                }
            }
        }
        getAllCalculate();
        if(calculateSet.size()>0){
            display();
        }      
    }
    
    private static void display(){
        System.out.println("共有解:"+calculateSet.size()+"个,具体如下:");
        for(String s:calculateSet){
            System.out.println(s+" = 24");
        }
    }
    
    private static void getAllCalculate(){
        if(result.size()<1){
            System.out.println("抱歉，没有解");
        }
        Node second = null;
        Node first = null;
        for(Node t:result){
            second = t.getPre_node();
            first = second.getPre_node();
            if(second.get_a().doubleValue()==first.getValue().doubleValue()){
                second.setA_cul_str(first.getCul_str());              
            }else{
                second.setB_cul_str(first.getCul_str());    
            }
            second.doCalculate();
            
            if(t.get_a().doubleValue()==second.getValue().doubleValue()){
                t.setA_cul_str(second.getCul_str());              
            }else{
                t.setB_cul_str(second.getCul_str());    
            }
            t.doCalculate();
            calculateSet.add(filterCalculate(t.getCul_str()));
            
        }
    }
    
    private static String filterCalculate(String str){
        str = str.substring(1, str.length()-1);
        str = str.replace(".0", "");
        str = str.replace("*", "×");
        str = str.replace("/", "÷");
        return str;
    }
    
    private static void pickNode(List<Node> list){
        for(Node t : list){
            if(judge24(t.getValue())){
                result.add(t);//result 集合添加符合24点的表达式
            }
        }
    }
    
    private static boolean judge24(Double d){//判断表达式结果
        if(Math.abs(d.doubleValue()-24)<=0.000001){
            return true;
        }
        return false;
        
    }
    private static List<Node> chooseThreeOrFourNum(Node t,Double b){
        List<Node> result = new ArrayList<Node>();
        Double a = t.getValue();
        Node n1 = new Node(a,b,'+');
        Node n2 = new Node(a,b,'-');
        Node n3 = new Node(a,b,'-',true);//a-b 或 a*b 结果与顺序相关
        Node n4 = new Node(a,b,'*');
        Node n5 = new Node(a,b,'/');
        Node n6 = new Node(a,b,'/',true);
        n1.doCalculate();
        n2.doCalculate();
        n3.doCalculate();
        n4.doCalculate();
        n5.doCalculate();
        n6.doCalculate();
        insertNode(n1,result);
        insertNode(n2,result);
        insertNode(n3,result);
        insertNode(n4,result);
        insertNode(n5,result);
        insertNode(n6,result);
        n1.setPre_node(t);
        n2.setPre_node(t);
        n3.setPre_node(t);
        n4.setPre_node(t);
        n5.setPre_node(t);
        n6.setPre_node(t);    
        return result;
    }
    
    private static List<Node> createHeaderList(Double a,Double b){
        List<Node> result = new ArrayList<Node>();
        Node n1 = new Node(a,b,'+');
        Node n2 = new Node(a,b,'-');
        Node n3 = new Node(a,b,'-',true);
        Node n4 = new Node(a,b,'*');
        Node n5 = new Node(a,b,'/');
        Node n6 = new Node(a,b,'/',true);
        n1.doCalculate();
        n2.doCalculate();
        n3.doCalculate();
        n4.doCalculate();
        n5.doCalculate();
        n6.doCalculate();
        insertNode(n1,result);
        insertNode(n2,result);
        insertNode(n3,result);
        insertNode(n4,result);
        insertNode(n5,result);
        insertNode(n6,result);
        return result;
    }
    
    
    private static void insertNode(Node p,List<Node> list){
        if(p.getValue()!=null){
            list.add(p);
        }
    }
    
}
 
class Node {
    Double _a;
    Double _b;
    char opr;
    Double value;
    boolean is_rev_order;
    String a_cul_str;//_a的算式
    String b_cul_str;//_b的算式
    String cul_str;//自身的算式
    /**
     * 实例化Node 对象
     */
    Node pre_node;
    Node next_branch1;
    Node next_branch2;
    Node next_branch3;
    Node next_branch4;
    Node next_branch5;
    Node next_branch6;
 
    public Node(Double a, Double b, char opr) {
        this._a = a;
        this._b = b;
        this.opr = opr;
        this.a_cul_str = Double.toString(_a);
        this.b_cul_str = Double.toString(_b);
    }
 
    public Node(Double a, Double b, char opr, boolean is_rev_order) {
        this._a = a;
        this._b = b;
        this.opr = opr;
        this.is_rev_order = is_rev_order;
        this.a_cul_str = Double.toString(_a);
        this.b_cul_str = Double.toString(_b);
    }
 
    public Double getValue(){//获得随机数
        return value;
    }
    
    
    /**
         *计算数学表达式
         *对操作符进行数据间插入
         *递归实现将两个数的运算继续参与运算   
         * */
    public void doCalculate(){
        switch(opr){
        case '+':
            cul_str = "("+a_cul_str+"+"+b_cul_str+")";
            value = _a+_b;
            break;
        case '-':
            if(is_rev_order){//是生成数据顺序
                cul_str = "("+b_cul_str+"-"+a_cul_str+")";
                value = _b-_a;
            }else{
                cul_str = "("+a_cul_str+"-"+b_cul_str+")";
                value = _a-_b;
            }
            break;
        case '*':
            cul_str = "("+a_cul_str+"*"+b_cul_str+")";
            value = _a*_b;
            break;
        case '/':
            if(is_rev_order){
                if(_a!=0){
                    cul_str = "("+b_cul_str+"/"+a_cul_str+")";
                    value = _b/_a;
                }
               
            }else{
                if(_b!=0){
                    cul_str = "("+a_cul_str+"/"+b_cul_str+")";
                    value = _a/_b;
                }
            }
            break;
        }
    }
    
    public Double get_a() {
        return _a;
    }
 
    public void set_a(Double _a) {
        this._a = _a;
    }
 
    public Double get_b() {
        return _b;
    }
 
    public void set_b(Double _b) {
        this._b = _b;
    }
 
    public String getA_cul_str() {
        return a_cul_str;
    }
 
    public void setA_cul_str(String a_cul_str) {
        this.a_cul_str = a_cul_str;
    }
 
    public String getB_cul_str() {
        return b_cul_str;
    }
 
    public void setB_cul_str(String b_cul_str) {
        this.b_cul_str = b_cul_str;
    }
 
    public String getCul_str() {//获得计算后的值
        return cul_str;
    }
 
    public void setCul_str(String cul_str) {
        this.cul_str = cul_str;
    }
 
    public Node getPre_node() {
        return pre_node;
    }
 
    public void setPre_node(Node pre_node) {
        this.pre_node = pre_node;
    }
 
    public Node getNext_branch1() {
        return next_branch1;
    }
 
    public void setNext_branch1(Node next_branch1) {
        this.next_branch1 = next_branch1;
    }
 
    public Node getNext_branch2() {
        return next_branch2;
    }
 
    public void setNext_branch2(Node next_branch2) {
        this.next_branch2 = next_branch2;
    }
 
    public Node getNext_branch3() {
        return next_branch3;
    }
 
    public void setNext_branch3(Node next_branch3) {
        this.next_branch3 = next_branch3;
    }
 
    public Node getNext_branch4() {
        return next_branch4;
    }
 
    public void setNext_branch4(Node next_branch4) {
        this.next_branch4 = next_branch4;
    }
 
    public Node getNext_branch5() {
        return next_branch5;
    }
 
    public void setNext_branch5(Node next_branch5) {
        this.next_branch5 = next_branch5;
    }
 
    public Node getNext_branch6() {
        return next_branch6;
    }
 
    public void setNext_branch6(Node next_branch6) {
        this.next_branch6 = next_branch6;
    }
 
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.Timer;
import java.util.TimerTask;

public class User_point {
	static boolean flag = true;//该变量标识是否超时
	static int life = 3;//初始化生命值
	static int score=0;//初始化分数
	
	    public static void main(String[] args)  throws IOException{
	    	start();//start 函数作函数入口
	    }

	    public static Double calculate (String str) {

	        //创建操作符栈
	        Stack<Character> ops = new Stack<>();
	        //创建操作数栈
	        Stack<Double> nums = new Stack<>();
	        for (int i = 0 ; i < str.length(); i++) {
	            char s = str.charAt(i);
	            switch (s) {
	                //无视左括号
	                case '(':
	                    break;
	                // +.-.*./ 这些操作符都压入栈
	                case '+':
	                    ops.push(s);
	                    break;
	                case '-':
	                    ops.push(s);
	                    break;
	                case '*':
	                    ops.push(s);
	                    break;
	                case '/':
	                    ops.push(s);
	                    break;
	                case ')':
	                    //遇到右括号时，根据从操作符栈中取出操作符，并从操作数栈中取出相应都操作数进行计算，并将计算结果压入操作数栈
	                    char op = ops.pop();
	                    Double num = nums.pop();
	                    switch (op) {
	                        case '+':
	                            num = num + nums.pop();
	                            break;
	                        case '-':
	                            num = num - nums.pop();
	                            break;
	                        case '*':
	                            num = num * nums.pop();
	                            break;
	                        case '/':
	                            num = num / nums.pop();
	                            break;
	                    }
	                    nums.push(num);
	                    break;
	                default:
	                    nums.push(Double.parseDouble(Character.toString(s)));
	                    break;
	            }
	        }
	        return nums.pop();//栈顶元素
	    }
	    
    
	
	
	public  static int[] set_num()
	{   
		int number[] = new int[4];
		Random random = new Random();
		
		for(int i=0;i<4;i++)
		{int x=random.nextInt(13)+1;
    	number[i]=x;
    	}
		
		return number;
	}
	//考虑异常处理
	public  static void start() throws IOException {
		Calendar date = Calendar.getInstance();//实例化Calendar对象，工厂方法
		while(life>0) {//当生命值大于0才会进行
			flag=true;//初始化分数标记
			/**
			 * 在60秒内输入表达式，超时将 flag 的值 变为 false ，在answer 中分支进入‘2’, 
			 */
			date.setTime(new Date()); // 重置 Calendar 显示当前时间

			date.add(Calendar.SECOND,60);//设置限定时间
			
			Timer timer = new Timer();
			//当达到限定时间将会执行run()方法,即把全局变量flag变为false
			timer.schedule(new RemindTask(), date.getTime());
			int answer = answer();
			switch(answer) {
			case -1:
				System.out.println("表达式错误！！    当前生命值为"+life+" 分数为："+score);
				break;
			case -2:
				System.out.println("输入超时！！    当前生命值为"+life+" 分数为："+score);
				break;
			case -3:
				System.out.println("结果错误！！    当前生命值为"+life+" 分数为："+score);
				break;
			case 1:	
				System.out.println("正确,得到1分奖励！！    当前生命值为"+life+" 分数为："+score);
				break;
			}
			System.out.println("-------------------------------------------------------------");
		}
		System.out.println("游戏结束……分数为: "+score);//循环结束也就是生命值为0,打印游戏结束
		saveScore(score);//将玩家当前分数存入文件
		return;
	} 
	/**
	 * 文件操作,将玩家最后得分存入e:/TopList.txt
	 */
	public static void saveScore(int score) throws IOException {
		FileOutputStream fos = new FileOutputStream("e:/TopList.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		bos.write((score+"").getBytes());//把分数写入文件
		bos.close();
		
	}
	/**
	 * 表达式正确性及时间处理函数
	 */
	public static int answer() {
		int[] number = set_num();
		System.out.println("                           "+Arrays.toString(number)+"                       "); //打印随机数组	
		System.out.println("------------------------------开始作答-----------------------------------");
		System.out.println("-------请在一分钟内输入您的24点表达式并将其括号化，（否则凉凉了呀）---------");
		Scanner sc= new Scanner(System.in);
	    String s = sc.nextLine();
	   
		
		try {
			for (int i = 0; i < number.length; i++)
				if (!s.contains(number[i] + "")) {//输入的表达式不含给定的值
					life--;
					return -1;
				}
			if(!flag) {//判断超时
				life--;
				return -2;
			}
			if (calculate(s)==24.0){//玩家表达式调用双栈运算
				score++;//分数加一
				return 1;
			}
			else life--;
			
		} catch (Exception e) {
			
			System.out.println("表达式输入不合法");
		}
		
		return -3;

	}

	
	}
class RemindTask extends TimerTask {  //TimerTask 类多线程计算从开始输入表达式倒计时

	@Override
	public void run() {//重写父类run方法
		User_point.flag = false;//当超时会把全局变量flag变为false
	}

}

四. 测试截图

基础要求

提高要求

五．个人总结

刚拿到题目时无从下手，由于对递归掌握的不是很好，所以也就没能想到利用降维的方法来解决问题，在网上看了很多很多算法后，才对这种递归降维的方法有了一定的认识，解决了问题。因为之前学习Java过程中关于集合的部分还未涉及，表达式去重也就变得相对困难，看了Java的集合部分后，才找到解决问题的办法——hashset。在提高要求的完成部分，解决表达式求值成了关键问题，这让我意识到学好数据结构的重要性，虽然有些算法的使用频率相对较低，但当使用的时候确实可以发挥奇效。还有一个问题是双栈算法尽管可以求值但需要将用户输入的表达式完全括号化，否则就会出现结果偏差，相较于这种算法，中缀表达式转后缀表达式的算法就更人性化一些，这也是本次程序设计还需完善的地方。

打赏