查找24点算法

查处24点算法有很多种. 这是是我自己写的. 

* 计算过程
* 如计算1,2,3,4
* 首先找出所有2项子集: 1,2 | 1,3 | 1,4 | 2,3 | 2,4 | 3,4. 总共6个
* 然后第i个和第5-i个进行组合计算, 如 1,2 和 3,4 组合计算, 1,3 和 2,4 组合
* 所有的运算符都使用一次, 如 (1+2) / (3*4), (2-1) / (3*4).....
* 最后得出结果

* 计算原则: 为了保证不重复计算, 规定大的数总是在左边, 如大的数除以小的数, 大的数减去小的数. 

* 如碰到不能除尽的, 则跳过

/**
 * @author Yuxing<yuxinghappy@gmail.com>
 * 
 */
public class Test2 {
    
    private static final char[] ops = new char[]{'+', '-', '*', '/'};
    private static final String resultFormat = "(%d%s%d)%s(%d%s%d)";
    
    public static void main(String[] args) {
        
        int[] nums = new int[]{2,3,11,6};
        
        int[][] a = new int[6][2];
        
        int m = 0;
        for (int ia = 0; ia < 4; ia ++) {
            for (int ib = ia + 1; ib < 4; ib ++) {
                if (nums[ia] >= nums[ib]) {
                    a[m][0] = nums[ia];
                    a[m][1] = nums[ib];
                } else {
                    a[m][0] = nums[ib];
                    a[m][1] = nums[ia];
                }
                m++;
            }
        }
        
        for (int i = 0; i < 3; i ++) {
            int[] left = a[i];
            int[] right = a[5 - i];
            for (int ia = 0; ia < 4; ia ++) {
                for (int ib = 0; ib < 4; ib ++) {
                    for (int ic = 0; ic < 4; ic ++) {
                        
                        int [] tl = left;
                        int [] tr = right;
                        
                        int l = comput(ia, tl[0], tl[1]);
                        if (l < 0)
                            continue;
                        
                        int r = comput(ic, tr[0], tr[1]);
                        if (r < 0) {
                            continue;
                        }
                        
                        int result;
                        boolean upside = l < r; //如果左边的数小于右边, 则颠倒过来运算.
                        if (upside) {
                            result = comput(ib, r, l);
                        } else {
                            result = comput(ib, l, r);
                        }
                        
                        if (result == 24) {
                            if (upside)
                                System.out.println(String.format(resultFormat, tr[0], ops[ic], tr[1], ops[ib], tl[0], ops[ia], tl[1]));
                            else
                                System.out.println(String.format(resultFormat, tl[0], ops[ia], tl[1], ops[ib], tr[0], ops[ic], tr[1]));
                        }
                            
                    }
                }
            }
        }
        
    }
    
    private static final int comput(int op, int left, int right) {
        switch (op) {
        case 0:
            return left + right;
        case 1:
            return left - right;
        case 2:
            return left * right;
        default:
            if (right == 0) {
                return -1;
            } else {
                if (left%right == 0)
                    return left/right;
                else
                    return -1;
            }
        }
    }
    
}