【2024年华为OD机试】 (C卷,100分)- 素数之积（JavaScriptJava PythonC/C++）

一、问题描述

RSA 因数分解问题

题目描述

RSA 加密算法在网络安全世界中无处不在，它利用了极大整数因数分解的困难度。数据越大，安全系数越高。给定一个 32 位正整数，请对其进行因数分解，找出是哪两个素数的乘积。

输入描述

一个正整数 num，满足 0 < num < 2147483647。

输出描述

如果成功找到，以单个空格分割，从小到大输出两个素数；如果分解失败，请输出 -1 -1。

用例

• 输入：15
  输出：3 5

• 输入：27
  输出：-1 -1

题目解析

1. 素数概念

素数（质数）是指大于 1 的自然数，且只能被 1 和它本身整除的数。例如，2、3、5、7、11 等都是素数。

2. 素数判定方法

在解决这个问题之前，我们需要掌握如何判断一个数是否为素数。常见的素数判定方法包括：

• 试除法：从 2 开始，依次试除到该数的平方根，如果都不能整除，则该数为素数。
• 埃拉托斯特尼筛法：适用于筛选一定范围内的素数。
• 米勒-拉宾素性测试：一种概率性算法，适用于大数的素数判定。

3. 题目要求

给定一个 32 位正整数，要求将其分解为两个素数的乘积。如果该数不能分解为两个素数的乘积，则输出 -1 -1。

特殊情况

• 如果给定的数本身就是素数，那么它只能分解为 1 和它本身。由于 1 不是素数，因此这种情况属于分解失败，输出 -1 -1。
• 如果一个数可以分解为两个素数的乘积，那么这两个素数必然是唯一的，因为素数无法再分解。

4. 解题思路

1. 判断是否为素数：首先判断给定的数是否为素数。如果是素数，则直接输出 -1 -1。
2. 寻找素数因子：如果该数不是素数，则从 2 开始，依次寻找能整除该数的最小素数因子。
3. 验证另一个因子是否为素数：找到第一个素数因子后，计算另一个因子，并验证其是否为素数。
4. 输出结果：如果两个因子都是素数，则输出它们；否则输出 -1 -1。

5. 示例分析

• 输入：15
  15 不是素数，可以分解为 3 * 5，且 3 和 5 都是素数，因此输出 3 5。

• 输入：27
  27 不是素数，可以分解为 3 * 9，但 9 不是素数，因此输出 -1 -1。

6. 总结

该问题的核心在于如何高效地判断一个数是否为素数，并找到其素数因子。通过合理的算法设计和优化，可以在合理的时间内完成对大整数的因数分解。

二、JavaScript算法源码

以下是 JavaScript 代码的详细注释和讲解，代码逻辑与之前的 Java 版本一致，但使用了 JavaScript 的语法和特性。

---

代码结构

1. 控制台输入获取：使用 readline 模块读取用户输入。
2. isPrime 函数：用于判断一个数是否为素数。
3. getResult 函数：核心逻辑，用于判断给定的数是否可以分解为两个素数的乘积。

---

代码逐行讲解

1. 控制台输入获取

const readline = require("readline");const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});rl.on("line", (line) => {console.log(getResult(parseInt(line)));
});

• 功能：从控制台读取用户输入，并调用 getResult 函数处理输入。
• 关键点：
  • readline 是 Node.js 内置模块，用于读取用户输入。
  • rl.on("line", ...) 监听用户输入，每次输入一行时触发回调函数。
  • parseInt(line) 将输入的字符串转换为整数。
  • 调用 getResult 函数并输出结果。

---

2. isPrime 函数

