【2024年华为OD机试】 (C卷,100分)- 数字涂色（Java JS PythonC/C++）

news2025/1/17 1:26:47

在这里插入图片描述

一、问题描述

题目描述

疫情过后，希望小学终于又重新开学了，三年二班开学第一天的任务是将后面的黑板报重新制作。

黑板上已经写上了N个正整数，同学们需要给这每个数分别上一种颜色。

为了让黑板报既美观又有学习意义，老师要求同种颜色的所有数都可以被这种颜色中最小的那个数整除。

现在请你帮帮小朋友们，算算最少需要多少种颜色才能给这N个数进行上色。

输入描述

第一行有一个正整数N，其中。

第二行有N个int型数(保证输入数据在[1,100]范围中)，表示黑板上各个正整数的值。

输出描述

输出只有一个整数，为最少需要的颜色种数。

用例

用例1

输入

3
2 4 6

输出

1

说明
所有数都能被2整除

用例2

输入

4
2 3 4 9

输出

2

说明
2与4涂一种颜色，4能被2整除；3与9涂另一种颜色，9能被3整除。不能4个数涂同一个颜色，因为3与9不能被2整除。所以最少的颜色是两种。

题目解析

考察点

考察排序和数组操作。

解析思路

  1. 排序：首先将输入的数列进行升序排序。这样数列从左到右，元素依次增大。
  2. 初始化标记数组：定义一个长度和输入数列相同的数组color，用于标记每个元素是否已经涂色。color的所有元素默认未初始化，即所有元素初始值为false。
  3. 遍历数列：从左到右遍历排序后的数列，每次取最左边未涂色的数arr[i]作为当前颜色的基准数。
  4. 检查并标记涂色：
    • 对于每个基准数arr[i]，遍历它后面的所有数arr[j]（j > i）。
    • 如果arr[j]可以被arr[i]整除，则将arr[j]标记为已涂色，即color[j] = true。
  5. 计数颜色：每找到一个基准数并完成涂色操作后，颜色计数加1。
  6. 输出结果：遍历完所有数列后，输出颜色计数。

注意事项

  • 排序：确保数列按升序排序，这样可以保证每次取的基准数是最小的未涂色数。
  • 标记数组：使用color数组来标记每个元素是否已经涂色，避免重复涂色。
  • 效率：虽然本题的数据范围较小（1到100），但仍然要注意算法的效率。排序操作的时间复杂度为O(n log n)，遍历操作的时间复杂度为O(n^2)，总体效率是可以接受的。

二、JavaScript算法源码

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

JavaScript 代码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline"); // 引入 readline 模块

// 创建 readline 接口
const rl = readline.createInterface({
  input: process.stdin,  // 输入流为标准输入
  output: process.stdout, // 输出流为标准输出
});

// 存储输入行的数组
const lines = [];

// 监听输入事件
rl.on("line", (line) => {
  lines.push(line); // 将输入行存入数组

  // 当输入行数为 2 时，开始处理
  if (lines.length === 2) {
    // 解析输入
    let n = parseInt(lines[0]); // 第一行是数组长度 n
    let arr = lines[1].split(" ").slice(0, n); // 第二行是数组内容，按空格分割并截取前 n 个元素

    // 调用算法函数并输出结果
    console.log(getMinColorCount(arr));

    // 清空输入行数组，准备下一次输入
    lines.length = 0;
  }
});

// 算法函数：计算最小分组数
function getMinColorCount(arr) {
  // 对数组进行升序排序
  arr.sort((a, b) => a - b);

  // 如果数组的第一个元素是 1，直接返回 1
  if (arr[0] === 1) {
    return 1;
  }

  // 创建一个标记数组，用于记录元素是否已被分组
  let color = new Array(arr.length);
  let count = 0; // 记录分组数量

  // 遍历数组中的每个元素
  for (let i = 0; i < arr.length; i++) {
    // 如果当前元素已被分组，跳过
    if (color[i]) continue;

    // 将当前元素标记为已分组
    color[i] = true;

    // 遍历当前元素后面的所有元素
    for (let j = i + 1; j < arr.length; j++) {
      // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
      if (!color[j] && arr[j] % arr[i] === 0) {
        color[j] = true;
      }
    }

    // 分组数量加 1
    count++;
  }

  // 返回分组的总数
  return count;
}

