【2024年华为OD机试】 (B卷,200分)- 数字游戏（Java & JS & Python&C/C++）

🕗 发布于 2025-01-17 04:57 华为od 游戏 java javascript C++

在这里插入图片描述

一、问题描述

题目描述

小明玩一个游戏。

系统发1+n张牌，每张牌上有一个整数。

第一张给小明，后n张按照发牌顺序排成连续的一行。

需要小明判断，后n张牌中，是否存在连续的若干张牌，其和可以整除小明手中牌上的数字。

输入描述

输入数据有多组，每组输入数据有两行，输入到文件结尾结束。

第一行有两个整数n和m，空格隔开。m代表发给小明牌上的数字。

第二行有n个数，代表后续发的n张牌上的数字，以空格隔开。

输出描述

对每组输入，如果存在满足条件的连续若干张牌，则输出1;否则，输出0。

备注

1 ≤ n ≤ 1000
1 ≤ 牌上的整数 ≤ 400000
输入的组数，不多于1000
用例确保输入都正确，不需要考虑非法情况。

用例

用例1

输入

6 7
2 12 6 3 5 5

输出

说明
两组输入。第一组小明牌的数字为7，再发了6张牌。第1、2两张牌数字和为14，可以整除7，输出1。

用例2

输入

10 11
1 1 1 1 1 1 1 1 1 1

输出

说明
第二组小明牌的数字为11，再发了10张牌，这10张牌数字和为10，无法整除11，输出0。

题目解析

考察点

考察前缀和和哈希表的应用。

解析思路

前缀和：
- 计算后n张牌的前缀和数组preSum，其中preSum[i]表示前i张牌的和。
哈希表：
- 使用哈希表记录每个前缀和对小明手中牌上的数字m取模的结果。
- 如果存在两个前缀和对m取模的结果相同，说明这两个前缀和之间的差可以被m整除，即存在连续的若干张牌的和可以整除m。
遍历：
- 遍历前缀和数组，对于每个前缀和，计算其对m取模的结果。
- 如果哈希表中已经存在相同的取模结果，则说明存在满足条件的连续若干张牌，输出1。
- 如果遍历完所有前缀和，哈希表中没有相同的取模结果，则输出0。

注意事项

前缀和：前缀和数组可以快速计算任意区间和。
哈希表：哈希表可以快速查找前缀和对m取模的结果是否已经存在。
效率：每组输入的时间复杂度为O(n)，总的时间复杂度为O(1000n)，可以接受。
边界情况：特别注意输入的组数可能为1000组，每组输入的n可能为1000，因此需要优化算法，避免超时。

二、JavaScript算法源码

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

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 () {
  while (true) {
    try {
      // 读取第一行输入，解析为 n 和 m
      const [n, m] = (await readline()).split(" ").map(Number);

      // 读取第二行输入，解析为数组 nums
      const nums = (await readline()).split(" ").map(Number);

      // 调用 isExsit 函数并输出结果
      console.log(isExsit(nums, m));
    } catch (error) {
      // 如果读取输入失败（如输入结束），退出循环
      break;
    }
  }
})();

/**
 * 判断是否存在子数组的和模 m 等于 0
 * @param nums 输入的数组
 * @param m 模数
 * @returns 如果存在满足条件的子数组，返回 1；否则返回 0
 */
function isExsit(nums, m) {
  // 使用 Set 记录前缀和模 m 的余数
  const remain = new Set();
  remain.add(0); // 初始化，前缀和为 0 的情况

  let sum = 0; // 当前前缀和
  for (let num of nums) {
    sum += num; // 更新前缀和
    const mod = sum % m; // 计算当前前缀和模 m 的余数

    // 如果余数已经存在于 Set 中，说明存在满足条件的子数组
    if (remain.has(mod)) {
      return 1;
    } else {
      remain.add(mod); // 否则将当前余数加入 Set
    }
  }

  // 遍历结束后未找到满足条件的子数组，返回 0
  return 0;
}

详细讲解

1. 输入处理

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

