【2024年华为OD机试】 (C卷,200分)- 反射计数（Java JS PythonC/C++）

一、问题描述

题目解析

题目描述

给定一个包含 0 和 1 的二维矩阵，一个物体从给定的初始位置出发，在给定的速度下进行移动。遇到矩阵的边缘时会发生镜面反射。无论物体经过 0 还是 1，都不影响其速度。请计算并给出经过 t 时间单位后，物体经过 1 点的次数。

输入描述

1. 第一行为初始信息：

   <w> <h> <x> <y> <sx> <sy> <t>
   

   • w 和 h 为矩阵的宽和高。
   • x 和 y 为起始位置。
   • sx 和 sy 为初始速度。
   • t 为经过的时间。

2. 第二行开始一共 h 行，为二维矩阵信息。

输出描述

输出经过 1 的个数。注意初始位置也要计算在内。

用例

输入

12 7 2 1 1 -1 13
001000010000
001000010000
001000010000
001000010000
001000010000
001000010000
001000010000

输出

3

说明

• 初始位置为 (2, 1)，速度为 (1, -1)。
• 经过 13 个时间单位后，物体经过 1 的个数为 3。

---

题目解析

问题分析

1. 目标
   计算物体在 t 时间单位内经过 1 的点的次数。

2. 关键点

   • 物体在矩阵中移动，遇到边缘时会发生镜面反射。
   • 每次移动的时间单位为 1，不考虑小于 1 个时间单位内经过的点。
   • 初始位置如果是 1，也要计算在内。

3. 问题转化
   模拟物体在矩阵中的移动过程，记录经过 1 的点的次数。

---

解题思路

1. 初始化

   • 读取矩阵的宽 w 和高 h。
   • 读取初始位置 (x, y) 和速度 (sx, sy)。
   • 读取时间 t。
   • 读取矩阵数据。

2. 模拟移动过程

   • 对于每个时间单位，更新物体的位置。
   • 如果位置超出矩阵边界，则进行镜面反射，并调整速度方向。
   • 检查当前位置是否为 1，如果是，则计数加 1。

3. 输出结果

   • 输出经过 1 的点的次数。

---

示例分析

输入

12 7 2 1 1 -1 13
001000010000
001000010000
001000010000
001000010000
001000010000
001000010000
001000010000

步骤

1. 初始化：

   • w = 12，h = 7。
   • 初始位置 (x, y) = (2, 1)。
   • 速度 (sx, sy) = (1, -1)。
   • 时间 t = 13。
   • 矩阵数据：

     001000010000
     001000010000
     001000010000
     001000010000
     001000010000
     001000010000
     001000010000
     

2. 模拟移动过程：

   • 初始位置 (2, 1) 是 1，计数加 1。
   • 移动 13 个时间单位，每次更新位置并检查是否为 1。
   • 经过 13 个时间单位后，物体经过 1 的点的次数为 3。

3. 输出结果：3。

---

复杂度分析

1. 时间复杂度

   • 模拟移动过程的时间复杂度为 O(t)，其中 t 是时间单位。
   • 总时间复杂度为 O(t)。

2. 空间复杂度

   • 存储矩阵数据的空间复杂度为 O(w * h)。
   • 总空间复杂度为 O(w * h)。

---

总结

本题的核心是通过模拟物体在矩阵中的移动过程，记录经过 1 的点的次数。关键在于：

1. 处理物体在矩阵边缘的镜面反射。
2. 每次移动后检查当前位置是否为 1。
3. 时间复杂度为 O(t)，适合处理 t 较小的输入。

二、JavaScript算法源码

这段 JavaScript 代码的功能是模拟一个在矩阵中“移动”的过程，并根据指定的规则统计符合条件的格子数。以下是代码的逐步解析。

代码概述

1. 输入

   • w、h：矩阵的宽度和高度（列数和行数）。
   • x、y：起始位置的横坐标和纵坐标（列号和行号）。
   • sx、sy：水平和垂直的速度，表示每次移动的步数。
   • t：模拟的最大时间步数。

2. 矩阵

   • 输入的矩阵由字符 '0' 和 '1' 组成，其中 '1' 代表一个特定的目标。

3. 目标

   • 目标是根据给定的规则在矩阵中移动并统计遇到的 '1' 的个数。

逐行分析

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

• 使用 Node.js 的 readline 模块来异步读取输入。
• iter 是 readline 的异步迭代器，通过 readline() 获取每一行输入。

