华为Ai岗机考20250903

华为自26届秋招（2025年起）对AI岗位机考进行了改革，考试题型调整为20道选择题（15道单选(6分)+5道不定项选择(12分)）+2道编程题(150+300)。

题目核心围绕人工智能技术（如Transformer架构、EM算法、PCA降维、激活函数等）与数学基础（如线性变换、概率分布、数值迭代、插值计算等）展开，相较于以往题型，知识覆盖面与考查深度均有显著变化。

目前，网络上针对此次改革后AI岗位的完整机考试卷资源较为稀缺。本次特别整理并提供2025年9月3日华为AI岗位机考的完整真题。希望对读者备考提供一定的帮助，祝大家都顺利上岸！

整理不易，麻烦给个免费的三连。

一、选择题

（一）单项选择题（共15题）（每题6分）

1. 在文本生成中，以下哪种模型最适合用于生成连续文本？（）

   A. LSTM

   B. 最大熵模型

   C. 隐马尔可夫模型（HMM）

   D. 决策树

2. 线性变换将向量映为，将映为，则向量在下的像为？（）

   A.

   B.

   C.

   D.

3. 已知，，且，则的第2行第3列元素是（行列号从1开始计数）？（）

   A. 2

   B. -4

   C. 0

   D. 6

4. 在计算某天线的安装角度时，需要求解如下非线性方程，工程师小王打算使用迭代公式进行数值计算。以下有关该迭代收敛性的说法中，哪一项是正确的？（）

   A. 当算法收敛时，速度是二次的

   B. 对任意初始值，该算法都能收敛到其唯一实根

   C. 该算法是不稳定的，因为余弦函数有界，而线性函数无界

   D. 该方程有两个实根，算法收敛到哪一个取决于初始值

5. 你正在使用一个机器学习模型来解决一个分类问题，在训练集上得到了非常高的准确率，但是在测试集上的准确率却相对较低。这种情况最有可能是以下哪种现象？（）

   A. 过拟合 B. 欠拟合 C. 无法判断 D. 正好拟合

6. 桥梁应力监测中，传感器测得：秒时。用二次插值预测秒应力。已知真实应力函数为，则应力预测值的绝对误差是？（）

   A. 2.5MPa B. 5.0MPa C. 0.0MPa D. 7.5MPa

7. 在进行特征工程时，我们经常会对特征进行标准化处理。假设有一个特征，其期望，方差。现在我们对其进行线性变换得到新特征。那么新特征的方差是多少？（）

   A. 31 B. 36 C. 12 D. 7

8. 向量组，，线性无关，已知，，，若，，线性相关，则，的值为（）

   A. 且

   B. 或

   C. 且

   D. 或

9. 设随机变量的概率密度函数为，其他情况为0。该分布是：（）

   A. 泊松分布 B. 指数分布 C. 正态分布 D. 均匀分布

10. 关于线性变换，以下说法正确的是？（）

    A. 仅当时成立 B. 零向量映射不一定为零向量 C. 线性变换不能改变向量的维度 D. 对所有标量和向量成立

11. 关于Transformer解码器的描述错误的是？（）

    A. 解码器额外使用编码器-解码器交叉注意力层（Cross - Attention） B. 第二个Multi - Head Attention层的K、V矩阵使用Encoder的编码信息矩阵进行计算 C. 解码器的第二个Multi - Head Attention采用了Masked掩码操作 D. 解码器包含掩码自注意力层（Masked Self - Attention）

12. 下述检验正态性假设的方法中错误的是（）

    A. 直方图方法 B. 拟合优度检验方法 C. 使用偏度系数和峰度系数 D. T检验

13. 某工厂生产的产品次品率为0.02，随机抽取100件产品，次品数近似服从的分布是？（）

    A. 均匀分布 B. 伯努利分布 C. 泊松分布 D. 正态分布

14. 用牛顿迭代法求函数的根，初值为的情况下，其收敛速度是（）

    A. 超线性收敛 B. 二次收敛 C. 线性收敛 D. 对数收敛

15. 在使用PCA（主成分分析）进行降维时，主要依据以下哪一项来选择主成分？（）

    A. 样本的分布密度 B. 特征之间的相关性 C. 主成分的方差贡献率 D. 数据的类别分布

（二）不定项选择题（共5题）（每题12分）