function isPrime(n) {n = parseInt(n);if (n <= 3) {return n > 1;}

• 功能：判断一个数 n 是否为素数。
• 关键点：
  • 如果 n 小于等于 3，则只有 2 和 3 是素数。

---

  if (n % 6 !== 1 && n % 6 !== 5) {return false;}

• 功能：利用素数的性质进行初步筛选。
• 关键点：
  • 素数（除了 2 和 3）一定满足 n % 6 === 1 或 n % 6 === 5。
  • 如果不满足，则 n 不是素数。

---

  for (let i = 5; i <= Math.sqrt(n); i += 6) {if (n % i === 0 || n % (i + 2) === 0) {return false;}}

• 功能：通过试除法判断 n 是否为素数。
• 关键点：
  • 从 5 开始，每次增加 6，检查 n 是否能被 i 或 i + 2 整除。
  • 如果能整除，则 n 不是素数。

---

  return true;
}

• 功能：如果 n 通过所有检查，则返回 true，表示 n 是素数。

---

3. getResult 函数

function getResult(n) {// 如果n为素数，则必然不可能是两个素数之积if (isPrime(n)) {return "-1 -1";}

• 功能：判断给定的数 n 是否可以分解为两个素数的乘积。
• 关键点：
  • 如果 n 是素数，则直接返回 -1 -1，因为素数无法分解为两个素数的乘积。

---

  // 假设i为n的因子for (let i = 2; i < n; i++) {// 若n不能整除i,则i不是n的因子，继续下次循环，找新的i// 若n可以整除i,则i就是n的因子if (n % i === 0) {// j为n的另一因子let j = n / i;

• 功能：遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
• 关键点：
  • 如果 n % i === 0，说明 i 是 n 的一个因子。
  • 计算另一个因子 j = n / i。

---

      // 只有i,j因子都为素数时，n才是符合题意的素数之积if (isPrime(i) && isPrime(j)) {// 如果n为两个素数之积，则n只能分解为这两个因子，因为素数无法再次分解出其他因子，也就是说n不再有其他因子了（因子不包含1和自身）return i < j ? `${i} ${j}` : `${j} ${i}`;} else {// 如果i，j有一个不是素数因子，则说明n存在非素数因子，此时n不可能是素数之积// 如果i，j为相同的素数因子，则n不是满足题意的素数之积// 此时可以判定n不符合要求了，直接退出循环break;}}}

• 功能：检查找到的两个因子 i 和 j 是否都是素数。
• 关键点：
  • 如果 i 和 j 都是素数，则返回这两个素数（按从小到大的顺序）。
  • 如果 i 或 j 不是素数，则说明 n 无法分解为两个素数的乘积，直接退出循环并返回 -1 -1。

---

  return "-1 -1";
}

• 功能：如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

---

总结

• 代码逻辑：

  1. 判断 n 是否为素数。如果是素数，直接返回 -1 -1。
  2. 遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
  3. 如果找到因子 i，则计算另一个因子 j = n / i。
  4. 检查 i 和 j 是否都是素数。如果是，则返回这两个素数；否则，继续查找。
  5. 如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

• 代码特点：

  • 使用 readline 模块实现控制台输入。
  • 通过 isPrime 函数高效判断素数。
  • 通过遍历和试除法寻找因子。
  • 代码逻辑清晰，注释详细，易于理解。

---

三、Java算法源码

以下是代码的详细注释和讲解：

---

代码结构

1. main 方法：程序的入口，负责读取用户输入并调用 getResult 方法。
2. getResult 方法：核心逻辑，用于判断给定的数是否可以分解为两个素数的乘积。
3. isPrime 方法：用于判断一个数是否为素数。

---

代码逐行讲解

1. main 方法

public static void main(String[] args) {Scanner sc = new Scanner(System.in); // 创建Scanner对象，用于读取用户输入System.out.println(getResult(sc.nextInt())); // 读取用户输入的整数，调用getResult方法并输出结果
}

• 功能：从用户输入中读取一个整数，调用 getResult 方法处理该整数，并输出结果。
• 关键点：
  • Scanner 用于读取用户输入。
  • sc.nextInt() 读取用户输入的整数。
  • getResult 方法返回结果后，直接通过 System.out.println 输出。

---

2. getResult 方法

