【2024年华为OD机试】 (B卷,100分)- 路灯照明问题（Java JS PythonC/C++）

在这里插入图片描述

一、问题描述

路灯照明问题

题目描述

在一条笔直的公路上安装了 ( N ) 个路灯，从位置 0 开始安装，路灯之间间距固定为 100 米。每个路灯都有自己的照明半径。请计算第一个路灯和最后一个路灯之间，无法照明的区间的长度和。

输入描述

第一行为一个数 ( N )，表示路灯个数，( 1 \leq N \leq 100000 )。
第二行为 ( N ) 个空格分隔的数，表示路灯的照明半径，( 1 \leq \text{照明半径} \leq 100000 \times 100 )。

输出描述

第一个路灯和最后一个路灯之间，无法照明的区间的长度和。

用例

输入 1

2
50 50

输出 1

说明 1

路灯 1 覆盖范围：( [0, 50] )。
路灯 2 覆盖范围：( [50, 100] )。
路灯 1 和路灯 2 之间（0 米 - 100 米）无未覆盖的区间。

输入 2

4
50 70 20 70

输出 2

说明 2

路灯 1 覆盖范围：( [0, 50] )。
路灯 2 覆盖范围：( [30, 170] )。
路灯 3 覆盖范围：( [180, 220] )。
路灯 4 覆盖范围：( [230, 370] )。
未覆盖的区间：( [170, 180] ) 和 ( [220, 230] )，总长度为 20 米。

题目解析

问题分析

路灯位置：
- 路灯的位置是固定的，第 ( i ) 个路灯的位置为 ( i \times 100 ) 米。
照明范围：
- 每个路灯的照明范围是一个区间，中心为路灯的位置，半径为照明半径。
- 假设第 ( i ) 个路灯的位置为 ( \text{center} = i \times 100 )，照明半径为 ( r )，则照明范围为 ( [\text{center} - r, \text{center} + r] )。
问题转化：
- 将所有路灯的照明范围区间合并，得到一组连续的照明区间。
- 计算这些合并后的区间之间的间隙长度之和，即为无法照明的区间长度和。

解决思路

区间表示：
- 对于每个路灯，计算其照明范围区间 ( [\text{center} - r, \text{center} + r] )。
区间排序：
- 将所有区间按照起始位置升序排序。
- 如果起始位置相同，则按照结束位置降序排序。
区间合并：
- 遍历排序后的区间，依次合并有交集的区间。
- 合并后的区间为 ( [\text{start}, \text{end}] )，其中：
  - ( \text{start} ) 为当前区间的起始位置。
  - ( \text{end} ) 为当前区间的结束位置。
计算间隙：
- 遍历合并后的区间，计算相邻区间之间的间隙长度。
- 将所有间隙长度累加，得到无法照明的区间长度和。

关键点

区间排序：
- 按照起始位置升序排序，确保区间按顺序处理。
- 如果起始位置相同，按照结束位置降序排序，简化合并逻辑。
区间合并：
- 判断当前区间与前一个合并后的区间是否有交集。
- 如果有交集，则更新合并后的区间的结束位置。
间隙计算：
- 遍历合并后的区间，计算相邻区间的间隙长度。
- 间隙长度为后一个区间的起始位置减去前一个区间的结束位置。

示例解析

输入 1

2
50 50

路灯 1 的照明范围：( [0 - 50, 0 + 50] = [0, 50] )。
路灯 2 的照明范围：( [100 - 50, 100 + 50] = [50, 150] )。
合并后的区间：( [0, 150] )。
无法照明的区间长度和：( 0 )。

输入 2

4
50 70 20 70

路灯 1 的照明范围：( [0 - 50, 0 + 50] = [0, 50] )。
路灯 2 的照明范围：( [100 - 70, 100 + 70] = [30, 170] )。
路灯 3 的照明范围：( [200 - 20, 200 + 20] = [180, 220] )。
路灯 4 的照明范围：( [300 - 70, 300 + 70] = [230, 370] )。
合并后的区间：( [0, 170] )、( [180, 220] )、( [230, 370] )。
无法照明的区间：( [170, 180] ) 和 ( [220, 230] )，总长度为 20 米。