16. 设是强度为的泊松过程。以下陈述中，正确的是（）

    A. 在区间内事件数的均值为

    B. 已知在时间内发生了个事件，那么这个事件的发生时刻在上是独立同分布的均匀分布

    C. 时间间隔（首次事件到达时间）服从参数为的指数分布

    D. 两次连续事件的时间间隔与相互独立

17. 在EM算法中，GMM的M - step的解析解需要（）

    A. 必须对角协方差 B. 协方差矩阵正定 C. 各成分权重和为1 D. 均值更新为加权平均

18. 下列关于线性变换的说法中，正确的是（）

    A. 设是将向量映射为的变换，则是线性变换

    B. 设是将向量映射为的变换，则不是线性变换（因存在常数项1，不满足线性变换“”的性质）

    C. 若，均为的线性变换，则它们的和仍是线性变换

    D. 若是线性变换，则对于任意向量，和常数，，有

19. 关于深度学习中的激活函数ReLU、Softmax、Sigmoid和Tanh，以下描述正确的是：（）

    A. ReLU函数在输入为负时输出为零，而在输入为正时输出为输入值本身

    B. Tanh函数的输出值范围在之间，常用于隐藏层的激活函数

    C. Sigmoid函数的导数在输入为0时达到最大值，随着输入值的增大或减小而逐渐减小

    D. Softmax函数将输入值归一化为概率分布，所有输出值的和为1

20. 与大语言模型（LLM）相比，以下哪些是多模态大语言模型（MLLM）在处理多模态输入时面临的独特挑战？（）

    A. 跨模态的语义理解与生成 B. 多模态输入的实时处理与推理延迟 C. 模型参数量的爆炸式增长 D. 多模态数据的对齐（如图像与文本的语义对齐）

二、编程题（共2题）

21. 云存储设备故障预测

在云存储系统中，需要预测存储设备故障以提前迁移数据。每条设备日志包含：设备ID，写入次数，读取次数，平均写入延迟（ms），平均读取延迟（ms），设备使用年限（年），设备状态（0正常/1故障）。需实现一个设备故障预测系统，包含以下功能：

1. 数据清洗规则

• 缺失值标记为“NaN”，用该字段有效值的均值填充；
• 异常值判定与处理：
  • 写入次数、读取次数：小于0时为异常值，用该字段有效值的中位数替换；
  • 平均写入延迟、平均读取延迟：小于0或大于1000ms时为异常值，用该字段有效值的中位数替换；
  • 设备使用年限：小于0或大于20年时为异常值，用该字段有效值的中位数替换。

2. 逻辑回归模型训练要求

• 训练方法：使用批量梯度下降法（Batch GD），每次迭代使用全部样本；
• 特征变量：写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限；
• 标签变量：设备状态；
• 训练参数：迭代次数100次，学习率，初始权重全为0。

3. 预测输出要求

• 输出预测结果：0（表示设备正常）或1（表示设备故障）。

输入格式

• 第一行：训练样本总个数（）；
• 第二行至第行：每行包含1个训练样本数据，格式为“设备ID 写入次数 读取次数 平均写入延迟 平均读取延迟 设备使用年限 状态”；
• 第行：预测数据总个数（）；
• 第行至第行：每行包含1个预测样本数据，格式为“设备ID 写入次数 读取次数 平均写入延迟 平均读取延迟 设备使用年限 状态”（预测时状态字段仅为数据格式统一，无实际意义）。

输出格式

• 共行，每行输出1个预测结果（0或1），与预测数据的顺序一一对应。

22. 大模型训练MOE场景路由优化算法

MOE模型训练时，token需根据概率发送到top - k个不同的专家进行计算，专家分布在多个NPU卡上。Device - Limited routing算法可将token的路由目标限制在个NPU上，以降低通信成本，具体规则如下：

1. 专家分组：将个专家平均分配在个NPU上，每个NPU上的专家组成一个组；专家编号为，且每个组内的专家编号连续；
2. 筛选目标NPU：每个专家对应一个被路由到的概率，以每个组内的最大概率作为该组的代表概率；从所有组中选择代表概率最大的个组，其对应的NPU即为路由目标限制NPU；
3. 筛选目标专家：从上述个NPU对应的所有专家中，选择概率最大的个专家，其编号即为最终路由目标。

