使用程序协助计算24点

从小就喜欢玩24点，简单的就是比反应能力，难的就是比思路，现在还记得第一次遇到1、5、5、5这道题，后来演变成1、4、5、6
学会编程之后，一直考虑是否可以使用程序实现24点的计算
第一次是把24点的所有可能性都列了一遍，事实证明不行，因为总有可能性列不出来，无法证明是不是所有的可能性都已列出
最新想法
1、从数组中任意取两个数，进行加减乘除，再放进数组(数组长度会减一)
2、如果数量为1，判断该数值是否为24，是说明计算成功
3、继续走1

public class Test24 {
    static int all = 0;
    static int success = 0;
    static int fail = 0;

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            for (int j = i; j <= 10; j++) {
                for (int k = j; k <= 10; k++) {
                    for (int l = k; l <= 10; l++) {
                        all++;
                        System.out.println(i + ":" + j + ":" + k + ":" + l + ":" + getAns(new int[]{i, j, k, l}));
                    }
                }
            }
        }
        System.out.println(all + ":" + success + ":" + fail);
    }

    private static String getAns(int[] values) {
        String s = getFromV(values);
        if (StringUtils.isNotBlank(s)) {
            success++;
            return s;
        }
        fail++;
        return "无解";
    }

    private static String getFromV(int[] v) {
        //ss是为了后续展示计算式
        String[] ss = new String[]{v[0] + "", v[1] + "", v[2] + "", v[3] + ""};
        double[] bb = new double[]{v[0], v[1], v[2], v[3]};
        return getStr2(bb, ss, 4);
    }

    private static String getStr(double[] bb, String[] ss, int len) {
        if (len == 1) {
            if (bb[0] > 23.999 && bb[0] < 24.001) {
                //差距小于0.001,可以认定是计算出来的误差
                return ss[0];
            } else {
                return null;
            }
        }
        //长度少一
        double[] nbb = new double[len - 1];
        String[] nss = new String[len - 1];
        String s;
        for (int i = 1; i < len - 1; i++) {
            nbb[i] = bb[i + 1];
            nss[i] = ss[i + 1];
        }
        //依次计算加减乘除
        nbb[0] = bb[0] * bb[1];
        nss[0] = "(" + ss[0] + "*" + ss[1] + ")";
        s = getStr2(nbb, nss, len - 1);
        if (StringUtils.isNotBlank(s)) {
            return s;
        }

        nbb[0] = bb[0] / bb[1];
        nss[0] = "(" + ss[0] + "/" + ss[1] + ")";
        s = getStr2(nbb, nss, len - 1);
        if (StringUtils.isNotBlank(s)) {
            return s;
        }

        nbb[0] = bb[0] + bb[1];
        nss[0] = "(" + ss[0] + "+" + ss[1] + ")";
        s = getStr2(nbb, nss, len - 1);
        if (StringUtils.isNotBlank(s)) {
            return s;
        }

        nbb[0] = bb[0] - bb[1];
        nss[0] = "(" + ss[0] + "-" + ss[1] + ")";
        s = getStr2(nbb, nss, len - 1);
        if (StringUtils.isNotBlank(s)) {
            return s;
        }

        return null;
    }

    //以下只是为了打乱顺序
    private static String getStr2(double[] bb, String[] ss, int len) {
        int[] tt = new int[len];

        l:
        for (int i = 0; ; i++) {
            int v = i;
            for (int j = 0; j < len; j++) {
                tt[j] = v % len;
                v = v / len;
                for (int k = 0; k < j; k++) {
                    if (tt[j] == tt[k]) {
                        continue l;
                    }
                }
            }
            if (v > 0) {
                return null;
            }
            double[] nbb = new double[len];
            String[] nss = new String[len];
            for (int j = 0; j < len; j++) {
                nbb[j] = bb[tt[j]];
                nss[j] = ss[tt[j]];
            }
            String s = getStr(nbb, nss, len);
            if (StringUtils.isNotBlank(s)) {
                return s;
            }
        }
    }
}

几个特殊的24点

1:5:5:5:(5*(5-(1/5)))
1:4:5:6:(4/(1-(5/6)))
4:4:10:10:(((10*10)-4)/4)
2:4:6:7:((7*4)+(2-6))