【2024年华为OD机试】 (C卷,200分)- 贪吃的猴子(JavaScriptJava PythonC/C++)
一、问题描述
题目解析
问题描述
一只猴子来到果园,发现许多串香蕉排成一行,每串香蕉上有若干根香蕉。每串香蕉的根数由数组 numbers
给出。猴子每次只能从行的开头或末尾获取香蕉,并且只能获取 N
次。求猴子最多能获取多少根香蕉。
输入描述
- 第一行为数组
numbers
的长度。 - 第二行为数组
numbers
的值,每个数字通过空格分开。 - 第三行输入为
N
,表示获取的次数。
输出描述
按照题目要求能获取的最大数值。
备注
- 1 ≤
numbers.length
≤ 100000 - 1 ≤
numbers
≤ 100 - 1 ≤
N
≤numbers.length
用例
-
输入:
7 1 2 2 7 3 6 1 3
输出:
10
说明:第一次从末尾获取1,第二次从末尾获取6,第三次从末尾获取3,最终根数为1+6+3=10。
-
输入:
3 1 2 3 3
输出:
6
说明:全部获取所有的香蕉,最终根数为1+2+3=6。
-
输入:
4 4 2 2 3 2
输出:
7
说明:第一次从开头获取4,第二次从末尾获取3,最终根数为4+3=7。
解题思路
初步思路
最初的想法是通过分支递归+缓存优化来求解。然而,由于 numbers.length
的最大值可以达到100000,递归操作会导致栈溢出,且缓存数组占用的内存会超出限制。
优化思路
经过进一步思考,发现无论猴子如何选择,左边和右边选择的香蕉必然是连续的,并且是从头尾开始的连续选择。因此,问题可以简化为将 N
次选择分解为左边选择的个数和右边选择的个数。
具体步骤
- 初始化:假设左边选择了0个,右边选择了
N
个,计算此时的总和。 - 逐步调整:每次将左边选择的个数增加1,右边选择的个数减少1,并基于前一个状态计算新的总和。
- 求最大值:在所有可能的选择中,找出总和最大的情况。
示例解析
以第一个用例为例:
- 初始时,左边选择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
运行过程:
- 初始
rightSum = 1 + 6 + 3 = 10
。 - 滑动窗口:
- 左边增加
1
,右边减少1
,sum = 10 + 1 - 1 = 10
。 - 左边增加
2
,右边减少6
,sum = 10 + 2 - 6 = 6
。 - 左边增加
2
,右边减少3
,sum = 6 + 2 - 3 = 5
。
- 左边增加
- 最大值为
10
。
输出:
10
示例 2
输入:
3
1 2 3
3
运行过程:
- 初始
rightSum = 1 + 2 + 3 = 6
。 - 因为
n == len
,直接返回6
。
输出:
6
示例 3
输入:
4
4 2 2 3
2
运行过程:
- 初始
rightSum = 2 + 3 = 5
。 - 滑动窗口:
- 左边增加
4
,右边减少2
,sum = 5 + 4 - 2 = 7
。 - 左边增加
2
,右边减少3
,sum = 7 + 2 - 3 = 6
。
- 左边增加
- 最大值为
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
运行过程:
- 初始
rightSum = 1 + 6 + 3 = 10
。 - 滑动窗口:
- 左边增加
1
,右边减少1
,sum = 10 + 1 - 1 = 10
。 - 左边增加
2
,右边减少6
,sum = 10 + 2 - 6 = 6
。 - 左边增加
2
,右边减少3
,sum = 6 + 2 - 3 = 5
。
- 左边增加
- 最大值为
10
。
输出:
10
示例 2
输入:
3
1 2 3
3
运行过程:
- 初始
rightSum = 1 + 2 + 3 = 6
。 - 因为
n == len
,直接返回6
。
输出:
6
示例 3
输入:
4
4 2 2 3
2
运行过程:
- 初始
rightSum = 2 + 3 = 5
。 - 滑动窗口:
- 左边增加
4
,右边减少2
,sum = 5 + 4 - 2 = 7
。 - 左边增加
2
,右边减少3
,sum = 7 + 2 - 3 = 6
。
- 左边增加
- 最大值为
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
运行过程:
- 初始
rightSum = 1 + 6 + 3 = 10
。 - 滑动窗口:
- 左边增加
1
,右边减少1
,sumV = 10 + 1 - 1 = 10
。 - 左边增加
2
,右边减少6
,sumV = 10 + 2 - 6 = 6
。 - 左边增加
2
,右边减少3
,sumV = 6 + 2 - 3 = 5
。
- 左边增加
- 最大值为
10
。
输出:
10
示例 2
输入:
3
1 2 3
3
运行过程:
- 初始
rightSum = 1 + 2 + 3 = 6
。 - 因为
n == length
,直接返回6
。
输出:
6
示例 3
输入:
4
4 2 2 3
2
运行过程:
- 初始
rightSum = 2 + 3 = 5
。 - 滑动窗口:
- 左边增加
4
,右边减少2
,sumV = 5 + 4 - 2 = 7
。 - 左边增加
2
,右边减少3
,sumV = 7 + 2 - 3 = 6
。
- 左边增加
- 最大值为
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
运行过程:
- 初始
rightSum = 1 + 6 + 3 = 10
。 - 滑动窗口:
- 左边增加
1
,右边减少1
,sum = 10 + 1 - 1 = 10
。 - 左边增加
2
,右边减少6
,sum = 10 + 2 - 6 = 6
。 - 左边增加
2
,右边减少3
,sum = 6 + 2 - 3 = 5
。
- 左边增加
- 最大值为
10
。
输出:
10
示例 2
输入:
3
1 2 3
3
运行过程:
- 初始
rightSum = 1 + 2 + 3 = 6
。 - 因为
n == len
,直接返回6
。
输出:
6
示例 3
输入:
4
4 2 2 3
2
运行过程:
- 初始
rightSum = 2 + 3 = 5
。 - 滑动窗口:
- 左边增加
4
,右边减少2
,sum = 5 + 4 - 2 = 7
。 - 左边增加
2
,右边减少3
,sum = 7 + 2 - 3 = 6
。
- 左边增加
- 最大值为
7
。
输出:
7
总结
- C语言 和 C++ 版本的实现逻辑完全一致,只是输入输出方式和语法略有不同。
- 代码通过滑动窗口的思想,高效地计算了猴子从左边和右边选择香蕉的最大值。
- 时间复杂度为
O(n)
,空间复杂度为O(1)
,能够很好地处理最大输入规模。
六、尾言
什么是华为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 或监考人员进行反馈。
祝你考试顺利,取得理想成绩!