每个软件工程师在不到1小时内就能解决的5个编程问题

一、前言

比较有意思的算法问题，好久没研究算法，感觉都生疏了。问题都比较简单，主要是考验编程思维，算法逻辑，还有写代码的能力，有兴趣就来试试吧

二、编程问题

问题一

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

问题二

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

问题三

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

问题四

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

问题五

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

三、解答

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

//for循环
public static int Test1(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("for--" + sum);
        return sum;
    }

//while循环
public static int Test2(int[] arr) {
        int sum = 0;
        int i = 0;
        while (i < arr.length) {
            sum += arr[i];
            i++;
        }
        System.out.println("while--" + sum);
        return sum;
    }

//递归算法
public static int Test3(int[] arr, int x) {
        int i = x;
        x = x < arr.length ? x + 1 : 0;
        if (x == 0) {
            return 0;
        }
        return arr[i] + Test3(arr, x);
    }

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

public static void Test4(char[] arr1, char[] arr2) {
        char arr[] = new char[arr1.length + arr2.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i % 2 == 0 ? arr1[i / 2] : arr2[i / 2];
            System.out.println(arr[i]);
        }
        return;
    }

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

public static void Test5(int m, int n) {
        System.out.print(m + " / ");
        i++;
        if (i == 100) {
            return;
        }
        Test5(n, m + n);
        return;
    }

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

public static void Test6(int[] arr) {
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++)
            arr1[i] = arr[i];
        for (int i = 0; i < arr1.length; i++) {
            while (arr1[i] / 10 > 0) {
                arr1[i] = arr1[i] / 10;
            }
        }
        for (int i = 0; i < arr1.length; i++) {
            int rec1 = arr1[i];
            int rec2 = arr[i];
            for (int j = i; j < arr.length; j++) {
                if (arr1[j] < arr1[i]) {
                    arr1[i] = arr1[j];
                    arr1[j] = rec1;

                    arr[i] = arr[j];
                    arr[j] = rec2;
                }
            }
        }
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i]);
        }

        return;
    }

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

public static void Test7() {
        String[] op = { "+", "-", "" };
        for (int a = 0; a < 3; a++)
            for (int b = 0; b < 3; b++)
                for (int c = 0; c < 3; c++)
                    for (int d = 0; d < 3; d++)
                        for (int e = 0; e < 3; e++)
                            for (int f = 0; f < 3; f++)
                                for (int g = 0; g < 3; g++)
                                    for (int h = 0; h < 3; h++) {
                                        String res = "1" + op[a] + "2" + op[b]
                                                + "3" + op[c] + "4" + op[d]
                                                + "5" + op[e] + "6" + op[f]
                                                + "7" + op[g] + "8" + op[h]
                                                + "9";
                                        _add(res);
                                    }
        return;
    }

    public static int _add(String s) {
        int sum = 0;
        char[] stringArr = ("+" + s + "#").toCharArray();
        String formula = "0";
        boolean operator = true;
        for (char a : stringArr) {
            if (a == '+') {
                sum = operator ? sum + Integer.valueOf(formula) : sum
                        - Integer.valueOf(formula);
                formula = "";
                operator = true;
                continue;
            } else if (a == '-') {
                sum = operator ? sum + Integer.valueOf(formula) : sum
                        - Integer.valueOf(formula);
                formula = "";
                operator = false;
                continue;
            } else if (a == '#') {
                sum = operator ? sum + Integer.valueOf(formula) : sum
                        - Integer.valueOf(formula);
                break;
            }
            formula += a;
        }
        if (sum == 100)
            System.out.println(s);
        return 0;
    }

    public static void main(String[] arg) {
        int[] arr = { 2, 3, 4, 1, 5, 6200 };
        Test1(arr);
        Test2(arr);
        System.out.println("recursive--" + Test3(arr, 0));
        char[] arr1 = { 'a', 'b', 'c' };
        char[] arr2 = { '1', '2', '3' };
        Test4(arr1, arr2);
        Test5(0, 1);
        Test6(arr);
        Test7();
    }