拼多多笔试题

/**
     * 1. 判断一个数是否对称，如121，12321，注意不能将数字转换成字符串比较
     */
    static boolean isReverse(int i) {
        if (i < 0) {
            return false;
        }
        int j = i;
        int result = 0;
        while (i != 0) {
            int temp = i % 10;
            result = result * 10 + temp;
            i = i / 10;
        }
        return j == result;

    }


    /**
     * 2. 给定一个整数，将其转化为7进制，并以字符串形式输出。如输入: 100->"202",注意: 输入范围是 [-1e7, 1e7] 。
     */
   static String convertToBase7(int num) {
        if(num == 0){
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        String neg = "";
        if(num < 0){
            neg = "-";
            num = - num;
        }
        while(num != 0) {
            int temp = num % 7;
            num = num / 7;
            sb.append(temp);
        }
        return sb.reverse().insert(0, neg).toString();
    }


    /**
     * 3. 输入一个递增排序的数组和一个数字X，在数组中查找两个数，使得他们的和正好是X，如果有多对数字的和等于X，输出两个数的乘积最小的。
     */
    static List<Integer> findNumbersWithSum(int[] array, int sum) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int i = 0;
        int count = 0;
        int j = array.length - 1;
        while (i < j) {
            int temp = array[i] + array[j];
            if (temp == sum) {
                map.put(count, Arrays.asList(array[i], array[j]));
                count++;
                i++;
                j--;
            } else if (temp >= sum) {
                j--;
            } else {
                i++;
            }
        }
        if (count == 1) {
            return map.get(0);
        }
        if (count > 1) {
            int min = map.get(0).get(0) * map.get(0).get(1);
            List<Integer> res = map.get(0);
            for (int k = 1; k < count; k++) {
                int t = map.get(k).get(0) * map.get(k).get(1);
                if (t < min) {
                    min = t;
                    res = map.get(k);
                }
            }
            return res;
        }
        return null;
    }


    /**
     * 3. 输入一个递增排序的数组和一个数字X，在数组中查找两个数，使得他们的和正好是X，如果有多对数字的和等于X，输出两个数的乘积最小的。
     */
    // 改进版 差值越大的两个数，其值越小
    static List<Integer> findNumbersWithSum2(int[] array, int sum) {
        int i = 0;
        int j = array.length - 1;
        while (i < j) {
            int temp = array[i] + array[j];
            if (temp == sum) {
                return Arrays.asList(array[i], array[j]);
            } else if (temp >= sum) {
                j--;
            } else {
                i++;
            }
        }
        return null;
    }



    /**
     * 4.给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径（每次只能向下或者向右移动一步），使得路径上的数字总和为最小。
     * 示例:
     * 输入:
     * [
     * [1,3,1],
     * [1,5,1],
     * [4,2,1]
     * ]
     * 输出: 7
     * 解释: 因为路径 1→3→1→1→1 的总和最小。
     */
    public static int minPathSum(int[][] arr) {
        if(arr.length == 0) return 0;
        int m = arr.length;
        int n = arr[0].length;
        int[][] array = new int[m][n];
        for(int i = 0;i<m;i++) {
            for(int j = 0;j<n;j++) {
                //起始位置为传入数组arr起始位置值
                if(i == 0 && j == 0) {
                    array[i][j] = arr[i][j];
                }else if (i == 0) {
                    //第0行，每一列的值为前一列值(array数组)加上当前列的值(arr数组)
                    array[i][j] = array[i][j - 1] + arr[i][j];
                }else if (j == 0) {
                    //第0列，每一行的值为前一行值(array数组)加上当前行的值(arr数组)
                    array[i][j] = array[i - 1][j] + arr[i][j];
                }else {
                    //该位置的值为 该位置(array[i][j])的左边和上边值的最小值 加上当前位置的值(arr数组)
                    array[i][j] = Math.min(array[i-1][j], array[i][j-1]) + arr[i][j];
                }
            }
        }
        return array[m-1][n-1];
    }