24点游戏--java打开方式

首先呢，为那些不知道24点游戏的盆友们介绍一下24点游戏的游戏规则：

对于给出的4个数字进行四种运算（最基础的加减乘除）最终得到运算结果是24的时候就算游戏通关（每个给出的数字都要用到，且数字不可以重复使用）。

 

当然，对于简单的问题跟着感觉就可以快速解答出来，但是对于难度稍大的题，想出一种方法都要费些时间，更别说解出所有的运算方法。于是呢，最近刚刚Java入门的我来了点尝试，写了个程序，bug找的深夜的我最后还是搞定了这个程序，好不容易创作的处女之作当然要在这里稍微秀一秀full mark的cw就不算咯，当然了还是为了分享下自己的成果，计算机的大神们不要嘲笑，身为应数狗的我（初二才会下游戏）也是不容易的。。。。

 

废话少说，先简单的说一下大概程序算法：

为了找到所有正确的运算方法，当然要首先找到所有可能的运算方法，基于这个简单的思路，整个编程过程包括三次运算，数字的个数由4到2一次递减，当然运算的可能性也是依次递增。在这里我给个例子：  对于12 6 9 11 （四个数）首先固定12和6 ，对11 和9进行四种最基本的运算方式得到至少三种的的运算可能（结果为整且为正）2 20 99 那么接下来四个数字演变成12 6 2，12 6 20，12 6 99三个数组，然后对刚刚的得到的三个数组（三个数）分别运算，在这里举例数组12
6 2，固定12 对6和2进行运算，得到 4 8 12 3，就得到了四个新的数组（两个数）12 4，12 8，12 12，12 3，接着对这三个数组进行运算，举例 12 12，12+12=24 最终得到希望的答案。

以上大概就程序的简单思路，处女之code紧跟着来：

package piont24;

import java.util.ArrayList;

import java.util.Scanner;

//created for storing data

class base01 {

    double Z;

    double x;

    double y;

    //caculation01 is for storing the caculation procedure

    String caculation01;

    base01(double x, double y, double z, String caculation01) {

        super();

        this.x = x;

        this.y = y;

        //Z is for storing the result of the caculation.

        this.Z = z;

        this.caculation01 = caculation01;

    }

}

//created for storing data

class base02 {

    double sum;

    double left;

    //caculation02 is for storing the caculation procedure

    String caculation02;

    String caculationOFleft;

    base02(double sum, double left, String caculation02, String caculationOFleft) {

        super();

        //sum is for storing the result of the caculation.

        this.sum = sum;

        this.left = left;

        this.caculation02 = caculation02;

        this.caculationOFleft = caculationOFleft;

    }

}

public class Piont24 {

    static Scanner kb = new Scanner(System.in);

    // game start, input number first for getting the answer

    public static void main(String[] args) {

        System.out.println("Please, input the four numbers for 24 piont game: ");

        String data = kb.nextLine();

        PotionGame(data);

    }

    // first procedure for finding the suitable caculation

    public static void PotionGame(String data) {

        String number[] = data.split(" ");

        Double[] NUMBER = new Double[4];

        for (int i = 0; i < 4; i++) {

            NUMBER[i] = Double.parseDouble(number[i]);

        }

        //Left is a ArrayList for storing the left number of two number which is under four caculations.

        ArrayList<Integer> Left = new ArrayList();

        //BASE01 is for storing the left number and the new caculation result.

        ArrayList<base01> BASE01 = new ArrayList();

        //X and Y is for storing the left number. Z is for storing the caculation result.

        double X, Y, Z, A, B;

        // A and B is for storing the two number (for four caculations(+ - * /)) by natural order.

        String caculation01;

        for (int x = 0; x < 4; x++) {

            //fix one number of the input numbers.

            caculation01 = null;

            //try each number of the left.

            for (int y = x + 1; y < 4; y++) {

                Left = Left(x, y);

                X = NUMBER[Left.get(0)];

                Y = NUMBER[Left.get(1)];

                A = NUMBER[y];

                B = NUMBER[x];

                //caculation is for recording the caculation procedure.

                Z = A - B;

                caculation01 = A + "-" + B;

                BASE01.add(new base01(X, Y, Z, caculation01));

                Z = B - A;

                caculation01 = B + "-" + A;

                BASE01.add(new base01(X, Y, Z, caculation01));

                Z = A + B;

                caculation01 = A + "+" + B;

                BASE01.add(new base01(X, Y, Z, caculation01));

                Z = B + A;

                caculation01 = B + "+" + A;

                BASE01.add(new base01(X, Y, Z, caculation01));

                Z = A * B;

                caculation01 = A + "*" + B;

                BASE01.add(new base01(X, Y, Z, caculation01));

                if (A != 0 && B != 0) {

                    Z = A / B;

                    caculation01 = A + "/" + B;

                    BASE01.add(new base01(X, Y, Z, caculation01));

                    Z = B / A;

                    caculation01 = B + "/" + A;

                    BASE01.add(new base01(X, Y, Z, caculation01));

                }

            }

        }

        //procedure 2 for getting the result.

        Procedure2(BASE01);

    }

    //try all of the possible caculation for the data got from Procedure1.

