实习日记:华为暑期实习(AI)- 4月15日机试题解

Ginkgo True love prevails.

写在前面

主包小丑了🤡。报的 AI 应用研发岗,以为是研发岗标准的三道编程题,结果 15 号机试一看:单选 + 多选 +(150)+ 两道编程(150+300),纯纯 AI 相关岗位的卷子……

主包 A 完两道编程题后,看选择题难度有点高,只把有把握的写了,剩下的随便蒙了就交卷,全程大概 1h 左右。

之后复盘刷了些之前 AI 岗的真题,总结规律如下:

  • 选择题:难度偏高,覆盖离散数学、概率论、DL、ML、LLM、强化学习、数据集等
  • 编程题:一般是一道模拟 + 一道简单算法(题目描述可能复杂,但可抽象成 DP、贪心等经典模型)
  • 语言差异:主包是 CPP 选手,听说有场考了矩阵求逆,完全不会……庆幸没碰到,不然直接 -300,这题 PY 选手会舒服很多

回到编程题本身,AI 岗的编程题难度其实还好:

  • 通常有一道 模拟题,给出算法的具体思路,让你实现
  • 需要对该算法有基本了解,完全不知道的话会麻烦些,但本质上还是模拟,难度不会太高

依旧从编程题入手。


1. AdamW 优化器训练线性预测模型

原题

在华为云通用大模型业务中,线性预测模型是处理流量数据稳定性的核心模型之一。通过历史流量建立的线性模型为:

其中:

  • 表示预测值
  • 和 为影响流量的特征
  • 和 为权重参数
  • 为偏置参数

请实现 AdamW 优化算法,用于根据给定的训练数据更新模型参数。

核心公式:

  1. 损失函数:

  2. 梯度计算:

  3. AdamW 参数更新():

  • 一阶动量:

  • 二阶动量:

  • 偏置校正:

  • 参数更新:

  1. 初始化:所有参数和动量均为 0
输入描述
  • 第一行包含一个整数 ,表示训练样本数
  • 接下来 行,每行 3 个浮点数
输出描述

输出一行,3 个浮点数,依次为更新后的 ,保留 6 位小数。

样例 1

输入:

1
2
3
4
3
1.0 1.0 2.0
2.0 2.0 4.0
3.0 3.0 6.0

输出:

1
0.002750 0.002750 0.002923
样例 2

输入:

1
2
1
0.0 0.0 0.0

输出:

1
0.000000 0.000000 0.000000

题意概述

给 个训练样本,每个样本 ,用 AdamW 优化器训练线性模型 。每个样本依次进行一轮参数更新,输出最终的 。

思路

纯模拟题,按公式一步步实现即可:

  1. 初始化参数和动量均为 0
  2. 对每个样本 :
    • 前向计算
    • 计算梯度
    • 更新一阶、二阶动量
    • 偏置校正
    • 更新参数
  3. 输出结果

参考实现(C++)

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
void solve() {
const double beta1 = 0.9, beta2 = 0.999;
const double lambda = 0.01, alpha = 0.001;
const double eps = 1e-8;

double w1 = 0, w2 = 0, b = 0;
double m_w1 = 0, m_w2 = 0, m_b = 0;
double v_w1 = 0, v_w2 = 0, v_b = 0;

int N;
cin >> N;

for (int t = 1; t <= N; ++t) {
double x1, x2, y_true;
cin >> x1 >> x2 >> y_true;

double y_pred = w1 * x1 + w2 * x2 + b;
double diff = 2.0 * (y_pred - y_true);

double g_w1 = diff * x1, g_w2 = diff * x2, g_b = diff;

m_w1 = beta1 * m_w1 + (1 - beta1) * g_w1;
m_w2 = beta1 * m_w2 + (1 - beta1) * g_w2;
m_b = beta1 * m_b + (1 - beta1) * g_b;

v_w1 = beta2 * v_w1 + (1 - beta2) * g_w1 * g_w1;
v_w2 = beta2 * v_w2 + (1 - beta2) * g_w2 * g_w2;
v_b = beta2 * v_b + (1 - beta2) * g_b * g_b;

double m_hat_w1 = m_w1 / (1 - pow(beta1, t));
double m_hat_w2 = m_w2 / (1 - pow(beta1, t));
double m_hat_b = m_b / (1 - pow(beta1, t));

double v_hat_w1 = v_w1 / (1 - pow(beta2, t));
double v_hat_w2 = v_w2 / (1 - pow(beta2, t));
double v_hat_b = v_b / (1 - pow(beta2, t));

w1 = w1 - alpha * (m_hat_w1 / sqrt(v_hat_w1 + eps) + lambda * w1);
w2 = w2 - alpha * (m_hat_w2 / sqrt(v_hat_w2 + eps) + lambda * w2);
b = b - alpha * (m_hat_b / sqrt(v_hat_b + eps) + lambda * b);
}

cout << fixed << setprecision(6) << w1 << " " << w2 << " " << b << endl;
return;
}