功能：
- 使用 readline 模块逐行读取输入。
- rl[Symbol.asyncIterator]() 创建一个异步迭代器，用于逐行读取输入。
- readline 函数返回当前行的输入。

2. 主逻辑

void (async function () {
  while (true) {
    try {
      // 读取第一行输入，解析为 n 和 m
      const [n, m] = (await readline()).split(" ").map(Number);

      // 读取第二行输入，解析为数组 nums
      const nums = (await readline()).split(" ").map(Number);

      // 调用 isExsit 函数并输出结果
      console.log(isExsit(nums, m));
    } catch (error) {
      // 如果读取输入失败（如输入结束），退出循环
      break;
    }
  }
})();

功能：
- 循环读取输入，直到输入结束。
- 每次读取两行输入：
  1. 第一行解析为 n（数组长度）和 m（模数）。
  2. 第二行解析为数组 nums。
- 调用 isExsit 函数判断是否存在满足条件的子数组，并输出结果。

3. 核心算法

function isExsit(nums, m) {
  // 使用 Set 记录前缀和模 m 的余数
  const remain = new Set();
  remain.add(0); // 初始化，前缀和为 0 的情况

  let sum = 0; // 当前前缀和
  for (let num of nums) {
    sum += num; // 更新前缀和
    const mod = sum % m; // 计算当前前缀和模 m 的余数

    // 如果余数已经存在于 Set 中，说明存在满足条件的子数组
    if (remain.has(mod)) {
      return 1;
    } else {
      remain.add(mod); // 否则将当前余数加入 Set
    }
  }

  // 遍历结束后未找到满足条件的子数组，返回 0
  return 0;
}

功能：
- 判断是否存在子数组的和模 m 等于 0。
算法逻辑：
1. 使用 Set 记录前缀和模 m 的余数。
2. 初始化 Set，加入 0，表示前缀和为 0 的情况。
3. 遍历数组，计算当前前缀和 sum 及其模 m 的余数 mod。
4. 如果 mod 已经存在于 Set 中，说明存在满足条件的子数组，返回 1。
5. 否则，将 mod 加入 Set，继续遍历。
6. 遍历结束后未找到满足条件的子数组，返回 0。

代码运行示例

示例 1：

输入：

5 3
1 2 3 4 5

输出：

解释：

子数组 [1, 2] 的和为 3，模 3 等于 0。

示例 2：

输入：

4 5
1 2 3 4

输出：

解释：

不存在子数组的和模 5 等于 0。

总结

功能：
- 判断是否存在子数组的和模 m 等于 0。
优点：
- 使用前缀和和哈希表（Set）优化时间复杂度。
- 时间复杂度为 O(n)，空间复杂度为 O(m)。
适用场景：
- 适用于需要快速判断子数组和模 m 是否等于 0 的场景。

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

三、Java算法源码

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

Java 代码

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

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

    // 循环读取输入，直到输入结束
    while (sc.hasNextLine()) {
      try {
        // 读取第一行输入，解析为数组 tmp
        int[] tmp = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

        // 读取第二行输入，解析为数组 nums
        int[] nums = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

        // 调用 isExist 函数并输出结果
        System.out.println(isExist(nums, tmp[1]));
      } catch (Exception e) {
        // 如果读取输入失败（如输入结束），退出循环
        break;
      }
    }
  }

  /**
   * 判断是否存在子数组的和模 m 等于 0
   * @param nums 输入的数组
   * @param m 模数
   * @return 如果存在满足条件的子数组，返回 1；否则返回 0
   */
  public static int isExist(int[] nums, int m) {
    // 使用 HashSet 记录前缀和模 m 的余数
    HashSet<Integer> remain = new HashSet<>();
    remain.add(0); // 初始化，前缀和为 0 的情况

    int sum = 0; // 当前前缀和
    for (int num : nums) {
      sum += num; // 更新前缀和
      int mod = sum % m; // 计算当前前缀和模 m 的余数

      // 如果余数已经存在于 HashSet 中，说明存在满足条件的子数组
      if (remain.contains(mod)) {
        return 1;
      } else {
        remain.add(mod); // 否则将当前余数加入 HashSet
      }
    }

    // 遍历结束后未找到满足条件的子数组，返回 0
    return 0;
  }
}

