【2024年华为OD机试】(B卷,200分)- 学生方阵 （Java JS PythonC/C++）
一、问题描述
题目解析
问题描述
学校组织活动，将学生排成一个矩形方阵。需要在矩形方阵中找到最大的位置相连的男生数量。这个相连位置在一个直线上，方向可以是水平的、垂直的、成对角线的或者呈反对角线的。学生个数不会超过10000。
输入描述
输入的第一行为矩阵的行数和列数，接下来的n行为矩阵元素，元素间用“,”分隔。
输出描述
输出一个整数，表示矩阵中最长的位置相连的男生个数。
解题思路
本题的解题思路可以分为以下几个步骤：
-
遍历矩阵：首先遍历矩阵中的每一个元素，找到所有表示男生的点（即值为’M’的点）。
-
查找相连的男生数量：对于每一个找到的男生点，分别向四个方向（水平、垂直、正对角线、反对角线）查找相连的男生数量。
-
避免重复查找：为了避免重复查找，可以增加判断条件。如果当前男生点的左上角点是’M’，则反对角线不用查找了；如果右上角点是’M’，则正对角线不用查找了；如果上边点是’M’，则垂直线不用查找了；如果左边点是’M’，则水平线不用查找了。
-
记录最大值：在查找过程中，记录下每个方向上的最大相连男生数量，最终输出这个最大值。
示例解析
以题目中的示例为例：
输入：
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出：
3
解释：
- 在矩阵中，第二行的两个’M’和第三行的最后一个’M’在水平方向上相连，形成了最长的相连男生数量为3。
优化思路
为了避免重复查找，可以通过以下方式优化：
- 标记已查找的点：在查找过程中，可以标记已经查找过的点，避免重复查找。
- 利用动态规划：可以使用动态规划的方法，记录每个点在各个方向上的最大相连男生数量，从而减少重复计算。
通过以上方法，可以有效地减少重复查找，提高算法的效率。
二、JavaScript算法源码
以下是代码的详细注释和讲解，帮助理解每一部分的功能和逻辑：
代码结构
-
输入处理部分：
- 使用
readline模块从控制台读取输入。 - 第一行输入是矩阵的行数
n和列数m。 - 接下来的
n行是矩阵的内容，每行用逗号分隔。
- 使用
-
核心逻辑部分：
- 遍历矩阵中的每一个点，如果该点是
'M'，则向四个方向（水平、垂直、正对角线、反对角线）查找相连的'M'数量。 - 为了避免重复查找，检查当前点的左上、上、左、右上方向是否已经是
'M'。如果是，则跳过该方向的查找。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点，如果该点是
详细注释
// 引入 readline 模块，用于从控制台读取输入
const readline = require("readline");
// 创建 readline 接口
const rl = readline.createInterface({
input: process.stdin, // 输入流为标准输入
output: process.stdout, // 输出流为标准输出
});
// 用于存储输入的行数据
const lines = [];
let n, m; // n 是矩阵的行数，m 是矩阵的列数
// 监听每一行的输入
rl.on("line", (line) => {
lines.push(line); // 将输入的行数据存入 lines 数组
// 如果输入的第一行已经读取完毕，解析出 n 和 m
if (lines.length === 1) {
[n, m] = lines[0].split(",").map(Number); // 将字符串转换为数字
}
// 如果输入的行数已经达到 n + 1（第一行是 n 和 m，后面 n 行是矩阵内容）
if (n && lines.length === n + 1) {
lines.shift(); // 移除第一行（n 和 m）
const matrix = lines.map((line) => line.split(",")); // 将每行数据按逗号分隔，生成矩阵
// 调用核心逻辑函数，输出结果
console.log(getResult(matrix, n, m));
// 清空 lines 数组，以便处理下一组输入
lines.length = 0;
}
});
// 核心逻辑函数，计算矩阵中最长的相连 'M' 数量
function getResult(matrix, n, m) {
let ans = 0; // 用于记录最终的最大相连 'M' 数量
// 定义四个方向的偏移量
const offsets = [
[0, 1], // 水平方向（向右）
[1, 0], // 垂直方向（向下）
[1, 1], // 正对角线方向（右下）
[1, -1], // 反对角线方向（左下）
];
// 遍历矩阵的每一行
for (let i = 0; i < n; i++) {
// 遍历矩阵的每一列
for (let j = 0; j < m; j++) {
// 如果当前点是 'M'
if (matrix[i][j] == "M") {
// 遍历四个方向
for (let offset of offsets) {
// 计算当前方向的前一个点的坐标
const oldI = i - offset[0];
const oldJ = j - offset[1];
// 如果前一个点在矩阵范围内且是 'M'，则跳过当前方向的查找
if (
oldI >= 0 &&
oldI < n &&
oldJ >= 0 &&
oldJ < m &&
matrix[oldI][oldJ] == "M"
) {
continue;
}
// 初始化当前方向的相连 'M' 数量为 1（当前点）
let len = 1;
// 计算下一个点的坐标
let newI = i + offset[0];
let newJ = j + offset[1];
// 沿着当前方向查找相连的 'M'
while (
newI >= 0 &&
newI < n &&
newJ >= 0 &&
newJ < m &&
matrix[newI][newJ] == "M"
) {
len++; // 每找到一个 'M'，长度加 1
newI += offset[0]; // 移动到下一个点
newJ += offset[1];
}
// 更新最终的最大相连 'M' 数量
ans = Math.max(ans, len);
}
}
}
}
// 返回最终结果
return ans;
}
代码逻辑讲解
-
输入处理：
- 使用
readline模块逐行读取输入。 - 第一行是矩阵的行数
n和列数m，将其解析为数字。 - 接下来的
n行是矩阵内容，每行按逗号分隔后存入二维数组matrix。
- 使用
-
核心逻辑：
- 遍历矩阵中的每一个点
(i, j)。 - 如果当前点是
'M'，则向四个方向查找相连的'M'数量。 - 为了避免重复查找，检查当前点的前一个点是否已经是
'M'。如果是，则跳过该方向的查找。 - 沿着当前方向查找相连的
'M'，直到遇到边界或非'M'点。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点
-
方向偏移量：
[0, 1]：水平方向（向右）。[1, 0]：垂直方向（向下）。[1, 1]：正对角线方向（右下）。[1, -1]：反对角线方向（左下）。
-
输出结果：
- 最终输出矩阵中最长的相连
'M'数量。
- 最终输出矩阵中最长的相连
示例运行
输入
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出
3
解释
- 在矩阵中，第二行的两个
'M'和第三行的最后一个'M'在水平方向上相连，形成了最长的相连男生数量为 3。
通过以上注释和讲解，可以清晰地理解代码的每一部分功能和逻辑。
三、Java算法源码
以下是代码的详细注释和讲解，帮助理解每一部分的功能和逻辑：
代码结构
-
输入处理部分：
- 使用
readline模块从控制台读取输入。 - 第一行输入是矩阵的行数
n和列数m。 - 接下来的
n行是矩阵的内容，每行用逗号分隔。
- 使用
-
核心逻辑部分：
- 遍历矩阵中的每一个点，如果该点是
'M'，则向四个方向（水平、垂直、正对角线、反对角线）查找相连的'M'数量。 - 为了避免重复查找，检查当前点的左上、上、左、右上方向是否已经是
'M'。如果是，则跳过该方向的查找。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点，如果该点是
详细注释
// 引入 readline 模块，用于从控制台读取输入
const readline = require("readline");
// 创建 readline 接口
const rl = readline.createInterface({
input: process.stdin, // 输入流为标准输入
output: process.stdout, // 输出流为标准输出
});
// 用于存储输入的行数据
const lines = [];
let n, m; // n 是矩阵的行数，m 是矩阵的列数
// 监听每一行的输入
rl.on("line", (line) => {
lines.push(line); // 将输入的行数据存入 lines 数组
// 如果输入的第一行已经读取完毕，解析出 n 和 m
if (lines.length === 1) {
[n, m] = lines[0].split(",").map(Number); // 将字符串转换为数字
}
// 如果输入的行数已经达到 n + 1（第一行是 n 和 m，后面 n 行是矩阵内容）
if (n && lines.length === n + 1) {
lines.shift(); // 移除第一行（n 和 m）
const matrix = lines.map((line) => line.split(",")); // 将每行数据按逗号分隔，生成矩阵
// 调用核心逻辑函数，输出结果
console.log(getResult(matrix, n, m));
// 清空 lines 数组，以便处理下一组输入
lines.length = 0;
}
});
// 核心逻辑函数，计算矩阵中最长的相连 'M' 数量
function getResult(matrix, n, m) {
let ans = 0; // 用于记录最终的最大相连 'M' 数量
// 定义四个方向的偏移量
const offsets = [
[0, 1], // 水平方向（向右）
[1, 0], // 垂直方向（向下）
[1, 1], // 正对角线方向（右下）
[1, -1], // 反对角线方向（左下）
];
// 遍历矩阵的每一行
for (let i = 0; i < n; i++) {
// 遍历矩阵的每一列
for (let j = 0; j < m; j++) {
// 如果当前点是 'M'
if (matrix[i][j] == "M") {
// 遍历四个方向
for (let offset of offsets) {
// 计算当前方向的前一个点的坐标
const oldI = i - offset[0];
const oldJ = j - offset[1];
// 如果前一个点在矩阵范围内且是 'M'，则跳过当前方向的查找
if (
oldI >= 0 &&
oldI < n &&
oldJ >= 0 &&
oldJ < m &&
matrix[oldI][oldJ] == "M"
) {
continue;
}
// 初始化当前方向的相连 'M' 数量为 1（当前点）
let len = 1;
// 计算下一个点的坐标
let newI = i + offset[0];
let newJ = j + offset[1];
// 沿着当前方向查找相连的 'M'
while (
newI >= 0 &&
newI < n &&
newJ >= 0 &&
newJ < m &&
matrix[newI][newJ] == "M"
) {
len++; // 每找到一个 'M'，长度加 1
newI += offset[0]; // 移动到下一个点
newJ += offset[1];
}
// 更新最终的最大相连 'M' 数量
ans = Math.max(ans, len);
}
}
}
}
// 返回最终结果
return ans;
}
代码逻辑讲解
-
输入处理：
- 使用
readline模块逐行读取输入。 - 第一行是矩阵的行数
n和列数m，将其解析为数字。 - 接下来的
n行是矩阵内容，每行按逗号分隔后存入二维数组matrix。
- 使用
-
核心逻辑：
- 遍历矩阵中的每一个点
(i, j)。 - 如果当前点是
'M'，则向四个方向查找相连的'M'数量。 - 为了避免重复查找，检查当前点的前一个点是否已经是
'M'。如果是，则跳过该方向的查找。 - 沿着当前方向查找相连的
'M'，直到遇到边界或非'M'点。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点
-
方向偏移量：
[0, 1]：水平方向（向右）。[1, 0]：垂直方向（向下）。[1, 1]：正对角线方向（右下）。[1, -1]：反对角线方向（左下）。
-
输出结果：
- 最终输出矩阵中最长的相连
'M'数量。
- 最终输出矩阵中最长的相连
示例运行
输入
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出
3
解释
- 在矩阵中，第二行的两个
'M'和第三行的最后一个'M'在水平方向上相连，形成了最长的相连男生数量为 3。
通过以上注释和讲解，可以清晰地理解代码的每一部分功能和逻辑。
四、Python算法源码
以下是代码的详细注释和讲解，帮助理解每一部分的功能和逻辑：
代码结构
-
输入处理部分：
- 从标准输入读取矩阵的行数
n和列数m。 - 读取接下来的
n行矩阵内容，每行用逗号分隔，存入二维列表matrix。
- 从标准输入读取矩阵的行数
-
核心逻辑部分：
- 遍历矩阵中的每一个点，如果该点是
'M'，则向四个方向（水平、垂直、正对角线、反对角线）查找相连的'M'数量。 - 为了避免重复查找，检查当前点的左上、上、左、右上方向是否已经是
'M'。如果是，则跳过该方向的查找。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点，如果该点是
详细注释
# 输入获取
# 读取第一行输入，解析出矩阵的行数 n 和列数 m
n, m = map(int, input().split(","))
# 读取接下来的 n 行输入，每行按逗号分隔，生成二维列表 matrix
matrix = [input().split(",") for _ in range(n)]
# 算法入口
def getResult():
ans = 0 # 用于记录最终的最大相连 'M' 数量
# 定义四个方向的偏移量
offsets = (
(0, 1), # 水平方向（向右）
(1, 0), # 垂直方向（向下）
(1, 1), # 正对角线方向（右下）
(1, -1), # 反对角线方向（左下）
)
# 遍历矩阵的每一行
for i in range(n):
# 遍历矩阵的每一列
for j in range(m):
# 如果当前点是 'M'
if matrix[i][j] == "M":
# 遍历四个方向
for offset in offsets:
# 计算当前方向的前一个点的坐标
oldI = i - offset[0]
oldJ = j - offset[1]
# 如果前一个点在矩阵范围内且是 'M'，则跳过当前方向的查找
if n > oldI >= 0 and m > oldJ >= 0 and matrix[oldI][oldJ] == "M":
continue
# 初始化当前方向的相连 'M' 数量为 1（当前点）
length = 1
# 计算下一个点的坐标
newI = i + offset[0]
newJ = j + offset[1]
# 沿着当前方向查找相连的 'M'
while n > newI >= 0 and m > newJ >= 0 and matrix[newI][newJ] == "M":
length += 1 # 每找到一个 'M'，长度加 1
newI += offset[0] # 移动到下一个点
newJ += offset[1]
# 更新最终的最大相连 'M' 数量
ans = max(ans, length)
# 返回最终结果
return ans
# 调用算法并输出结果
print(getResult())
代码逻辑讲解
-
输入处理：
- 使用
input().split(",")读取第一行输入，解析出矩阵的行数n和列数m。 - 使用列表推导式读取接下来的
n行输入，每行按逗号分隔后存入二维列表matrix。
- 使用
-
核心逻辑：
- 遍历矩阵中的每一个点
(i, j)。 - 如果当前点是
'M'，则向四个方向查找相连的'M'数量。 - 为了避免重复查找，检查当前点的前一个点是否已经是
'M'。如果是，则跳过该方向的查找。 - 沿着当前方向查找相连的
'M'，直到遇到边界或非'M'点。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
- 遍历矩阵中的每一个点
-
方向偏移量：
(0, 1)：水平方向（向右）。(1, 0)：垂直方向（向下）。(1, 1)：正对角线方向（右下）。(1, -1)：反对角线方向（左下）。
-
输出结果：
- 最终输出矩阵中最长的相连
'M'数量。
- 最终输出矩阵中最长的相连
示例运行
输入
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出
3
解释
- 在矩阵中，第二行的两个
'M'和第三行的最后一个'M'在水平方向上相连，形成了最长的相连男生数量为 3。
通过以上注释和讲解，可以清晰地理解代码的每一部分功能和逻辑。
五、C/C++算法源码：
以下是 C语言 和 C++ 版本的代码，并附带详细的中文注释和讲解：
C语言代码
#include <stdio.h>
// 定义一个宏，用于计算两个数的最大值
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
int n, m; // 定义矩阵的行数 n 和列数 m
scanf("%d,%d\n", &n, &m); // 读取第一行输入，获取 n 和 m 的值
char matrix[n][m]; // 定义二维字符数组，用于存储矩阵
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%c", &matrix[i][j]); // 读取矩阵的每个元素
getchar(); // 读取逗号或换行符
}
}
int ans = 0; // 用于记录最终的最大相连 'M' 数量
// 定义四个方向的偏移量
int offsets[4][2] = {
{0, 1}, // 水平方向（向右）
{1, 0}, // 垂直方向（向下）
{1, 1}, // 正对角线方向（右下）
{1, -1} // 反对角线方向（左下）
};
// 遍历矩阵的每一行
for (int i = 0; i < n; i++) {
// 遍历矩阵的每一列
for (int j = 0; j < m; j++) {
// 如果当前点是 'M'
if (matrix[i][j] == 'M') {
// 遍历四个方向
for (int k = 0; k < 4; k++) {
int offsetI = offsets[k][0]; // 当前方向的行偏移量
int offsetJ = offsets[k][1]; // 当前方向的列偏移量
// 计算当前方向的前一个点的坐标
int oldI = i - offsetI;
int oldJ = j - offsetJ;
// 如果前一个点在矩阵范围内且是 'M'，则跳过当前方向的查找
if (oldI >= 0 && oldI < n && oldJ >= 0 && oldJ < m && matrix[oldI][oldJ] == 'M') {
continue;
}
// 初始化当前方向的相连 'M' 数量为 1（当前点）
int len = 1;
// 计算下一个点的坐标
int newI = i + offsetI;
int newJ = j + offsetJ;
// 沿着当前方向查找相连的 'M'
while (newI >= 0 && newI < n && newJ >= 0 && newJ < m && matrix[newI][newJ] == 'M') {
len++; // 每找到一个 'M'，长度加 1
newI += offsetI; // 移动到下一个点
newJ += offsetJ;
}
// 更新最终的最大相连 'M' 数量
ans = MAX(ans, len);
}
}
}
}
// 输出最终结果
printf("%d\n", ans);
return 0;
}
C++代码
#include <iostream>
#include <vector>
using namespace std;
// 定义一个宏，用于计算两个数的最大值
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
int n, m; // 定义矩阵的行数 n 和列数 m
char comma;
cin >> n >> comma >> m; // 读取第一行输入，获取 n 和 m 的值
vector<vector<char>> matrix(n, vector<char>(m)); // 定义二维字符数组，用于存储矩阵
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> matrix[i][j]; // 读取矩阵的每个元素
if (j < m - 1) cin >> comma; // 读取逗号
}
}
int ans = 0; // 用于记录最终的最大相连 'M' 数量
// 定义四个方向的偏移量
int offsets[4][2] = {
{0, 1}, // 水平方向（向右）
{1, 0}, // 垂直方向（向下）
{1, 1}, // 正对角线方向（右下）
{1, -1} // 反对角线方向（左下）
};
// 遍历矩阵的每一行
for (int i = 0; i < n; i++) {
// 遍历矩阵的每一列
for (int j = 0; j < m; j++) {
// 如果当前点是 'M'
if (matrix[i][j] == 'M') {
// 遍历四个方向
for (int k = 0; k < 4; k++) {
int offsetI = offsets[k][0]; // 当前方向的行偏移量
int offsetJ = offsets[k][1]; // 当前方向的列偏移量
// 计算当前方向的前一个点的坐标
int oldI = i - offsetI;
int oldJ = j - offsetJ;
// 如果前一个点在矩阵范围内且是 'M'，则跳过当前方向的查找
if (oldI >= 0 && oldI < n && oldJ >= 0 && oldJ < m && matrix[oldI][oldJ] == 'M') {
continue;
}
// 初始化当前方向的相连 'M' 数量为 1（当前点）
int len = 1;
// 计算下一个点的坐标
int newI = i + offsetI;
int newJ = j + offsetJ;
// 沿着当前方向查找相连的 'M'
while (newI >= 0 && newI < n && newJ >= 0 && newJ < m && matrix[newI][newJ] == 'M') {
len++; // 每找到一个 'M'，长度加 1
newI += offsetI; // 移动到下一个点
newJ += offsetJ;
}
// 更新最终的最大相连 'M' 数量
ans = MAX(ans, len);
}
}
}
}
// 输出最终结果
cout << ans << endl;
return 0;
}
代码逻辑讲解
1. 输入处理
- 读取矩阵的行数
n和列数m。 - 读取矩阵内容，存储到二维数组
matrix中。
2. 核心逻辑
- 遍历矩阵中的每一个点
(i, j)。 - 如果当前点是
'M'，则向四个方向（水平、垂直、正对角线、反对角线）查找相连的'M'数量。 - 为了避免重复查找，检查当前点的前一个点是否已经是
'M'。如果是，则跳过该方向的查找。 - 沿着当前方向查找相连的
'M'，直到遇到边界或非'M'点。 - 记录每个方向的最大相连
'M'数量，并更新最终结果ans。
3. 方向偏移量
{0, 1}：水平方向（向右）。{1, 0}：垂直方向（向下）。{1, 1}：正对角线方向（右下）。{1, -1}：反对角线方向（左下）。
4. 输出结果
- 最终输出矩阵中最长的相连
'M'数量。
示例运行
输入
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出
3
解释
- 在矩阵中，第二行的两个
'M'和第三行的最后一个'M'在水平方向上相连，形成了最长的相连男生数量为 3。
通过以上注释和讲解，可以清晰地理解代码的每一部分功能和逻辑。
六、尾言
什么是华为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 或监考人员进行反馈。
祝你考试顺利，取得理想成绩！