【数据挖掘】2022年京东算法工程师笔试题（23届）

时间：90分钟
2022年京东算法工程师笔试题（23届）

1 单选题

1、MySQL内部存储代码的优势

• 服务器上执行还可以节省带宽和网络延迟
• 代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性
• 简化代码的维护和版本更新
• 帮助提升安全，比如提供更细粒度的权限控制
• 备份、维护都可以在服务器端完成，所以存储程序的维护工作会很简单。他没有什么外部依赖，不需要依赖外部程序的部署。

2、MySQL 中Seperate by ’ | '的使用

题目是SQL语句的使用，查询回来的多个字段组成一个字符串，以|分开，判断’|‘和’ | ‘（有空格）两种方法，哪种正确

答案：不知

3、全微分(ay^2 -3xy)dx = (bx^2+3xy+2)dy，求a，b

答案：a = 3/2 ,b= -3/2

积分相等求a,b

$\int a{y}^2-3xydx=\int b{x}^2+3xy+2dy$

$ ay^2x -\frac{3}{2}x^2y = bx^{2y+\frac{3}{2}xy}2+2y$

$a=\frac{3}{2}，b=-\frac{3}{2}$

4、判断：ReLu在R上可导，可以反向传播？

错误：relu在零点处不可导

5、栈S1，S2,大小分别是2，1。先进栈A，再进栈B。栈满再出，A、B、C、D一次进栈，则出栈顺序是？

答案：B 、C、D、A

6、label = [A、A、A、A、B、B、B、B、C、C]

预测的结果pred = [A、A、B、C、C、A、C、C、C、C]

求macro的F1-Score

答案：

原label和预测值

y_true = [0,0,0,0,1,1,1,1,2,2]
y_pred = [0,0,1,2,2,1,2,2,2,2]

根据P/R的计算规则，

Precision = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP)
Recall = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)
F1 = 2×(Precision×Recall)/(Precision+Recall)
下面计算过程中，若除法过程中，分子分母同时为零，则最终结果也为0.

则Macro Average F1的计算过程如下：

（1）如下，将第1个类别设置为True（1），非第1个类别的设置为False（0），计算其P1,R1

y_true=[1,1,1,1,0,0,0,0,0,0]
y_pred=[1,1,0,0,0,0,0,0,0,0]

TP = 2/10,FN= 2/10,FP = 0,TN = 6/10

P1 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP) = 1
R1 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)=1/2
F1_1 = 2×(Precision×Recall)/(Precision+Recall)=2/3
（2）如下，将第2个类别设置为True（1），非第2个类别的设置为False（0），计算其P2,R2

y_true=[0,0,0,0,1,1,1,1,0,0]
y_pred=[0,0,1,0,0,1,0,0,0,0]

P2 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP) =1/2
R2 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)= 1/4
F1_2 = 1/3
（3）如下，将第3个类别设置为True（1），非第3个类别的设置为False（0），计算其P3,R3

y_true=[0,0,0,0,0,0,0,0,1,1]
y_pred=[0,0,0,1,1,0,1,1,1,1]

P3 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP) = 1/3
R3 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)= 1
F1_3 = 1/2
（4）对P1/P2/P3取平均为P，对R1/R2/R3取平均为R，对F1_1/F1_2/F1_3取平均F1
F1 =（F1_1+F1_2+F1_3）/3 = 1/2 = 0.5
最后这个取平均后的得到的P值/R值，就是Macro规则下的P值/R值。

对这个3类别模型来说，它的F1就是0.5。

from sklearn.metrics import f1_score

y_true = [0,0,0,0,1,1,1,1,2,2]
y_pred = [0,0,1,2,2,1,2,2,2,2]
print(f1_score(y_true, y_pred, average='macro')) 
输出：0.5
1
2
3
4
5
6

7、LSTM中两个激活函数的作用

解析：

sigmoid 用在了各种gate上，产生0~1之间的值。

tanh 用在了状态和输出上，是对数据的处理，这个用其他激活函数或许也可以。

8、有一个正整数n=10,每次可以花费3个金币让n除以2，向上取整，或者花费一个金币让n减去1，想知道让n变成1，最少要多少金币?

答案：7
当n/2>3时跨度，选择花3金币的方法
当n/2<=3时，选择花1金币的方法
则10/2 = 5，跨度10-5>3，选择3金币的方法，花费3个金币
[5/2] = 3 ,跨度5-3 = 2<3 ,选择1金币的方法，需要花费2个金币
[3/2] = 2，跨度3-2 = 1<3,选择1金币的方法，需要花费1个金币
[2/2] = 1，跨度2-1 = 1<3,选择1金币的方法，需要花费1个金币
综上，需要总共花费3+2+1+1 = 7