详细讲解

1. 输入处理

Scanner sc = new Scanner(System.in);

while (sc.hasNextLine()) {
  try {
    // 读取第一行输入，解析为数组 tmp
    int[] tmp = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

    // 读取第二行输入，解析为数组 nums
    int[] nums = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

    // 调用 isExist 函数并输出结果
    System.out.println(isExist(nums, tmp[1]));
  } catch (Exception e) {
    // 如果读取输入失败（如输入结束），退出循环
    break;
  }
}

功能：
- 使用 Scanner 逐行读取输入。
- 每次读取两行输入：
  1. 第一行解析为数组 tmp，其中 tmp[0] 是数组长度 n，tmp[1] 是模数 m。
  2. 第二行解析为数组 nums。
- 调用 isExist 函数判断是否存在满足条件的子数组，并输出结果。

2. 核心算法

public static int isExist(int[] nums, int m) {
  // 使用 HashSet 记录前缀和模 m 的余数
  HashSet<Integer> remain = new HashSet<>();
  remain.add(0); // 初始化，前缀和为 0 的情况

  int sum = 0; // 当前前缀和
  for (int num : nums) {
    sum += num; // 更新前缀和
    int mod = sum % m; // 计算当前前缀和模 m 的余数

    // 如果余数已经存在于 HashSet 中，说明存在满足条件的子数组
    if (remain.contains(mod)) {
      return 1;
    } else {
      remain.add(mod); // 否则将当前余数加入 HashSet
    }
  }

  // 遍历结束后未找到满足条件的子数组，返回 0
  return 0;
}

功能：
- 判断是否存在子数组的和模 m 等于 0。
算法逻辑：
1. 使用 HashSet 记录前缀和模 m 的余数。
2. 初始化 HashSet，加入 0，表示前缀和为 0 的情况。
3. 遍历数组，计算当前前缀和 sum 及其模 m 的余数 mod。
4. 如果 mod 已经存在于 HashSet 中，说明存在满足条件的子数组，返回 1。
5. 否则，将 mod 加入 HashSet，继续遍历。
6. 遍历结束后未找到满足条件的子数组，返回 0。

代码运行示例

示例 1：

输入：

5 3
1 2 3 4 5

输出：

解释：

子数组 [1, 2] 的和为 3，模 3 等于 0。

示例 2：

输入：

4 5
1 2 3 4

输出：

解释：

不存在子数组的和模 5 等于 0。

总结

功能：
- 判断是否存在子数组的和模 m 等于 0。
优点：
- 使用前缀和和哈希表（HashSet）优化时间复杂度。
- 时间复杂度为 O(n)，空间复杂度为 O(m)。
适用场景：
- 适用于需要快速判断子数组和模 m 是否等于 0 的场景。

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

四、Python算法源码

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

Python 代码

def isExist(nums, m):
    """
    判断是否存在子数组的和模 m 等于 0
    :param nums: 输入的数组
    :param m: 模数
    :return: 如果存在满足条件的子数组，返回 1；否则返回 0
    """
    # 使用集合记录前缀和模 m 的余数
    remain = set()
    remain.add(0)  # 初始化，前缀和为 0 的情况

    total = 0  # 当前前缀和
    for num in nums:
        total += num  # 更新前缀和
        mod = total % m  # 计算当前前缀和模 m 的余数

        # 如果余数已经存在于集合中，说明存在满足条件的子数组
        if mod in remain:
            return 1
        else:
            remain.add(mod)  # 否则将当前余数加入集合

    # 遍历结束后未找到满足条件的子数组，返回 0
    return 0


# 输入获取
while True:
    try:
        # 读取第一行输入，解析为 n 和 m
        n, m = map(int, input().split())

        # 读取第二行输入，解析为数组 nums
        nums = list(map(int, input().split()))

        # 调用 isExist 函数并输出结果
        print(isExist(nums, m))
    except ValueError:
        # 如果输入格式错误（如输入结束），退出循环
        break