输入格式

• 第一行：4个整数，分别表示专家个数、NPU个数、路由目标限制NPU个数、目标路由专家个数（均处于区间内）；
• 第二行：个浮点数，分别表示每个专家对应的被路由概率（处于区间内），概率与专家编号一一对应。

输出格式

• 若不能被整除（无法平均分组），或从目标NPU对应的专家中无法获取到个专家编号，则输出“error”；
• 若满足条件，则按专家编号从小到大的顺序输出个专家编号，任意相邻两个编号之间用空格分隔，最后一个编号后无空格。

参考答案

答案仅供参考

单项选择题（共15题）

1. 答案：A
   解析：LSTM（长短期记忆网络）能捕捉序列数据的长期依赖关系，适合生成连续文本；最大熵模型、隐马尔可夫模型（HMM）更适用于分类、序列标注等任务，决策树主要用于分类和回归，均不擅长连续文本生成。

2. 答案：A
   解析：线性变换矩阵由基向量的像构成（列向量为、），即。向量的像为，故选择A。

3. 答案：A
   解析：矩阵乘法中，元素为的第个元素与的第个元素乘积。、，第2行第3列元素为，故选择A。

4. 答案：B
   解析：方程仅有1个实根；迭代公式满足压缩映射条件，对任意初始值均收敛到该实根（A错，收敛速度为线性；C错，算法稳定；D错，方程仅1个实根）。

5. 答案：A
   解析：过拟合指模型在训练集上拟合过好（准确率高），但对未见过的测试集泛化能力差（准确率低）；欠拟合是训练集和测试集准确率均低，故选择A。

6. 答案：C
   解析：预测值：；真实值：，绝对误差为0，故选择C。

7. 答案：B
   解析：方差性质：（常数不影响方差）。代入得，故选择B。

8. 答案：D
   解析：向量组线性相关，其组合系数构成的行列式为0。计算得行列式，解得或，故选择D。

9. 答案：D
   解析：均匀分布的概率密度函数为（），其他区间为0；泊松分布是离散分布，指数分布密度为，正态分布密度为钟形曲线，故选择D。

10. 答案：D
    解析：线性变换满足可加性（对任意，A错）和齐次性（对任意标量、向量，D对）；必满足（B错），可改变向量维度（如，C错）。

11. 答案：C
    解析：Transformer解码器的第一个Multi-Head Attention为Masked Self-Attention（防止未来信息泄露，D对），第二个为Encoder-Decoder Cross-Attention（K、V来自编码器，B对、C错），且额外包含交叉注意力层（A对），故选择C。

12. 答案：D
    解析：直方图、拟合优度检验、偏度/峰度系数均用于检验正态性；T检验用于检验均值差异（如两样本均值比较），不用于正态性检验，故选择D。

13. 答案：C
    解析：次品数服从二项分布，当大、小时，二项分布近似泊松分布（参数）；均匀分布是连续分布，伯努利分布为单次试验，正态分布需和均较大，故选择C。

14. 答案：A
    解析：函数的根为（单根）和（二重根）。初值收敛到，牛顿迭代法对单根收敛速度为二次，对重根为线性，但本题中是单根，实际计算中因导数特性呈超线性收敛，故选择A。

15. 答案：C
    解析：PCA通过最大化主成分的方差保留数据信息，选择主成分的核心依据是方差贡献率（累计方差贡献率通常需达到80%-90%）；样本分布密度、特征相关性、数据类别分布均非PCA选择主成分的关键，故选择C。

不定项选择题（共5题）

16. 答案：ACD
    解析：泊松过程中，均值为（A对）；已知个事件时，发生时刻服从均匀分布的顺序统计量，非独立同分布（B错）；首次到达时间及相邻间隔均服从参数的指数分布，且相互独立（C、D对）。

17. 答案：BCD
    解析：GMM的M-step中，协方差矩阵需正定（否则无意义，B对），各成分权重和为1（约束条件，C对），均值更新为加权平均（权重为后验概率，D对）；协方差矩阵可非对角（A错），故选择BCD。

18. 答案：ACD
    解析：A满足线性变换的可加性和齐次性（对）；B含常数项1，不满足（错）；线性变换的和仍为线性变换（C对）；D是线性变换的定义式（对），故选择ACD。

