跳到内容
当前位置:首页>笔试招聘真题>OPPO27届 2026.8.22秋招笔试真题

OPPO27届 2026.8.22秋招笔试真题

  • 2026-11-13 18:22:01
OPPO27届 2026.8.22秋招笔试真题

今天练习的是OPPO最新机考笔试题3题。

各大厂真题都整理了近两年的机考题,题库里面有详细思路和答案~

肥猫学长也提供机考辅导助攻(100%通过率)和面试辅导欢迎咨询。

微信号:jackwwang8

目前已经整理的题库有如下:如果有需要可以加我微信获取哦~

华为
阿里
滴滴
荣耀
虾皮
京东
得物
字节跳动
蚂蚁
中国电信
美团
小米
大疆
携程
oppo
360
米哈游
小红书
网易
联想
拼多多
中兴
百度
新凯来
饿了么
理想
Funplus
哔哩哔哩
科大讯飞
极兔
招银网络
钉钉
腾讯
美的
58同城
顺丰

OPPO-27届秋招题目8.24

第1题 选择题

1. 最大堆

任务队列使用最大堆保存优先级,堆中已有 3、8、5。随后依次插入 6 和 10,期间没有执行弹出操作。下一次从堆顶取出的优先级是多少?

•
A. 5
•
B. 8
•
C. 10
•
D. 6

答案:C

解析: 最大堆始终把当前最大元素放在堆顶。插入完成后,集合中的最大值为 10,所以下一次弹出的优先级是 10。

2. Python 生成器

执行下面的 Python 代码,打印结果是什么?

squares = (k * k for k in range(4))
view = squares
p = next(squares)
q = next(view)
rest = list(squares)
try:
    tail = next(view)
except StopIteration:
    tail = "end"
print(p, q, rest, tail)
•
A. 0 0 [1, 4, 9] 1
•
B. 0 1 [0, 1, 4, 9] end
•
C. 0 1 [4, 9] end
•
D. 0 1 [4, 9] 0

答案:C

解析:view 和 squares 指向同一个生成器,而不是两份独立副本。前两次 next 依次取出 0 和 1,list(squares) 再消耗剩余的 4、9。生成器已经耗尽,最后一次调用触发 StopIteration,因此 tail 为 "end"。

3. 齐次线性方程

线性变换对应矩阵,且。齐次方程的自由未知量个数,以及解空间一组基中的向量个数,分别是多少?

•
A. 4 个;3 个
•
B. 3 个;4 个
•
C. 1 个;1 个
•
D. 3 个;3 个

答案:D

解析: 矩阵有 6 列,秩为 3。根据秩—零度定理,零空间维数为。因此自由未知量有 3 个,零空间任意一组基也包含 3 个向量。

4. SQL 分组筛选

表 exam_mark 的数据如下:

id
kind
point
1
A
92
2
A
78
3
A
85
4
B
81
5
B
73
6
B
90
7
C
88

执行:

SELECT kind, COUNT(*) AS cnt
FROM exam_mark
WHERE point >= 80
GROUP BY kind
HAVING COUNT(*) >= 2
ORDER BY kind;

结果是哪一项?

•
A. 仅返回 A、B 两组,计数均为 2
•
B. 返回 A、B、C 三组,计数依次为 2、2、1
•
C. 仅返回 A、B 两组,计数均为 3
•
D. 返回 A、B、C 三组,计数依次为 3、3、1

答案:A

解析:WHERE 先保留分数不低于 80 的记录,此时 A、B、C 三组的数量分别是 2、2、1。HAVING COUNT(*) >= 2 再排除 C 组,最终只返回 A 和 B,计数均为 2。

5. InnoDB 一致性读与当前读

InnoDB 隔离级别为 REPEATABLE READ,账户余额初始为 200。事务 T1 第一次普通 SELECT 读到 200;随后事务 T2 将余额修改为 250 并提交。T1 再执行一次相同的普通 SELECT,接着执行 SELECT ... FOR UPDATE。忽略其他事务,两次分别读到什么?