详细讲解

1. 核心函数 `isExist`

def isExist(nums, m):
    """
    判断是否存在子数组的和模 m 等于 0
    :param nums: 输入的数组
    :param m: 模数
    :return: 如果存在满足条件的子数组，返回 1；否则返回 0
    """
    # 使用集合记录前缀和模 m 的余数
    remain = set()
    remain.add(0)  # 初始化，前缀和为 0 的情况

    total = 0  # 当前前缀和
    for num in nums:
        total += num  # 更新前缀和
        mod = total % m  # 计算当前前缀和模 m 的余数

        # 如果余数已经存在于集合中，说明存在满足条件的子数组
        if mod in remain:
            return 1
        else:
            remain.add(mod)  # 否则将当前余数加入集合

    # 遍历结束后未找到满足条件的子数组，返回 0
    return 0

功能：
- 判断是否存在子数组的和模 m 等于 0。
算法逻辑：
1. 使用集合 remain 记录前缀和模 m 的余数。
2. 初始化集合，加入 0，表示前缀和为 0 的情况。
3. 遍历数组，计算当前前缀和 total 及其模 m 的余数 mod。
4. 如果 mod 已经存在于集合中，说明存在满足条件的子数组，返回 1。
5. 否则，将 mod 加入集合，继续遍历。
6. 遍历结束后未找到满足条件的子数组，返回 0。

2. 输入处理

# 输入获取
while True:
    try:
        # 读取第一行输入，解析为 n 和 m
        n, m = map(int, input().split())

        # 读取第二行输入，解析为数组 nums
        nums = list(map(int, input().split()))

        # 调用 isExist 函数并输出结果
        print(isExist(nums, m))
    except ValueError:
        # 如果输入格式错误（如输入结束），退出循环
        break

功能：
- 使用 input() 逐行读取输入。
- 每次读取两行输入：
  1. 第一行解析为 n（数组长度）和 m（模数）。
  2. 第二行解析为数组 nums。
- 调用 isExist 函数判断是否存在满足条件的子数组，并输出结果。
- 如果输入格式错误（如输入结束），捕获 ValueError 异常并退出循环。

代码运行示例

示例 1：

输入：

5 3
1 2 3 4 5

输出：

解释：

子数组 [1, 2] 的和为 3，模 3 等于 0。

示例 2：

输入：

4 5
1 2 3 4

输出：

解释：

不存在子数组的和模 5 等于 0。

总结

功能：
- 判断是否存在子数组的和模 m 等于 0。
优点：
- 使用前缀和和哈希表（集合）优化时间复杂度。
- 时间复杂度为 O(n)，空间复杂度为 O(m)。
适用场景：
- 适用于需要快速判断子数组和模 m 是否等于 0 的场景。

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

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

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

C++ 代码

#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;

/**
 * 判断是否存在子数组的和模 m 等于 0
 * @param nums 输入的数组
 * @param m 模数
 * @return 如果存在满足条件的子数组，返回 1；否则返回 0
 */
int isExist(vector<int>& nums, int m) {
    unordered_set<int> remain; // 使用 unordered_set 记录前缀和模 m 的余数
    remain.insert(0);          // 初始化，前缀和为 0 的情况

    int total = 0; // 当前前缀和
    for (int num : nums) {
        total += num;         // 更新前缀和
        int mod = total % m;  // 计算当前前缀和模 m 的余数

        // 如果余数已经存在于 unordered_set 中，说明存在满足条件的子数组
        if (remain.find(mod) != remain.end()) {
            return 1;
        } else {
            remain.insert(mod); // 否则将当前余数加入 unordered_set
        }
    }

    // 遍历结束后未找到满足条件的子数组，返回 0
    return 0;
}

int main() {
    int n, m;
    while (cin >> n >> m) { // 读取 n 和 m
        vector<int> nums(n);
        for (int i = 0; i < n; i++) {
            cin >> nums[i]; // 读取数组 nums
        }

        // 调用 isExist 函数并输出结果
        cout << isExist(nums, m) << endl;
    }
    return 0;
}