public static String getResult(int n) {// 如果n为素数，则必然不可能是两个素数之积if (isPrime(n)) {return "-1 -1";}

• 功能：判断给定的数 n 是否可以分解为两个素数的乘积。
• 关键点：
  • 如果 n 是素数，则直接返回 -1 -1，因为素数无法分解为两个素数的乘积（只能分解为 1 和它本身，而 1 不是素数）。

---

  // 假设i为n的因子for (int i = 2; i < n; i++) {// 若n不能整除i,则i不是n的因子，继续下次循环，找新的i// 若n可以整除i,则i就是n的因子if (n % i == 0) {// j为n的另一因子int j = n / i;

• 功能：遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
• 关键点：
  • 如果 n % i == 0，说明 i 是 n 的一个因子。
  • 计算另一个因子 j = n / i。

---

      // 只有i,j因子都为素数时，n才是符合题意的素数之积if (isPrime(i) && isPrime(j)) {// 如果n为两个素数之积，则n只能分解为这两个因子，因为素数无法再次分解出其他因子，也就是说n不再有其他因子了（因子不包含1和自身）return i < j ? i + " " + j : j + " " + i;} else {// 如果i，j有一个不是素数因子，则说明n存在非素数因子，此时n不可能是素数之积// 如果i，j为相同的素数因子，则n不是满足题意的素数之积// 此时可以判定n不符合要求了，直接退出循环break;}}}

• 功能：检查找到的两个因子 i 和 j 是否都是素数。
• 关键点：
  • 如果 i 和 j 都是素数，则返回这两个素数（按从小到大的顺序）。
  • 如果 i 或 j 不是素数，则说明 n 无法分解为两个素数的乘积，直接退出循环并返回 -1 -1。

---

  return "-1 -1";
}

• 功能：如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

---

3. isPrime 方法

public static boolean isPrime(int n) {if (n <= 3) return n > 1; // 2和3是素数，1不是素数

• 功能：判断一个数 n 是否为素数。
• 关键点：
  • 如果 n 小于等于 3，则只有 2 和 3 是素数。

---

  if (n % 6 != 1 && n % 6 != 5) return false; // 素数一定满足 n % 6 == 1 或 n % 6 == 5

• 功能：利用素数的性质进行初步筛选。
• 关键点：
  • 素数（除了 2 和 3）一定满足 n % 6 == 1 或 n % 6 == 5。
  • 如果不满足，则 n 不是素数。

---

  for (int i = 5; i <= Math.sqrt(n); i += 6) {if (n % i == 0 || n % (i + 2) == 0) {return false;}}

• 功能：通过试除法判断 n 是否为素数。
• 关键点：
  • 从 5 开始，每次增加 6，检查 n 是否能被 i 或 i + 2 整除。
  • 如果能整除，则 n 不是素数。

---

  return true; // 如果上述条件都不满足，则n是素数
}

• 功能：如果 n 通过所有检查，则返回 true，表示 n 是素数。

---

总结

• 代码逻辑：

  1. 判断 n 是否为素数。如果是素数，直接返回 -1 -1。
  2. 遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
  3. 如果找到因子 i，则计算另一个因子 j = n / i。
  4. 检查 i 和 j 是否都是素数。如果是，则返回这两个素数；否则，继续查找。
  5. 如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

• 代码特点：

  • 通过 isPrime 方法高效判断素数。
  • 通过遍历和试除法寻找因子。
  • 代码逻辑清晰，注释详细，易于理解。

---

四、Python算法源码

以下是 Python 代码的详细注释和讲解，代码逻辑与之前的 Java 和 JavaScript 版本一致，但使用了 Python 的语法和特性。

---

代码结构

1. 输入获取：使用 input() 函数读取用户输入。
2. isPrime 函数：用于判断一个数是否为素数。
3. getResult 函数：核心逻辑，用于判断给定的数是否可以分解为两个素数的乘积。
4. 算法调用：调用 getResult 函数并输出结果。

---

代码逐行讲解

1. 输入获取

n = int(input())