•
A. 第二次普通查询得到 250,锁定查询也得到 250
•
B. 第二次普通查询得到 200,锁定查询得到 250
•
C. 第二次普通查询被阻塞,锁定查询得到 250
•
D. 第二次普通查询得到 200,锁定查询也得到 200

答案:B

解析: 普通 SELECT 属于一致性读,T1 会继续读取自己已经建立的快照,所以仍得到 200。SELECT ... FOR UPDATE 属于当前读,会查看最新已提交版本并加锁,因此读取到 250。

6. 函数极值

考查函数

若它在开区间内恰有一个极值点且为极小值点,并且在闭区间上的最小值不小于,则的范围是?

•
A.
•
B.
•
C.
•
D.

答案:C

解析: 由可知两个驻点为。要让区间内只保留极小值点,需满足且。极小值为,结合,得到。综上,。

7. 长对话上下文管理

多轮问答每次都把全部历史拼进提示。对话变长后会逼近上下文上限,早期闲聊还会冲淡当前任务约束。下面哪项更适合作为基础处理?

•
A. 保留关键事实和约束,摘要相关历史,并裁剪低价值内容
•
B. 提高生成温度,让模型在长上下文里尝试更多答法
•
C. 继续追加全部历史,只在超限后截掉最新一轮
•
D. 把全部历史改写成少量示例,不再保留当前任务的明确约束

答案:A

解析: 长对话管理的重点是保留真正影响后续回答的事实、限制和当前目标。对相关历史进行摘要,同时删除闲聊和重复信息,既能降低上下文占用,也能避免关键要求被无关内容稀释。

8. 最小堆调整

最小堆的层序数组为 [2, 5, 4, 9, 7, 8]。先插入 1,再删除当前堆顶,并按标准上浮、下沉调整。完成后,堆顶以及它的左、右孩子依次是什么?

•
A. 2、4、5
•
B. 1、5、2
•
C. 2、5、4
•
D. 4、5、8

答案:C

解析: 插入 1 后不断上浮,1 成为堆顶。随后删除堆顶,用末尾元素补到根并向下调整,最终前三个层序元素为 2、5、4。

9. Python 可变默认参数

执行下面的 Python 代码,打印结果是什么?

def push(x, buf=[]):
    buf.append(x)
    return buf
print(push(1), push(2))
•
A. [1] [2]
•
B. [1, 2] [1, 2]
•
C. [1] [1, 2]
•
D. [1, 2] [2]

答案:B

解析: 默认列表只在函数定义时创建一次,两次调用复用同一个对象。第二次调用把 2 追加到原列表后,两个返回值都指向已经变成 [1, 2] 的同一列表。print 在真正格式化参数时看到的都是更新后的内容。

10. 无权图最短路

在无权无向图上求从指定起点到其余可达点的最少边数,下列做法最合适的是?

•
A. 深度优先搜索,并把递归深度作为距离
•
B. 任意生成一棵生成树,再使用树上的路径长度
•
C. 用最大堆按结点编号从大到小扩展
•
D. 广度优先搜索,以结点首次到达时的层数作为距离

答案:D

解析: BFS 会按距离起点的边数逐层扩展。一个结点第一次被访问时,所处层数就是起点到它的最少边数,因此适合解决无权图单源最短路问题。

第2题 最长匀差脉冲

题目描述

航标站记录了一晚的个灯塔脉冲读数,每个读数都是模意义下的非负整数。相邻读数的前向变化量定义为:

如果一段连续读数中,每一对相邻读数的变化量都相同,就称其为一段匀差脉冲。

请找出最长的匀差脉冲。如果有多段长度相同,选择起始下标最小的一段。单个读数也算一段,其公共变化量规定为。

输入描述

•
第一行输入两个整数和,分别表示读数个数和模数。
•
第二行输入个整数。

数据范围:

•
;
•
;
•
。

输出描述

输出三个整数:最长匀差脉冲的长度、左端点下标(从 1 开始)以及该段的公共变化量。

样例1

输入:

5 100 2 4 7 0

输出:

3 1 2

说明:0,2,4 的变化量均为 2;4,7,0 在模 10 下的变化量均为 3。两段长度相同,选择起点更靠前的第一段。

样例2

输入:

1 53

输出:

1 1 0

样例3

输入:

6 92 2 2 5 8 2

输出:

4 3 3

解题思路

把原数组转化为相邻变化量序列:

原数组中的一段匀差脉冲,对应变化量数组中的一段连续相同元素。如果连续相同的变化量有个,那么它覆盖的原读数有个。

因此可以从左向右扫描变化量。维护当前连续段的起点、公共变化量和长度;当新的变化量与前一个不同,就从当前位置重新开始统计。只有当前段严格更长时才更新答案,这样遇到并列时会自然保留最靠左的段。

当时没有变化量,直接按照题意输出 1 1 0。

复杂度分析

•
每对相邻读数只处理一次,时间复杂度为。
•
除输入数组外只使用常数个变量,额外空间复杂度为。

更加详细解题思路和 CPP、Java 代码加我微信获取:jackwwang8

import sys
def longest_uniform_pulse(values, modulus):
    count = len(values)
    if count == 1:
        return 1, 1, 0
    best_length = 2
    best_start = 1
    best_step = (values[1] - values[0]) % modulus
    current_start = 0
    current_step = best_step
    for right in range(2, count):
        step = (values[right] - values[right - 1]) % modulus
        if step != current_step:
            current_start = right - 1
            current_step = step
        current_length = right - current_start + 1
        if current_length > best_length:
            best_length = current_length
            best_start = current_start + 1
            best_step = current_step
    return best_length, best_start, best_step
def main():
    input_data = sys.stdin.readline
    count, modulus = map(int, input_data().split())
    values = list(map(int, input_data().split()))
    answer = longest_uniform_pulse(values, modulus)
    print(*answer)
if __name__ == "__main__":
    main()

第3题 抽检子空间质心投票

题目描述

现有一批带标签的训练样品,需要构造个基分类器,再对测试样品进行投票分类。标签均为非负整数,每个基分类器按照以下顺序生成:

1
使用 rg = np.random.RandomState(seed) 创建随机数生成器。
2
有放回抽取个训练样本:idx = rg.randint(0, n, size=n)。
3
无放回抽取个特征:feat = rg.choice(d, size=m, replace=False),并将特征下标升序保存。
4
在当前袋样本和特征子空间上,计算每个类别的质心。
5
按平方欧氏距离将测试点分给最近的质心,距离并列时选择类别编号较小者。

若当前抽袋没有出现某个类别,该类别不能被删除,而要使用完整训练集中该类别在相同特征子集上的质心。

所有基分类器完成预测后进行多数投票;票数相同,同样选择类别编号较小者。

本题实现只允许使用 numpy、pandas 和 scikit-learn。

输入描述

标准输入为一行 JSON:

{
  "train": [[1, 0, 0], [0, 4, 1]],
  "test": [[1, 0], [0, 4]],
  "n_estimators": 5,
  "max_features": 1,
  "seed": 42
}
•
train:二维列表,每行最后一列为标签,其余列为特征;
•
test:二维列表,只包含特征;
•
n_estimators:基分类器数量;
•
max_features:每个分类器抽取的特征数;
•
seed:随机种子。

数据范围:

•
训练条数、测试条数均在内;
•
;
•
;
•
标签为非负整数。

输出描述

输出一行 JSON,包含:

•
features:每个分类器使用的升序特征下标;
•
bootstraps:每个分类器的抽袋样本下标;
•
pred:测试集最终预测结果。

输出采用紧凑 JSON 格式,括号、逗号和空格应与样例一致。

样例1

输入:

{"train":[[1,0,0],[2,0,0],[0,4,1],[0,5,1]],"test":[[1,0],[0,4],[1,2]],"n_estimators":2,"max_features":1,"seed":7}

输出:

{"features":[[0],[0]],"bootstraps":[[3,0,1,2],[3,3,3,0]],"pred":[0,1,0]}

样例2

输入:

{"train":[[0,0,0],[1,0,0],[0,1,1],[8,8,2]],"test":[[0,0],[8,8]],"n_estimators":4,"max_features":2,"seed":1}

输出:

{"features":[[0,1],[0,1],[0,1],[0,1]],"bootstraps":[[1,3,0,0],[1,3,1,3],[0,1,0,3],[0,2,1,2]],"pred":[0,2]}