C 语言代码

#include <stdio.h>
#include <stdlib.h>

/**
 * 判断是否存在子数组的和模 m 等于 0
 * @param nums 输入的数组
 * @param n 数组长度
 * @param m 模数
 * @return 如果存在满足条件的子数组，返回 1；否则返回 0
 */
int isExist(int nums[], int n, int m) {
    int* remain = (int*)calloc(m, sizeof(int)); // 使用数组记录前缀和模 m 的余数
    remain[0] = 1; // 初始化，前缀和为 0 的情况

    int total = 0; // 当前前缀和
    for (int i = 0; i < n; i++) {
        total += nums[i]; // 更新前缀和
        int mod = total % m; // 计算当前前缀和模 m 的余数

        // 如果余数已经存在于 remain 数组中，说明存在满足条件的子数组
        if (remain[mod]) {
            free(remain); // 释放动态分配的内存
            return 1;
        } else {
            remain[mod] = 1; // 否则将当前余数标记为已存在
        }
    }

    free(remain); // 释放动态分配的内存
    return 0; // 遍历结束后未找到满足条件的子数组，返回 0
}

int main() {
    int n, m;
    while (scanf("%d %d", &n, &m) != EOF) { // 读取 n 和 m
        int* nums = (int*)malloc(n * sizeof(int)); // 动态分配数组内存
        for (int i = 0; i < n; i++) {
            scanf("%d", &nums[i]); // 读取数组 nums
        }

        // 调用 isExist 函数并输出结果
        printf("%d\n", isExist(nums, n, m));

        free(nums); // 释放动态分配的内存
    }
    return 0;
}

详细讲解

1. C++ 代码讲解

核心函数 isExist：
- 使用 unordered_set 记录前缀和模 m 的余数。
- 初始化时，将 0 加入集合，表示前缀和为 0 的情况。
- 遍历数组，计算当前前缀和 total 及其模 m 的余数 mod。
- 如果 mod 已经存在于集合中，说明存在满足条件的子数组，返回 1。
- 否则，将 mod 加入集合，继续遍历。
- 遍历结束后未找到满足条件的子数组，返回 0。
输入处理：
- 使用 cin 读取输入，直到输入结束。
- 每次读取两行输入：
  1. 第一行解析为 n（数组长度）和 m（模数）。
  2. 第二行解析为数组 nums。
- 调用 isExist 函数判断是否存在满足条件的子数组，并输出结果。

2. C 语言代码讲解

核心函数 isExist：
- 使用动态分配的数组 remain 记录前缀和模 m 的余数。
- 初始化时，将 remain[0] 设置为 1，表示前缀和为 0 的情况。
- 遍历数组，计算当前前缀和 total 及其模 m 的余数 mod。
- 如果 remain[mod] 为 1，说明存在满足条件的子数组，返回 1。
- 否则，将 remain[mod] 设置为 1，继续遍历。
- 遍历结束后未找到满足条件的子数组，返回 0。
输入处理：
- 使用 scanf 读取输入，直到输入结束。
- 每次读取两行输入：
  1. 第一行解析为 n（数组长度）和 m（模数）。
  2. 第二行解析为数组 nums。
- 调用 isExist 函数判断是否存在满足条件的子数组，并输出结果。
- 动态分配的内存需要在函数结束时释放。

代码运行示例

示例 1：

输入：

5 3
1 2 3 4 5

输出：

解释：

子数组 [1, 2] 的和为 3，模 3 等于 0。

示例 2：

输入：

4 5
1 2 3 4

输出：

解释：

不存在子数组的和模 5 等于 0。

总结

功能：
- 判断是否存在子数组的和模 m 等于 0。
优点：
- 使用前缀和和哈希表（unordered_set 或数组）优化时间复杂度。
- 时间复杂度为 O(n)，空间复杂度为 O(m)。
适用场景：
- 适用于需要快速判断子数组和模 m 是否等于 0 的场景。

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

六、尾言

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

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

原文地址：https://blog.csdn.net/m0_63168877/article/details/145158487

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：用人话讲计算机：python篇！（十六）面向对象：类、对象、属性、方法、实例化（上）
下一篇：没有了

