几道有趣的算法题

 　　题目：给定一个数字，得出这个数字的连续正整数之和，如给出15，得出1+2+3+4+5=4+5+6=7+8



 1  public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> integers= new ArrayList<>();
        //假定给给出的数子是15
        Integer num = 15;

        /**
         *  循环调用method方法，其实第14行代码的调用可以放到37行代码下面，
         *  但是这样就回出现同一个集合重复的情况，
         *  我的解决办法是用HashMap<String,ArrayList<Integer>>进行存储，
         *  连续正整数开始的数字和结尾的数字拼接成　字符串作为key，在存储是进行判断，map中没有再存储
         *  但是我觉得这样的话就有点过于复杂，我就没有那样写了
         */
        for (int i = 1; i < num; i++) {
            method(num, i, 0, integers);
        }
        //遍历输出　　　
        for (ArrayList<Integer> integer:integers) {
            for (Integer i:integer) {
                System.out.print(i);
            }
            System.out.println("");
        }
    }

    /**
     *
     * @param num  给定的数字
     * @param start 连续正整数开始的数字
     * @param current 当前的数字
     * @param integers 用来答案的集合
     */
    public static void method(Integer num, Integer start, Integer current, ArrayList<ArrayList<Integer>> integers) {

        if (count(start, current) > num) {
            return;
        }else if (count(start,current)< num) {
            method(num, start, ++current, integers);
        } else if (count(start, current) == num) {
            integers.add(util(start, current));
        }
    }

    /**
     *  计算答案，用来判断这一组连续正整数是否等于给的数
     * @param start
     * @param end
     * @return
     */
    public static Integer count(int start,int end){
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }

    /**
     *  将可以组成答案集合的连续正整数的开始和结尾的数字变成答案集合
     * @param start
     * @param end
     * @return
     */
    public static ArrayList<Integer> util(Integer start, Integer end) {
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = start; i <= end; i++) {
            integers.add(i);
        }
        return integers;
    }

 运行结果

第二题

/**
 * 给出一个数组，将这个数组的奇数放在数组的前半部分，偶数放在后半部分
 */
public class two {

    public static void main(String[] args) {
        /**
         * 假定我给出的数组如下
         */
        Integer[] integers = {1,2,3,4,5,6,7,8,9};
        //调用方法
        method(0, 0, integers);
        //打印结果
        for (Integer integer:integers) {
            System.out.printf(String.valueOf(integer));
        }
    }

    /**
     *
     * @param current 当前运算的下标
     * @param count 运算了多少次，用来防止死循环
     * @param integers  运算的数组
     * @return
     */
    public static Integer[] method(int current,int count,Integer[] integers) {
        if (count >= integers.length) {
            return integers;
        }

        //如果当前运算的是数字是奇数，那么就不管他，继续下一个
        if (integers[current] % 2==1) {
            current++;
        } else {
            //是偶数就换到数组最后，然后数组从当前下标之后的下标往前移动一位
            swep(current, integers);
        }
        //迭代
        return method(current, ++count, integers);
    }


    /**
     * 把这个数放到最后，并且原来所有的数往前面以一个位置
     * @param current
     * @param array
     */
    public static void swep(int current,Integer[] array) {
        int currentvalue = array[current];
        for (int i = current; i < array.length - 1; i++) {
            array[i] = array[i + 1];
        }
        array[array.length - 1] = currentvalue;
    }
}

 运行结果：

 这篇博客有序还会保持更新，如有兴趣，请保持关注

当然如果你也有一些有意思的算法题，请联系我 vx:18569022155

如果你有更好的解法请务必联系我，我的邮箱2310874577@qq.com,多谢