let [w, h, x, y, sx, sy, t] = (await readline()).split(" ").map(Number);

• 读取输入的第一行，并将其拆分成数字：
  • w：矩阵的列数。
  • h：矩阵的行数。
  • x：起始的列坐标（水平坐标）。
  • y：起始的行坐标（纵坐标）。
  • sx：水平移动步数（速度）。
  • sy：垂直移动步数（速度）。
  • t：移动的最大步数（时间）。

const matrix = [];
for (let i = 0; i < h; i++) {matrix.push(await readline());
}

• 初始化一个空的二维矩阵 matrix。
• 使用 for 循环读取 h 行，填充 matrix。

let ans = 0;

• ans 用于记录遇到的 '1' 的数量。

while (t >= 0) {if (matrix[y][x] == "1") {ans++;}

• 开始一个 while 循环，循环次数为 t。
• 如果当前位置的格子是 '1'，则统计计数器 ans 加 1。

  y += sy;x += sx;

• 更新位置，y 按照垂直方向的速度 sy 变化，x 按照水平方向的速度 sx 变化。

  if (x < 0) {x = 1;sx = -sx;} else if (x >= w) {x = w - 2;sx = -sx;}

• 检查 x（列坐标）是否越界：
  • 如果 x 小于 0（即超出了左边界），将 x 设为 1，并且反转水平移动速度 sx（使其向右）。
  • 如果 x 超出了右边界（即 x >= w），将 x 设为 w - 2，并反转水平速度 sx（使其向左）。

  if (y < 0) {y = 1;sy = -sy;} else if (y >= h) {y = h - 2;sy = -sy;}

• 检查 y（行坐标）是否越界：
  • 如果 y 小于 0（即超出了上边界），将 y 设为 1，并反转垂直移动速度 sy（使其向下）。
  • 如果 y 超出了下边界（即 y >= h），将 y 设为 h - 2，并反转垂直速度 sy（使其向上）。

  t--;
}

• 每次循环结束后，减少 t，表示已经消耗了一个时间步。

console.log(ans);

• 输出统计的 '1' 的数量，即在矩阵中遇到的目标数。

总结

1. 问题本质：

   • 这段代码模拟了一个物体在矩阵中根据给定的规则进行移动的过程。
   • 如果当前位置是 '1'，就增加计数器，最终输出计数器的值。

2. 坐标的变化和边界处理：

   • 通过检查坐标是否越界，并反转方向的方式确保物体在矩阵中“反弹”。
   • 水平和垂直坐标的处理是独立的，根据具体的方向反转速度。

3. 边界处理：

   • 代码中明确处理了矩阵的上下左右边界，一旦超出边界，坐标反转。

输入输出示例

假设输入如下：

5 5 0 0 1 1 10
00000
00000
00100
00000
00000

• w = 5, h = 5：矩阵的大小为 5x5。
• x = 0, y = 0：起始坐标是左上角。
• sx = 1, sy = 1：每次水平方向和垂直方向都移动 1 步。
• t = 10：模拟 10 步。

矩阵如下：

00000
00000
00100
00000
00000

• 起始时，坐标 (0, 0) 处的值是 '0'，然后按规则向下、向右移动。
• 每次遇到 '1' 统计一次。
• 代码会输出在 10 步内遇到的 '1' 的个数。

三、Java算法源码

这段 Java 代码的功能与之前的 JavaScript 代码类似，目的是在矩阵中模拟一个物体的移动过程，并根据规则统计移动过程中经过的 '1' 的数量。让我们逐行分析这段代码：

代码分析

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);

• 使用 Scanner 类读取输入数据。sc 是一个 Scanner 对象，用于从标准输入读取数据。

    int w = sc.nextInt();int h = sc.nextInt();int x = sc.nextInt();int y = sc.nextInt();int sx = sc.nextInt();int sy = sc.nextInt();int t = sc.nextInt();

• 读取输入数据：矩阵的宽度 w、高度 h，起始位置 (x, y)，每步的水平和垂直速度 sx 和 sy，以及模拟的最大时间步数 t。

    char[][] matrix = new char[h][w];for (int i = 0; i < h; i++) {matrix[i] = sc.next().toCharArray();}

• 初始化一个二维字符数组 matrix，用于存储矩阵中的每个字符。
• 使用循环读取矩阵的每一行，并将其转换为字符数组存储在 matrix 中。

    int ans = 0;

