【2024年华为OD机试】 (B卷,100分)- 跳房子I（Java JS PythonC/C++）

在这里插入图片描述

一、问题描述

题目描述

跳房子，也叫跳飞机，是一种世界性的儿童游戏。

游戏参与者需要分多个回合按顺序跳到第1格直到房子的最后一格。

跳房子的过程中，可以向前跳，也可以向后跳。

假设房子的总格数是count，小红每回合可能连续跳的步数都放在数组steps中，请问数组中是否有一种步数的组合，可以让小红两个回合跳到最后一格？

如果有，请输出索引和最小的步数组合。

注意：

数组中的步数可以重复，但数组中的元素不能重复使用。
提供的数据保证存在满足题目要求的组合，且索引和最小的步数组合是唯一的。

输入描述

第一行输入为房子总格数count，它是int整数类型。
第二行输入为每回合可能连续跳的步数，它是int整数数组类型。

输出描述

返回索引和最小的满足要求的步数组合（顺序保持steps中原有顺序）

备注

count ≤ 1000
0 ≤ steps.length ≤ 5000
-100000000 ≤ steps[i] ≤ 100000000

用例

用例1

输入

[1,4,5,2,2]
7

输出

[5, 2]

用例2

输入

[-1,2,4,9,6]
8

输出

[-1, 9]

说明
此样例有多种组合满足两回合跳到最后，譬如：[-1,9]，[2,6]，其中[-1,9]的索引和为0+3=3，[2,6]的索和为1+4=5，所以索引和最小的步数组合[-1,9]

用例3

输入

[1,2,9,9,9,1,9,9,3,2]
4

输出

[1, 3]

说明
我们需要注意的是，第二个1的索引要大于第一个1的索引，因此后面遇到3时，我们应该让3和第一个1进行匹配，而不是第二个1。

题目解析

考察点

考察两数之和问题的变种。

解析思路

问题理解：
- 本题要求在数组 steps 中找到两个数，它们的和等于 count。
- 与传统的两数之和问题不同，本题要求找到索引和最小的步数组合。
哈希表：
- 使用一个哈希表记录每个步数的索引。
- 遍历 steps 数组，对于每个步数 steps[i]，计算 target = count - steps[i]。
- 检查 target 是否在哈希表中，如果在，且 target 的索引小于当前索引 i，则找到了一个有效的组合。
记录最小索引和：
- 初始化一个变量 min_index_sum 为一个较大的值，用于记录最小的索引和。
- 初始化一个变量 result 为一个空列表，用于记录最终的步数组合。
- 遍历过程中，如果找到一个有效的组合，计算其索引和，如果索引和小于 min_index_sum，更新 min_index_sum 和 result。
输出结果：
- 输出 result，即为索引和最小的步数组合。

注意事项

哈希表的使用：哈希表用于快速查找 target 是否存在，以及记录其索引。
索引和的计算：确保计算索引和时，target 的索引小于当前索引 i，避免重复使用同一个元素。
效率：使用哈希表的时间复杂度为O(n)，适用于本题的数据规模。

二、JavaScript算法源码

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

JavaScript 代码

// 引入 readline 模块，用于读取控制台输入
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();  // 获取异步迭代器
const readline = async () => (await iter.next()).value;  // 定义异步读取函数

// 自执行异步函数
void (async function () {
  const steps = JSON.parse(await readline());  // 读取并解析步骤数组
  const count = parseInt(await readline());    // 读取目标值 count

  console.log(getResult(steps, count));  // 调用 getResult 函数并输出结果
})();

