8月21日滴滴笔试

前言

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

选择题

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

笔试题

求结果

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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时的情况:

image-20200822152849415

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
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即可)。

总结

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

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