时间：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 ay^2-3xy dx = \int bx^2+3xy+2 dy$
$ ay^2x -\frac{3}{2}x^2y = bx2y+\frac{3}{2}xy2+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,R2y_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,R3y_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
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 5 4 6 7
13、三次重复独立时间，A的概率不变，时间A至少发生一次的概率是 37 64 \frac{37}{64} 6437，则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)
答案：{‘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()
答案：
Decorated
Ordinary
2 编程题
1、最小因子问题
小红拿到一个正整数n，他希望找到n的一个最小因子p，满足p*p>n
案例：
输入
2
36
37
输出
937
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)
以上算法超时
优化后的方法
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))
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)
