【2024年华为OD机试】 (C卷,200分)- 贪吃的猴子（JavaScriptJava PythonC/C++）

一、问题描述

题目解析

问题描述

一只猴子来到果园，发现许多串香蕉排成一行，每串香蕉上有若干根香蕉。每串香蕉的根数由数组 numbers 给出。猴子每次只能从行的开头或末尾获取香蕉，并且只能获取 N 次。求猴子最多能获取多少根香蕉。

输入描述

• 第一行为数组 numbers 的长度。
• 第二行为数组 numbers 的值，每个数字通过空格分开。
• 第三行输入为 N，表示获取的次数。

输出描述

按照题目要求能获取的最大数值。

备注

• 1 ≤ numbers.length ≤ 100000
• 1 ≤ numbers ≤ 100
• 1 ≤ N ≤ numbers.length

用例

1. 输入：

   7
   1 2 2 7 3 6 1
   3
   

   输出：

   10
   

   说明：第一次从末尾获取1，第二次从末尾获取6，第三次从末尾获取3，最终根数为1+6+3=10。

2. 输入：

   3
   1 2 3
   3
   

   输出：

   6
   

   说明：全部获取所有的香蕉，最终根数为1+2+3=6。

3. 输入：

   4
   4 2 2 3
   2
   

   输出：

   7
   

   说明：第一次从开头获取4，第二次从末尾获取3，最终根数为4+3=7。

解题思路

初步思路

最初的想法是通过分支递归+缓存优化来求解。然而，由于 numbers.length 的最大值可以达到100000，递归操作会导致栈溢出，且缓存数组占用的内存会超出限制。

优化思路

经过进一步思考，发现无论猴子如何选择，左边和右边选择的香蕉必然是连续的，并且是从头尾开始的连续选择。因此，问题可以简化为将 N 次选择分解为左边选择的个数和右边选择的个数。

具体步骤

1. 初始化：假设左边选择了0个，右边选择了 N 个，计算此时的总和。
2. 逐步调整：每次将左边选择的个数增加1，右边选择的个数减少1，并基于前一个状态计算新的总和。
3. 求最大值：在所有可能的选择中，找出总和最大的情况。

示例解析

以第一个用例为例：

• 初始时，左边选择0个，右边选择3个，总和为1+6+3=10。
• 左边选择1个，右边选择2个，总和为1+6+3=10。
• 左边选择2个，右边选择1个，总和为2+7+3=12。
• 左边选择3个，右边选择0个，总和为1+2+2=5。

最终，最大总和为12。

总结

通过将问题简化为左边和右边选择的连续子数组，可以有效地避免递归带来的栈溢出问题，并且通过逐步调整选择的方式，能够高效地计算出猴子最多能获取的香蕉数量。

二、JavaScript算法源码

代码详细注释与讲解

以下是代码的逐行注释和逻辑讲解：

// 引入 readline 模块，用于从标准输入读取数据
const rl = require("readline").createInterface({ input: process.stdin });// 创建一个异步迭代器，用于逐行读取输入
var iter = rl[Symbol.asyncIterator]();// 定义一个异步函数 readline，用于读取一行输入
const readline = async () => (await iter.next()).value;// 立即执行异步函数
void (async function () {// 读取第一行输入，表示数组的长度，并将其转换为整数const len = parseInt(await readline());// 读取第二行输入，表示数组的值，将其按空格分割并转换为数字数组const nums = (await readline()).split(" ").map(Number);// 读取第三行输入，表示猴子可以获取的次数，并将其转换为整数const n = parseInt(await readline());// 调用 getResult 函数计算结果，并输出console.log(getResult(len, nums, n));
})();// 定义 getResult 函数，用于计算猴子最多能获取的香蕉数量
function getResult(len, nums, n) {// 初始时，左边选择 0 个香蕉，因此左边选择的香蕉数为 0let leftSum = 0;// 初始时，右边选择 n 个香蕉，因此右边选择的香蕉数为 nums[len - n] ~ nums[len - 1] 这个 n 个元素之和let rightSum = 0;for (let i = len - n; i < len; i++) {rightSum += nums[i];}// 如果选择数 n == len，即全选，此时直接返回初始 rightSumif (len == n) {return rightSum;}// 如果不是全选// sum 记录当前选择结果let sum = leftSum + rightSum;// ans 记录所有选择结果中最大的值let ans = sum;// l 指向左边将要获得的香蕉，即左边获得一个let l = 0;// r 指向右边将要失去的香蕉，即右边失去一个let r = len - n;// 循环遍历所有可能的选择情况while (l < n) {// 左边增加一个香蕉，右边减少一个香蕉sum += nums[l++] - nums[r++];// 更新最大值ans = Math.max(ans, sum);}// 返回最终的最大值return ans;
}

