8月21日滴滴笔试

前言

2020年08月21日晚上7点开始的滴滴笔试题，有20题选择题，每题三分共计60分；两道大题每题20分，共计40分。试卷总分是100分。

选择题

印象不是很深了，就记得考了一道完全都看不懂的c++，然后问了一道C++写的杨辉三角（我手推出的答案和4个选项都不同233333），问了一道机器学习，如果用朴素贝叶斯来分类，不小心把其中的一个属性重复计算了两次会怎么样。

笔试题

求结果

已知abc为三个不同的数字，那么给出一个n，求出满足符合n = abc+acc的所有数字。

思路很简单，由于仅有三个不同的数字，那我暴力做就可以了：

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> abc = new ArrayList<>();
        List<Integer> acc = new ArrayList<>();
        for (int i = 100; i < 1000; i++) {
            String temp = String.valueOf(i);
            char[] chars = temp.toCharArray();
            int a = chars[0] - '0';
            int b = chars[1] - '0';
            int c = chars[2] - '0';
            if (a != b && b != c && a != c) {
                abc.add(i);
            }
            if (a != b && b == c) {
                acc.add(i);
            }
        }

        // 读取输入，直到没有整型数据可读
        while (sc.hasNextInt()) {
            int n = sc.nextInt();
            int res = 0;
            for (Integer integer : abc) {
                if (acc.contains(n - integer)) {
                    if ((integer / 100 == ((n - integer)) / 100) && (integer % 10 == (n - integer) % 10)) {
                        res++;
                    }

                }
            }
            System.out.println(res);
            for (Integer integer : abc) {
                if (acc.contains(n - integer)) {
                    if ((integer / 100 == ((n - integer)) / 100) && (integer % 10 == (n - integer) % 10)) {
                        System.out.println(integer + " " + (n - integer));
                    }
                }
            }
        }
    }
}

旋转输出矩阵 + 斐波那契数列

小明昨晚做了一个梦。在梦里，很多很多斐波那契数连成了一条蛇。突然，最大的那个数变成了蛇头，把小明一口给吞到肚子里去了。

小明被吓醒了，他赶紧拿笔在纸上面画了一条斐波那契蛇。

这是一个蛇形迂回的斐波那契数列，它是一个n*n的矩阵，在上面的矩阵中n=3。第1行第1列是最大值，然后按照顺时针的次序数字逐渐变小。

下面是n=4时的情况：

小明希望你能够编写一个程序，输入一个正整数n，然后逐行逐列输出斐波那契蛇形矩阵中的元素。

也没啥好说的，那就是先把菲波那切数列搞出来，然后倒着给填到这个矩阵里面不就好了吗？

public class SnakePrint {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            int n = sc.nextInt();
            if(n == 1){
                System.out.println(1);
                continue;
            }
            long[][] matrix = new long[n][n];
            long[] dp = new long[n * n];
            dp[0] = 1L;
            dp[1] = 1L;
            for (int i = 2; i < dp.length; i++) {
                dp[i] = dp[i - 2] + dp[i - 1];
            }
            // System.out.println(Arrays.toString(dp));

            long row = n;
            long column = n;

            long count = row * column;

            //初始化四个顶点
            long row1 = 0;
            long column1 = 0;

            long row2 = 0;
            long column2 = column;

            long row3 = row;
            long column3 = column;

            long row4 = row;
            long column4 = 0;
            while (count > 0) {
                //第一趟从左往右
                for (long j = column1; j < column2; j++) {
                    //System.out.print("1:");
                    //System.out.println(matrix[row1][j]);
                    matrix[(int) row1][(int) j] = dp[(int) (count-1)];
                    count--;
                }
                if (0 == count) {
                    break;
                }

                //第二趟从上往下
                for (long i = row2 + 1; i < row3; i++) {
                    //System.out.print("2:");
                    //System.out.println(matrix[i][column2 - 1]);
                    matrix[(int) i][(int) (column2 - 1)] = dp[(int) (count-1)];
                    count--;
                }
                if (0 == count) {
                    break;
                }

                //第三趟从右到左
                for (long j = column3 - 2; j >= column4; j--) {
                    //System.out.print("3:");
                    //System.out.println(matrix[row3 - 1][j]);
                    matrix[(int) (row3 - 1)][(int) j] = dp[(int) (count-1)];
                    count--;

                }
                if (0 == count) {
                    break;
                }

                //第四趟从下到上
                for (long i = row4 - 2; i > row1; i--) {
                    //System.out.print("4:");
                    //System.out.println(matrix[i][column4]);
                    matrix[(int) i][(int) column4] = dp[(int) (count-1)];
                    count--;

                }
                if (0 == count) {
                    break;
                }

                //移动四个顶点
                row1++;
                column1++;

                row2++;
                column2--;

                row3--;
                column3--;

                row4--;
                column4++;
            }

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    System.out.print(matrix[i][j] + " ");
                }
                System.out.println();
            }
        }
    }
}

唯一的坑点应该就是在斐波那契数列要用long进行存储，用int会溢出（我上面那个代码把所有的int都改成了long….其实只需要把二维数组和斐波那契数列改成long即可）。

总结

选择题中规中矩，各种各样的题目都有，简直包罗万象。

编程题有点太简单了。提前了大半个小时交卷，应该能过吧。