详细讲解

1. 输入获取
const readline = require("readline"); // 引入 readline 模块

// 创建 readline 接口
const rl = readline.createInterface({
  input: process.stdin,  // 输入流为标准输入
  output: process.stdout, // 输出流为标准输出
});

// 存储输入行的数组
const lines = [];

// 监听输入事件
rl.on("line", (line) => {
  lines.push(line); // 将输入行存入数组

  // 当输入行数为 2 时，开始处理
  if (lines.length === 2) {
    // 解析输入
    let n = parseInt(lines[0]); // 第一行是数组长度 n
    let arr = lines[1].split(" ").slice(0, n); // 第二行是数组内容，按空格分割并截取前 n 个元素

    // 调用算法函数并输出结果
    console.log(getMinColorCount(arr));

    // 清空输入行数组，准备下一次输入
    lines.length = 0;
  }
});
  • 功能：
    • 使用 readline 模块从控制台读取输入。
    • 第一行读取整数 n，表示数组的长度。
    • 第二行读取数组内容，按空格分割并截取前 n 个元素。
  • 说明：
    • rl.on("line", ...) 监听输入事件。
    • lines.push(line) 将输入行存入数组。
    • 当输入行数为 2 时，开始处理。
2. 数组排序
arr.sort((a, b) => a - b); // 对数组进行升序排序
  • 功能：
    • 对数组 arr 进行升序排序。
  • 说明：
    • 排序后，数组中的元素从小到大排列。
3. 特殊情况处理
if (arr[0] === 1) {
  return 1; // 如果数组的第一个元素是 1，直接返回 1
}
  • 功能：
    • 如果数组的第一个元素是 1，直接返回 1。
  • 说明：
    • 因为 1 可以整除任何数，所以如果数组中有 1，所有元素都可以被分到同一组。
4. 分组逻辑
let color = new Array(arr.length); // 标记数组，记录元素是否已被分组
let count = 0; // 记录分组数量

// 遍历数组中的每个元素
for (let i = 0; i < arr.length; i++) {
  // 如果当前元素已被分组，跳过
  if (color[i]) continue;

  // 将当前元素标记为已分组
  color[i] = true;

  // 遍历当前元素后面的所有元素
  for (let j = i + 1; j < arr.length; j++) {
    // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
    if (!color[j] && arr[j] % arr[i] === 0) {
      color[j] = true;
    }
  }

  // 分组数量加 1
  count++;
}
  • 功能：
    • 使用双重循环遍历数组，将元素分组。
    • 如果某个元素可以被当前元素整除，则将其分到同一组。
  • 说明：
    • color 数组用于标记元素是否已被分组。
    • 外层循环遍历每个元素，内层循环检查后面的元素是否可以被当前元素整除。
    • 如果满足条件，则将元素标记为已分组。
5. 返回结果
return count; // 返回分组的总数
  • 功能：
    • 返回分组的总数。

代码运行示例

示例 1：

输入：

5
2 3 4 9 8

输出：

3

解释：

  • 排序后的数组：[2, 3, 4, 8, 9]。
  • 分组情况：
    • 第一组：[2, 4, 8]（因为 4 和 8 可以被 2 整除）。
    • 第二组：[3, 9]（因为 9 可以被 3 整除）。
    • 第三组：[ ]（没有其他元素）。
  • 总分组数为 3。
示例 2：

输入：

4
1 2 3 4

输出：

1

解释：

  • 排序后的数组：[1, 2, 3, 4]。
  • 因为数组中有 1，所有元素都可以被分到同一组。
  • 总分组数为 1。

总结

  1. 功能：

    • 将数组中的元素分组，每组中的元素可以被组内的最小元素整除。
    • 返回分组的总数。

  2. 优点：

    • 使用排序和双重循环，逻辑清晰。
    • 时间复杂度为 O(n^2)，适用于小规模数据。

  3. 适用场景：

    • 适用于需要将元素按特定规则分组的场景。

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

三、Java算法源码