// 核心函数：查找满足条件的两个步骤
function getResult(steps, count) {
  const map = {};  // 定义哈希表，用于存储步骤值及其索引

  let minIdxSum = Infinity;  // 初始化最小索引和为无穷大
  let ans = "";  // 初始化结果字符串

  // 遍历步骤数组
  for (let idx1 = 0; idx1 < steps.length; idx1++) {
    const step1 = steps[idx1];  // 当前步骤值
    const step2 = count - step1;  // 计算目标值与当前步骤值的差值

    // 如果差值存在于哈希表中
    if (map[step2] != undefined) {
      const idx2 = map[step2];  // 获取差值的索引
      const idxSum = idx1 + idx2;  // 计算当前索引和

      // 如果当前索引和小于最小索引和
      if (idxSum < minIdxSum) {
        minIdxSum = idxSum;  // 更新最小索引和
        ans = `[${step2}, ${step1}]`;  // 更新结果字符串
      }
    } else {
      // 如果当前步骤值未存在于哈希表中
      if (map[step1] == undefined) {
        map[step1] = idx1;  // 将当前步骤值及其索引存入哈希表
      }
    }
  }

  return ans;  // 返回结果字符串
}

详细讲解

1. 输入处理

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
  const steps = JSON.parse(await readline());  // 读取并解析步骤数组
  const count = parseInt(await readline());    // 读取目标值 count

  console.log(getResult(steps, count));  // 调用 getResult 函数并输出结果
})();

功能：
- 从控制台读取输入。
- 第一行输入是步骤数组 steps，格式为 JSON 数组。
- 第二行输入是目标值 count。
逻辑：
1. 使用 readline 模块读取输入。
2. 解析第一行输入为数组 steps。
3. 解析第二行输入为整数 count。
4. 调用 getResult 函数计算结果并输出。

2. 核心函数 `getResult`

function getResult(steps, count) {
  const map = {};  // 定义哈希表，用于存储步骤值及其索引

  let minIdxSum = Infinity;  // 初始化最小索引和为无穷大
  let ans = "";  // 初始化结果字符串

  // 遍历步骤数组
  for (let idx1 = 0; idx1 < steps.length; idx1++) {
    const step1 = steps[idx1];  // 当前步骤值
    const step2 = count - step1;  // 计算目标值与当前步骤值的差值

    // 如果差值存在于哈希表中
    if (map[step2] != undefined) {
      const idx2 = map[step2];  // 获取差值的索引
      const idxSum = idx1 + idx2;  // 计算当前索引和

      // 如果当前索引和小于最小索引和
      if (idxSum < minIdxSum) {
        minIdxSum = idxSum;  // 更新最小索引和
        ans = `[${step2}, ${step1}]`;  // 更新结果字符串
      }
    } else {
      // 如果当前步骤值未存在于哈希表中
      if (map[step1] == undefined) {
        map[step1] = idx1;  // 将当前步骤值及其索引存入哈希表
      }
    }
  }

  return ans;  // 返回结果字符串
}

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值 count，并且它们的索引和最小。
逻辑：
1. 定义哈希表 map，用于存储步骤值及其索引。
2. 初始化最小索引和为无穷大，结果字符串为空。
3. 遍历步骤数组：
  - 计算当前步骤值与目标值的差值 step2。
  - 如果差值存在于哈希表中，计算当前索引和，并更新最小索引和和结果字符串。
  - 如果当前步骤值未存在于哈希表中，将其存入哈希表。
4. 返回结果字符串。

3. 示例运行

输入：

[1, 2, 3, 4, 5]
5

输出：

[2, 3]

解释：

步骤数组为 [1, 2, 3, 4, 5]，目标值为 5。
满足条件的步骤对为 [2, 3]，它们的和为 5，索引和为 1 + 2 = 3，是最小的。

总结

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值，并且它们的索引和最小。
优点：
- 使用哈希表存储步骤值及其索引，查找效率高。
- 时间复杂度为 O(n)，空间复杂度为 O(n)。
适用场景：
- 适用于需要查找满足条件的两个元素的场景。

如果您有其他问题，欢迎随时提问！

三、Java算法源码

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

