24点游戏

问题描述

随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。

---

一、流程图

分析

用穷举法列出四个数加上三个运算符号所构成的表达式所有可能的结果，或 实现一个简单的计算器判断用户的输入是否正确（

---

源代码

public class Main {
    public static void main(String[] args) {
        int number[]=new int[4];//定义一个数组，用于存放输入的4个数
        input getNum=new input();
        deal a=new deal();
        getNum.getNumber(number);
        a.ji(number);
    }
}

import java.util.Random;

public class input {
    public void getNumber(int []number) {
        //友好输出，提示用户输入4个数
        Random random=new Random();
        int i = 0;
        while (i < number.length) {
            number[i] = random.nextInt(13)+1;
                i++;
            }
        System.out.print("随机生成的数为:");
        for (int j=0;j<number.length;j++){
        System.out.println(number[j]);}
        }
    public int Operator(int num1, int num2, char operator){
        //创建函数，用于数据的运算
        if (operator == '+') {
            return num1 + num2;
        }
        else if (operator == '-') {
            return num1 - num2;
        }
        else if (operator == '*') {
            return num1 * num2;
        }
        else if ((operator == '/' )&& (num2 != 0) && (num1%num2==0)) {
            return num1 / num2;
        }
        else {
            return -1;
        }
    }
}

import java.util.TreeSet;