以下是 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);

    // 读取整数 n，表示数组的长度
    int n = Integer.parseInt(sc.nextLine());

    // 读取一行输入，将其拆分为字符串数组，并转换为整数数组
    int[] arr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

    // 调用 getResult 方法并输出结果
    System.out.println(getResult(n, arr));
  }

  // 算法入口
  public static int getResult(int n, int[] arr) {
    // 对数组进行排序
    Arrays.sort(arr);

    // 如果数组的第一个元素是 1，直接返回 1
    if (arr[0] == 1) {
      return 1;
    }

    // 创建一个布尔数组 color，用于标记元素是否已经被分组
    boolean[] color = new boolean[n];
    int count = 0; // 记录分组的数量

    // 遍历数组中的每个元素
    for (int i = 0; i < n; i++) {
      // 如果当前元素已经被分组，跳过
      if (color[i]) continue;

      // 将当前元素标记为已分组
      color[i] = true;

      // 遍历当前元素后面的所有元素
      for (int j = i + 1; j < n; j++) {
        // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
        if (!color[j] && arr[j] % arr[i] == 0) {
          color[j] = true;
        }
      }

      // 分组数量加 1
      count++;
    }

    // 返回分组的总数
    return count;
  }
}

详细讲解

1. 输入获取
Scanner sc = new Scanner(System.in); // 创建 Scanner 对象
int n = Integer.parseInt(sc.nextLine()); // 读取整数 n
int[] arr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray(); // 读取数组
  • 功能：
    • 使用 Scanner 从控制台读取输入。
    • 第一行读取整数 n，表示数组的长度。
    • 第二行读取一行输入，将其拆分为字符串数组，并转换为整数数组 arr。
  • 说明：
    • sc.nextLine() 读取一行输入。
    • split(" ") 将输入按空格拆分为字符串数组。
    • mapToInt(Integer::parseInt) 将字符串数组转换为整数数组。
2. 数组排序
Arrays.sort(arr); // 对数组进行排序
  • 功能：
    • 对数组 arr 进行升序排序。
  • 说明：
    • 排序后，数组中的元素从小到大排列。
3. 特殊情况处理
if (arr[0] == 1) {
  return 1; // 如果数组的第一个元素是 1，直接返回 1
}
  • 功能：
    • 如果数组的第一个元素是 1，直接返回 1。
  • 说明：
    • 因为 1 可以整除任何数，所以如果数组中有 1，所有元素都可以被分到同一组。
4. 分组逻辑
boolean[] color = new boolean[n]; // 标记数组，记录元素是否已被分组
int count = 0; // 记录分组的数量

for (int i = 0; i < n; i++) {
  if (color[i]) continue; // 如果当前元素已被分组，跳过

  color[i] = true; // 将当前元素标记为已分组

  // 遍历当前元素后面的所有元素
  for (int j = i + 1; j < n; j++) {
    // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
    if (!color[j] && arr[j] % arr[i] == 0) {
      color[j] = true;
    }
  }

  count++; // 分组数量加 1
}
  • 功能：
    • 使用双重循环遍历数组，将元素分组。
    • 如果某个元素可以被当前元素整除，则将其分到同一组。
  • 说明：
    • color 数组用于标记元素是否已被分组。
    • 外层循环遍历每个元素，内层循环检查后面的元素是否可以被当前元素整除。
    • 如果满足条件，则将元素标记为已分组。
5. 返回结果
return count; // 返回分组的总数
  • 功能：
    • 返回分组的总数。

代码运行示例

示例 1：

输入：

5
2 3 4 9 8

输出：

3

解释：

  • 排序后的数组：[2, 3, 4, 8, 9]。
  • 分组情况：
    • 第一组：[2, 4, 8]（因为 4 和 8 可以被 2 整除）。
    • 第二组：[3, 9]（因为 9 可以被 3 整除）。
    • 第三组：[ ]（没有其他元素）。
  • 总分组数为 3。
示例 2：

输入：

4
1 2 3 4

输出：

1

解释：

  • 排序后的数组：[1, 2, 3, 4]。
  • 因为数组中有 1，所有元素都可以被分到同一组。
  • 总分组数为 1。