---

代码逻辑讲解

1. 输入处理

• 使用 readline 模块逐行读取输入。
• 第一行是数组的长度 len。
• 第二行是数组 nums，表示每串香蕉的根数。
• 第三行是猴子可以获取的次数 n。

2. 初始化

• leftSum 表示从左边选择的香蕉总数，初始为 0。
• rightSum 表示从右边选择的香蕉总数，初始为数组最后 n 个元素的和。

3. 特殊情况处理

• 如果 n == len，即猴子可以获取所有香蕉，直接返回 rightSum。

4. 滑动窗口计算

• 使用滑动窗口的思想，逐步调整左边和右边的选择。
• l 指向左边将要获得的香蕉，r 指向右边将要失去的香蕉。
• 每次循环：
  • 左边增加一个香蕉（nums[l++]）。
  • 右边减少一个香蕉（nums[r++]）。
  • 更新当前总和 sum。
  • 更新最大值 ans。

5. 返回结果

• 最终返回所有选择情况中的最大值 ans。

---

示例运行

示例 1

输入：

7
1 2 2 7 3 6 1
3

运行过程：

1. 初始 rightSum = 1 + 6 + 3 = 10。
2. 滑动窗口：
   • 左边增加 1，右边减少 1，sum = 10 + 1 - 1 = 10。
   • 左边增加 2，右边减少 6，sum = 10 + 2 - 6 = 6。
   • 左边增加 2，右边减少 3，sum = 6 + 2 - 3 = 5。
3. 最大值为 10。

输出：

10

示例 2

输入：

3
1 2 3
3

运行过程：

1. 初始 rightSum = 1 + 2 + 3 = 6。
2. 因为 n == len，直接返回 6。

输出：

6

示例 3

输入：

4
4 2 2 3
2

运行过程：

1. 初始 rightSum = 2 + 3 = 5。
2. 滑动窗口：
   • 左边增加 4，右边减少 2，sum = 5 + 4 - 2 = 7。
   • 左边增加 2，右边减少 3，sum = 7 + 2 - 3 = 6。
3. 最大值为 7。

输出：

7

---

总结

• 代码通过滑动窗口的思想，高效地计算了猴子从左边和右边选择香蕉的最大值。
• 时间复杂度为 O(n)，空间复杂度为 O(1)，能够很好地处理最大输入规模。

三、Java算法源码

以下是 Java 代码的详细注释和逻辑讲解，帮助你更好地理解代码的实现：

---

代码详细注释