• 功能：从控制台读取用户输入，并将其转换为整数。
• 关键点：
  • input() 函数用于读取用户输入，返回的是字符串类型。
  • int() 函数将字符串转换为整数。

---

2. isPrime 函数

def isPrime(n):if n <= 3:return n > 1

• 功能：判断一个数 n 是否为素数。
• 关键点：
  • 如果 n 小于等于 3，则只有 2 和 3 是素数。

---

    if n % 6 != 1 and n % 6 != 5:return False

• 功能：利用素数的性质进行初步筛选。
• 关键点：
  • 素数（除了 2 和 3）一定满足 n % 6 == 1 或 n % 6 == 5。
  • 如果不满足，则 n 不是素数。

---

    for i in range(5, int(math.sqrt(n)) + 1, 6):if n % i == 0 or n % (i + 2) == 0:return False

• 功能：通过试除法判断 n 是否为素数。
• 关键点：
  • 从 5 开始，每次增加 6，检查 n 是否能被 i 或 i + 2 整除。
  • 如果能整除，则 n 不是素数。

---

    return True

• 功能：如果 n 通过所有检查，则返回 True，表示 n 是素数。

---

3. getResult 函数

def getResult(n):# 如果n为素数，则必然不可能是两个素数之积if isPrime(n):return "-1 -1"

• 功能：判断给定的数 n 是否可以分解为两个素数的乘积。
• 关键点：
  • 如果 n 是素数，则直接返回 -1 -1，因为素数无法分解为两个素数的乘积。

---

    # 假设i为n的因子for i in range(2, n):# 若n不能整除i,则i不是n的因子，继续下次循环，找新的i# 若n可以整除i,则i就是n的因子if n % i == 0:# j为n的另一因子j = n // i

• 功能：遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
• 关键点：
  • 如果 n % i == 0，说明 i 是 n 的一个因子。
  • 计算另一个因子 j = n // i（使用整数除法）。

---

            # 只有i,j因子都为素数时，n才是符合题意的素数之积if isPrime(i) and isPrime(j):# 如果n为两个素数之积，则n只能分解为这两个因子，因为素数无法再次分解出其他因子，也就是说n不再有其他因子了（因子不包含1和自身）return f"{i} {j}" if i < j else f"{j} {i}"else:# 如果i，j有一个不是素数因子，则说明n存在非素数因子，此时n不可能是素数之积# 如果i，j为相同的素数因子，则n不是满足题意的素数之积# 此时可以判定n不符合要求了，直接退出循环break

• 功能：检查找到的两个因子 i 和 j 是否都是素数。
• 关键点：
  • 如果 i 和 j 都是素数，则返回这两个素数（按从小到大的顺序）。
  • 如果 i 或 j 不是素数，则说明 n 无法分解为两个素数的乘积，直接退出循环并返回 -1 -1。

---

    return "-1 -1"

• 功能：如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

---

4. 算法调用

print(getResult(n))

• 功能：调用 getResult 函数并输出结果。
• 关键点：
  • print() 函数用于输出结果。

---

总结

• 代码逻辑：

  1. 判断 n 是否为素数。如果是素数，直接返回 -1 -1。
  2. 遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
  3. 如果找到因子 i，则计算另一个因子 j = n // i。
  4. 检查 i 和 j 是否都是素数。如果是，则返回这两个素数；否则，继续查找。
  5. 如果遍历结束后仍未找到符合条件的素数因子，则返回 -1 -1。

• 代码特点：

  • 使用 input() 函数实现控制台输入。
  • 通过 isPrime 函数高效判断素数。
  • 通过遍历和试除法寻找因子。
  • 代码逻辑清晰，注释详细，易于理解。

---

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

以下是 C 语言和 C++ 代码的详细注释和讲解，代码逻辑与之前的 Python、Java 和 JavaScript 版本一致，但使用了 C 和 C++ 的语法和特性。

---

C 语言代码

代码结构

1. main 函数：程序的入口，负责读取用户输入并调用 getResult 函数。
2. getResult 函数：核心逻辑，用于判断给定的数是否可以分解为两个素数的乘积。
3. isPrime 函数：用于判断一个数是否为素数。