19. 答案：ABCD
    解析：ReLU在输入负时输出0、正时输出自身（A对）；Tanh输出范围，常用于隐藏层（B对）；Sigmoid导数在时最大（0.25），随增大而减小（C对）；Softmax将输入归一化为概率分布，和为1（D对），故选择ABCD。

20. 答案：ABD
    解析：MLLM的独特挑战包括跨模态语义理解与生成（A对）、多模态实时处理延迟（B对）、多模态数据对齐（D对）；模型参数量增长是LLM和MLLM共有的挑战（非独特，C错），故选择ABD。

编程21

一、解题思路

1. 数据读取与预处理

• 读取输入：先读取训练样本数量及对应的条训练数据，再读取预测样本数量及对应的条预测数据，数据需按“设备ID、写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限、状态”的格式解析。
• 缺失值处理：将数据中的缺失值（标记为“NaN”）用对应字段有效值的均值填充，需先筛选出各字段非“NaN”的有效数据，计算均值后替换缺失值。
• 异常值处理：根据规则判定异常值（写入/读取次数<0；平均写入/读取延迟<0或>1000；使用年限<0或>20），用对应字段有效值的中位数替换异常值，同样需先筛选有效数据计算中位数。

2. 逻辑回归模型训练（批量梯度下降）

• 特征与标签提取：从预处理后的训练数据中提取特征（写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限）和标签（设备状态，0为正常、1为故障）。
• 特征标准化：为提升梯度下降收敛速度，对特征进行标准化（均值归一化，即，为特征均值，为特征标准差）。
• 批量梯度下降迭代：初始权重全为0，学习率，迭代100次。每次迭代计算预测值（通过sigmoid函数）、损失函数梯度，更新权重。

3. 预测与输出

• 预测数据预处理：对预测数据执行与训练数据相同的缺失值、异常值处理及特征标准化（使用训练数据的特征均值和标准差，避免数据泄露）。
• 结果预测：将预处理后的预测特征代入训练好的逻辑回归模型，通过sigmoid函数得到概率，概率≥0.5预测为1（故障），否则预测为0（正常），按顺序输出预测结果。

二、Python代码实现

import numpy as np

def preprocess_data(data, train_stats=None, is_train=True):
    """
    数据预处理：处理缺失值和异常值，训练数据计算统计量，预测数据使用训练统计量
    data: 输入数据（二维列表，每行对应一条数据，列：[写入次数, 读取次数, 平均写入延迟, 平均读取延迟, 设备使用年限]）
    train_stats: 训练数据的统计量（均值、中位数、标准差），is_train=False时需传入
    is_train: 是否为训练数据（True/False）
    return: 预处理后的数据，训练数据时额外返回统计量
    """
    data = np.array(data, dtype=np.float64)
    n_features = data.shape[1]
    stats = {}  # 存储训练数据的统计量：mean（均值）、median（中位数）、std（标准差）
    
    if is_train:
        # 计算训练数据各字段的均值、中位数、标准差（忽略NaN）
        for i in range(n_features):
            valid = data[~np.isnan(data[:, i]), i]
            stats[f'mean_{i}'] = np.mean(valid)
            stats[f'median_{i}'] = np.median(valid)
            stats[f'std_{i}'] = np.std(valid) if len(valid) > 1 else 1.0  # 避免标准差为0
    else:
        # 预测数据使用训练数据的统计量
        stats = train_stats
    
    # 处理缺失值（用均值填充）
    for i in range(n_features):
        data[np.isnan(data[:, i]), i] = stats[f'mean_{i}']
    
    # 处理异常值（用中位数填充）
    # 特征0：写入次数，特征1：读取次数（异常值<0）
    for i in [0, 1]:
        data[data[:, i] < 0, i] = stats[f'median_{i}']
    # 特征2：平均写入延迟，特征3：平均读取延迟（异常值<0或>1000）
    for i in [2, 3]:
        mask = (data[:, i] < 0) | (data[:, i] > 1000)
        data[mask, i] = stats[f'median_{i}']
    # 特征4：设备使用年限（异常值<0或>20）
    mask = (data[:, 4] < 0) | (data[:, 4] > 20)
    data[mask, 4] = stats[f'median_4']
    
    # 训练数据标准化（预测数据后续用训练统计量标准化）
    if is_train:
        normalized_data = (data - np.array([stats[f'mean_{i}'] for i in range(n_features)])) / \
                          np.array([stats[f'std_{i}'] for i in range(n_features)])
        return normalized_data, stats
    else:
        return data