Java 代码

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

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);  // 创建 Scanner 对象，用于读取输入

    // 读取步骤数组
    String tmp = sc.nextLine();  // 读取一行输入，格式为 "[1,2,3,4,5]"
    int[] steps =
        Arrays.stream(tmp.substring(1, tmp.length() - 1).split(","))  // 去掉首尾的方括号，按逗号分割
            .mapToInt(Integer::parseInt)  // 将字符串转换为整数
            .toArray();  // 转换为整数数组

    // 读取目标值
    int count = Integer.parseInt(sc.nextLine());  // 读取目标值 count

    // 调用 getResult 函数并输出结果
    System.out.println(getResult(steps, count));
  }

  // 核心函数：查找满足条件的两个步骤
  public static String getResult(int[] steps, int count) {
    HashMap<Integer, Integer> map = new HashMap<>();  // 定义哈希表，用于存储步骤值及其索引

    int minIdxSum = Integer.MAX_VALUE;  // 初始化最小索引和为最大整数值
    String ans = "";  // 初始化结果字符串

    // 遍历步骤数组
    for (int idx1 = 0; idx1 < steps.length; idx1++) {
      int step1 = steps[idx1];  // 当前步骤值
      int step2 = count - step1;  // 计算目标值与当前步骤值的差值

      // 如果差值存在于哈希表中
      if (map.containsKey(step2)) {
        int idx2 = map.get(step2);  // 获取差值的索引
        int idxSum = idx1 + idx2;  // 计算当前索引和

        // 如果当前索引和小于最小索引和
        if (idxSum < minIdxSum) {
          minIdxSum = idxSum;  // 更新最小索引和
          ans = "[" + step2 + ", " + step1 + "]";  // 更新结果字符串
        }
      } else {
        // 如果当前步骤值未存在于哈希表中
        map.putIfAbsent(step1, idx1);  // 将当前步骤值及其索引存入哈希表
      }
    }

    return ans;  // 返回结果字符串
  }
}

详细讲解

1. 输入处理

Scanner sc = new Scanner(System.in);  // 创建 Scanner 对象，用于读取输入

// 读取步骤数组
String tmp = sc.nextLine();  // 读取一行输入，格式为 "[1,2,3,4,5]"
int[] steps =
    Arrays.stream(tmp.substring(1, tmp.length() - 1).split(","))  // 去掉首尾的方括号，按逗号分割
        .mapToInt(Integer::parseInt)  // 将字符串转换为整数
        .toArray();  // 转换为整数数组

// 读取目标值
int count = Integer.parseInt(sc.nextLine());  // 读取目标值 count

功能：
- 从控制台读取输入。
- 第一行输入是步骤数组 steps，格式为 [1,2,3,4,5]。
- 第二行输入是目标值 count。
逻辑：
1. 使用 Scanner 读取第一行输入，去掉首尾的方括号，按逗号分割为字符串数组。
2. 将字符串数组转换为整数数组 steps。
3. 使用 Scanner 读取第二行输入，转换为整数 count。

2. 核心函数 `getResult`

public static String getResult(int[] steps, int count) {
  HashMap<Integer, Integer> map = new HashMap<>();  // 定义哈希表，用于存储步骤值及其索引

  int minIdxSum = Integer.MAX_VALUE;  // 初始化最小索引和为最大整数值
  String ans = "";  // 初始化结果字符串

  // 遍历步骤数组
  for (int idx1 = 0; idx1 < steps.length; idx1++) {
    int step1 = steps[idx1];  // 当前步骤值
    int step2 = count - step1;  // 计算目标值与当前步骤值的差值

    // 如果差值存在于哈希表中
    if (map.containsKey(step2)) {
      int idx2 = map.get(step2);  // 获取差值的索引
      int idxSum = idx1 + idx2;  // 计算当前索引和

      // 如果当前索引和小于最小索引和
      if (idxSum < minIdxSum) {
        minIdxSum = idxSum;  // 更新最小索引和
        ans = "[" + step2 + ", " + step1 + "]";  // 更新结果字符串
      }
    } else {
      // 如果当前步骤值未存在于哈希表中
      map.putIfAbsent(step1, idx1);  // 将当前步骤值及其索引存入哈希表
    }
  }

  return ans;  // 返回结果字符串
}

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值 count，并且它们的索引和最小。
逻辑：
1. 定义哈希表 map，用于存储步骤值及其索引。
2. 初始化最小索引和为最大整数值，结果字符串为空。
3. 遍历步骤数组：
  - 计算当前步骤值与目标值的差值 step2。
  - 如果差值存在于哈希表中，计算当前索引和，并更新最小索引和和结果字符串。
  - 如果当前步骤值未存在于哈希表中，将其存入哈希表。