通过以上分析，可以清晰地理解题目的要求和解题思路。

二、JavaScript算法源码

以下是您提供的 JavaScript 代码的详细解析和注释，帮助您更好地理解代码的逻辑和实现。

代码解析

1. 输入获取

const readline = require("readline");const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});const lines = [];
rl.on("line", (line) => {lines.push(line);if (lines.length === 2) {const n = lines[0] - 0;const arr = lines[1].split(" ").map(Number);console.log(getResult(n, arr));lines.length = 0;}
});

功能：
- 使用 Node.js 的 readline 模块创建一个接口，用于从标准输入读取数据。
- 将输入的行数据存储到 lines 数组中。
- 当输入的行数达到 2 行时，解析输入数据并调用 getResult 函数计算结果。
- 输出结果后，清空 lines 数组，以便处理下一组输入。

2. 算法实现

function getResult(n, arr) {const ranges = []; // 存储所有路灯的照明范围区间// 计算每个路灯的照明范围for (let i = 0; i < n; i++) {const center = i * 100; // 路灯的位置ranges.push([center - arr[i], center + arr[i]]); // 照明范围区间 [start, end]}// 按起始位置升序排序，起始位置相同则按结束位置降序排序ranges.sort((a, b) => (a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]));let ans = 0; // 无法照明的区间长度和let t = ranges[0][1]; // 上一个区间的结束位置for (let i = 1; i < n; i++) {const [s, e] = ranges[i]; // 当前区间的【开始位置，结束位置】// 有交集if (t >= s) {// 合并后的新区间将变为下一轮的上一个区间，t 为新区间的结束位置t = Math.max(e, t);} else {// 没有交集，则统计区间间隙 s - tans += s - t;// 当前区间变为下一轮的上一个区间，更新 tt = e;}}return ans;
}

功能：
- 计算每个路灯的照明范围区间，并存储到 ranges 数组中。
- 对 ranges 数组进行排序：
  - 按起始位置升序排序。
  - 如果起始位置相同，则按结束位置降序排序。
- 遍历排序后的区间，合并有交集的区间，并计算无法照明的区间长度和。
- 返回无法照明的区间长度和。

代码逻辑总结

输入处理：
- 读取路灯数量 ( n )。
- 读取每个路灯的照明半径，并存储到 arr 数组中。
照明范围计算：
- 对于每个路灯，计算其照明范围区间 ( [\text{center} - r, \text{center} + r] )，其中 ( \text{center} = i \times 100 )。
区间排序：
- 将所有照明范围区间按起始位置升序排序。
- 如果起始位置相同，则按结束位置降序排序。
区间合并与间隙计算：
- 遍历排序后的区间，合并有交集的区间。
- 计算相邻区间之间的间隙长度，并累加到 ans 中。
输出结果：
- 返回无法照明的区间长度和。

示例运行

输入 1

2
50 50

输出 1

说明 1

路灯 1 的照明范围：( [0 - 50, 0 + 50] = [0, 50] )。
路灯 2 的照明范围：( [100 - 50, 100 + 50] = [50, 150] )。
合并后的区间：( [0, 150] )。
无法照明的区间长度和：( 0 )。

输入 2

4
50 70 20 70

输出 2

说明 2

路灯 1 的照明范围：( [0 - 50, 0 + 50] = [0, 50] )。
路灯 2 的照明范围：( [100 - 70, 100 + 70] = [30, 170] )。
路灯 3 的照明范围：( [200 - 20, 200 + 20] = [180, 220] )。
路灯 4 的照明范围：( [300 - 70, 300 + 70] = [230, 370] )。
合并后的区间：( [0, 170] )、( [180, 220] )、( [230, 370] )。
无法照明的区间：( [170, 180] ) 和 ( [220, 230] )，总长度为 20 米。