9、一个矩阵的特征值是1、-2、3、10、52、41、83、8，当该矩阵加减一个单位矩阵后，它可能的特征值是多少？

答案：11

解析：一个矩阵加$\lambda$倍的单位矩阵，A+$\lambda$E ，则所有特征值加$\lambda$

10、KMP匹配算法中，子串S= ’aaaab‘，主串T= ’abaaaabca‘。求匹配过程中的比较次数？

答案：我计算得到的是8次，但不知道是否准确，推理过程如下

第一轮

a b a a a a b c a

a a a a b(比较2次)

第二轮

a b a a a a b c a

a a a a b(比较1次)

第三轮

a b a a a a b c a

​ a a a a b(比较5次)

共8次

11，a = [1,2,3,4],b = [‘c’,‘d’]，如何得到a = [1,2,3,4,‘c’,‘d’]

答案：a = a+b

12、程序的输出是什么？

题目我忘了?
T(15467)
1
2

答案：1 5 4 6 7

13、三次重复独立时间，A的概率不变，时间A至少发生一次的概率是$\frac{37}{64}$，则A的概率是多少？

1- $\frac{37}{64}=\frac{27}{64}=P(A{)}^3$

则 P(A) =$ \frac{3}{4}$

14、程序的输出是？

dic = dict.fromkeys(['k1','k2','k3'],[])
dic['k1'].append(1)
dic['k2'].append(2)
dic['k1'] = 1
print(dic)
1
2
3
4
5

答案：{‘k1’: 1, ‘k2’: [1, 2], ‘k3’: [1, 2]}

15、程序的输出是

def mk(x):
    def mk1():
        print("Decorated")
        x()
    return mk1
def mk2():
    print("Ordinary")
p = mk(mk2)
p()
1
2
3
4
5
6
7
8
9

答案：

Decorated

Ordinary

2 编程题

1、最小因子问题

小红拿到一个正整数n，他希望找到n的一个最小因子p，满足p*p>n

案例：

输入

2

36

37

输出
9

37

def low_fac(n):
    k = n
    for i in range(1,n+1):
        if n%i==0 and i*i>k:
            print(int(i))
N = int(input())
for _ in range(N):
    j = int(input())
    low_fac(j)
1
2
3
4
5
6
7
8
9

以上算法超时

优化后的方法

import math
def low_fac(n):
    ans = []
    for i in range(1,int(math.sqrt(n))):
        if n%i==0:
            if i*i>n:
                ans.append(i)
            t = int(n/i)
            if t!=i and t*t>n:
                ans.append(t)
    return min(ans)       

N = int(input())
for _ in range(N):
    j = int(input())
    print(low_fac(j))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2、括号匹配问题：

定义一个括号串的权值为，它的最长合法括号子序列的长度，例如()())的权值是4，因为它的最长合法括号子序列为()(),求一个给定括号串的所有子串权值之和。

注意，我忘了题目，自己理解的题意是，先求一个字符串的所有子串，并计算子串的权值（即最长合法括号子序列）

并且，权值的计算，我忘记了，不确定是否是这么计算的，我记得的题目给中())())的权值是4。我理解不通。我把题目改成了()())。

from itertools import combinations
# 求最长合法括号子序列的长度，即权值
def Process(s):
    # resl记录最长合法子串的长度
    w = 0
    stack = list()
    for i in range(len(s)):
        if stack and s[i] == ")" and s[stack[-1]] == "(":
            stack.pop()
        # 将当前的右括号加入到栈中, 可以充当分割的作用
        else:
            stack.append(i)
        # 栈非空的时候更新当前的长度, 说明已经匹配完所有的左括号了
        if stack:
            r = i - stack[-1]
        else:
            # 说明当前的左括号已经全部消除掉了
            r = i + 1
        # 合法序列的长度更大则更新, 相等则数目加1
        if r > w:
            w = r
    return w
# 生成所有子串
def generate_s(s):    
    substring = []
    for i in range(1,len(s)+1):
        substring.extend(list(combinations(s,i)))
    substring = [''.join(i) for i in substring]
    return substring
if __name__ == '__main__':
    s = '()()())'
    score = 0
    for i in generate_s(s):
        score +=Process(s)
    print(score)
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