2020年學而思春招算法題

時間 2020-03-19

標籤 2020年學而思春算法简体版

原文原文鏈接

今天學弟分享了一下學而思2020年春招算法題，整理一下，但願對有須要的小夥伴有幫助java

斐波那契數列題幹思路代碼數組問題題幹思路代碼web

斐波那契數列

題幹

有一對兔子，3個月後，每一個月都會生一對兔子，生下的兔子過了3個月，也會每個月生一對兔子，假設兔子不會死亡，n個月後總共有多少兔子?算法

思路

這道題咱們能夠首先列一下前幾個月的兔子數，找一下有沒有什麼規律。數組

能夠看到這是一個斐波那契數列,這裏給出兩種解法，分別是遞歸法，和動態規劃法。（這裏建議使用動態規劃法，遞歸法存在大量的重複計算，即f(5) = f(4) + f(3),可是f(4),f(3)在以前的運算中就已經計算過了，此時是重複計算）

代碼

遞歸法：app

1public int function(int n){
2    if(n == 1 || n == 2){
3        return 1;
4    }
5    return function(n - 1) + function(n - 2);
6}

動態規劃法：測試

 1public int function(int n){
 2    if(n <= 2){
 3        return 1;
 4    }
 5    int pre1 = 1;
 6    int pre2 = 2;
 7    for(int i = 3;i <=n; i++){
 8        int cur = pre1 + pre2;
 9        pre1 = pre2;
10        pre2 = cur;
11    }
12    return pre1;
13}

數組問題

題幹

輸入一個升序數組和一個整數，若是這個數在數組裏則返回下標，不在數組裏面，就插入到數組，而後返回下標。this

思路

這道題就比較有意思了，解法有不少種，java中的數組不支持動態擴容，因此須要咱們去寫擴容和數據搬移的邏輯，這裏首先先給出一個取巧的辦法，咱們能夠把數組放到ArrayList裏，而後利用ArrayList支持動態擴容的特性，來解決這個問題(方法1)。固然咱們也能夠手寫這部分邏輯(方法2)spa

代碼

方法1:code

 1public class Main {
 2    private int position;
 3
 4    private Integer[] getOrInsertElement(Integer[] arr, int target) {
 5        List<Integer> list = new ArrayList<>(Arrays.asList(arr));
 6        for (int i = 0; i < list.size(); i++) {
 7            if(list.get(i) <= target){
 8                position = i;
 9            }
10        }
11        if(list.get(position) != target){
12            position++;
13            list.add(position,target);
14        }
15        Integer[] newArr = new Integer[list.size()];
16        return list.toArray(newArr);
17    }
18}

方法2:orm

 1public class Main {
 2
 3    private int position;
 4
 5    private int[] getOrInsertElement(int[] arr, int target) {
 6        // 輸入校驗
 7        if (arr == null || arr.length == 0) {
 8            throw new RuntimeException("輸入數據非法!");
 9        }
10        int max = arr[arr.length - 1];
11        // 擴容位置在數組末尾
12        if (target > max) {
13            return insertTargetElement(arr, target, arr.length - 1);
14        }
15        //查詢數組中，小於等於target的第一個位置
16        int pos = getMinOrEqualsTargetPosition(arr, target);
17        if (arr[pos] == target) {
18            this.position = pos;
19            return arr;
20        }
21        return insertTargetElement(arr, target, pos);
22    }
23
24    private int[] insertTargetElement(int[] arr, int target, int pos) {
25        // 擴容
26        int[] newArr = Arrays.copyOf(arr, arr.length + 1);
27        // 數據搬運
28        System.arraycopy(arr, pos, newArr, pos + 1, arr.length - pos);
29        newArr[pos + 1] = target;
30        this.position = pos + 1;
31        return newArr;
32    }
33
34    private int getMinOrEqualsTargetPosition(int[] arr, int target) {
35        int i = 0;
36        int j = arr.length - 1;
37        int result = 0;
38        while (i <= j) {
39            int mid = i + ((j - i) >> 1);
40            if (arr[mid] < target) {
41                i = mid + 1;
42                result = mid;
43            } else if (arr[mid] > target) {
44                j = mid - 1;
45            } else {
46                return mid;
47            }
48        }
49        return result;
50    }
51}

測試代碼：

1public static void main(String[] args) {
2    int[] arr = {1, 4, 5, 6, 7, 8, 10};
3    Main main = new Main();
4    int[] newArr = main.getOrInsertElement(arr, 11);
5    System.out.println("原數組:" + Arrays.toString(arr));
6    System.out.println("目標值下標：" + main.position);
7    System.out.println("擴容後的數組：" + Arrays.toString(newArr));
8}