public class deal{
    static boolean flag=false;
    public void ji(int []number){
        TreeSet list=new TreeSet();                 //将输入的数转换为树，目的在于判断数组内重复的数
        for (int i=0;i<number.length;i++){
            list.add(number[i]);
        }
        //当4个数完全不同时，共有24种排序
        if (list.size()==4){
            jisuan(number[0],number[1],number[2],number[3]);
            jisuan(number[0],number[1],number[3],number[2]);
            jisuan(number[0],number[2],number[1],number[3]);
            jisuan(number[0],number[2],number[3],number[1]);
            jisuan(number[0],number[3],number[1],number[2]);
            jisuan(number[0],number[3],number[2],number[1]);
            jisuan(number[1],number[0],number[2],number[3]);
            jisuan(number[1],number[0],number[3],number[2]);
            jisuan(number[1],number[2],number[3],number[0]);
            jisuan(number[1],number[2],number[0],number[3]);
            jisuan(number[1],number[3],number[0],number[2]);
            jisuan(number[1],number[3],number[2],number[0]);
            jisuan(number[2],number[0],number[1],number[3]);
            jisuan(number[2],number[0],number[3],number[1]);
            jisuan(number[2],number[1],number[0],number[3]);
            jisuan(number[2],number[1],number[3],number[0]);
            jisuan(number[2],number[3],number[0],number[1]);
            jisuan(number[2],number[3],number[1],number[0]);
            jisuan(number[3],number[0],number[1],number[2]);
            jisuan(number[3],number[0],number[2],number[1]);
            jisuan(number[3],number[1],number[0],number[2]);
            jisuan(number[3],number[1],number[2],number[0]);
            jisuan(number[3],number[2],number[0],number[1]);
            jisuan(number[3],number[2],number[1],number[0]);
        }
        if (list.size()==3){
            //当有2个数完全相同时，共有12种排序
            for (int i=0;i<number.length-1;i++){
                for (int j=i+1;j<number.length;j++){
                    if (number[i]==number[j]){
                        int a,b;
                        a=number[i];
                        number[i]=number[2];
                        number[2]=a;
                        b=number[j];
                        number[j]=number[3];
                        number[3]=b;
                    }
                }
            }
            jisuan(number[0],number[1],number[2],number[2]);
            jisuan(number[0],number[2],number[1],number[2]);
            jisuan(number[0],number[2],number[2],number[1]);
            jisuan(number[1],number[0],number[2],number[2]);
            jisuan(number[1],number[2],number[0],number[2]);
            jisuan(number[1],number[2],number[2],number[0]);
            jisuan(number[2],number[2],number[0],number[1]);
            jisuan(number[2],number[2],number[1],number[0]);
            jisuan(number[2],number[1],number[2],number[0]);
            jisuan(number[2],number[0],number[2],number[1]);
            jisuan(number[2],number[0],number[1],number[2]);
            jisuan(number[2],number[1],number[0],number[2]);
        }
        if (list.size()==2){
            //当有2个数重复时，我们每种有3种排列顺序
            if (number[0]==number[1]&&number[2]==number[3]){
                jisuan(number[0],number[0],number[2],number[2]);
                jisuan(number[0],number[2],number[0],number[2]);
                jisuan(number[0],number[2],number[2],number[0]);
                jisuan(number[2],number[2],number[0],number[0]);
                jisuan(number[2],number[0],number[2],number[0]);
                jisuan(number[2],number[0],number[0],number[2]);
            }
            if (number[0]==number[2]&&number[1]==number[3]){
                jisuan(number[0],number[0],number[1],number[1]);
                jisuan(number[0],number[1],number[0],number[1]);
                jisuan(number[0],number[1],number[1],number[0]);
                jisuan(number[1],number[1],number[0],number[0]);
                jisuan(number[1],number[0],number[1],number[0]);
                jisuan(number[1],number[0],number[0],number[1]);
            }
            if (number[0]==number[3]&&number[1]==number[2]){
                jisuan(number[0],number[0],number[1],number[1]);
                jisuan(number[0],number[1],number[0],number[1]);
                jisuan(number[0],number[1],number[1],number[0]);
                jisuan(number[1],number[1],number[0],number[0]);
                jisuan(number[1],number[0],number[1],number[0]);
                jisuan(number[1],number[0],number[0],number[1]);
            }
            if(number[0]==number[1]&&number[1]==number[2]){
                jisuan(number[3],number[0],number[0],number[0]);
                jisuan(number[0],number[3],number[0],number[0]);
                jisuan(number[0],number[0],number[3],number[0]);
                jisuan(number[0],number[0],number[0],number[3]);
            }
            if(number[0]==number[1]&&number[1]!=number[2]){
                jisuan(number[2],number[0],number[0],number[0]);
                jisuan(number[0],number[2],number[0],number[0]);
                jisuan(number[0],number[0],number[2],number[0]);
                jisuan(number[0],number[0],number[0],number[2]);
            }
            if(number[0]!=number[1]&&number[1]==number[2]){
                jisuan(number[0],number[1],number[1],number[1]);
                jisuan(number[1],number[0],number[1],number[1]);
                jisuan(number[1],number[1],number[0],number[1]);
                jisuan(number[1],number[1],number[1],number[0]);
            }
            if(number[0]!=number[1]&&number[1]!=number[2]){
                jisuan(number[1],number[0],number[0],number[0]);
                jisuan(number[0],number[1],number[0],number[0]);
                jisuan(number[0],number[0],number[1],number[0]);
                jisuan(number[0],number[0],number[0],number[1]);
            }
        }
        if (list.size()==1){
            //当4个数相同时只要有一种排列 顺序
            jisuan(number[0], number[0],number[0],number[0]);
        }
        if (flag ==false ){
            System.out.println("该组合无法算出24");
        }
    }
    public static boolean jisuan(int num1, int num2, int num3, int num4) {
        input in = new input();
        char[] operator = {'+', '-', '*', '/'};
        for (int i = 0; i < 4; i++) {
            //第1次计算，先从四个数中任意选择两个进行计算
            char operator1 = operator[i];
            int firstResult = in.Operator(num1, num2, operator1);//先选第一，和第二个数进行计算
            int midResult = in.Operator(num2, num3, operator1);//先选第二和第三两个数进行计算
            int tailResult = in.Operator(num3, num4, operator1);//先选第三和第四俩个数进行计算
            for (int j = 0; j < 4; j++) {
                //第2次计算，从上次计算的结果继续执行，这次从三个数中选择两个进行计算
                char operator2 = operator[j];
                int firstMidResult = in.Operator(firstResult, num3, operator2);
                int firstTailResult = in.Operator(num3, num4, operator2);
                int midFirstResult = in.Operator(num1, midResult, operator2);
                int midTailResult = in.Operator(midResult, num4, operator2);
                int tailMidResult = in.Operator(num2, tailResult, operator2);
                for (int k = 0; k < 4; k++) {
                    //第3次计算，也是最后1次计算，计算两个数的结果，如果是24则输出表达式
                    char operator3 = operator[k];
                    if (in.Operator(firstMidResult, num4, operator3) == 24) {
                        System.out.println("((" + num1 + operator1 + num2 + ")" + operator2 + num3 + ")" + operator3 + num4);
                        flag=true;
                    }
                    if (in.Operator(firstResult, firstTailResult, operator3) == 24) {
                        flag=true;;
                        System.out.println("(" + num1 + operator1 + num2 + ")" + operator3 + "(" + num3 + operator2 + num4 + ")");
                    }
                    if (in.Operator(midFirstResult, num4, operator3) == 24) {
                        flag=true;
                        System.out.println("(" + num1 + operator2 + "(" + num2 + operator1 + num3 + "))" + operator3 + num4);
                    }
                    if (in.Operator(num1, midTailResult, operator3) == 24) {
                        flag=true;
                        System.out.println(" " + num1 + operator3 + "((" + num2 + operator1 + num3 + ")" + operator2 + num4 + ")");
                    }
                    if (in.Operator(num1, tailMidResult, operator3) == 24) {
                        flag=true;
                        System.out.println(" " + num1 + operator3 + "(" + num2 + operator2 + "(" + num3 + operator1 + num4 + "))");
                    }
                }
            }
        }
        return flag;
    }
}