• 初始化 ans 变量，用于统计遇到的 '1' 的数量。

    while (t >= 0) {

• 开始一个 while 循环，直到 t 为负，表示已经完成所有时间步。

      if (matrix[y][x] == '1') {ans++;}

• 检查当前位置的格子是否为 '1'，如果是，增加 ans。

      y += sy;x += sx;

• 更新当前位置 (x, y)。y 按垂直方向速度 sy 变化，x 按水平方向速度 sx 变化。

      if (x < 0) {x = 1;sx = -sx;} else if (x >= w) {x = w - 2;sx = -sx;}

• 判断水平方向的越界情况：
  • 如果 x 小于 0（即超出了左边界），将 x 设置为 1，并反转水平方向速度 sx（即使得物体向右移动）。
  • 如果 x 超过了右边界（即 x >= w），将 x 设置为 w - 2，并反转水平方向速度 sx（即使得物体向左移动）。

      if (y < 0) {y = 1;sy = -sy;} else if (y >= h) {y = h - 2;sy = -sy;}

• 判断垂直方向的越界情况：
  • 如果 y 小于 0（即超出了上边界），将 y 设置为 1，并反转垂直方向速度 sy（即使得物体向下移动）。
  • 如果 y 超过了下边界（即 y >= h），将 y 设置为 h - 2，并反转垂直方向速度 sy（即使得物体向上移动）。

      t--;}

• 每次循环结束后，减少 t，表示时间步数已经消耗。

    System.out.println(ans);}
}

• 输出统计结果 ans，即在整个过程中遇到的 '1' 的数量。

总结

这段 Java 代码模拟了一个物体在一个矩阵中按给定规则移动的过程，并统计经过的 '1' 的数量。代码中的关键步骤包括：

1. 输入处理：通过 Scanner 读取矩阵的尺寸、起始坐标、速度以及最大时间步数。
2. 矩阵处理：根据输入的矩阵，使用二维数组 matrix 存储每个格子的值（'0' 或 '1'）。
3. 边界检测：在每次移动后，检查是否越界，如果越界则反转物体的移动方向，并根据规则修正坐标。
4. 统计 '1' 的数量：在每个时间步，检查当前位置是否是 '1'，如果是则增加计数。

示例输入输出

假设输入如下：

5 5 0 0 1 1 10
00000
00000
00100
00000
00000

• w = 5, h = 5：矩阵的宽度和高度分别为 5 和 5。
• x = 0, y = 0：起始位置为左上角。
• sx = 1, sy = 1：每次水平方向和垂直方向都移动 1 步。
• t = 10：模拟 10 步。

矩阵如下：

00000
00000
00100
00000
00000

输出：

1

代码的复杂度分析

• 时间复杂度：每次循环中，更新位置、检查边界、统计 '1' 等操作都是常数时间操作。最坏情况下，循环会执行 t 次，所以时间复杂度是 O(t)。

• 空间复杂度：存储矩阵的空间复杂度是 O(w * h)，即矩阵的大小。

因此，整体的时间复杂度为 O(t)，空间复杂度为 O(w * h)。

四、Python算法源码

下面是对这段 Python 代码的详细注释和讲解：

1. 输入部分

w, h, x, y, sx, sy, t = map(int, input().split())
matrix = [input() for _ in range(h)]

• w, h, x, y, sx, sy, t = map(int, input().split())：

  • 使用 input().split() 获取一行输入并将其按空格分割，然后用 map(int, ...) 将所有值转换为整数。它们分别代表：
    • w：矩阵的列数（宽度）。
    • h：矩阵的行数（高度）。
    • x：起始列坐标（水平坐标）。
    • y：起始行坐标（垂直坐标）。
    • sx：水平移动的速度（步长）。
    • sy：垂直移动的速度（步长）。
    • t：总的时间步数，模拟物体移动的步数。

• matrix = [input() for _ in range(h)]：

  • 这里使用列表推导式，循环 h 次，读取每一行矩阵并存储为字符列表。每行是一个字符串，表示矩阵中的一行。
  • 例如，若输入矩阵的某一行是 00100，则 matrix[i] 将是这个字符串。

2. 算法部分

def getResult():global x, y, sx, sy, tans = 0

• 定义 getResult 函数，其中 global x, y, sx, sy, t 表示在该函数中会使用和修改外部定义的变量 x, y, sx, sy, t。
• ans = 0：初始化一个变量 ans 来统计遇到的 '1' 的数量。

    while t >= 0:

• 进入一个 while 循环，循环的条件是 t >= 0。每次循环代表一次时间步长，直到 t 减少为负值为止。

        if matrix[y][x] == '1':ans += 1