    public static void Procedure2(ArrayList<base01> BASE) {

        ArrayList<base02> BASE02 = new ArrayList();

        int len = BASE.size();

        double left, sum, a, b;

        String caculationOFleft;

        Double NUMBER02[];

        //F and S is for recoding down the caculation procedure.

        String caculation02, F, S;

        for (int i = 0; i < len; i++) {

            NUMBER02 = new Double[3];

            NUMBER02[0] = BASE.get(i).x;

            NUMBER02[1] = BASE.get(i).y;

            NUMBER02[2] = BASE.get(i).Z;

            for (int p = 0; p < 3; p++) {

                for (int u = p + 1; u < 3; u++) {

                    caculationOFleft = null;

                    a = NUMBER02[p];

                    b = NUMBER02[u];

                    left = NUMBER02[3 - (p + u)];

                    if (p == 2) {

                        F = "(" + BASE.get(i).caculation01 + ")";

                    } else {

                        F = Double.toString(a);

                    }

                    if (u == 2) {

                        S = "(" + BASE.get(i).caculation01 + ")";

                    } else {

                        S = Double.toString(b);

                    }

                    //when the left number is got from the caculation in the procedure1.

                    if (u != 2 && p != 2) {

                        //use caculationOFleft to record the caculation procedure.

                        caculationOFleft = BASE.get(i).caculation01;

                    }

                    sum = a - b;

                    caculation02 = F + "-" + S;

                    BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    sum = b - a;

                    caculation02 = S + "-" + F;

                    BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    sum = a + b;

                    caculation02 = F + "+" + S;

                    BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    sum = b + a;

                    caculation02 = S + "+" + F;

                    BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    sum = a * b;

                    caculation02 = F + "*" + S;

                    BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    if (a != 0 && b != 0) {

                        sum = a / b;

                        caculation02 = F + "/" + S;

                        BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                        sum = b / a;

                        caculation02 = S + "/" + F;

                        BASE02.add(new base02(sum, left, caculation02, caculationOFleft));

                    }

                }

            }

        }

        RESULT(BASE02);

    }

    //test all of the possible caculations on such four numbers.

    public static void RESULT(ArrayList<base02> BASE02) {

        String caculationOFleft;

        double LEFT, SUM;

        base02 temp01, temp02;

        int length = BASE02.size(), k = 0;

        //here is for removing the repeated solution.

        while (k < length) {

            temp01 = BASE02.get(k);

            for (int l = k + 1; l < length; l++) {

                temp02 = BASE02.get(l);

                if (temp01.caculation02.equalsIgnoreCase(temp02.caculation02)) {

                    BASE02.remove(temp02);

                    l--;

                    length = BASE02.size();

                }

            }

            k++;

        }

        int LEN = BASE02.size(), u = 1;

        for (int r = 0; r < LEN; r++) {

            caculationOFleft = BASE02.get(r).caculationOFleft;

            LEFT = BASE02.get(r).left;

            SUM = BASE02.get(r).sum;

            if (result(LEN, BASE02, LEFT, SUM, BASE02.get(r).caculation02, caculationOFleft, u)) {

                u++;

            }

        }

        if (u == 1) {

            System.out.print("Sorry, the input data is not correct!!");

        } else {

            System.out.print("\r\n\r\nThe above is all of the possible solution.");

        }

    }

    //get all of the correct caculations on the four numbers for 24point game.

    public static boolean result(double LEN, ArrayList<base02> BASE02, double LEFT, double SUM, String CACULATION, String caculationOFleft, int u) {

        boolean result = false;

        //F and S is for recoding down the caculation procedure.

        String S, F;

        S = Double.toString(LEFT);

        F = "(" + CACULATION + ")";

        if (caculationOFleft != null) {

            S = "(" + caculationOFleft + ")";

        }

        if (LEFT + SUM == 24) {

            System.out.print("\r\n\r\n" + "Solution" + u + ": " + S + "+" + F);

            result = true;

            u++;

        }

        if (LEFT * SUM == 24) {

            System.out.print("\r\n\r\n" + "Solution" + u + ": " + S + "*" + F);

            result = true;

        }

        if (LEFT - SUM == 24) {

            System.out.print("\r\n\r\n" + "Solution" + u + ": " + S + "-" + F);

            result = true;

        }

        if (SUM - LEFT == 24) {

            System.out.print("\r\n\r\n" + "Solution" + u + ": " + F + "-" + S);

            result = true;

        }

        if (LEFT != 0 && SUM != 0) {

            if (LEFT / SUM == 24) {

                result = true;

                System.out.print("\r\n\r\n" + "Solution" + u + ": " + S + "/" + F);

            }

            if (SUM / LEFT == 24) {

                result = true;

                System.out.print("\r\n\r\n" + "Solution" + u + ": " + F + "/" + S);

            }

        }

        return result;

    }

    //get the left number of the two numbers under caculations.

    public static ArrayList Left(int x, int y) {

        ArrayList<Integer> left = new ArrayList();

        for (int i = 0; i < 4; i++) {

            if (i != x && i != y) {

                left.add(i);

            }

        }

        return left;

    }

}