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

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

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

微信号：jackwwang8

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

OPPO-27届秋招题目8.24

第1题 选择题

1. 最大堆

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

答案：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)

答案：C

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

3. 齐次线性方程

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

答案：D

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

4. SQL 分组筛选

表 exam_mark 的数据如下：

执行：

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

结果是哪一项？

答案：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。忽略其他事务，两次分别读到什么？

答案：B

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

6. 函数极值

考查函数

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

答案：C

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

7. 长对话上下文管理

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

答案：A

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

8. 最小堆调整

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

答案：C

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

9. Python 可变默认参数

执行下面的 Python 代码，打印结果是什么？

def push(x, buf=[]):
    buf.append(x)
    return buf
print(push(1), push(2))

答案：B

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

10. 无权图最短路

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

答案：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题 抽检子空间质心投票

题目描述

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

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

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

本题实现只允许使用 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
}

数据范围：

输出描述

输出一行 JSON，包含：

输出采用紧凑 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 选择特征；任何调换都会改变后续随机状态，使结果与标准答案不一致。

对每个基分类器，可按以下步骤处理：

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

复杂度分析

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

更加详细解题思路和 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()