• 查找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;
                }
            }
        }
        
    }
  • 相关阅读:
    OO第二单元架构随笔
    OO第二单元小结
    OO第一单元小结
    OO第四单元总结
    oo第三单元总结
    OO第二单元总结
    OO第一单元总结
    OO第四单元及课程总结
    OO第三单元总结
    OO第二单元总结
  • 原文地址:https://www.cnblogs.com/yuxing/p/2763786.html
Copyright © 2020-2023  润新知