---

代码逐行讲解

1. main 函数

#include <stdio.h>
#include <math.h>void getResult(int n);
int isPrime(int n);int main() {int n;scanf("%d", &n); // 读取用户输入的整数getResult(n);    // 调用 getResult 函数处理输入return 0;
}

• 功能：从用户输入中读取一个整数，调用 getResult 函数处理该整数。
• 关键点：
  • scanf("%d", &n) 用于读取用户输入的整数。
  • getResult(n) 调用核心逻辑函数。

---

2. getResult 函数

void getResult(int n) {// 如果n为素数，则必然不可能是两个素数之积if (isPrime(n)) {puts("-1 -1"); // 输出 -1 -1return;}

• 功能：判断给定的数 n 是否可以分解为两个素数的乘积。
• 关键点：
  • 如果 n 是素数，则直接输出 -1 -1，因为素数无法分解为两个素数的乘积。

---

    // 假设i为n的因子for (int i = 2; i < n; i++) {// 若n不能整除i,则i不是n的因子，继续下次循环，找新的i// 若n可以整除i,则i就是n的因子if (n % i == 0) {// j为n的另一因子int j = n / i;

• 功能：遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
• 关键点：
  • 如果 n % i == 0，说明 i 是 n 的一个因子。
  • 计算另一个因子 j = n / i。

---

            // 只有i,j因子都为素数时，n才是符合题意的素数之积if (isPrime(i) && isPrime(j)) {// 如果n为两个素数之积，则n只能分解为这两个因子，因为素数无法再次分解出其他因子，也就是说n不再有其他因子了（因子不包含1和自身）if (i < j) {printf("%d %d", i, j); // 输出较小的素数在前} else {printf("%d %d", j, i); // 输出较小的素数在前}return;} else {// 如果i，j有一个不是素数因子，则说明n存在非素数因子，此时n不可能是素数之积// 如果i，j为相同的素数因子，则n不是满足题意的素数之积// 此时可以判定n不符合要求了，直接退出循环break;}}}

• 功能：检查找到的两个因子 i 和 j 是否都是素数。
• 关键点：
  • 如果 i 和 j 都是素数，则输出这两个素数（按从小到大的顺序）。
  • 如果 i 或 j 不是素数，则说明 n 无法分解为两个素数的乘积，直接退出循环。

---

    puts("-1 -1"); // 输出 -1 -1
}

• 功能：如果遍历结束后仍未找到符合条件的素数因子，则输出 -1 -1。

---

3. isPrime 函数