import java.util.Arrays;
import java.util.Scanner;public class Main {public static void main(String[] args) {// 创建 Scanner 对象，用于从标准输入读取数据Scanner sc = new Scanner(System.in);// 读取第一行输入，表示数组的长度，并将其转换为整数int len = Integer.parseInt(sc.nextLine());// 读取第二行输入，表示数组的值，将其按空格分割并转换为整数数组int[] nums = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();// 读取第三行输入，表示猴子可以获取的次数，并将其转换为整数int n = Integer.parseInt(sc.nextLine());// 调用 getResult 函数计算结果，并输出System.out.println(getResult(len, nums, n));}// 定义 getResult 函数，用于计算猴子最多能获取的香蕉数量public static int getResult(int len, int[] nums, int n) {// 初始时，左边选择 0 个香蕉，因此左边选择的香蕉数为 0int leftSum = 0;// 初始时，右边选择 n 个香蕉，因此右边选择的香蕉数为 nums[len - n] ~ nums[len - 1] 这个 n 个元素之和int rightSum = 0;for (int i = len - n; i < len; i++) {rightSum += nums[i];}// 如果选择数 n == len，即全选，此时直接返回初始 rightSumif (len == n) {return rightSum;}// 如果不是全选// sum 记录当前选择结果int sum = leftSum + rightSum;// ans 记录所有选择结果中最大的值int ans = sum;// l 指向左边将要获得的香蕉，即左边获得一个int l = 0;// r 指向右边将要失去的香蕉，即右边失去一个int r = len - n;// 循环遍历所有可能的选择情况while (l < n) {// 左边增加一个香蕉，右边减少一个香蕉sum += nums[l++] - nums[r++];// 更新最大值ans = Math.max(ans, sum);}// 返回最终的最大值return ans;}
}

---

代码逻辑讲解

1. 输入处理

• 使用 Scanner 从标准输入读取数据。
• 第一行是数组的长度 len。
• 第二行是数组 nums，表示每串香蕉的根数。
• 第三行是猴子可以获取的次数 n。

2. 初始化

• leftSum 表示从左边选择的香蕉总数，初始为 0。
• rightSum 表示从右边选择的香蕉总数，初始为数组最后 n 个元素的和。

3. 特殊情况处理

• 如果 n == len，即猴子可以获取所有香蕉，直接返回 rightSum。

4. 滑动窗口计算

• 使用滑动窗口的思想，逐步调整左边和右边的选择。
• l 指向左边将要获得的香蕉，r 指向右边将要失去的香蕉。
• 每次循环：
  • 左边增加一个香蕉（nums[l++]）。
  • 右边减少一个香蕉（nums[r++]）。
  • 更新当前总和 sum。
  • 更新最大值 ans。

5. 返回结果

• 最终返回所有选择情况中的最大值 ans。

---

示例运行

示例 1

输入：

7
1 2 2 7 3 6 1
3

运行过程：

1. 初始 rightSum = 1 + 6 + 3 = 10。
2. 滑动窗口：
   • 左边增加 1，右边减少 1，sum = 10 + 1 - 1 = 10。
   • 左边增加 2，右边减少 6，sum = 10 + 2 - 6 = 6。
   • 左边增加 2，右边减少 3，sum = 6 + 2 - 3 = 5。
3. 最大值为 10。

输出：

10

示例 2

输入：

3
1 2 3
3

运行过程：

1. 初始 rightSum = 1 + 2 + 3 = 6。
2. 因为 n == len，直接返回 6。

输出：

6

示例 3

输入：

4
4 2 2 3
2

运行过程：

1. 初始 rightSum = 2 + 3 = 5。
2. 滑动窗口：
   • 左边增加 4，右边减少 2，sum = 5 + 4 - 2 = 7。
   • 左边增加 2，右边减少 3，sum = 7 + 2 - 3 = 6。
3. 最大值为 7。

输出：

7

---

总结

• 代码通过滑动窗口的思想，高效地计算了猴子从左边和右边选择香蕉的最大值。
• 时间复杂度为 O(n)，空间复杂度为 O(1)，能够很好地处理最大输入规模。
• Java 的实现与 JavaScript 版本逻辑一致，只是语法和输入输出方式有所不同。

四、Python算法源码

以下是 Python 代码的详细注释和逻辑讲解，帮助你更好地理解代码的实现：

---

代码详细注释

# 输入获取
# 读取第一行输入，表示数组的长度，并将其转换为整数
length = int(input())# 读取第二行输入，表示数组的值，将其按空格分割并转换为整数列表
nums = list(map(int, input().split()))# 读取第三行输入，表示猴子可以获取的次数，并将其转换为整数
n = int(input())# 算法入口
def getResult():# 初始时，左边选择 0 个香蕉，因此左边选择的香蕉数为 0leftSum = 0# 初始时，右边选择 n 个香蕉，因此右边选择的香蕉数为 nums[length - n] ~ nums[length - 1] 这个 n 个元素之和rightSum = sum(nums[length - n:])# 如果选择数 n == length，即全选，此时直接返回初始 rightSumif length == n:return rightSum# 如果不是全选# sumV 记录当前选择结果sumV = leftSum + rightSum# ans 记录所有选择结果中最大的值ans = sumV# l 指向左边将要获得的香蕉，即左边获得一个l = 0# r 指向右边将要失去的香蕉，即右边失去一个r = length - n# 循环遍历所有可能的选择情况while l < n:# 左边增加一个香蕉，右边减少一个香蕉sumV += nums[l] - nums[r]# 更新最大值ans = max(ans, sumV)# 移动指针l += 1r += 1# 返回最终的最大值return ans# 算法调用
print(getResult())

---

代码逻辑讲解

1. 输入处理

• 使用 input() 函数从标准输入读取数据。
• 第一行是数组的长度 length。
• 第二行是数组 nums，表示每串香蕉的根数。
• 第三行是猴子可以获取的次数 n。

2. 初始化

• leftSum 表示从左边选择的香蕉总数，初始为 0。
• rightSum 表示从右边选择的香蕉总数，初始为数组最后 n 个元素的和，通过 sum(nums[length - n:]) 计算。

3. 特殊情况处理

• 如果 n == length，即猴子可以获取所有香蕉，直接返回 rightSum。

4. 滑动窗口计算

• 使用滑动窗口的思想，逐步调整左边和右边的选择。
• l 指向左边将要获得的香蕉，r 指向右边将要失去的香蕉。
• 每次循环：
  • 左边增加一个香蕉（nums[l]）。
  • 右边减少一个香蕉（nums[r]）。
  • 更新当前总和 sumV。
  • 更新最大值 ans。
  • 移动指针 l 和 r。

5. 返回结果

• 最终返回所有选择情况中的最大值 ans。

---

示例运行

示例 1

输入：

7
1 2 2 7 3 6 1
3

运行过程：

1. 初始 rightSum = 1 + 6 + 3 = 10。
2. 滑动窗口：
   • 左边增加 1，右边减少 1，sumV = 10 + 1 - 1 = 10。
   • 左边增加 2，右边减少 6，sumV = 10 + 2 - 6 = 6。
   • 左边增加 2，右边减少 3，sumV = 6 + 2 - 3 = 5。
3. 最大值为 10。

输出：

10

示例 2

输入：

3
1 2 3
3

运行过程：

1. 初始 rightSum = 1 + 2 + 3 = 6。
2. 因为 n == length，直接返回 6。

输出：

6

示例 3

输入：

4
4 2 2 3
2

运行过程：

1. 初始 rightSum = 2 + 3 = 5。
2. 滑动窗口：
   • 左边增加 4，右边减少 2，sumV = 5 + 4 - 2 = 7。
   • 左边增加 2，右边减少 3，sumV = 7 + 2 - 3 = 6。
3. 最大值为 7。

输出：

7

---

总结

• 代码通过滑动窗口的思想，高效地计算了猴子从左边和右边选择香蕉的最大值。
• 时间复杂度为 O(n)，空间复杂度为 O(1)，能够很好地处理最大输入规模。
• Python 的实现与其他语言版本逻辑一致，只是语法和输入输出方式有所不同。

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

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

---

C语言代码

#include <stdio.h>// 定义一个宏，用于计算两个数的最大值
#define MAX(a, b) ((a) > (b) ? (a) : (b))// 定义 getResult 函数，用于计算猴子最多能获取的香蕉数量
int getResult(int nums_len, const int nums[], int n) {// 初始时，左边选择 0 个香蕉，因此左边选择的香蕉数为 0int leftSum = 0;// 初始时，右边选择 n 个香蕉，因此右边选择的香蕉数为 nums[len - n] ~ nums[len - 1] 这个 n 个元素之和int rightSum = 0;for (int i = nums_len - n; i < nums_len; i++) {rightSum += nums[i];}// 如果选择数 n == len，即全选，此时直接返回初始 rightSumif (nums_len == n) {return rightSum;}// 如果不是全选// sum 记录当前选择结果int sum = leftSum + rightSum;// ans 记录所有选择结果中最大的值int ans = sum;// l 指向左边将要获得的香蕉，即左边获得一个int l = 0;// r 指向右边将要失去的香蕉，即右边失去一个int r = nums_len - n;// 循环遍历所有可能的选择情况while (l < n) {// 左边增加一个香蕉，右边减少一个香蕉sum += nums[l++] - nums[r++];// 更新最大值ans = MAX(ans, sum);}// 返回最终的最大值return ans;
}int main() {// 读取数组的长度int nums_len;scanf("%d", &nums_len);// 读取数组的值int nums[nums_len];for (int i = 0; i < nums_len; i++) {scanf("%d", &nums[i]);}// 读取猴子可以获取的次数int n;scanf("%d", &n);// 调用 getResult 函数计算结果，并输出printf("%d\n", getResult(nums_len, nums, n));return 0;
}

---

C++代码

#include <iostream>
#include <vector>
using namespace std;// 定义 getResult 函数，用于计算猴子最多能获取的香蕉数量
int getResult(int nums_len, const vector<int>& nums, int n) {// 初始时，左边选择 0 个香蕉，因此左边选择的香蕉数为 0int leftSum = 0;// 初始时，右边选择 n 个香蕉，因此右边选择的香蕉数为 nums[len - n] ~ nums[len - 1] 这个 n 个元素之和int rightSum = 0;for (int i = nums_len - n; i < nums_len; i++) {rightSum += nums[i];}// 如果选择数 n == len，即全选，此时直接返回初始 rightSumif (nums_len == n) {return rightSum;}// 如果不是全选// sum 记录当前选择结果int sum = leftSum + rightSum;// ans 记录所有选择结果中最大的值int ans = sum;// l 指向左边将要获得的香蕉，即左边获得一个int l = 0;// r 指向右边将要失去的香蕉，即右边失去一个int r = nums_len - n;// 循环遍历所有可能的选择情况while (l < n) {// 左边增加一个香蕉，右边减少一个香蕉sum += nums[l++] - nums[r++];// 更新最大值ans = max(ans, sum);}// 返回最终的最大值return ans;
}int main() {// 读取数组的长度int nums_len;cin >> nums_len;// 读取数组的值vector<int> nums(nums_len);for (int i = 0; i < nums_len; i++) {cin >> nums[i];}// 读取猴子可以获取的次数int n;cin >> n;// 调用 getResult 函数计算结果，并输出cout << getResult(nums_len, nums, n) << endl;return 0;
}

---

代码逻辑讲解

1. 输入处理

• C语言：使用 scanf 从标准输入读取数据。
• C++：使用 cin 从标准输入读取数据。

2. 初始化

• leftSum 表示从左边选择的香蕉总数，初始为 0。
• rightSum 表示从右边选择的香蕉总数，初始为数组最后 n 个元素的和。

3. 特殊情况处理

• 如果 n == len，即猴子可以获取所有香蕉，直接返回 rightSum。

4. 滑动窗口计算

• 使用滑动窗口的思想，逐步调整左边和右边的选择。
• l 指向左边将要获得的香蕉，r 指向右边将要失去的香蕉。
• 每次循环：
  • 左边增加一个香蕉（nums[l++]）。
  • 右边减少一个香蕉（nums[r++]）。
  • 更新当前总和 sum。
  • 更新最大值 ans。

5. 返回结果

• 最终返回所有选择情况中的最大值 ans。

---

示例运行

示例 1

输入：

7
1 2 2 7 3 6 1
3

运行过程：

1. 初始 rightSum = 1 + 6 + 3 = 10。
2. 滑动窗口：
   • 左边增加 1，右边减少 1，sum = 10 + 1 - 1 = 10。
   • 左边增加 2，右边减少 6，sum = 10 + 2 - 6 = 6。
   • 左边增加 2，右边减少 3，sum = 6 + 2 - 3 = 5。
3. 最大值为 10。

输出：

10

示例 2

输入：

3
1 2 3
3

运行过程：

1. 初始 rightSum = 1 + 2 + 3 = 6。
2. 因为 n == len，直接返回 6。

输出：

6

示例 3

输入：

4
4 2 2 3
2

运行过程：

1. 初始 rightSum = 2 + 3 = 5。
2. 滑动窗口：
   • 左边增加 4，右边减少 2，sum = 5 + 4 - 2 = 7。
   • 左边增加 2，右边减少 3，sum = 7 + 2 - 3 = 6。
3. 最大值为 7。

输出：

7

---

总结

• C语言 和 C++ 版本的实现逻辑完全一致，只是输入输出方式和语法略有不同。
• 代码通过滑动窗口的思想，高效地计算了猴子从左边和右边选择香蕉的最大值。
• 时间复杂度为 O(n)，空间复杂度为 O(1)，能够很好地处理最大输入规模。

六、尾言

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

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