总结

  1. 功能：

    • 将数组中的元素分组，每组中的元素可以被组内的最小元素整除。
    • 返回分组的总数。

  2. 优点：

    • 使用排序和双重循环，逻辑清晰。
    • 时间复杂度为 O(n^2)，适用于小规模数据。

  3. 适用场景：

    • 适用于需要将元素按特定规则分组的场景。

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

四、Python算法源码

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

Python 代码

# 输入获取
n = int(input())  # 读取整数 n，表示数组的长度
arr = list(map(int, input().split()))  # 读取数组内容，按空格分割并转换为整数列表

# 算法入口
def getResult():
    # 对数组进行升序排序
    arr.sort()

    # 如果数组的第一个元素是 1，直接返回 1
    if arr[0] == 1:
        return 1

    # 创建一个标记数组，用于记录元素是否已被分组
    color = [False] * n
    count = 0  # 记录分组数量

    # 遍历数组中的每个元素
    for i in range(n):
        # 如果当前元素已被分组，跳过
        if color[i]:
            continue

        # 将当前元素标记为已分组
        color[i] = True

        # 遍历当前元素后面的所有元素
        for j in range(i + 1, n):
            # 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
            if not color[j] and arr[j] % arr[i] == 0:
                color[j] = True

        # 分组数量加 1
        count += 1

    # 返回分组的总数
    return count

# 调用算法并输出结果
print(getResult())

详细讲解

1. 输入获取
n = int(input())  # 读取整数 n，表示数组的长度
arr = list(map(int, input().split()))  # 读取数组内容，按空格分割并转换为整数列表
  • 功能：
    • 从控制台读取输入。
    • 第一行读取整数 n，表示数组的长度。
    • 第二行读取数组内容，按空格分割并转换为整数列表 arr。
  • 说明：
    • input() 读取一行输入。
    • split() 将输入按空格拆分为字符串列表。
    • map(int, ...) 将字符串列表转换为整数列表。
2. 数组排序
arr.sort()  # 对数组进行升序排序
  • 功能：
    • 对数组 arr 进行升序排序。
  • 说明：
    • 排序后，数组中的元素从小到大排列。
3. 特殊情况处理
if arr[0] == 1:
    return 1  # 如果数组的第一个元素是 1，直接返回 1
  • 功能：
    • 如果数组的第一个元素是 1，直接返回 1。
  • 说明：
    • 因为 1 可以整除任何数，所以如果数组中有 1，所有元素都可以被分到同一组。
4. 分组逻辑
color = [False] * n  # 标记数组，记录元素是否已被分组
count = 0  # 记录分组数量

# 遍历数组中的每个元素
for i in range(n):
    # 如果当前元素已被分组，跳过
    if color[i]:
        continue

    # 将当前元素标记为已分组
    color[i] = True

    # 遍历当前元素后面的所有元素
    for j in range(i + 1, n):
        # 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
        if not color[j] and arr[j] % arr[i] == 0:
            color[j] = True

    # 分组数量加 1
    count += 1
  • 功能：
    • 使用双重循环遍历数组，将元素分组。
    • 如果某个元素可以被当前元素整除，则将其分到同一组。
  • 说明：
    • color 数组用于标记元素是否已被分组。
    • 外层循环遍历每个元素，内层循环检查后面的元素是否可以被当前元素整除。
    • 如果满足条件，则将元素标记为已分组。
5. 返回结果
return count  # 返回分组的总数
  • 功能：
    • 返回分组的总数。
6. 调用算法
print(getResult())  # 调用算法并输出结果
  • 功能：
    • 调用 getResult 函数并输出结果。

代码运行示例

示例 1：

输入：

5
2 3 4 9 8

输出：

3

解释：

  • 排序后的数组：[2, 3, 4, 8, 9]。
  • 分组情况：
    • 第一组：[2, 4, 8]（因为 4 和 8 可以被 2 整除）。
    • 第二组：[3, 9]（因为 9 可以被 3 整除）。
    • 第三组：[ ]（没有其他元素）。
  • 总分组数为 3。
示例 2：

输入：

4
1 2 3 4

输出：

1

解释：

  • 排序后的数组：[1, 2, 3, 4]。
  • 因为数组中有 1，所有元素都可以被分到同一组。
  • 总分组数为 1。

