【2025年华为OD机试】(E卷,200分)-最大社交距离 （JavaScript&Java & Python&C/C++）
一、问题描述
题目解析：会议室座位安排
题目描述
疫情期间需要保证一定的社交距离，公司组织开交流会议。会议室有一排共 N 个座位，编号分别为 [0, N-1]。要求员工一个接着一个进入会议室，并且可以在任何时候离开会议室。需要满足以下规则：
-
进入规则：
- 每当一个员工进入时，需要坐到最大社交距离（最大化自己和其他人的距离的座位）。
- 如果有多个这样的座位，则坐到索引最小的那个座位。
-
离开规则：
- 元素值为负数，表示出场。例如
-4表示坐在位置4的员工离开。 - 特殊规则：位置
0的员工不会离开。
- 元素值为负数，表示出场。例如
输入描述
- 会议室座位总数
seatNum，满足1 ≤ seatNum ≤ 500。 - 员工的进出顺序
seatOrLeave数组：- 元素值为
1，表示进场。 - 元素值为负数，表示出场（例如
-4表示坐在位置4的员工离开）。
- 元素值为
输出描述
- 最后进来员工，他会坐在第几个位置。如果位置已满，则输出
-1。
示例
示例 1
- 输入：
10
[1, 1, 1, 1, -4, 1] - 输出：
5 - 说明：
- 第一个员工进入，坐在
0号座位。 - 第二个员工进入，坐在
9号座位。 - 第三个员工进入，坐在
4号座位。 - 第四个员工进入，坐在
2号座位。 - 第五个操作，
-4表示4号座位的员工离开。 - 第六个员工进入，坐在
5号座位。
- 第一个员工进入，坐在
解题思路
1. 问题分析
- 会议室有
N个座位，员工按顺序进入或离开。 - 每次进入时，员工需要坐在与其他已占座位距离最大的位置。
- 如果有多个满足条件的位置，选择索引最小的位置。
- 每次离开时，更新座位状态。
2. 核心逻辑
- 初始化：
- 使用一个动态数组
seat记录当前已被占用的座位编号。
- 使用一个动态数组
- 处理操作：
- 遍历操作序列
seatOrLeave，对于每个操作：- 进入操作（值为
1）：- 如果
seat为空，直接坐在0号座位。 - 如果
seat不为空，计算每个相邻已占座位之间的距离，以及第一个座位到0号座位的距离和最后一个座位到N-1的距离。 - 找到最大距离对应的座位，作为新员工的座位。
- 如果
- 离开操作（值为负数）：
- 根据操作值的绝对值找到对应的座位编号，并从
seat数组中移除该座位编号。
- 根据操作值的绝对值找到对应的座位编号，并从
- 进入操作（值为
- 更新
seat数组，确保其有序，以便快速找到最佳座位。
- 遍历操作序列
- 输出结果：
- 处理完所有操作后，输出最后一个进入的员工的座位编号。如果会议室已满，则输出
-1。
- 处理完所有操作后，输出最后一个进入的员工的座位编号。如果会议室已满，则输出
关键点
1. 进入规则
- 最大化社交距离：
- 计算每个相邻已占座位之间的距离。
- 计算第一个座位到
0号座位的距离和最后一个座位到N-1的距离。 - 选择最大距离对应的座位。
- 索引最小优先：
- 如果有多个座位满足最大距离条件，选择索引最小的座位。
2. 离开规则
- 根据操作值的绝对值找到对应的座位编号，并从
seat数组中移除该座位编号。
3. 动态维护座位状态
- 使用一个有序数组
seat记录当前已被占用的座位编号。 - 每次进入或离开操作后，更新
seat数组，并确保其有序。
示例分析
输入
10
[1, 1, 1, 1, -4, 1]
步骤
-
第一个员工进入：
seat为空，直接坐在0号座位。seat = [0]。
-
第二个员工进入：
- 计算最大距离：
- 第一个座位到
0号座位的距离：0。 - 最后一个座位到
9号座位的距离：9 - 0 = 9。
- 第一个座位到
- 选择
9号座位。 seat = [0, 9]。
- 计算最大距离：
-
第三个员工进入：
- 计算相邻已占座位之间的距离：
0和9之间的距离：9 - 0 = 9。
- 选择中间位置
4号座位。 seat = [0, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第四个员工进入：
- 计算相邻已占座位之间的距离：
0和4之间的距离：4 - 0 = 4。4和9之间的距离：9 - 4 = 5。
- 选择
2号座位。 seat = [0, 2, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第五个操作，
-4表示4号座位的员工离开：- 移除
4号座位。 seat = [0, 2, 9]。
- 移除
-
第六个员工进入：
- 计算相邻已占座位之间的距离：
0和2之间的距离：2 - 0 = 2。2和9之间的距离：9 - 2 = 7。
- 选择
5号座位。 seat = [0, 2, 5, 9]。
- 计算相邻已占座位之间的距离：
输出
最后一个进入的员工坐在 5 号座位，输出 5。
总结
本题通过动态维护已占用座位的有序数组，计算每次进入操作时的最佳座位，并处理离开操作更新座位状态。核心在于最大化社交距离并选择索引最小的座位，最终输出最后一个进入的员工的座位编号。
二、JavaScript算法源码
代码详细注释与讲解
const readline = require('readline');
// 创建 readline 接口实例
const rl = readline.createInterface({
input: process.stdin, // 标准输入流
output: process.stdout // 标准输出流
});
// 监听 'line' 事件，每次输入一行触发
rl.on('line', (seatNum) => {
// 再次监听 'line' 事件，获取座位占用和离开的操作序列
rl.on('line', (str) => {
// 解析输入的字符串，去掉首尾的括号，分割后转换为数字数组
const seatOrLeave = str.slice(1, -1).split(',').map(Number);
let seat = []; // 存储已占用的座位
let ans = -1; // 下一个人的最佳座位号
// 遍历操作序列
for (let sol of seatOrLeave) {
if (sol !== 1) {
// 如果操作不是1，表示有员工离开，移除对应座位号
seat = seat.filter(s => s !== -sol);
} else {
// 如果操作是1，表示有员工进入，需要找到最佳座位
if (seat.length === 0) {
// 如果会议室为空，新员工坐在0号座位
ans = 0;
} else {
// 如果会议室不为空，找到最大的空闲区间
let max_distance = seat[0]; // 初始化最大距离为第一个座位号
ans = 0; // 初始化最佳座位号为0
for (let i = 0; i < seat.length; i++) {
// 计算当前座位与下一个座位之间的距离
let distance = i === seat.length - 1 ? seatNum - 1 - seat[i] : Math.floor((seat[i + 1] - seat[i]) / 2);
if (distance > max_distance) {
// 如果当前距离大于最大距离，则更新最大距离和最佳座位号
max_distance = distance;
ans = i === seat.length - 1 ? seatNum - 1 : seat[i] + distance;
}
}
}
// 如果会议室已满，设置最佳座位号为-1
if (seat.length === seatNum) {
ans = -1;
} else {
// 将新员工的座位号加入到座位列表，并按升序排序
seat.push(ans);
seat.sort((a, b) => a - b);
}
}
}
// 输出最后一个操作后的最佳座位号
console.log(ans);
// 关闭 readline 接口实例
rl.close();
});
});
代码讲解
1. 输入处理
- 使用
readline模块创建一个接口实例，用于读取标准输入。 - 监听
line事件，当用户输入一行内容时触发回调函数：- 第一次
line事件读取座位总数seatNum。 - 第二次
line事件读取操作序列的字符串，并解析为整数数组seatOrLeave。
- 第一次
2. 初始化变量
seat：用于存储当前已占用的座位编号，初始化为空数组。ans：用于记录下一个员工的最佳座位号，初始化为-1。
3. 遍历操作序列
- 对于每个操作
sol：- 离开操作：
- 如果
sol不是1（即负数），表示有员工离开，从seat数组中移除对应座位号。
- 如果
- 进入操作：
- 如果
sol是1，表示有员工进入，需要找到最佳座位：- 如果
seat为空，新员工直接坐在0号座位。 - 如果
seat不为空，计算最大空闲区间：- 遍历
seat数组，计算相邻座位之间的距离。 - 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 找到最大距离对应的座位，作为新员工的座位。
- 遍历
- 如果会议室已满（
seat.length === seatNum），设置ans为-1。 - 否则，将新员工的座位号添加到
seat数组，并排序。
- 如果
- 如果
- 离开操作：
4. 输出结果
- 输出最后一个操作后的最佳座位号
ans。 - 关闭
readline接口实例。
关键点
1. 进入规则
- 最大化社交距离：
- 计算相邻已占座位之间的距离。
- 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 选择最大距离对应的座位。
- 索引最小优先：
- 如果有多个座位满足最大距离条件，选择索引最小的座位。
2. 离开规则
- 根据操作值的绝对值找到对应的座位编号，并从
seat数组中移除该座位编号。
3. 动态维护座位状态
- 使用
seat数组记录当前已占用的座位编号。 - 每次进入或离开操作后，更新
seat数组，并确保其有序。
示例分析
输入
10
[1, 1, 1, 1, -4, 1]
步骤
-
第一个员工进入：
seat为空，直接坐在0号座位。seat = [0]。
-
第二个员工进入：
- 计算最大距离：
- 第一个座位到
0号座位的距离：0。 - 最后一个座位到
9号座位的距离：9 - 0 = 9。
- 第一个座位到
- 选择
9号座位。 seat = [0, 9]。
- 计算最大距离：
-
第三个员工进入：
- 计算相邻已占座位之间的距离：
0和9之间的距离：9 - 0 = 9。
- 选择中间位置
4号座位。 seat = [0, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第四个员工进入：
- 计算相邻已占座位之间的距离：
0和4之间的距离：4 - 0 = 4。4和9之间的距离：9 - 4 = 5。
- 选择
2号座位。 seat = [0, 2, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第五个操作，
-4表示4号座位的员工离开：- 移除
4号座位。 seat = [0, 2, 9]。
- 移除
-
第六个员工进入：
- 计算相邻已占座位之间的距离：
0和2之间的距离：2 - 0 = 2。2和9之间的距离：9 - 2 = 7。
- 选择
5号座位。 seat = [0, 2, 5, 9]。
- 计算相邻已占座位之间的距离：
输出
最后一个进入的员工坐在 5 号座位，输出 5。
总结
这段代码通过动态维护已占用座位的有序数组，计算每次进入操作时的最佳座位，并处理离开操作更新座位状态。核心在于最大化社交距离并选择索引最小的座位，最终输出最后一个进入的员工的座位编号。
三、Java算法源码
代码详细注释与讲解
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 创建Scanner对象，用于读取输入
Scanner scanner = new Scanner(System.in);
// 读取座位总数
int seatNum = scanner.nextInt(); // 读取座位总数
scanner.nextLine(); // 读取换行符，避免影响后续输入
// 读取座位占用和离开的操作序列
String str = scanner.nextLine(); // 读取操作序列的字符串
// 去除字符串首尾的括号并分割成数组
String[] parts = str.substring(1, str.length() - 1).split(",");
ArrayList<Integer> seatOrLeave = new ArrayList<>(); // 存储操作序列的列表
for (String part : parts) {
seatOrLeave.add(Integer.parseInt(part.trim())); // 将字符串转换为整数并添加到列表
}
// 初始化变量
ArrayList<Integer> seat = new ArrayList<>(); // 存储已占用的座位编号
int ans = -1; // 下一个人的最佳座位号，初始化为-1
// 遍历操作序列
for (int sol : seatOrLeave) {
if (sol != 1) {
// 如果sol为负数，表示有员工离开，移除对应座位号
seat.remove(Integer.valueOf(-sol)); // 从seat列表中移除该座位号
} else {
// 如果sol为1，表示有员工进入，需要找到最佳座位
if (seat.isEmpty()) {
// 如果会议室为空，新员工坐在0号座位
ans = 0;
} else {
// 如果会议室不为空，找到最大的空闲区间
int maxDistance = seat.get(0); // 初始化最大距离为第一个座位号
ans = 0; // 初始化最佳座位号为0
for (int i = 0; i < seat.size(); i++) {
int distance;
if (i == seat.size() - 1) {
// 检查最后一个座位到座位总数之间的距离
distance = seatNum - 1 - seat.get(i);
} else {
// 检查相邻座位之间的距离
distance = (seat.get(i + 1) - seat.get(i)) / 2;
}
if (distance > maxDistance) {
// 更新最大距离和最佳座位号
maxDistance = distance;
ans = (i == seat.size() - 1) ? seatNum - 1 : seat.get(i) + distance;
}
}
}
// 如果会议室已满，设置最佳座位号为-1
if (seat.size() == seatNum) {
ans = -1;
} else {
// 将新员工的座位号加入到座位列表，并排序
seat.add(ans);
Collections.sort(seat); // 排序以便后续查找最大距离
}
}
}
// 打印最后一个操作后的最佳座位号
System.out.println(ans);
scanner.close(); // 关闭Scanner对象
}
}
代码讲解
1. 输入处理
- 使用
Scanner读取输入：- 读取座位总数
seatNum。 - 读取操作序列的字符串，并去除首尾的方括号
[]。 - 将操作序列按逗号
,分割，并转换为整数列表seatOrLeave。
- 读取座位总数
2. 初始化变量
seat：用于存储当前已占用的座位编号。ans：用于记录下一个员工的最佳座位号，初始化为-1。
3. 遍历操作序列
- 对于每个操作
sol：- 如果
sol不是1（即负数），表示有员工离开，从seat列表中移除对应座位号。 - 如果
sol是1，表示有员工进入，需要找到最佳座位：- 如果
seat为空，新员工直接坐在0号座位。 - 如果
seat不为空，计算最大空闲区间：- 遍历
seat列表，计算相邻座位之间的距离。 - 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 找到最大距离对应的座位，作为新员工的座位。
- 遍历
- 如果会议室已满（
seat.size() == seatNum），设置ans为-1。 - 否则，将新员工的座位号添加到
seat列表，并排序。
- 如果
- 如果
4. 输出结果
- 输出最后一个操作后的最佳座位号
ans。 - 关闭
Scanner对象。
关键点
1. 进入规则
- 最大化社交距离：
- 计算相邻已占座位之间的距离。
- 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 选择最大距离对应的座位。
- 索引最小优先：
- 如果有多个座位满足最大距离条件，选择索引最小的座位。
2. 离开规则
- 根据操作值的绝对值找到对应的座位编号，并从
seat列表中移除该座位编号。
3. 动态维护座位状态
- 使用
seat列表记录当前已占用的座位编号。 - 每次进入或离开操作后，更新
seat列表，并确保其有序。
示例分析
输入
10
[1, 1, 1, 1, -4, 1]
步骤
-
第一个员工进入：
seat为空，直接坐在0号座位。seat = [0]。
-
第二个员工进入：
- 计算最大距离：
- 第一个座位到
0号座位的距离：0。 - 最后一个座位到
9号座位的距离：9 - 0 = 9。
- 第一个座位到
- 选择
9号座位。 seat = [0, 9]。
- 计算最大距离：
-
第三个员工进入：
- 计算相邻已占座位之间的距离：
0和9之间的距离：9 - 0 = 9。
- 选择中间位置
4号座位。 seat = [0, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第四个员工进入：
- 计算相邻已占座位之间的距离：
0和4之间的距离：4 - 0 = 4。4和9之间的距离：9 - 4 = 5。
- 选择
2号座位。 seat = [0, 2, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第五个操作，
-4表示4号座位的员工离开：- 移除
4号座位。 seat = [0, 2, 9]。
- 移除
-
第六个员工进入：
- 计算相邻已占座位之间的距离：
0和2之间的距离：2 - 0 = 2。2和9之间的距离：9 - 2 = 7。
- 选择
5号座位。 seat = [0, 2, 5, 9]。
- 计算相邻已占座位之间的距离：
输出
最后一个进入的员工坐在 5 号座位，输出 5。
总结
这段代码通过动态维护已占用座位的有序列表，计算每次进入操作时的最佳座位，并处理离开操作更新座位状态。核心在于最大化社交距离并选择索引最小的座位，最终输出最后一个进入的员工的座位编号。
四、Python算法源码
代码详细注释与讲解
import math
# 读取输入
seatNum = int(input()) # 读取座位总数
str = input() # 读取座位占用和离开的操作序列
seatOrLeave = list(map(int, str[1:-1].split(","))) # 将字符串转换为整数数组
# 初始化
seat = [] # 存储已占用的座位
ans = -1 # 下一个人的最佳座位号
for sol in seatOrLeave: # 遍历座位占用和离开的操作序列
if sol != 1:
# 如果 sol 为负数，表示有员工离开，移除对应座位号
seat.remove(-sol)
else:
# 如果 sol 为 1，表示有员工进入，需要找到最佳座位
if not seat:
# 如果会议室为空，新员工坐在 0 号座位
ans = 0
else:
# 如果会议室不为空，找到最大的空闲区间
max_distance = seat[0] # 初始化最大距离为第一个座位号
ans = 0 # 初始化最佳座位号为 0
for i in range(len(seat)):
if i == len(seat) - 1:
# 检查最后一个座位到座位总数之间的距离
distance = seatNum - 1 - seat[i]
else:
# 检查相邻座位之间的距离
distance = (seat[i + 1] - seat[i]) // 2
if distance > max_distance:
# 更新最大距离和最佳座位号
max_distance = distance
if i == len(seat) - 1:
ans = seatNum - 1
else:
ans = seat[i] + distance
# 如果会议室已满，输出 -1
if len(seat) == seatNum:
ans = -1
else:
# 将新员工的座位号加入到座位列表，并排序
seat.append(ans)
seat.sort()
print(ans)
代码讲解
1. 输入处理
- 读取座位总数：
- 使用
input()读取座位总数seatNum，并将其转换为整数。
- 使用
- 读取操作序列：
- 使用
input()读取操作序列的字符串。 - 去除字符串首尾的方括号
[]，并按逗号,分割，将结果转换为整数列表seatOrLeave。
- 使用
2. 初始化变量
seat：用于存储当前已占用的座位编号，初始化为空列表。ans：用于记录下一个员工的最佳座位号，初始化为-1。
3. 遍历操作序列
- 对于每个操作
sol：- 离开操作：
- 如果
sol不是1（即负数），表示有员工离开，从seat列表中移除对应座位号。
- 如果
- 进入操作：
- 如果
sol是1，表示有员工进入，需要找到最佳座位：- 如果
seat为空，新员工直接坐在0号座位。 - 如果
seat不为空，计算最大空闲区间：- 遍历
seat列表，计算相邻座位之间的距离。 - 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 找到最大距离对应的座位，作为新员工的座位。
- 遍历
- 如果会议室已满（
len(seat) == seatNum），设置ans为-1。 - 否则，将新员工的座位号添加到
seat列表，并排序。
- 如果
- 如果
- 离开操作：
4. 输出结果
- 输出最后一个操作后的最佳座位号
ans。
关键点
1. 进入规则
- 最大化社交距离：
- 计算相邻已占座位之间的距离。
- 计算第一个座位到
0号座位的距离和最后一个座位到seatNum-1的距离。 - 选择最大距离对应的座位。
- 索引最小优先：
- 如果有多个座位满足最大距离条件，选择索引最小的座位。
2. 离开规则
- 根据操作值的绝对值找到对应的座位编号，并从
seat列表中移除该座位编号。
3. 动态维护座位状态
- 使用
seat列表记录当前已占用的座位编号。 - 每次进入或离开操作后，更新
seat列表，并确保其有序。
示例分析
输入
10
[1, 1, 1, 1, -4, 1]
步骤
-
第一个员工进入：
seat为空，直接坐在0号座位。seat = [0]。
-
第二个员工进入：
- 计算最大距离：
- 第一个座位到
0号座位的距离：0。 - 最后一个座位到
9号座位的距离：9 - 0 = 9。
- 第一个座位到
- 选择
9号座位。 seat = [0, 9]。
- 计算最大距离：
-
第三个员工进入：
- 计算相邻已占座位之间的距离：
0和9之间的距离：9 - 0 = 9。
- 选择中间位置
4号座位。 seat = [0, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第四个员工进入：
- 计算相邻已占座位之间的距离：
0和4之间的距离：4 - 0 = 4。4和9之间的距离：9 - 4 = 5。
- 选择
2号座位。 seat = [0, 2, 4, 9]。
- 计算相邻已占座位之间的距离：
-
第五个操作，
-4表示4号座位的员工离开：- 移除
4号座位。 seat = [0, 2, 9]。
- 移除
-
第六个员工进入：
- 计算相邻已占座位之间的距离：
0和2之间的距离：2 - 0 = 2。2和9之间的距离：9 - 2 = 7。
- 选择
5号座位。 seat = [0, 2, 5, 9]。
- 计算相邻已占座位之间的距离：
输出
最后一个进入的员工坐在 5 号座位，输出 5。
总结
这段代码通过动态维护已占用座位的有序列表，计算每次进入操作时的最佳座位，并处理离开操作更新座位状态。核心在于最大化社交距离并选择索引最小的座位，最终输出最后一个进入的员工的座位编号。
五、C/C++算法源码：
C++ 代码详细注释与讲解
#include 代码讲解
1. 输入处理
- 使用
cin读取座位总数seatNum。 - 使用
getline读取操作序列的字符串，并去掉首尾的方括号[]。 - 使用
stringstream将字符串按逗号,分割，并转换为整数数组seatOrLeave。
2. 寻找最佳座位
findBestSeat函数：- 如果会议室为空，返回
0号座位。 - 如果只有一个人坐，返回最后一个座位。
- 计算最大空闲区间：
- 第一个座位到
0号座位的距离。 - 最后一个座位到
seatNum-1的距离。 - 相邻座位之间的距离。
- 第一个座位到
- 返回最大距离对应的座位。
- 如果会议室为空，返回
3. 处理操作序列
- 遍历操作序列
seatOrLeave：- 进入操作：
- 调用
findBestSeat找到最佳座位。 - 将最佳座位添加到
occupiedSeats数组，并排序。 - 更新
lastSeat。
- 调用
- 离开操作：
- 从
occupiedSeats数组中移除对应座位。
- 从
- 进入操作：
4. 输出结果
- 输出最后一个进入的员工的座位号
lastSeat。
C 语言代码详细注释与讲解
#include 代码讲解
1. 输入处理
- 使用
scanf读取座位总数seatNum。 - 使用
getchar读取换行符。 - 使用
scanf读取操作序列，支持[数字,]或数字,的格式。
2. 处理操作序列
- 遍历操作序列
seatOrLeave：- 离开操作：
- 从
seat数组中移除对应座位。
- 从
- 进入操作：
- 如果会议室为空，坐在
0号座位。 - 否则，计算最大空闲区间并找到最佳座位。
- 将最佳座位添加到
seat数组，并排序。 - 更新
lastSeatIdx。
- 如果会议室为空，坐在
- 离开操作：
3. 输出结果
- 输出最后一个进入的员工的座位号
lastSeatIdx。
总结
C++ 和 C 代码的核心逻辑相同，都是通过动态维护已占用座位的数组，计算每次进入操作时的最佳座位，并处理离开操作更新座位状态。最终输出最后一个进入的员工的座位编号。
六、尾言
什么是华为OD？
华为OD（Outsourcing Developer，外包开发工程师）是华为针对软件开发工程师岗位的一种招聘形式，主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分，算法题的机试至关重要。
为什么刷题很重要？
-
机试是进入技术面的第一关：
华为OD机试（常被称为机考）主要考察算法和编程能力。只有通过机试，才能进入后续的技术面试环节。 -
技术面试需要手撕代码：
技术一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多练习是通过面试的重要保障。 -
入职后的可信考试：
入职华为后，还需要通过“可信考试”。可信考试分为三个等级：- 入门级：主要考察基础算法与编程能力。
- 工作级：更贴近实际业务需求，可能涉及复杂的算法或与工作内容相关的场景题目。
- 专业级：最高等级，考察深层次的算法以及优化能力，与薪资直接挂钩。
刷题策略与说明：
2024年8月14日之后，华为OD机试的题库转为 E卷，由往年题库（D卷、A卷、B卷、C卷）和全新题目组成。刷题时可以参考以下策略：
-
关注历年真题：
- 题库中的旧题占比较大，建议优先刷历年的A卷、B卷、C卷、D卷题目。
- 对于每道题目，建议深度理解其解题思路、代码实现，以及相关算法的适用场景。
-
适应新题目：
- E卷中包含全新题目，需要掌握全面的算法知识和一定的灵活应对能力。
- 建议关注新的刷题平台或交流群，获取最新题目的解析和动态。
-
掌握常见算法：
华为OD考试通常涉及以下算法和数据结构：- 排序算法（快速排序、归并排序等）
- 动态规划（背包问题、最长公共子序列等）
- 贪心算法
- 栈、队列、链表的操作
- 图论（最短路径、最小生成树等）
- 滑动窗口、双指针算法
-
保持编程规范：
- 注重代码的可读性和注释的清晰度。
- 熟练使用常见编程语言，如C++、Java、Python等。
如何获取资源？
-
官方参考：
- 华为招聘官网或相关的招聘平台会有一些参考信息。
- 华为OD的相关公众号可能也会发布相关的刷题资料或学习资源。
-
加入刷题社区：
- 找到可信的刷题交流群，与其他备考的小伙伴交流经验。
- 关注知名的刷题网站，如LeetCode、牛客网等，这些平台上有许多华为OD的历年真题和解析。
-
寻找系统性的教程：
- 学习一本经典的算法书籍，例如《算法导论》《剑指Offer》《编程之美》等。
- 完成系统的学习课程，例如数据结构与算法的在线课程。
积极心态与持续努力：
刷题的过程可能会比较枯燥，但它能够显著提升编程能力和算法思维。无论是为了通过华为OD的招聘考试，还是为了未来的职业发展，这些积累都会成为重要的财富。
考试注意细节
-
本地编写代码
- 在本地 IDE（如 VS Code、PyCharm 等）上编写、保存和调试代码，确保逻辑正确后再复制粘贴到考试页面。这样可以减少语法错误，提高代码准确性。
-
调整心态，保持冷静
- 遇到提示不足或实现不确定的问题时，不必慌张，可以采用更简单或更有把握的方法替代，确保思路清晰。
-
输入输出完整性
- 注意训练和考试时都需要编写完整的输入输出代码，尤其是和题目示例保持一致。完成代码后务必及时调试，确保功能符合要求。
-
快捷键使用
- 删除行可用
Ctrl+D，复制、粘贴和撤销分别为Ctrl+C，Ctrl+V，Ctrl+Z，这些可以正常使用。 - 避免使用
Ctrl+S，以免触发浏览器的保存功能。
- 删除行可用
-
浏览器要求
- 使用最新版的 Google Chrome 浏览器完成考试，确保摄像头开启并正常工作。考试期间不要切换到其他网站，以免影响考试成绩。
-
交卷相关
- 答题前，务必仔细查看题目示例，避免遗漏要求。
- 每完成一道题后，点击【保存并调试】按钮，多次保存和调试是允许的，系统会记录得分最高的一次结果。完成所有题目后，点击【提交本题型】按钮。
- 确保在考试结束前提交试卷，避免因未保存或调试失误而丢分。
-
时间和分数安排
- 总时间：150 分钟；总分：400 分。
- 试卷结构：2 道一星难度题（每题 100 分），1 道二星难度题（200 分）。及格分为 150 分。合理分配时间，优先完成自己擅长的题目。
-
考试环境准备
- 考试前请备好草稿纸和笔。考试中尽量避免离开座位，确保监控画面正常。
- 如需上厕所，请提前规划好时间以减少中途离开监控的可能性。
-
技术问题处理 a
- 如果考试中遇到断电、断网、死机等技术问题，可以关闭浏览器并重新打开试卷链接继续作答。
- 出现其他问题，请第一时间联系 HR 或监考人员进行反馈。
祝你考试顺利，取得理想成绩！