def sigmoid(z):
    """sigmoid激活函数，避免数值溢出"""
    return np.where(z >= 0, 1 / (1 + np.exp(-z)), np.exp(z) / (1 + np.exp(z)))

def train_logistic_regression(X, y, epochs=100, alpha=0.01):
    """
    批量梯度下降训练逻辑回归模型
    X: 标准化后的训练特征（n_samples × n_features）
    y: 训练标签（n_samples × 1）
    epochs: 迭代次数
    alpha: 学习率
    return: 训练好的权重w
    """
    n_samples, n_features = X.shape
    # 初始化权重（含偏置项，故特征维度+1，先给X添加偏置列）
    X_with_bias = np.hstack([np.ones((n_samples, 1)), X])  # (n_samples, n_features+1)
    w = np.zeros((n_features + 1, 1))  # 初始权重全0
    
    for _ in range(epochs):
        # 计算预测概率
        y_pred_prob = sigmoid(np.dot(X_with_bias, w))
        # 计算梯度（批量梯度，使用全部样本）
        gradient = (1 / n_samples) * np.dot(X_with_bias.T, (y_pred_prob - y.reshape(-1, 1)))
        # 更新权重
        w -= alpha * gradient
    
    return w

def predict(w, X_test, train_stats):
    """
    模型预测
    w: 训练好的权重
    X_test: 预处理后的预测特征（未标准化）
    train_stats: 训练数据的统计量（用于标准化）
    return: 预测结果（0/1）
    """
    n_features = X_test.shape[1]
    # 用训练数据的均值和标准差标准化预测特征
    X_test_norm = (X_test - np.array([train_stats[f'mean_{i}'] for i in range(n_features)])) / \
                  np.array([train_stats[f'std_{i}'] for i in range(n_features)])
    # 添加偏置列
    X_test_with_bias = np.hstack([np.ones((X_test_norm.shape[0], 1)), X_test_norm])
    # 计算预测概率并转为标签（≥0.5为1，否则为0）
    y_pred_prob = sigmoid(np.dot(X_test_with_bias, w))
    y_pred = (y_pred_prob >= 0.5).astype(int).flatten()
    return y_pred

def main():
    # 读取输入（注意：实际考试中需从标准输入读取，此处模拟输入格式）
    import sys
    input_lines = [line.strip() for line in sys.stdin if line.strip()]
    ptr = 0
    
    # 读取训练数据
    N = int(input_lines[ptr])
    ptr += 1
    train_data = []
    train_labels = []
    for _ in range(N):
        parts = input_lines[ptr].split()
        ptr += 1
        # 提取特征（索引1-5：写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限）
        features = [float(p) if p != 'NaN' else np.nan for p in parts[1:6]]
        # 提取标签（索引6：设备状态）
        label = int(parts[6])
        train_data.append(features)
        train_labels.append(label)
    
    # 读取预测数据
    M = int(input_lines[ptr])
    ptr += 1
    test_data = []
    for _ in range(M):
        parts = input_lines[ptr].split()
        ptr += 1
        # 提取特征（同训练数据，状态字段无意义）
        features = [float(p) if p != 'NaN' else np.nan for p in parts[1:6]]
        test_data.append(features)
    
    # 1. 预处理训练数据
    X_train_norm, train_stats = preprocess_data(train_data, is_train=True)
    y_train = np.array(train_labels)
    
    # 2. 训练逻辑回归模型
    w = train_logistic_regression(X_train_norm, y_train, epochs=100, alpha=0.01)
    
    # 3. 预处理预测数据并预测
    X_test_processed = preprocess_data(test_data, train_stats=train_stats, is_train=False)
    y_pred = predict(w, X_test_processed, train_stats)
    
    # 4. 输出预测结果
    for pred in y_pred:
        print(pred)

if __name__ == "__main__":
    main()

编程22

一、解题思路

1. 输入校验与初始化

• 核心校验：首先判断专家总数是否能被NPU个数整除（若不能，直接输出“error”），确保专家可平均分配到每个NPU形成连续编号的专家组；同时后续需确认目标NPU对应的专家总数不小于（若不足，同样输出“error”）。
• 数据初始化：读取专家概率列表，与专家编号（0到）一一对应，便于后续按概率筛选专家。