总结

  1. 功能：

    • 将数组中的元素分组，每组中的元素可以被组内的最小元素整除。
    • 返回分组的总数。

  2. 优点：

    • 使用排序和双重循环，逻辑清晰。
    • 时间复杂度为 O(n^2)，适用于小规模数据。

  3. 适用场景：

    • 适用于需要将元素按特定规则分组的场景。

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

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

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

C语言代码

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

// 函数声明
int getResult(int nums[], int nums_size);

// 比较函数，用于 qsort
int cmp(const void* a, const void* b) {
    return (*(int*) a) - (*(int*) b); // 升序排序
}

int main() {
    int n;
    scanf("%d", &n); // 读取整数 n，表示数组的长度

    int nums[n]; // 定义数组
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]); // 读取数组内容
    }

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

    return 0;
}

// 算法函数：计算最小分组数
int getResult(int nums[], int nums_size) {
    // 对数组进行升序排序
    qsort(nums, nums_size, sizeof(int), cmp);

    // 如果数组的第一个元素是 1，直接返回 1
    if (nums[0] == 1) {
        return 1;
    }

    // 创建一个标记数组，用于记录元素是否已被分组
    int* color = (int*) calloc(nums_size, sizeof(int));
    int count = 0; // 记录分组数量

    // 遍历数组中的每个元素
    for (int i = 0; i < nums_size; i++) {
        // 如果当前元素已被分组，跳过
        if (color[i]) continue;

        // 将当前元素标记为已分组
        color[i] = 1;

        // 遍历当前元素后面的所有元素
        for (int j = i + 1; j < nums_size; j++) {
            // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
            if (!color[j] && nums[j] % nums[i] == 0) {
                color[j] = 1;
            }
        }

        // 分组数量加 1
        count++;
    }

    // 释放动态分配的内存
    free(color);

    // 返回分组的总数
    return count;
}

C++代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 算法函数：计算最小分组数
int getResult(vector<int>& nums) {
    // 对数组进行升序排序
    sort(nums.begin(), nums.end());

    // 如果数组的第一个元素是 1，直接返回 1
    if (nums[0] == 1) {
        return 1;
    }

    // 创建一个标记数组，用于记录元素是否已被分组
    vector<bool> color(nums.size(), false);
    int count = 0; // 记录分组数量

    // 遍历数组中的每个元素
    for (int i = 0; i < nums.size(); i++) {
        // 如果当前元素已被分组，跳过
        if (color[i]) continue;

        // 将当前元素标记为已分组
        color[i] = true;

        // 遍历当前元素后面的所有元素
        for (int j = i + 1; j < nums.size(); j++) {
            // 如果元素未被分组，并且可以被当前元素整除，则将其标记为已分组
            if (!color[j] && nums[j] % nums[i] == 0) {
                color[j] = true;
            }
        }

        // 分组数量加 1
        count++;
    }

    // 返回分组的总数
    return count;
}

int main() {
    int n;
    cin >> n; // 读取整数 n，表示数组的长度

    vector<int> nums(n); // 定义数组
    for (int i = 0; i < n; i++) {
        cin >> nums[i]; // 读取数组内容
    }

    // 调用算法函数并输出结果
    cout << getResult(nums) << endl;

    return 0;
}

详细讲解

1. 输入获取

  • C语言：

    int n;
scanf("%d", &n); // 读取整数 n
int nums[n];
for (int i = 0; i < n; i++) {
    scanf("%d", &nums[i]); // 读取数组内容
}
    • 使用 scanf 从标准输入读取整数 n 和数组内容。

  • C++：

    int n;
cin >> n; // 读取整数 n
vector<int> nums(n);
for (int i = 0; i < n; i++) {
    cin >> nums[i]; // 读取数组内容
}
    • 使用 cin 从标准输入读取整数 n 和数组内容。
2. 数组排序

  • C语言：

    qsort(nums, nums_size, sizeof(int), cmp); // 使用 qsort 排序
    • 使用 qsort 对数组进行升序排序。

  • C++：

    sort(nums.begin(), nums.end()); // 使用 sort 排序
    • 使用 sort 对数组进行升序排序。