4. 返回结果字符串。

3. 示例运行

输入：

[1, 2, 3, 4, 5]
5

输出：

[2, 3]

解释：

步骤数组为 [1, 2, 3, 4, 5]，目标值为 5。
满足条件的步骤对为 [2, 3]，它们的和为 5，索引和为 1 + 2 = 3，是最小的。

总结

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值，并且它们的索引和最小。
优点：
- 使用哈希表存储步骤值及其索引，查找效率高。
- 时间复杂度为 O(n)，空间复杂度为 O(n)。
适用场景：
- 适用于需要查找满足条件的两个元素的场景。

如果您有其他问题，欢迎随时提问！

四、Python算法源码

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

Python 代码

# 输入获取
import sys

# 读取步骤数组
steps = list(map(int, input()[1:-1].split(",")))  # 去掉首尾的方括号，按逗号分割并转换为整数列表
# 读取目标值
count = int(input())  # 读取目标值 count

# 算法入口
def getResult():
    dic = {}  # 定义字典，用于存储步骤值及其索引

    minIdxSum = sys.maxsize  # 初始化最小索引和为最大整数值
    ans = ""  # 初始化结果字符串

    # 遍历步骤数组
    for idx1 in range(len(steps)):
        step1 = steps[idx1]  # 当前步骤值
        step2 = count - step1  # 计算目标值与当前步骤值的差值

        # 如果差值不存在于字典中
        if dic.get(step2) is None:
            dic.setdefault(step1, idx1)  # 将当前步骤值及其索引存入字典
        else:
            # 如果差值存在于字典中
            idx2 = dic[step2]  # 获取差值的索引
            idxSum = idx1 + idx2  # 计算当前索引和

            # 如果当前索引和小于最小索引和
            if idxSum < minIdxSum:
                minIdxSum = idxSum  # 更新最小索引和
                ans = f"[{step2}, {step1}]"  # 更新结果字符串

    return ans  # 返回结果字符串

# 算法调用
print(getResult())

详细讲解

1. 输入处理

# 读取步骤数组
steps = list(map(int, input()[1:-1].split(",")))  # 去掉首尾的方括号，按逗号分割并转换为整数列表
# 读取目标值
count = int(input())  # 读取目标值 count

功能：
- 从控制台读取输入。
- 第一行输入是步骤数组 steps，格式为 [1,2,3,4,5]。
- 第二行输入是目标值 count。
逻辑：
1. 使用 input() 读取第一行输入，去掉首尾的方括号，按逗号分割为字符串列表。
2. 使用 map(int, ...) 将字符串列表转换为整数列表 steps。
3. 使用 input() 读取第二行输入，转换为整数 count。

2. 核心函数 `getResult`