代码详细注释

const readline = require("readline");const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});const lines = [];
rl.on("line", (line) => {lines.push(line);if (lines.length === 2) {const n = lines[0] - 0; // 读取路灯数量const arr = lines[1].split(" ").map(Number); // 读取照明半径并转换为数字数组console.log(getResult(n, arr)); // 调用算法并输出结果lines.length = 0; // 清空输入缓存}
});function getResult(n, arr) {const ranges = []; // 存储所有路灯的照明范围区间// 计算每个路灯的照明范围for (let i = 0; i < n; i++) {const center = i * 100; // 路灯的位置ranges.push([center - arr[i], center + arr[i]]); // 照明范围区间 [start, end]}// 按起始位置升序排序，起始位置相同则按结束位置降序排序ranges.sort((a, b) => (a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]));let ans = 0; // 无法照明的区间长度和let t = ranges[0][1]; // 上一个区间的结束位置for (let i = 1; i < n; i++) {const [s, e] = ranges[i]; // 当前区间的【开始位置，结束位置】// 有交集if (t >= s) {// 合并后的新区间将变为下一轮的上一个区间，t 为新区间的结束位置t = Math.max(e, t);} else {// 没有交集，则统计区间间隙 s - tans += s - t;// 当前区间变为下一轮的上一个区间，更新 tt = e;}}return ans; // 返回无法照明的区间长度和
}

希望这段代码和注释对您有帮助！如果有其他问题，欢迎随时提问！

三、Java算法源码

这段Java代码的主要功能是处理一组区间（ranges），计算这些区间之间的间隙总和。下面是对代码的详细注释和讲解：

1. 导入必要的类

import java.util.Arrays;
import java.util.Scanner;

Arrays 类用于数组操作，比如排序。
Scanner 类用于从标准输入读取数据。

2. 主类 `Main`

public class Main {public static void main(String[] args) {// 创建一个Scanner对象，用于读取输入Scanner sc = new Scanner(System.in);// 读取区间的数量nint n = sc.nextInt();// 创建一个二维数组ranges，用于存储每个区间的起始和结束位置int[][] ranges = new int[n][2];// 循环读取每个区间的半径，并计算区间的起始和结束位置for (int i = 0; i < n; i++) {int center = i * 100; // 区间的中心位置int r = sc.nextInt(); // 读取区间的半径ranges[i][0] = center - r; // 区间的起始位置ranges[i][1] = center + r; // 区间的结束位置}// 调用getResult方法计算区间间隙总和，并输出结果System.out.println(getResult(n, ranges));}

main 方法是程序的入口。
Scanner 对象 sc 用于从标准输入读取数据。
n 是区间的数量。
ranges 是一个二维数组，存储每个区间的起始和结束位置。
通过循环读取每个区间的半径，并计算区间的起始和结束位置。

3. `getResult` 方法

  public static int getResult(int n, int[][] ranges) {int ans = 0; // 初始化间隙总和为0// 按起始位置升序排序，如果起始位置相同，则按结束位置降序排序Arrays.sort(ranges, (a, b) -> a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]);// 初始化上一个区间的结束位置为第一个区间的结束位置int t = ranges[0][1];// 遍历剩余的区间for (int i = 1; i < n; i++) {// 当前区间的【开始位置，结束位置】int s = ranges[i][0];int e = ranges[i][1];// 如果当前区间与上一个区间有交集if (t >= s) {// 合并区间，更新t为当前区间和上一个区间的最大结束位置t = Math.max(e, t);} else {// 如果没有交集，则计算间隙并累加到ansans += s - t;// 更新t为当前区间的结束位置t = e;}}// 返回区间间隙总和return ans;}
}

ans 用于存储区间间隙的总和。
Arrays.sort 对区间进行排序，首先按起始位置升序排序，如果起始位置相同，则按结束位置降序排序。
t 用于记录上一个区间的结束位置。
遍历剩余的区间，检查当前区间与上一个区间是否有交集：
- 如果有交集，则合并区间，更新 t 为当前区间和上一个区间的最大结束位置。
- 如果没有交集，则计算间隙并累加到 ans，然后更新 t 为当前区间的结束位置。
最后返回区间间隙总和 ans。

4. 代码逻辑总结

该代码首先读取一组区间的半径，并计算每个区间的起始和结束位置。
然后对这些区间进行排序，确保它们按起始位置升序排列。
接着遍历这些区间，计算它们之间的间隙总和。
最终输出区间间隙的总和。

5. 代码执行流程

读取输入的区间数量 n。
读取每个区间的半径，并计算区间的起始和结束位置。
对区间进行排序。
遍历区间，计算间隙总和。
输出结果。

6. 代码的适用场景

该代码适用于需要计算一组区间之间间隙总和的场景，例如在时间调度、资源分配等领域中，计算时间或资源的空闲时间。

四、Python算法源码

这段Python代码的功能与之前的Java代码类似，也是处理一组区间并计算它们之间的间隙总和。以下是代码的详细注释和讲解：

1. 输入获取

n = int(input())
arr = list(map(int, input().split()))

n 是区间的数量。
arr 是一个列表，存储每个区间的半径。

2. 算法入口 `getResult`

def getResult():rans = []  # 用于存储每个区间的起始和结束位置

rans 是一个列表，用于存储每个区间的起始和结束位置。

3. 计算每个区间的起始和结束位置

    for i in range(n):center = i * 100  # 区间的中心位置rans.append([center - arr[i], center + arr[i]])  # 计算区间的起始和结束位置

对于每个区间，计算其中心位置 center = i * 100。
根据半径 arr[i]，计算区间的起始位置 center - arr[i] 和结束位置 center + arr[i]，并将其添加到 rans 列表中。

4. 对区间进行排序

    # 按起始位置升序，起始位置相同，则继续按结束位置降序rans.sort(key=lambda ran: (ran[0], -ran[1]))

使用 sort 方法对区间进行排序：
- 首先按起始位置升序排序。
- 如果起始位置相同，则按结束位置降序排序。

5. 初始化变量

    ans = 0  # 用于存储区间间隙的总和t = rans[0][1]  # 上一个区间的结束位置

ans 用于存储区间间隙的总和，初始值为 0。
t 用于记录上一个区间的结束位置，初始值为第一个区间的结束位置。

6. 遍历区间并计算间隙

    for i in range(1, n):s, e = rans[i]  # 当前区间的【开始位置，结束位置】# 有交集if t >= s:# 合并后的新区间将变为下一轮的上一个区间，t为新区间的结束位置t = max(e, t)else:# 没有交集，则统计区间间隙 s - tans += s - t# 当前区间变为下一轮的上一个区间，更新tt = e

遍历剩余的区间：
- s 是当前区间的起始位置，e 是当前区间的结束位置。
- 如果当前区间与上一个区间有交集（即 t >= s），则合并区间，更新 t 为当前区间和上一个区间的最大结束位置。
- 如果没有交集，则计算间隙 s - t 并累加到 ans，然后更新 t 为当前区间的结束位置。

7. 返回结果

    return ans

返回区间间隙的总和 ans。

8. 算法调用

print(getResult())

调用 getResult 函数并输出结果。

9. 代码逻辑总结

输入获取：
- 读取区间的数量 n 和每个区间的半径 arr。
区间计算：
- 根据半径计算每个区间的起始和结束位置，并存储在 rans 列表中。
区间排序：
- 对区间按起始位置升序排序，起始位置相同时按结束位置降序排序。
间隙计算：
- 遍历区间，计算区间之间的间隙总和。
输出结果：
- 返回并输出区间间隙的总和。

10. 代码执行流程

读取输入的区间数量 n 和半径列表 arr。
计算每个区间的起始和结束位置。
对区间进行排序。
遍历区间，计算间隙总和。
输出结果。

11. 代码的适用场景

该代码适用于需要计算一组区间之间间隙总和的场景，例如：
- 时间调度中的空闲时间计算。
- 资源分配中的空闲资源计算。
- 区间覆盖问题的间隙分析。

12. 示例运行

输入：

3
20 30 10

计算过程：

计算区间：
- 区间 0：[0 - 20, 0 + 20] = [-20, 20]
- 区间 1：[100 - 30, 100 + 30] = [70, 130]
- 区间 2：[200 - 10, 200 + 10] = [190, 210]
排序区间：
- 排序后：[[-20, 20], [70, 130], [190, 210]]
计算间隙：
- 区间 0 和区间 1 之间的间隙：70 - 20 = 50
- 区间 1 和区间 2 之间的间隙：190 - 130 = 60
- 总间隙：50 + 60 = 110

输出：

五、C/C++算法源码：

以下是 C语言 和 C++ 版本的代码，并附带详细的中文注释和讲解。

C语言代码

#include <stdio.h>
#include <stdlib.h>#define MAX(a, b) (a) > (b) ? (a) : (b)  // 定义一个宏，用于求两个数的最大值// 函数声明
int getResult(int n, int ranges[][2]);  // 计算区间间隙总和的函数
int cmp(const void* a, const void* b);  // 用于qsort的比较函数int main() {int n;scanf("%d", &n);  // 读取区间的数量int ranges[n][2];  // 定义一个二维数组，存储每个区间的起始和结束位置// 读取每个区间的半径，并计算区间的起始和结束位置for (int i = 0; i < n; i++) {int center = i * 100;  // 区间的中心位置int r;scanf("%d", &r);  // 读取区间的半径ranges[i][0] = center - r;  // 区间的起始位置ranges[i][1] = center + r;  // 区间的结束位置}// 调用getResult函数计算区间间隙总和，并输出结果printf("%d\n", getResult(n, ranges));return 0;
}// 计算区间间隙总和的函数
int getResult(int n, int ranges[][2]) {int ans = 0;  // 初始化间隙总和为0// 使用qsort对区间进行排序// 排序规则：按起始位置升序，起始位置相同则按结束位置降序qsort(ranges, n, sizeof(int*), cmp);int t = ranges[0][1];  // 初始化上一个区间的结束位置为第一个区间的结束位置// 遍历剩余的区间for (int i = 1; i < n; i++) {int s = ranges[i][0];  // 当前区间的起始位置int e = ranges[i][1];  // 当前区间的结束位置if (t >= s) {// 有交集，合并区间t = MAX(e, t);  // 更新t为当前区间和上一个区间的最大结束位置} else {// 没有交集，计算间隙并累加到ansans += s - t;t = e;  // 更新t为当前区间的结束位置}}return ans;  // 返回区间间隙总和
}// 用于qsort的比较函数
int cmp(const void* a, const void* b) {int* A = (int*)a;int* B = (int*)b;// 按起始位置升序，起始位置相同则按结束位置降序return A[0] != B[0] ? A[0] - B[0] : B[1] - A[1];
}

C语言代码讲解

宏定义：
- #define MAX(a, b)：定义一个宏，用于求两个数的最大值。
主函数 main：
- 读取区间的数量 n。
- 定义一个二维数组 ranges，用于存储每个区间的起始和结束位置。
- 通过循环读取每个区间的半径，并计算区间的起始和结束位置。
- 调用 getResult 函数计算区间间隙总和，并输出结果。
getResult 函数：
- 初始化间隙总和 ans 为 0。
- 使用 qsort 对区间进行排序，排序规则为按起始位置升序，起始位置相同则按结束位置降序。
- 初始化 t 为第一个区间的结束位置。
- 遍历剩余的区间，检查当前区间与上一个区间是否有交集：
  - 如果有交集，则合并区间，更新 t 为当前区间和上一个区间的最大结束位置。
  - 如果没有交集，则计算间隙并累加到 ans，然后更新 t 为当前区间的结束位置。
- 返回区间间隙总和 ans。
cmp 函数：
- 用于 qsort 的比较函数，按起始位置升序，起始位置相同则按结束位置降序。

C++代码

#include <iostream>
#include <vector>
#include <algorithm>using namespace std;// 定义一个宏，用于求两个数的最大值
#define MAX(a, b) (a) > (b) ? (a) : (b)// 计算区间间隙总和的函数
int getResult(int n, vector<vector<int>>& ranges) {int ans = 0;  // 初始化间隙总和为0// 使用sort对区间进行排序// 排序规则：按起始位置升序，起始位置相同则按结束位置降序sort(ranges.begin(), ranges.end(), [](const vector<int>& a, const vector<int>& b) {return a[0] != b[0] ? a[0] < b[0] : a[1] > b[1];});int t = ranges[0][1];  // 初始化上一个区间的结束位置为第一个区间的结束位置// 遍历剩余的区间for (int i = 1; i < n; i++) {int s = ranges[i][0];  // 当前区间的起始位置int e = ranges[i][1];  // 当前区间的结束位置if (t >= s) {// 有交集，合并区间t = MAX(e, t);  // 更新t为当前区间和上一个区间的最大结束位置} else {// 没有交集，计算间隙并累加到ansans += s - t;t = e;  // 更新t为当前区间的结束位置}}return ans;  // 返回区间间隙总和
}int main() {int n;cin >> n;  // 读取区间的数量vector<vector<int>> ranges(n, vector<int>(2));  // 定义一个二维向量，存储每个区间的起始和结束位置// 读取每个区间的半径，并计算区间的起始和结束位置for (int i = 0; i < n; i++) {int center = i * 100;  // 区间的中心位置int r;cin >> r;  // 读取区间的半径ranges[i][0] = center - r;  // 区间的起始位置ranges[i][1] = center + r;  // 区间的结束位置}// 调用getResult函数计算区间间隙总和，并输出结果cout << getResult(n, ranges) << endl;return 0;
}

C++代码讲解

宏定义：
- #define MAX(a, b)：定义一个宏，用于求两个数的最大值。
主函数 main：
- 读取区间的数量 n。
- 定义一个二维向量 ranges，用于存储每个区间的起始和结束位置。
- 通过循环读取每个区间的半径，并计算区间的起始和结束位置。
- 调用 getResult 函数计算区间间隙总和，并输出结果。
getResult 函数：
- 初始化间隙总和 ans 为 0。
- 使用 sort 对区间进行排序，排序规则为按起始位置升序，起始位置相同则按结束位置降序。
- 初始化 t 为第一个区间的结束位置。
- 遍历剩余的区间，检查当前区间与上一个区间是否有交集：
  - 如果有交集，则合并区间，更新 t 为当前区间和上一个区间的最大结束位置。
  - 如果没有交集，则计算间隙并累加到 ans，然后更新 t 为当前区间的结束位置。
- 返回区间间隙总和 ans。
排序规则：
- 使用 sort 函数，并通过 Lambda 表达式定义排序规则。

总结

C语言 和 C++ 版本的代码逻辑完全一致，只是语法和库函数的使用有所不同。
C语言 使用 qsort 进行排序，而 C++ 使用 sort 函数。
C++ 代码使用了 vector 来存储区间，更加灵活和现代化。

六、尾言

什么是华为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 分。合理分配时间，优先完成自己擅长的题目。
考试环境准备
- 考试前请备好草稿纸和笔。考试中尽量避免离开座位，确保监控画面正常。
- 如需上厕所，请提前规划好时间以减少中途离开监控的可能性。
技术问题处理
- 如果考试中遇到断电、断网、死机等技术问题，可以关闭浏览器并重新打开试卷链接继续作答。
- 出现其他问题，请第一时间联系 HR 或监考人员进行反馈。