int isPrime(int n) {if (n <= 3) return n > 1; // 2和3是素数，1不是素数

• 功能：判断一个数 n 是否为素数。
• 关键点：
  • 如果 n 小于等于 3，则只有 2 和 3 是素数。

---

    if (n % 6 != 1 && n % 6 != 5) {return 0; // 素数一定满足 n % 6 == 1 或 n % 6 == 5}

• 功能：利用素数的性质进行初步筛选。
• 关键点：
  • 素数（除了 2 和 3）一定满足 n % 6 == 1 或 n % 6 == 5。
  • 如果不满足，则 n 不是素数。

---

    for (int i = 5; i <= sqrt(n); i += 6) {if (n % i == 0 || n % (i + 2) == 0) {return 0; // 如果能整除，则n不是素数}}

• 功能：通过试除法判断 n 是否为素数。
• 关键点：
  • 从 5 开始，每次增加 6，检查 n 是否能被 i 或 i + 2 整除。
  • 如果能整除，则 n 不是素数。

---

    return 1; // 如果上述条件都不满足，则n是素数
}

• 功能：如果 n 通过所有检查，则返回 1，表示 n 是素数。

---

C++ 代码

C++ 代码与 C 语言代码几乎完全相同，只需稍作修改：

1. 头文件：

   • 将 #include <stdio.h> 替换为 #include <iostream>。
   • 将 #include <math.h> 替换为 #include <cmath>。

2. 输入输出：

   • 将 scanf 替换为 std::cin。
   • 将 printf 替换为 std::cout。
   • 将 puts 替换为 std::cout。

以下是修改后的 C++ 代码：

#include <iostream>
#include <cmath>void getResult(int n);
bool isPrime(int n);int main() {int n;std::cin >> n; // 读取用户输入的整数getResult(n);  // 调用 getResult 函数处理输入return 0;
}void getResult(int n) {// 如果n为素数，则必然不可能是两个素数之积if (isPrime(n)) {std::cout << "-1 -1" << std::endl; // 输出 -1 -1return;}// 假设i为n的因子for (int i = 2; i < n; i++) {// 若n不能整除i,则i不是n的因子，继续下次循环，找新的i// 若n可以整除i,则i就是n的因子if (n % i == 0) {// j为n的另一因子int j = n / i;// 只有i,j因子都为素数时，n才是符合题意的素数之积if (isPrime(i) && isPrime(j)) {// 如果n为两个素数之积，则n只能分解为这两个因子，因为素数无法再次分解出其他因子，也就是说n不再有其他因子了（因子不包含1和自身）if (i < j) {std::cout << i << " " << j << std::endl; // 输出较小的素数在前} else {std::cout << j << " " << i << std::endl; // 输出较小的素数在前}return;} else {// 如果i，j有一个不是素数因子，则说明n存在非素数因子，此时n不可能是素数之积// 如果i，j为相同的素数因子，则n不是满足题意的素数之积// 此时可以判定n不符合要求了，直接退出循环break;}}}std::cout << "-1 -1" << std::endl; // 输出 -1 -1
}// 判断n是否为素数
bool isPrime(int n) {if (n <= 3) return n > 1; // 2和3是素数，1不是素数if (n % 6 != 1 && n % 6 != 5) {return false; // 素数一定满足 n % 6 == 1 或 n % 6 == 5}for (int i = 5; i <= std::sqrt(n); i += 6) {if (n % i == 0 || n % (i + 2) == 0) {return false; // 如果能整除，则n不是素数}}return true; // 如果上述条件都不满足，则n是素数
}

---

总结

• C 语言和 C++ 代码逻辑一致：

  1. 判断 n 是否为素数。如果是素数，直接输出 -1 -1。
  2. 遍历从 2 到 n-1 的所有整数，寻找 n 的因子。
  3. 如果找到因子 i，则计算另一个因子 j = n / i。
  4. 检查 i 和 j 是否都是素数。如果是，则输出这两个素数；否则，继续查找。
  5. 如果遍历结束后仍未找到符合条件的素数因子，则输出 -1 -1。

• 代码特点：

  • 使用 scanf 和 printf（C 语言）或 std::cin 和 std::cout（C++）实现输入输出。
  • 通过 isPrime 函数高效判断素数。
  • 通过遍历和试除法寻找因子。
  • 代码逻辑清晰，注释详细，易于理解。

---

六、尾言

什么是华为OD？

华为OD（Outsourcing Developer，外包开发工程师）是华为针对软件开发工程师岗位的一种招聘形式，主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分，算法题的机试至关重要。

为什么刷题很重要？

1. 机试是进入技术面的第一关：
   华为OD机试（常被称为机考）主要考察算法和编程能力。只有通过机试，才能进入后续的技术面试环节。

2. 技术面试需要手撕代码：
   技术一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多练习是通过面试的重要保障。

3. 入职后的可信考试：
   入职华为后，还需要通过“可信考试”。可信考试分为三个等级：

   • 入门级：主要考察基础算法与编程能力。
   • 工作级：更贴近实际业务需求，可能涉及复杂的算法或与工作内容相关的场景题目。
   • 专业级：最高等级，考察深层次的算法以及优化能力，与薪资直接挂钩。

刷题策略与说明：

2024年8月14日之后，华为OD机试的题库转为 E卷，由往年题库（D卷、A卷、B卷、C卷）和全新题目组成。刷题时可以参考以下策略：

1. 关注历年真题：

   • 题库中的旧题占比较大，建议优先刷历年的A卷、B卷、C卷、D卷题目。
   • 对于每道题目，建议深度理解其解题思路、代码实现，以及相关算法的适用场景。

2. 适应新题目：

   • E卷中包含全新题目，需要掌握全面的算法知识和一定的灵活应对能力。
   • 建议关注新的刷题平台或交流群，获取最新题目的解析和动态。

3. 掌握常见算法：
   华为OD考试通常涉及以下算法和数据结构：

   • 排序算法（快速排序、归并排序等）
   • 动态规划（背包问题、最长公共子序列等）
   • 贪心算法
   • 栈、队列、链表的操作
   • 图论（最短路径、最小生成树等）
   • 滑动窗口、双指针算法

4. 保持编程规范：

   • 注重代码的可读性和注释的清晰度。
   • 熟练使用常见编程语言，如C++、Java、Python等。

如何获取资源？

1. 官方参考：

   • 华为招聘官网或相关的招聘平台会有一些参考信息。
   • 华为OD的相关公众号可能也会发布相关的刷题资料或学习资源。

2. 加入刷题社区：

   • 找到可信的刷题交流群，与其他备考的小伙伴交流经验。
   • 关注知名的刷题网站，如LeetCode、牛客网等，这些平台上有许多华为OD的历年真题和解析。

3. 寻找系统性的教程：

   • 学习一本经典的算法书籍，例如《算法导论》《剑指Offer》《编程之美》等。
   • 完成系统的学习课程，例如数据结构与算法的在线课程。

积极心态与持续努力：

刷题的过程可能会比较枯燥，但它能够显著提升编程能力和算法思维。无论是为了通过华为OD的招聘考试，还是为了未来的职业发展，这些积累都会成为重要的财富。

考试注意细节

1. 本地编写代码

   • 在本地 IDE（如 VS Code、PyCharm 等）上编写、保存和调试代码，确保逻辑正确后再复制粘贴到考试页面。这样可以减少语法错误，提高代码准确性。

2. 调整心态，保持冷静

   • 遇到提示不足或实现不确定的问题时，不必慌张，可以采用更简单或更有把握的方法替代，确保思路清晰。

3. 输入输出完整性

   • 注意训练和考试时都需要编写完整的输入输出代码，尤其是和题目示例保持一致。完成代码后务必及时调试，确保功能符合要求。

4. 快捷键使用

   • 删除行可用 Ctrl+D，复制、粘贴和撤销分别为 Ctrl+C，Ctrl+V，Ctrl+Z，这些可以正常使用。
   • 避免使用 Ctrl+S，以免触发浏览器的保存功能。

5. 浏览器要求

   • 使用最新版的 Google Chrome 浏览器完成考试，确保摄像头开启并正常工作。考试期间不要切换到其他网站，以免影响考试成绩。

6. 交卷相关

   • 答题前，务必仔细查看题目示例，避免遗漏要求。
   • 每完成一道题后，点击【保存并调试】按钮，多次保存和调试是允许的，系统会记录得分最高的一次结果。完成所有题目后，点击【提交本题型】按钮。
   • 确保在考试结束前提交试卷，避免因未保存或调试失误而丢分。

7. 时间和分数安排

   • 总时间：150 分钟；总分：400 分。
   • 试卷结构：2 道一星难度题（每题 100 分），1 道二星难度题（200 分）。及格分为 150 分。合理分配时间，优先完成自己擅长的题目。

8. 考试环境准备

   • 考试前请备好草稿纸和笔。考试中尽量避免离开座位，确保监控画面正常。
   • 如需上厕所，请提前规划好时间以减少中途离开监控的可能性。

9. 技术问题处理

   • 如果考试中遇到断电、断网、死机等技术问题，可以关闭浏览器并重新打开试卷链接继续作答。
   • 出现其他问题，请第一时间联系 HR 或监考人员进行反馈。

祝你考试顺利，取得理想成绩！