def getResult():
    dic = {}  # 定义字典，用于存储步骤值及其索引

    minIdxSum = sys.maxsize  # 初始化最小索引和为最大整数值
    ans = ""  # 初始化结果字符串

    # 遍历步骤数组
    for idx1 in range(len(steps)):
        step1 = steps[idx1]  # 当前步骤值
        step2 = count - step1  # 计算目标值与当前步骤值的差值

        # 如果差值不存在于字典中
        if dic.get(step2) is None:
            dic.setdefault(step1, idx1)  # 将当前步骤值及其索引存入字典
        else:
            # 如果差值存在于字典中
            idx2 = dic[step2]  # 获取差值的索引
            idxSum = idx1 + idx2  # 计算当前索引和

            # 如果当前索引和小于最小索引和
            if idxSum < minIdxSum:
                minIdxSum = idxSum  # 更新最小索引和
                ans = f"[{step2}, {step1}]"  # 更新结果字符串

    return ans  # 返回结果字符串

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值 count，并且它们的索引和最小。
逻辑：
1. 定义字典 dic，用于存储步骤值及其索引。
2. 初始化最小索引和为最大整数值，结果字符串为空。
3. 遍历步骤数组：
  - 计算当前步骤值与目标值的差值 step2。
  - 如果差值不存在于字典中，将当前步骤值及其索引存入字典。
  - 如果差值存在于字典中，计算当前索引和，并更新最小索引和和结果字符串。
4. 返回结果字符串。

3. 示例运行

输入：

[1, 2, 3, 4, 5]
5

输出：

[2, 3]

解释：

步骤数组为 [1, 2, 3, 4, 5]，目标值为 5。
满足条件的步骤对为 [2, 3]，它们的和为 5，索引和为 1 + 2 = 3，是最小的。

总结

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值，并且它们的索引和最小。
优点：
- 使用字典存储步骤值及其索引，查找效率高。
- 时间复杂度为 O(n)，空间复杂度为 O(n)。
适用场景：
- 适用于需要查找满足条件的两个元素的场景。

如果您有其他问题，欢迎随时提问！

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

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

C++ 代码

#include <iostream>
#include <vector>
#include <unordered_map>
#include <climits>  // 用于 INT_MAX
using namespace std;

// 核心函数：查找满足条件的两个步骤
string getResult(vector<int>& steps, int count) {
    unordered_map<int, int> dic;  // 定义哈希表，用于存储步骤值及其索引

    int minIdxSum = INT_MAX;  // 初始化最小索引和为最大整数值
    string ans = "";  // 初始化结果字符串

    // 遍历步骤数组
    for (int idx1 = 0; idx1 < steps.size(); idx1++) {
        int step1 = steps[idx1];  // 当前步骤值
        int step2 = count - step1;  // 计算目标值与当前步骤值的差值

        // 如果差值存在于哈希表中
        if (dic.find(step2) != dic.end()) {
            int idx2 = dic[step2];  // 获取差值的索引
            int idxSum = idx1 + idx2;  // 计算当前索引和

            // 如果当前索引和小于最小索引和
            if (idxSum < minIdxSum) {
                minIdxSum = idxSum;  // 更新最小索引和
                ans = "[" + to_string(step2) + ", " + to_string(step1) + "]";  // 更新结果字符串
            }
        } else {
            // 如果当前步骤值未存在于哈希表中
            dic[step1] = idx1;  // 将当前步骤值及其索引存入哈希表
        }
    }

    return ans;  // 返回结果字符串
}

int main() {
    // 输入获取
    string tmp;
    getline(cin, tmp);  // 读取一行输入，格式为 "[1,2,3,4,5]"
    tmp = tmp.substr(1, tmp.length() - 2);  // 去掉首尾的方括号
    vector<int> steps;
    size_t pos = 0;
    while ((pos = tmp.find(",")) != string::npos) {
        steps.push_back(stoi(tmp.substr(0, pos)));  // 按逗号分割并转换为整数
        tmp.erase(0, pos + 1);
    }
    steps.push_back(stoi(tmp));  // 处理最后一个元素

    int count;
    cin >> count;  // 读取目标值 count

    // 调用 getResult 函数并输出结果
    cout << getResult(steps, count) << endl;

    return 0;
}

C 语言代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>  // 用于 INT_MAX

