Java五道题

今天在微信公众号看到一篇“每个程序员半小时内必须解决的5个编程问题”，发现自己也不完全会，在网上搜罗做了整理，以便不时之需。

问题1

使用for循环、while循环和递归写出3个函数来计算给定数列的总和。

问题2

编写一个交错合并列表元素的函数。例如：给定的两个列表为[a，B，C]和[1，2，3]，函数返回[a，1，B，2，C，3]。

问题3

编写一个计算前100位斐波那契数的函数。根据定义，斐波那契序列的前两位数字是0和1，随后的每个数字是前两个数字的和。例如，前10位斐波那契数为：0，1，1，2，3，5，8，13，21，34。

问题4

编写一个能将给定非负整数列表中的数字排列成最大数字的函数。例如，给定[50，2，1,9]，最大数字为95021。

问题5

编写一个在1，2，…，9（顺序不能变）数字之间插入+或-或什么都不插入，使得计算结果总是100的程序，并输出所有的可能性。例如：1 + 2 + 34 – 5 + 67 – 8 + 9 = 100。

 

问题1：

 

public class SumTest {

    public static void whileMethod(int[] array) {
        if (null == array || array.length == 0) {
            return;
        }
        int sum = 0;
        int i = 0;
        while (i < array.length) {
            sum += array[i];
            i++;
        }
        System.out.println("Sum result is while : " + sum);
    }

    public static void forMethod(int[] array) {
        if (null == array || array.length == 0) {
            return;
        }
        int sum = 0;
        int i = 0;
        for (int num: array) {
            sum += num;
        }
        System.out.println("Sum result is for : " + sum);
    }

    public static int recursiveMethod(int[] array, int i) {
        if (null == array || array.length == 0) {
            return 0;
        }
        if (i < array.length) {
            return array[i] + recursiveMethod(array, i + 1);
        }
        return 0;
    }
    public static void main(String[] args){

        int[] array = {1, 2, 3, 4, 5, 6, 7};
        whileMethod(array);
        forMethod(array);
        System.out.println(recursiveMethod(array, 0));
    }
}

问题2：

 

public class ListMerge {
    public static String[] mergeList(String[] arg1, String[] arg2) {
        String[] arr = new String[arg1.length + arg2.length];
        int i, j;
        for (i = 0, j = 0; i < arg1.length; i++) {
            j = 2 * i;
            if (j > 2 * arg2.length){
                j = arg2.length + i;
            }
            arr[j] = arg1[i];
         }
        for (i = 0, j = 0; i < arg2.length; i++) {
            j = 2 * i + 1;
            if (j > 2 * arg1.length) {
                j = arg1.length + 1;
            }
            arr[j] = arg2[i];
        }
        return arr;
    }
    public static void main(String[] args){
        String[] arr1 = { "a", "B", "c", "D", "e" };
        String[] arr2 = { "1", "2", "3" };
        String[] arr = mergeList(arr1, arr2);
        System.out.println(Arrays.toString(arr));
    }
}

问题3：

 

public class Fibonacci {
    private static int getNum(int num) {
        int count = 0;
        if (num <= 1) {
            count = 0;
        } else if (num == 2) {
            count = 1;
        } else {
            count = getNum(num - 1) + getNum(num - 2);
        }
        return count;
    }

    private static String getSum(int num) {
        String numStr = "";
        for (int i = 0; i <= num; i++) {
            numStr = getNum(i) + ",";
        }
        numStr = numStr.substring(0, numStr.length() - 1);
        return numStr;
    }

    public static void main(String[] args){

        System.out.println("The number is : " + getSum(100));
    }
}

问题4：

 

public class MaxValue {
    private static Integer[] VALUES = { 50, 2, 100, 99, 5, 7, 51,50 ,11};
    public static void main(String[] args){
        Arrays.sort(VALUES, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                String v1 = o1.toString();
                String v2 = o2.toString();
                return (v1 + v2).compareTo(v2 + v1) * - 1;
            }
        });
        String result = "";
        for (Integer integer: VALUES) {
            result += integer.toString();
        }
        System.out.println(result);
    }
}

问题5：

 

public class SameSum {
    
    private static int TARGET_SUM = 100;
    private static int[] VALUES = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    private static ArrayList add(int digit, String sign, ArrayList branches) {
        for (int i = 0; i < branches.size(); i++) {
            branches.set(i, digit + sign + branches.get(i));
        }
        return branches;
    }

    private static ArrayList f(int sum, int number, int index) {
        int digit = Math.abs(number % 10);
        if (index >= VALUES.length) {
            if (sum == number) {
                ArrayList result = new ArrayList();
                result.add(Integer.toString(digit));
                return result;
            } else {
                return new ArrayList();
            }
        }
        ArrayList branch1 = f(sum - number, VALUES[index], index + 1);
        ArrayList branch2 = f(sum - number, -VALUES[index], index + 1);
        int concatenatedNumber = number >= 0 ? 10 * number + VALUES[index] : 10
             * number - VALUES[index];
        ArrayList branch3 = f(sum, concatenatedNumber, index + 1);
        ArrayList results = new ArrayList();
        results.addAll(add(digit, "+", branch1));
        results.addAll(add(digit, "-", branch2));
        results.addAll(add(digit, "", branch3));
        return results;
    }

    public static void main(String[] args) {
        ArrayList list = f(TARGET_SUM, VALUES[0], 1);
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i));
        }
    }
}