样例3

输入:

{"train":[[3,1,0,0],[3,2,0,0],[1,3,1,1],[1,4,1,1],[9,9,9,2]],"test":[[3,1,0],[1,3,1],[9,9,9]],"n_estimators":3,"max_features":2,"seed":13}

输出:

{"features":[[1,2],[0,1],[1,2]],"bootstraps":[[2,0,2,0,2],[4,2,3,2,4],[2,1,3,4,2]],"pred":[0,1,2]}

解题思路

关键是严格保持随机数调用顺序。每轮必须先调用 randint 生成抽袋下标,再调用 choice 选择特征;任何调换都会改变后续随机状态,使结果与标准答案不一致。

对每个基分类器,可按以下步骤处理:

1
保存抽袋下标和排好序的特征下标。
2
对所有合法类别逐一计算质心。若袋中有该类,使用袋中样本;否则退回完整训练集。
3
利用 NumPy 广播,一次计算所有测试点到所有质心的平方距离。
4
类别列表提前按编号升序排列,argmin 遇到距离并列时会返回最靠前的位置,从而满足选择较小类别的规则。

所有分类器的预测可以存入一个二维数组。最后对每个测试样品统计各类别票数,并从票数最多的类别中选择编号最小者。

复杂度分析

设训练样本数为,测试样本数为,类别数为,每个分类器抽取个特征。

•
构造质心并预测的总时间复杂度约为。
•
保存抽样结果和各分类器预测所需空间为,距离矩阵额外需要空间。

更加详细解题思路和 CPP、Java 代码加我微信获取:jackwwang8

import json
import numpy as np
def build_ensemble(payload):
    training = np.asarray(payload["train"], dtype=float)
    testing = np.asarray(payload["test"], dtype=float)
    train_x = training[:, :-1]
    train_y = training[:, -1].astype(int)
    sample_count, feature_count = train_x.shape
    estimator_count = int(payload["n_estimators"])
    selected_count = int(payload["max_features"])
    random_state = np.random.RandomState(int(payload["seed"]))
    classes = np.unique(train_y)
    feature_history = []
    bootstrap_history = []
    prediction_history = []
    for _ in range(estimator_count):
        sampled_rows = random_state.randint(
            0,
            sample_count,
            size=sample_count,
        )
        selected_features = np.sort(
            random_state.choice(
                feature_count,
                size=selected_count,
                replace=False,
            )
        )
        bootstrap_history.append(sampled_rows.astype(int).tolist())
        feature_history.append(selected_features.astype(int).tolist())
        bag_x = train_x[sampled_rows][:, selected_features]
        bag_y = train_y[sampled_rows]
        centers = []
        for class_id in classes:
            in_bag = bag_y == class_id
            if in_bag.any():
                center = bag_x[in_bag].mean(axis=0)
            else:
                full_class = train_y == class_id
                center = train_x[full_class][:, selected_features].mean(axis=0)
            centers.append(center)
        centers = np.asarray(centers)
        test_view = testing[:, selected_features]
        offsets = test_view[:, None, :] - centers[None, :, :]
        squared_distances = np.sum(offsets * offsets, axis=2)
        nearest_positions = np.argmin(squared_distances, axis=1)
        prediction_history.append(classes[nearest_positions])
    all_predictions = np.asarray(prediction_history, dtype=int)
    final_predictions = []
    for column in range(testing.shape[0]):
        votes = np.bincount(all_predictions[:, column])
        final_predictions.append(int(np.argmax(votes)))
    return {
        "features": feature_history,
        "bootstraps": bootstrap_history,
        "pred": final_predictions,
    }
def main():
    payload = json.loads(input())
    result = build_ensemble(payload)
    print(json.dumps(result, separators=(",", ":")))
if __name__ == "__main__":
    main()
部分题库截图:

扫描它,然后带走我:

微信号| jackwwang8

bilibili|  养只猫一米哒

小红书| 2878931801

微信咨询 微信客服二维码微信扫一扫 · 添加人工客服 QQ QQ咨询 QQ咨询二维码QQ扫一扫 · 添加人工客服 帮助手册