欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2022-03-03 09:07:53
...

一、前言

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

二、编程问题

问题一

使用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();
    }