2. 大模型调用资源分配最小成本

题目描述

给定 N 个大模型调用请求,每个请求有优先级数值。需要为这些请求分配计算资源单位(单位:千 token),要求:

  1. 有效分配:优先级 > 0 的请求才需要分配资源;优先级 ≤ 0 的视为无效,不分配 token
  2. 每个有效请求至少分配 1 千 token
  3. 相邻的有效请求中,优先级较高的必须分配更多的 token
  4. 目标:在满足所有有效请求的前提下,使总 token 数最小
输入描述

一行逗号分隔的整数,表示各请求优先级。

输出描述

输出一个整数,表示所有有效请求的 token 总和。

样例 1

输入:

1
10,10,5

输出:

1
4
样例 2

输入:

1
4,2,6

输出:

1
5
样例 3

输入:

1
1,-1,2

输出:

1
2
样例 4

输入:

1
0,-5,-3

输出:

1
0

题意概述

给一组优先级,过滤掉 ≤ 0 的无效请求。每个有效请求至少 1 token,相邻请求中优先级高的必须 token 更多。求最小总 token 数。

思路

经典「分发糖果」问题,双向扫描贪心:

  1. 过滤无效请求(优先级 ≤ 0)
  2. 初始化每个有效请求为 1 token
  3. 左→右扫描:右边优先级 > 左边时,右边 token = 左边 + 1
  4. 右→左扫描:左边优先级 > 右边时,左边 token = max(原值,右边 + 1)
  5. 求和

时间复杂度 ,空间复杂度 。

参考实现(C++)

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
void solve() {
string line;
getline(cin, line);

vector<int> priorities;
stringstream ss(line);
string token;
while (getline(ss, token, ',')) {
priorities.push_back(stoi(token));
}

vector<int> valid;
for (int p : priorities) {
if (p > 0) valid.push_back(p);
}

int n = valid.size();
if (n == 0) {
cout << 0 << endl;
return;
}

vector<int> res(n, 1);

for (int i = 1; i < n; ++i) {
if (valid[i] > valid[i-1]) {
res[i] = res[i-1] + 1;
}
}

for (int i = n - 2; i >= 0; --i) {
if (valid[i] > valid[i+1]) {
res[i] = max(res[i], res[i+1] + 1);
}
}

int total = 0;
for (int t : res) total += t;

cout << total << endl;
return;
}

小结

两题对应两类常见模型:

  1. 纯模拟:按公式实现,注意细节(偏置校正的 从 1 开始)
  2. 贪心 + 双向扫描:经典分发糖果变种,左右各扫一遍保证约束

AI 岗的机试难度还行,没有太复杂的算法,主要考察基础实现能力和题意理解。

  • Title: 实习日记:华为暑期实习(AI)- 4月15日机试题解
  • Author: Ginkgo
  • Created at : 2026-04-17 19:20:00
  • Updated at : 2026-04-26 21:33:35
  • Link: https://g1nkgo7.github.io/2026/04/17/实习日记-华为暑期实习(AI岗)4月15日机试题解/
  • License: This work is licensed under CC BY-NC-SA 4.0.
Comments
On this page
实习日记:华为暑期实习(AI)- 4月15日机试题解