STM32三导联蓝牙心电监护仪设计,C#上位机显示波形附源码与电路和论文
本设计详细分析了各种MCU包括STC89C52、STM32F103VET6、STM32F407、MSP430等多种MCU之间的优缺点，同时分析了市场上使用的ADS1298，AD8232，ADAS100
阅读更多2025-01-17
构建高效可复用的 Vue.js 渲染无关组件
渲染无关组件本质上是一种纯逻辑组件，它不直接渲染 HTML，而是将渲染的责任通过插槽或其他方式交给使用者。逻辑复用：将复杂逻辑从视图中抽离，减少代码重复。高度可定制：开发者可以完全自定义组件的渲染方式
阅读更多2025-01-17
基于 Vue 的拖拽缩放卡片组件：实现思路、方法及使用指南
通过上述的实现思路、代码实现和使用方法介绍，我们可以看到这个基于 Vue 的可缩放卡片组件为前端开发中实现可交互的卡片功能提供了一个有效的解决方案。你也可以根据实际需求进一步扩展和优化该组件，以满足不
阅读更多2025-01-17
Vue.js 组件的基本结构：模板、脚本和样式
Vue 组件的.vue模板：负责定义视图，支持数据绑定和指令。脚本：负责处理逻辑，管理数据、方法和生命周期。样式：负责定义组件的外观，可以作用于组件内部的元素。清晰的结构让 Vue 组件开发变得简单直
阅读更多2025-01-17
自动化之Ansible
Ansible是一个同时管理多个远程主机的软件(任何可以通过SSH协议登录的机器)，因此Ansible可以管理运程虚拟机、物理机，也可以是本地主机(linux、windows)。Ansible通过S
阅读更多2025-01-17
Docker 部署 Typecho
github官网： https://github.com/typecho/Dockerfile。
阅读更多2025-01-17
学习threejs，使用OrbitControls相机控制器
本文详细介绍如何基于threejs在三维场景中使用OrbitControls相机控制器，亲测可用。希望能帮助到您。一起学习，加油！加油！
阅读更多2025-01-17
电子应用设计方案91：智能AI花洒系统设计
花洒系统设计方案融合了先进的技术和人性化的设计理念，为用户带来全新的淋浴体验。花洒系统旨在为用户提供更加个性化、舒适和便捷的淋浴体验，结合人工智能技术和先进的水控技术，满足不同用户的需求。花洒系统主要
阅读更多2025-01-17
【MyDB】3-DataManager数据管理之 2-共享内存数组
【MyDB】3-DataManager数据管理之
阅读更多2025-01-17
使用 spring boot 2.5.6 版本时缺少 * jvm_* 指标
我们也不能删除“springfox-boot-starter”，因为我们的应用程序中需要 swagger。，在使用的 Spring Boot 版本中默认情况下未注册。此注册已在 Spring Boot
阅读更多2025-01-17

【2024年华为OD机试】 (B卷,200分)- 数字游戏（Java & JS & Python&C/C++）

一、问题描述

题目描述

输入描述

输出描述

备注

用例

用例1

用例2

题目解析

考察点

解析思路

注意事项

二、JavaScript算法源码

JavaScript 代码

详细讲解

1. 输入处理

2. 主逻辑

3. 核心算法

代码运行示例

示例 1：

示例 2：

总结

三、Java算法源码

Java 代码

详细讲解

1. 输入处理

2. 核心算法

代码运行示例

示例 1：

示例 2：

总结

四、Python算法源码

Python 代码

详细讲解

1. 核心函数 isExist

2. 输入处理

代码运行示例

示例 1：

示例 2：

总结

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

C++ 代码

C 语言代码

详细讲解

1. C++ 代码讲解

2. C 语言代码讲解

代码运行示例

示例 1：

示例 2：

总结

六、尾言

什么是华为OD？

为什么刷题很重要？

刷题策略与说明：

如何获取资源？

积极心态与持续努力：

考试注意细节

相关文章

1. 核心函数 `isExist`