• 在当前的坐标 (x, y) 位置，检查矩阵中的字符是否为 '1'。如果是 '1'，就将 ans 加 1，表示遇到一个目标。

        y += syx += sx

• 更新当前坐标 (x, y)：
  • y += sy：垂直坐标 y 按照垂直速度 sy 更新，向上或向下移动。
  • x += sx：水平坐标 x 按照水平速度 sx 更新，向左或向右移动。

        if x < 0:x = 1sx = -sxelif x >= w:x = w - 2sx = -sx

• 处理水平边界：
  • 如果 x < 0（即移动超出了左边界），则将 x 设置为 1，并反转水平速度 sx（即使得物体开始向右移动）。
  • 如果 x >= w（即移动超出了右边界），则将 x 设置为 w - 2（确保物体不再越过边界），并反转水平速度 sx（即物体开始向左移动）。

        if y < 0:y = 1sy = -syelif y >= h:y = h - 2sy = -sy

• 处理垂直边界：
  • 如果 y < 0（即移动超出了上边界），则将 y 设置为 1，并反转垂直速度 sy（即物体开始向下移动）。
  • 如果 y >= h（即移动超出了下边界），则将 y 设置为 h - 2（确保物体不再越过边界），并反转垂直速度 sy（即物体开始向上移动）。

        t -= 1

• 每次循环后，减少 t，表示已经消耗了一个时间步。

3. 返回结果

    return ans

• 当时间步数 t 用完时，返回统计的结果 ans，即物体经过的 '1' 的总数。

4. 算法调用部分

print(getResult())

• 调用 getResult() 函数并打印返回的结果，输出遇到的 '1' 的数量。

完整工作流程

1. 输入数据：

   • 程序首先从用户输入中读取矩阵的尺寸、起始位置、速度和最大时间步数。
   • 然后读取矩阵的内容，每个字符代表矩阵中的一部分。

2. 模拟运动：

   • 在矩阵中从起始位置 (x, y) 开始，按照给定的速度 sx 和 sy 移动。
   • 每一步移动后检查当前位置是否是 '1'，如果是，则增加 ans 计数。
   • 碰到矩阵边界时，会反转运动方向，继续在矩阵中反弹。

3. 返回结果：

   • 当经过所有时间步 t 后，返回统计的 '1' 数量。

示例说明

假设输入如下：

5 5 0 0 1 1 10
00000
00000
00100
00000
00000

• w = 5, h = 5：矩阵的宽度和高度是 5。
• x = 0, y = 0：起始位置在矩阵的左上角。
• sx = 1, sy = 1：每次水平方向和垂直方向都移动 1 步。
• t = 10：模拟 10 步。

矩阵如下：

00000
00000
00100
00000
00000

运行过程：

• 从起始位置 (0, 0) 开始，向右向下移动。
• 第 3 步时，物体移动到 (2, 2)，矩阵位置是 '1'，计数器 ans 加 1。
• 随后物体反弹继续移动，直到时间步数 t 结束。

输出结果：

1

总结

这段代码通过模拟一个物体在矩阵中的移动，并根据碰到的 '1' 进行计数，最终输出物体经过的 '1' 的个数。关键的技术点包括边界检测和反弹的处理，每次越界时反转方向，确保物体不超出矩阵的范围。

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

模拟了一个物体在矩阵中按指定的速度移动，并统计它经过的 '1' 的数量。我们将逐步讲解每个部分，并转换为 C++ 版本。

C 语言代码转换为 C++ 代码

1. C 语言代码部分：

#include <stdio.h>#define MAX_SIZE 100int main() {int w, h, x, y, sx, sy, t;scanf("%d %d %d %d %d %d %d", &w, &h, &x, &y, &sx, &sy, &t);getchar();char matrix[MAX_SIZE][MAX_SIZE];for (int i = 0; i < h; i++) {gets(matrix[i]);}int ans = 0;while (t >= 0) {// 注意本题横纵坐标是反的，因此y其实是行号，x是列号if (matrix[y][x] == '1') {ans++;}y += sy;x += sx;if (x < 0) {x = 1;sx = -sx;} else if (x >= w) { //  注意本题横纵坐标是反的，因此x是列号，w是矩阵列数x = w - 2;sx = -sx;}if (y < 0) {y = 1;sy = -sy;} else if (y >= h) { //  注意本题横纵坐标是反的，因此y是行号，h是矩阵行数y = h - 2;sy = -sy;}t--;}printf("%d\n", ans);return 0;
}