// 核心函数：查找满足条件的两个步骤
char* getResult(int* steps, int stepsSize, int count) {
    int* dic = (int*)malloc(100000 * sizeof(int));  // 定义哈希表，用于存储步骤值及其索引
    memset(dic, -1, 100000 * sizeof(int));  // 初始化哈希表为 -1

    int minIdxSum = INT_MAX;  // 初始化最小索引和为最大整数值
    char* ans = (char*)malloc(100 * sizeof(char));  // 初始化结果字符串
    ans[0] = '\0';  // 初始化为空字符串

    // 遍历步骤数组
    for (int idx1 = 0; idx1 < stepsSize; idx1++) {
        int step1 = steps[idx1];  // 当前步骤值
        int step2 = count - step1;  // 计算目标值与当前步骤值的差值

        // 如果差值存在于哈希表中
        if (dic[step2] != -1) {
            int idx2 = dic[step2];  // 获取差值的索引
            int idxSum = idx1 + idx2;  // 计算当前索引和

            // 如果当前索引和小于最小索引和
            if (idxSum < minIdxSum) {
                minIdxSum = idxSum;  // 更新最小索引和
                sprintf(ans, "[%d, %d]", step2, step1);  // 更新结果字符串
            }
        } else {
            // 如果当前步骤值未存在于哈希表中
            dic[step1] = idx1;  // 将当前步骤值及其索引存入哈希表
        }
    }

    free(dic);  // 释放哈希表内存
    return ans;  // 返回结果字符串
}

int main() {
    // 输入获取
    char tmp[1000];
    fgets(tmp, sizeof(tmp), stdin);  // 读取一行输入，格式为 "[1,2,3,4,5]"
    tmp[strlen(tmp) - 1] = '\0';  // 去掉末尾的换行符
    tmp[strlen(tmp) - 1] = '\0';  // 去掉末尾的方括号
    tmp[0] = '\0';  // 去掉开头的方括号

    int steps[1000];
    int stepsSize = 0;
    char* token = strtok(tmp, ",");  // 按逗号分割
    while (token != NULL) {
        steps[stepsSize++] = atoi(token);  // 将字符串转换为整数
        token = strtok(NULL, ",");
    }

    int count;
    scanf("%d", &count);  // 读取目标值 count

    // 调用 getResult 函数并输出结果
    char* result = getResult(steps, stepsSize, count);
    printf("%s\n", result);

    free(result);  // 释放结果字符串内存
    return 0;
}

详细讲解

1. 输入处理

C++：
- 使用 getline 读取一行输入，去掉首尾的方括号，按逗号分割并转换为整数列表。
- 使用 cin 读取目标值 count。
C：
- 使用 fgets 读取一行输入，去掉首尾的方括号，按逗号分割并转换为整数数组。
- 使用 scanf 读取目标值 count。

2. 核心函数 `getResult`

C++：
- 使用 unordered_map 作为哈希表，存储步骤值及其索引。
- 遍历步骤数组，计算差值并更新结果。
C：
- 使用数组作为哈希表，存储步骤值及其索引。
- 遍历步骤数组，计算差值并更新结果。

3. 示例运行

输入：

[1, 2, 3, 4, 5]
5

输出：

[2, 3]

解释：

步骤数组为 [1, 2, 3, 4, 5]，目标值为 5。
满足条件的步骤对为 [2, 3]，它们的和为 5，索引和为 1 + 2 = 3，是最小的。

总结

功能：
- 查找满足条件的两个步骤，使得它们的和等于目标值，并且它们的索引和最小。
优点：
- 使用哈希表存储步骤值及其索引，查找效率高。
- 时间复杂度为 O(n)，空间复杂度为 O(n)。
适用场景：
- 适用于需要查找满足条件的两个元素的场景。

如果您有其他问题，欢迎随时提问！

六、尾言

什么是华为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 或监考人员进行反馈。