3. 特殊情况处理

  • C语言：

    if (nums[0] == 1) {
    return 1; // 如果数组的第一个元素是 1，直接返回 1
}

  • C++：

    if (nums[0] == 1) {
    return 1; // 如果数组的第一个元素是 1，直接返回 1
}
4. 分组逻辑

  • C语言：

    int* color = (int*) calloc(nums_size, sizeof(int)); // 动态分配标记数组
int count = 0; // 记录分组数量

for (int i = 0; i < nums_size; i++) {
    if (color[i]) continue; // 如果当前元素已被分组，跳过
    color[i] = 1; // 将当前元素标记为已分组

    for (int j = i + 1; j < nums_size; j++) {
        if (!color[j] && nums[j] % nums[i] == 0) {
            color[j] = 1; // 将满足条件的元素标记为已分组
        }
    }

    count++; // 分组数量加 1
}

  • C++：

    vector<bool> color(nums.size(), false); // 定义标记数组
int count = 0; // 记录分组数量

for (int i = 0; i < nums.size(); i++) {
    if (color[i]) continue; // 如果当前元素已被分组，跳过
    color[i] = true; // 将当前元素标记为已分组

    for (int j = i + 1; j < nums.size(); j++) {
        if (!color[j] && nums[j] % nums[i] == 0) {
            color[j] = true; // 将满足条件的元素标记为已分组
        }
    }

    count++; // 分组数量加 1
}
5. 返回结果

  • C语言：

    free(color); // 释放动态分配的内存
return count; // 返回分组的总数

  • C++：

    return count; // 返回分组的总数

代码运行示例

示例 1：

输入：

5
2 3 4 9 8

输出：

3

解释：

  • 排序后的数组：[2, 3, 4, 8, 9]。
  • 分组情况：
    • 第一组：[2, 4, 8]（因为 4 和 8 可以被 2 整除）。
    • 第二组：[3, 9]（因为 9 可以被 3 整除）。
    • 第三组：[ ]（没有其他元素）。
  • 总分组数为 3。
示例 2：

输入：

4
1 2 3 4

输出：

1

解释：

  • 排序后的数组：[1, 2, 3, 4]。
  • 因为数组中有 1，所有元素都可以被分到同一组。
  • 总分组数为 1。

总结

  1. 功能：

    • 将数组中的元素分组，每组中的元素可以被组内的最小元素整除。
    • 返回分组的总数。

  2. 优点：

    • 使用排序和双重循环，逻辑清晰。
    • 时间复杂度为 O(n^2)，适用于小规模数据。

  3. 适用场景：

    • 适用于需要将元素按特定规则分组的场景。

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

六、尾言

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2277786.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

JavaScript动态渲染页面爬取之Splash

JavaScript动态渲染页面爬取之Splash

Splash是一个 JavaScript渲染服务,是一个含有 HTTP API的轻量级浏览器,它还对接了 Python 中的 Twisted 库和 OT库。利用它&#xff0c;同样可以爬取动态渲染的页面。 功能介绍 利用 Splash&#xff0c;可以实现如下功能&#xff1a; 异步处理多个网页的渲染过程:获取渲染后…
阅读更多...
天机学堂2-高并发优化

天机学堂2-高并发优化

day04-高并发优化 方案选择 实现了学习计划和学习进度的统计功能。特别是学习进度部分&#xff0c;为了更精确的记录用户上一次播放的进度&#xff0c;我们采用的方案是&#xff1a;前端每隔15秒就发起一次请求&#xff0c;将播放记录写入数据库。 在并发较高的情况下&#xf…
阅读更多...
ROS2 准备工作（虚拟机安装，Ubuntu安装，ROS2系统安装）

ROS2 准备工作（虚拟机安装，Ubuntu安装，ROS2系统安装）

准备工作 虚拟机安装 大家可以自行去安装VMware链接&#xff1a;https://pan.baidu.com/s/1KcN1I9FN--Sp1bUsjKqWVA?pwd6666 提取码&#xff1a;6666(提供者&#xff1a;零基础编程入门教程) 教程&#xff1a;【【2025最新版】VMware虚拟机安装教程&#xff0c;手把手教你免…
阅读更多...
在一个地方待多久才会改变ip属地

在一个地方待多久才会改变ip属地