转换为 C++ 代码

在 C++ 中，我们通常使用 iostream 来替代 stdio.h 来进行输入输出，使用 std::vector 或 std::string 来管理矩阵而不是固定大小的数组。我们还要避免使用 gets()，因为它已经被废弃。我们改为使用 std::cin 和 std::getline() 来读取输入。

C++ 代码

#include <iostream>
#include <vector>
#include <string>#define MAX_SIZE 100using namespace std;int main() {int w, h, x, y, sx, sy, t;// 读取矩阵的宽度、高度、起始位置、速度和时间cin >> w >> h >> x >> y >> sx >> sy >> t;cin.ignore();  // 读取整行数据时，忽略前面换行符vector<string> matrix(h);  // 使用 string 类型的 vector 存储每行的矩阵for (int i = 0; i < h; i++) {getline(cin, matrix[i]);  // 读取每行矩阵}int ans = 0;while (t >= 0) {// 检查当前位置是否是 '1'if (matrix[y][x] == '1') {ans++;}// 更新当前位置y += sy;x += sx;// 水平方向越界检测if (x < 0) {x = 1;sx = -sx;} else if (x >= w) {x = w - 2;sx = -sx;}// 垂直方向越界检测if (y < 0) {y = 1;sy = -sy;} else if (y >= h) {y = h - 2;sy = -sy;}t--;  // 每次模拟步数减 1}cout << ans << endl;  // 输出遇到的 '1' 的数量return 0;
}

详细注释和讲解

1. 输入处理

cin >> w >> h >> x >> y >> sx >> sy >> t;
cin.ignore();

• cin >> w >> h >> x >> y >> sx >> sy >> t;：通过 cin 从标准输入读取 7 个整数，分别代表矩阵的宽度 w、高度 h，起始位置 (x, y)，水平速度 sx，垂直速度 sy，以及最大时间步数 t。
• cin.ignore();：在读取完整数后，使用 cin.ignore() 忽略掉换行符，防止在读取矩阵时受到干扰。

2. 矩阵输入

vector<string> matrix(h);
for (int i = 0; i < h; i++) {getline(cin, matrix[i]);
}

• vector<string> matrix(h);：使用 vector<string> 来存储矩阵，h 表示矩阵的行数。
• getline(cin, matrix[i]);：每行输入用 getline 来读取。getline 读取一整行并存储为字符串。

3. 变量初始化

int ans = 0;

• ans 用来统计经过的 '1' 的数量，初始值为 0。

4. 模拟过程

while (t >= 0) {if (matrix[y][x] == '1') {ans++;}y += sy;x += sx;if (x < 0) {x = 1;sx = -sx;} else if (x >= w) {x = w - 2;sx = -sx;}if (y < 0) {y = 1;sy = -sy;} else if (y >= h) {y = h - 2;sy = -sy;}t--;
}

• while (t >= 0)：每次循环代表一个时间步，直到 t 小于 0 为止。
• if (matrix[y][x] == '1') { ans++; }：检查当前坐标 (x, y) 是否为 '1'，如果是则 ans 增加 1。
• y += sy; x += sx;：更新当前位置 (x, y)，根据水平速度 sx 和垂直速度 sy 移动。
• 边界检测：
  • 水平方向：如果 x < 0，表示超出了左边界，则将 x 设置为 1，并反转水平速度 sx；如果 x >= w，表示超出了右边界，则将 x 设置为 w - 2，并反转水平速度 sx。
  • 垂直方向：如果 y < 0，表示超出了上边界，则将 y 设置为 1，并反转垂直速度 sy；如果 y >= h，表示超出了下边界，则将 y 设置为 h - 2，并反转垂直速度 sy。
• 每次时间步结束后，t--。

5. 输出结果

cout << ans << endl;

• 输出统计到的 ans，即遇到的 '1' 的数量。

总结

• 本代码模拟了一个物体在一个矩阵中按照给定的速度进行移动，并统计物体经过的 '1' 数量。
• 使用 vector<string> 存储矩阵内容，避免了固定大小数组的限制，同时也更方便处理动态大小的矩阵。
• 边界检测和反弹处理确保物体在矩阵边缘反弹，而不是超出边界。
• 最后通过 cout 输出遇到的 '1' 的总数。

示例输入输出

输入：

5 5 0 0 1 1 10
00000
00000
00100
00000
00000

输出：

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 或监考人员进行反馈。

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