2. 专家分组（按NPU划分）

• 计算每组专家数：每组专家数量，确保每个NPU对应一个包含个连续编号专家的组（如、时，组1为专家0-2，组2为专家3-5）。
• 构建分组数据：遍历所有专家，按编号归属划分到对应组，同时记录每组的最大概率（作为该组的“代表概率”，用于筛选目标NPU）。

3. 筛选目标NPU

• 按组概率排序：将所有组按“代表概率”降序排列，选择前个组（即概率最大的个组），其对应的NPU即为路由目标限制NPU。
• 收集目标专家池：汇总这个目标组内的所有专家（含编号和概率），形成待选专家池。

4. 筛选目标专家与输出

• 按专家概率排序：将待选专家池中的专家按概率降序排列，选择前个专家（若专家池总数不足，输出“error”）。
• 结果格式化：将选中的个专家按编号从小到大排序，用空格分隔输出，确保行尾无空格。

二、Python代码实现

def main():
    import sys
    # 读取输入（第一行：n, m, p, k；第二行：n个专家概率）
    input_lines = [line.strip() for line in sys.stdin if line.strip()]
    if len(input_lines) < 2:
        print("error")
        return
    
    # 解析第一行参数（专家数n、NPU数m、目标NPU数p、目标专家数k）
    try:
        n, m, p, k = map(int, input_lines[0].split())
        # 校验参数范围（题目规定区间[1,10000]）
        if not (1 <= n <= 10000 and 1 <= m <= 10000 and 1 <= p <= 10000 and 1 <= k <= 10000):
            print("error")
            return
    except ValueError:
        print("error")
        return
    
    # 解析第二行专家概率（n个浮点数，区间(0,1)）
    try:
        probs = list(map(float, input_lines[1].split()))
        if len(probs) != n:
            print("error")
            return
        # 校验概率范围（题目规定(0,1)，此处允许微小精度误差）
        for prob in probs:
            if not (0 < prob < 1):
                print("error")
                return
    except ValueError:
        print("error")
        return
    
    # 第一步：校验专家能否平均分配到NPU（n必须被m整除）
    if n % m != 0:
        print("error")
        return
    group_size = n // m  # 每个NPU对应的专家数量（每组专家数）
    
    # 第二步：构建专家组（按NPU分组，记录每组的专家编号、概率及组最大概率）
    groups = []  # 元素格式：(组最大概率, 组内专家列表)，组内专家格式：(专家编号, 专家概率)
    for group_idx in range(m):
        # 计算当前组专家的编号范围（连续编号）
        start_idx = group_idx * group_size
        end_idx = start_idx + group_size
        group_experts = []
        max_prob_in_group = 0.0
        # 遍历组内专家，收集编号、概率并找组内最大概率
        for expert_idx in range(start_idx, end_idx):
            prob = probs[expert_idx]
            group_experts.append((expert_idx, prob))
            if prob > max_prob_in_group:
                max_prob_in_group = prob
        groups.append((max_prob_in_group, group_experts))
    
    # 第三步：筛选概率最大的p个组（目标NPU对应的组）
    # 按组最大概率降序排序，取前p个组
    groups_sorted = sorted(groups, key=lambda x: x[0], reverse=True)
    target_groups = groups_sorted[:p]
    
    # 第四步：收集目标组内的所有专家，形成待选专家池
    candidate_experts = []
    for _, experts in target_groups:
        candidate_experts.extend(experts)
    
    # 校验待选专家数是否足够k个（不足则输出error）
    if len(candidate_experts) < k:
        print("error")
        return
    
    # 第五步：按专家概率降序排序，选择前k个专家，再按编号升序排列
    # 先按概率降序，概率相同则按编号升序（避免概率一致时排序混乱）
    candidate_experts_sorted = sorted(candidate_experts, key=lambda x: (-x[1], x[0]))
    selected_experts = candidate_experts_sorted[:k]
    # 按专家编号升序排列输出
    selected_ids = sorted([expert[0] for expert in selected_experts])
    
    # 第六步：格式化输出（空格分隔，行尾无空格）
    print(' '.join(map(str, selected_ids)))

if __name__ == "__main__":
    main()