‌在当今数字化时代&#xff0c;IP地址作为网络世界的“门牌号”&#xff0c;不仅承载着设备连接互联网的身份信息&#xff0c;还常常与地理位置相关联。随着人们频繁地迁徙、旅行或在不同地点工作&#xff0c;一个自然而然的问题浮现在许多人心头&#xff1a;究竟在一个地方待…
阅读更多...
CCLINKIE转ModbusTCP网关，助机器人“掀起”工业智能的“惊涛骇浪”

CCLINKIE转ModbusTCP网关，助机器人“掀起”工业智能的“惊涛骇浪”

以下是一个稳联技术CCLINKIE转ModbusTCP网关&#xff08;WL-CCL-MTCP&#xff09;连接三菱PLC与机器人的配置案例&#xff1a;设备与软件准备设备&#xff1a;稳联技术WL-CCL-MTCP网关、三菱FX5UPLC、支持ModbusTCP协议的机器人、网线等。 稳联技术ModbusTCP转CCLINKIE网关&…
阅读更多...
QT在 MacOS X上，如何检测点击程序坞中的Dock图标

QT在 MacOS X上，如何检测点击程序坞中的Dock图标

最近在开发MacOS的qt应用&#xff0c;在做到最小化系统托盘功能时&#xff0c;发现关闭窗口后再次点击程序坞中的Dock图标不能将主界面再显示出来。查询里很多资料&#xff0c;发现是QT自身的问题&#xff0c;没有做相关的点击Dock图标的处理。 于是我参考了国内和国外的这两篇…
阅读更多...
langchain4j执行源码分析

langchain4j执行源码分析

要做大模型应用&#xff0c;不可避免会接触到langchain&#xff0c;但是langchain本身使用py实现&#xff0c;对于java用户上手体验不是很友好。继而出现了java版的langchain&#xff0c;即langchain-4j。这里我们用脑图分析一下其执行源码。
阅读更多...
【案例81】NMC调用导致数据库的效率问题

【案例81】NMC调用导致数据库的效率问题

问题现象 客户在使用NC系统时&#xff0c;发现系统特别卡顿。需要紧急排查。 问题分析 排查NMC发现&#xff0c;所有的线程都处于执行SQL层面&#xff0c;说明数据库当前出现了异常。查看数据库资源状态发现&#xff0c;Oracle相关进程CPU利用率达到了100%。 查看现在数据库…
阅读更多...
PyTorch框架——基于深度学习YOLOv5神经网络水果蔬菜检测识别系统

PyTorch框架——基于深度学习YOLOv5神经网络水果蔬菜检测识别系统

基于深度学习YOLOv5神经网络水果蔬菜检测识别系统&#xff0c;其能识别的水果蔬菜有15种&#xff0c;# 水果的种类 names: [黑葡萄, 绿葡萄, 樱桃, 西瓜, 龙眼, 香蕉, 芒果, 菠萝, 柚子, 草莓, 苹果, 柑橘, 火龙果, 梨子, 花生, 黄瓜, 土豆, 大蒜, 茄子, 白萝卜, 辣椒, 胡萝卜,…
阅读更多...
DFT可测性设置与Tetramax测试笔记

DFT可测性设置与Tetramax测试笔记

1 DFT 1.1 DFT类型 1、扫描链&#xff08;SCAN&#xff09;&#xff1a; 扫描路径法是一种针对时序电路芯片的DFT方案.其基本原理是时序电路可以模型化为一个组合电路网络和带触发器(Flip-Flop&#xff0c;简称FF)的时序电路网络的反馈。 Scan 包括两个步骤&#xff0c;scan…
阅读更多...
分布式ID的实现方案

分布式ID的实现方案

1. 什么是分布式ID ​ 对于低访问量的系统来说&#xff0c;无需对数据库进行分库分表&#xff0c;单库单表完全可以应对&#xff0c;但是随着系统访问量的上升&#xff0c;单表单库的访问压力逐渐增大&#xff0c;这时候就需要采用分库分表的方案&#xff0c;来缓解压力。 ​…
阅读更多...
28.找出字符串中第一个匹配项的下标【力扣】KMP前缀表 ≈ find() 函数、暴力解法

28.找出字符串中第一个匹配项的下标【力扣】KMP前缀表 ≈ find() 函数、暴力解法

class Solution { public: //得到前缀表void getNext(int *next,string needle){int j0;for(int i1;i<needle.size();i){while(j>0 && needle[j]!needle[i]) jnext[j-1];//**j>0**>j0是出口if(needle[i]needle[j]) j;next[i]j;//若写入if中&#xff0c;则该…
阅读更多...
当自动包布机遇上Profinet转ModbusTCP网关，“妙啊”，工业智能“前景无限

当自动包布机遇上Profinet转ModbusTCP网关，“妙啊”，工业智能“前景无限

在自动化控制技术日新月异的当下&#xff0c;Profinet与ModbusTCP这两种协议在工业通信领域占据着举足轻重的地位。ModbusTCP是基于以太网的串行通信协议&#xff0c;而Profinet则是依托工业以太网的现场总线协议。它们在数据传输速度、实时性表现以及兼容性等方面各具特色。不…
阅读更多...
ADC(Analog-to-digital converter)模拟-数字转换器

ADC(Analog-to-digital converter)模拟-数字转换器

ADC简介 ADC&#xff08;Analog-to-Digital Converter&#xff09;&#xff0c;即模拟-数字转换器&#xff0c;是一种将模拟信号转换成数字信号的电子设备。它在现代电子系统中扮演着至关重要的角色&#xff0c;广泛应用于传感器信号处理、通信系统、医疗设备、工业自动化等多…
阅读更多...
Uniapp判断设备是安卓还是 iOS，并调用不同的方法

Uniapp判断设备是安卓还是 iOS，并调用不同的方法

在 UniApp 中&#xff0c;可以通过 uni.getSystemInfoSync() 方法来获取设备信息&#xff0c;然后根据系统类型判断当前设备是安卓还是 iOS&#xff0c;并调用不同的方法。 示例代码 export default {onLoad() {this.checkPlatform();},methods: {checkPlatform() {// 获取系…
阅读更多...
TP4056锂电池充放电芯片教程文章详解·内置驱动电路资源！！！

TP4056锂电池充放电芯片教程文章详解·内置驱动电路资源！！！

目录 TP4056工作原理 TP4056引脚详解 TP4056驱动电路图 锂电池充放电板子绘制 编写不易&#xff0c;仅供学习&#xff0c;感谢理解。 TP4056工作原理 TP4056是专门为单节锂电池或锂聚合物电池设计的线性充电器&#xff0c;充电电流可以用外部电阻设定&#xff0c;最大充电…
阅读更多...
平滑算法 效果比较

平滑算法 效果比较

目录 高斯平滑 效果对比 移动平均效果比较： 高斯平滑 效果对比 右边两个参数是1.5 2 代码： smooth_demo.py import numpy as np import cv2 from scipy.ndimage import gaussian_filter1ddef gaussian_smooth_array(arr, sigma):smoothed_arr = gaussian_filter1d(arr, s…
阅读更多...
Jenkins-简介/安装！

Jenkins-简介/安装！

一. 关于持续集成&#xff1a; 持续集成(CI ) [ Continuous Integration ]&#xff0c;通俗来讲&#xff0c;就是一个能监控版本控制系统变化的工具&#xff0c;可以自动编译和测试集成的应用程序。出现问题&#xff0c;能够及时的通知相应人员。持续集成是一种思维工具集&…
阅读更多...
Flutter中Get.snackbar避免重复显示的实现

Flutter中Get.snackbar避免重复显示的实现

在pubspec.yaml中引入依赖框架。 #GetX依赖注解get: ^4.6.5创建一个SnackBarManager管理类去管理每个提示框。 import package:get/get.dart; import package:flutter/material.dart;class SnackBarManager {factory SnackBarManager() > instance;static final SnackBarMa…
阅读更多...
c#删除文件和目录到回收站

c#删除文件和目录到回收站

之前在c上遇到过这个问题&#xff0c;折腾许久才解决了&#xff0c;这次在c#上再次遇到这个问题&#xff0c;不过似乎容易了一些&#xff0c;亲测代码如下&#xff0c;两种删除方式都写在代码中了。 直接上完整代码&#xff1a; using Microsoft.VisualBasic.FileIO; using Sy…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023