【2024年华为OD机试】(A卷,200分)- 简单的解压缩算法 （JavaScriptJava PythonC/C++）

在这里插入图片描述

一、问题描述

题目描述

现需要实现一种算法，能将一组压缩字符串还原成原始字符串，还原规则如下：

  1. 字符后面加数字N，表示重复字符N次。例如：压缩内容为 A3，表示原始字符串为 AAA。
  2. 花括号中的字符串加数字N，表示花括号中的字符重复N次。例如压缩内容为 {AB}3，表示原始字符串为 ABABAB。
  3. 字符加N和花括号后面加N，支持任意的嵌套，包括互相嵌套。例如：压缩内容可以 {A3B1{C}3}3。
输入描述

输入一行压缩后的字符串。

输出描述

输出压缩前的字符串。

备注
  • 输入保证，数字不会为0，花括号中的内容不会为空，保证输入的都是合法有效的压缩字符串。
  • 输入输出字符串区分大小写。
  • 输入的字符串长度范围为 [1, 10000]。
  • 输出的字符串长度范围为 [1, 100000]。
  • 数字N范围为 [1, 10000]。
用例
  • 输入：{A3B1{C}3}3
  • 输出：AAABCCCAAABCCCAAABCCC
  • 说明：{A3B1{C}3}3 代表 A 字符重复3次，B 字符重复1次，花括号中的 C 字符重复3次，最外层花括号中的 AAABCCC 重复3次。

题目解析

本题的核心是将压缩字符串还原为原始字符串。压缩规则支持字符重复和嵌套花括号重复，因此需要处理多层嵌套的情况。

解题思路

  1. 栈结构的使用：

    • 使用栈来保存当前处理的字符和字符串片段。
    • 遇到非数字字符时，直接压入栈中。
    • 遇到数字字符时，根据栈顶元素决定如何重复字符或字符串片段。

  2. 处理嵌套规则：

    • 遇到 { 时，记录其在栈中的位置。
    • 遇到 } 时，取出栈中从 { 到 } 之间的字符串片段，并根据后面的数字重复该片段。
    • 将重复后的字符串片段重新压入栈中。

  3. 数字的处理：

    • 数字可能为多位数（如 A13），需要完整解析数字的值。
    • 根据数字的值重复字符或字符串片段。

  4. 最终结果：

    • 遍历完输入字符串后，栈中保存的即为解压后的原始字符串。
关键点
  • 栈的使用：栈是处理嵌套结构的利器，能够很好地保存中间状态。
  • 数字解析：需要正确处理多位数的情况。
  • 嵌套规则：需要递归或迭代处理多层嵌套的压缩规则。
示例解析

以输入 {A3B1{C}3}3 为例：

  1. 解析 {A3B1{C}3}3：
    • 遇到 {，记录位置。
    • 解析 A3，表示 AAA。
    • 解析 B1，表示 B。
    • 解析 {C}3，表示 CCC。
    • 组合 AAABCCC。
    • 最外层 {} 重复3次，最终结果为 AAABCCCAAABCCCAAABCCC。
注意事项
  • 输入保证合法，无需处理异常情况。
  • 数字可能为多位数，需要完整解析。
  • 嵌套层级可能较深，需要确保栈的容量足够。

总结

本题的核心是使用栈结构处理嵌套的压缩规则，并通过解析数字实现字符或字符串片段的重复。通过从左到右遍历输入字符串，结合栈的压入和弹出操作，可以高效地完成解压缩任务。

二、JavaScript算法源码

以下是 JavaScript 代码的详细注释和逻辑讲解，帮助你更好地理解代码的实现：

代码详细注释

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");// 创建 readline 接口，用于从控制台读取输入
const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});// 监听输入事件，每次输入一行时触发
rl.on("line", (line) => {// 调用 getResult 函数处理输入，并输出结果console.log(getResult(line));
});// 定义 getResult 函数，用于解压缩字符串
function getResult(str) {// 使用栈结构保存字符和字符串片段const stack = [];// 使用 idxs 数组记录 '{' 在栈中的位置const idxs = [];// 使用 repeat 数组保存数字字符，用于解析多位数const repeat = [];// 在字符串末尾添加一个空格，用于处理最后一个数字str += " ";// 遍历输入字符串的每一个字符for (let c of str) {// 如果当前字符是数字，将其加入 repeat 数组if (/\d/.test(c)) {repeat.push(c);continue;}// 如果 repeat 数组不为空，说明需要处理数字if (repeat.length > 0) {// 将 repeat 数组中的数字字符拼接成完整的数字const n = parseInt(repeat.join(""));// 清空 repeat 数组repeat.length = 0;// 获取栈顶元素const top = stack.pop();// 如果栈顶元素是 '}'，说明需要处理花括号中的内容if (top === "}") {// 取出花括号中的内容const frag = stack.splice(idxs.pop()).slice(1).join("");// 将花括号中的内容重复 n 次，并压入栈中stack.push(...new Array(n).fill(frag).join(""));} else {// 如果栈顶元素不是 '}'，说明是单个字符，将其重复 n 次并压入栈中stack.push(...new Array(n).fill(top));}}// 如果当前字符是 '{'，记录其在栈中的位置if (c === "{") {idxs.push(stack.length);}// 将当前字符压入栈中stack.push(c);}// 将栈中的字符拼接成最终的解压缩字符串，并去除末尾的空格return stack.join("").trim();
}

代码逻辑讲解

1. 输入处理
  • 使用 readline 模块从控制台读取输入。
  • 每次输入一行时，调用 getResult 函数处理输入，并输出结果。
2. 栈结构的使用
  • stack：用于保存字符和字符串片段。
  • idxs：用于记录 { 在栈中的位置，方便后续处理花括号中的内容。
  • repeat：用于保存数字字符，解析多位数。
3. 遍历输入字符串
  • 遍历输入字符串的每一个字符：
    • 如果字符是数字，将其加入 repeat 数组。
    • 如果字符不是数字，且 repeat 数组不为空，说明需要处理数字：
      • 将 repeat 数组中的数字字符拼接成完整的数字 n。
      • 根据栈顶元素决定如何处理：
        • 如果栈顶是 }，说明需要处理花括号中的内容：
          • 取出花括号中的内容 frag。
          • 将 frag 重复 n 次，并压入栈中。
        • 如果栈顶不是 }，说明是单个字符：
          • 将字符重复 n 次，并压入栈中。
    • 如果字符是 {，记录其在栈中的位置。
    • 将当前字符压入栈中。
4. 最终结果
  • 将栈中的字符拼接成最终的解压缩字符串，并去除末尾的空格。

示例运行

示例 1

输入：

{A3B1{C}3}3

运行过程：

  1. 遍历字符：
    • {：记录位置，压入栈中。
    • A：压入栈中。
    • 3：加入 repeat 数组。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 1：加入 repeat 数组。
    • {：记录位置，压入栈中。
    • C：压入栈中。
    • 3：加入 repeat 数组。
    • }：处理数字 3，将 C 重复 3 次，压入栈中。
    • 3：加入 repeat 数组。
    • 空格：处理数字 3，将 AAABCCC 重复 3 次，压入栈中。
  2. 最终栈中内容：AAABCCCAAABCCCAAABCCC。

输出：

AAABCCCAAABCCCAAABCCC
示例 2

输入：

A3B2

运行过程：

  1. 遍历字符：
    • A：压入栈中。
    • 3：加入 repeat 数组。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 2：加入 repeat 数组。
    • 空格：处理数字 2，将 B 重复 2 次，压入栈中。
  2. 最终栈中内容：AAABBB。

输出：

AAABBB

总结

  • 代码通过栈结构处理嵌套的压缩规则，能够高效地解压缩字符串。
  • 支持多位数数字和嵌套花括号的处理。
  • 时间复杂度为 O(n)，空间复杂度为 O(n)，能够很好地处理最大输入规模。

三、Java算法源码

以下是 Java 代码的详细注释和逻辑讲解，帮助你更好地理解代码的实现：

代码详细注释

import java.util.LinkedList;
import java.util.Scanner;public class Main {public static void main(String[] args) {// 创建 Scanner 对象，用于从控制台读取输入Scanner sc = new Scanner(System.in);// 读取输入字符串String str = sc.next();// 调用 getResult 函数处理输入，并输出结果System.out.println(getResult(str));}// 定义 getResult 函数，用于解压缩字符串public static String getResult(String str) {// 使用 LinkedList 模拟栈结构LinkedList<String> stack = new LinkedList<>();// 使用 LinkedList 记录 '{' 在栈中的位置LinkedList<Integer> idxs = new LinkedList<>();// 使用 StringBuilder 保存数字字符，用于解析多位数StringBuilder repeat = new StringBuilder();// 在字符串末尾添加一个空格，用于处理最后一个数字str += " ";// 遍历输入字符串的每一个字符for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);// 如果当前字符是数字，将其加入 repeatif (c >= '0' && c <= '9') {repeat.append(c);continue;}// 如果 repeat 不为空，说明需要处理数字if (repeat.length() > 0) {// 将 repeat 中的数字字符拼接成完整的数字int n = Integer.parseInt(repeat.toString());// 清空 repeatrepeat = new StringBuilder();// 如果栈顶元素是 '}'，说明需要处理花括号中的内容if ("}".equals(stack.getLast())) {// 取出 '{' 在栈中的位置int left = idxs.removeLast();// 移除 '{'stack.remove(left);// 移除 '}'stack.removeLast();// 将 '{' 和 '}' 中间的内容重复 n 次后重新压入栈中updateStack(stack, left, n);} else {// 如果栈顶元素不是 '}'，说明是单个字符，将其重复 n 次updateStack(stack, stack.size() - 1, n);}}// 如果当前字符是 '{'，记录其在栈中的位置if (c == '{') {idxs.addLast(stack.size());}// 将当前字符压入栈中stack.addLast(c + "");}// 将栈中的字符拼接成最终的解压缩字符串StringBuilder sb = new StringBuilder();for (String c : stack) {sb.append(c);}// 返回结果，并去除末尾的空格return sb.toString().trim();}// 定义 updateStack 函数，用于将栈中从 left 索引开始的内容重复 repeat 次后重新压入栈中public static void updateStack(LinkedList<String> stack, int left, int repeat) {// 计算需要弹栈的元素数量int count = stack.size() - left;// 使用数组保存弹栈的内容String[] frag = new String[count];// 弹栈并保存内容while (count-- > 0) {frag[count] = stack.removeLast();}// 将弹栈内容合并成一个字符串StringBuilder sb = new StringBuilder();for (String s : frag) {sb.append(s);}// 将合并后的字符串重复 repeat 次String fragment = sb.toString();StringBuilder ans = new StringBuilder();for (int i = 0; i < repeat; i++) {ans.append(fragment);}// 将重复后的字符串重新压入栈中stack.addLast(ans.toString());}
}

代码逻辑讲解

1. 输入处理
  • 使用 Scanner 从控制台读取输入字符串。
2. 栈结构的使用
  • stack：使用 LinkedList 模拟栈结构，保存字符和字符串片段。
  • idxs：使用 LinkedList 记录 { 在栈中的位置，方便后续处理花括号中的内容。
  • repeat：使用 StringBuilder 保存数字字符，解析多位数。
3. 遍历输入字符串
  • 遍历输入字符串的每一个字符：
    • 如果字符是数字，将其加入 repeat。
    • 如果字符不是数字，且 repeat 不为空，说明需要处理数字：
      • 将 repeat 中的数字字符拼接成完整的数字 n。
      • 根据栈顶元素决定如何处理：
        • 如果栈顶是 }，说明需要处理花括号中的内容：
          • 取出 { 在栈中的位置。
          • 移除 { 和 }。
          • 将 { 和 } 中间的内容重复 n 次后重新压入栈中。
        • 如果栈顶不是 }，说明是单个字符：
          • 将字符重复 n 次后重新压入栈中。
    • 如果字符是 {，记录其在栈中的位置。
    • 将当前字符压入栈中。
4. 最终结果
  • 将栈中的字符拼接成最终的解压缩字符串，并去除末尾的空格。

示例运行

示例 1

输入：

{A3B1{C}3}3

运行过程：

  1. 遍历字符：
    • {：记录位置，压入栈中。
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 1：加入 repeat。
    • {：记录位置，压入栈中。
    • C：压入栈中。
    • 3：加入 repeat。
    • }：处理数字 3，将 C 重复 3 次，压入栈中。
    • 3：加入 repeat。
    • 空格：处理数字 3，将 AAABCCC 重复 3 次，压入栈中。
  2. 最终栈中内容：AAABCCCAAABCCCAAABCCC。

输出：

AAABCCCAAABCCCAAABCCC
示例 2

输入：

A3B2

运行过程：

  1. 遍历字符：
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 2：加入 repeat。
    • 空格：处理数字 2，将 B 重复 2 次，压入栈中。
  2. 最终栈中内容：AAABBB。

输出：

AAABBB

总结

  • 代码通过 LinkedList 模拟栈结构，能够高效地处理嵌套的压缩规则。
  • 支持多位数数字和嵌套花括号的处理。
  • 时间复杂度为 O(n)，空间复杂度为 O(n)，能够很好地处理最大输入规模。

四、Python算法源码

以下是 Python 代码的详细注释和逻辑讲解，帮助你更好地理解代码的实现：

代码详细注释

# 输入获取
s = input()# 算法入口
def getResult(s):# 使用列表模拟栈结构stack = []# 使用列表记录 '{' 在栈中的位置idxs = []# 使用列表保存数字字符，用于解析多位数repeat = []# 在字符串末尾添加一个空格，用于处理最后一个数字s = s + " "# 遍历输入字符串的每一个字符for c in s:# 如果当前字符是数字，将其加入 repeat 列表if c.isdigit():repeat.append(c)continue# 如果 repeat 列表不为空，说明需要处理数字if len(repeat) > 0:# 将 repeat 列表中的数字字符拼接成完整的数字n = int("".join(repeat))# 清空 repeat 列表repeat = []# 获取栈顶元素top = stack.pop()# 如果栈顶元素是 '}'，说明需要处理花括号中的内容if top == "}":# 取出 '{' 在栈中的位置start = idxs.pop()# 取出 '{' 和 '}' 中间的内容frag = "".join(stack[start + 1:])# 移除 '{' 和 '}' 中间的内容stack = stack[:start]# 将中间内容重复 n 次后重新压入栈中stack.extend([frag] * n)else:# 如果栈顶元素不是 '}'，说明是单个字符，将其重复 n 次stack.extend([top] * n)# 如果当前字符是 '{'，记录其在栈中的位置if c == "{":idxs.append(len(stack))# 将当前字符压入栈中stack.append(c)# 将栈中的字符拼接成最终的解压缩字符串，并去除末尾的空格return "".join(stack).strip()# 算法调用
print(getResult(s))

代码逻辑讲解

1. 输入处理
  • 使用 input() 函数从控制台读取输入字符串。
2. 栈结构的使用
  • stack：使用列表模拟栈结构，保存字符和字符串片段。
  • idxs：使用列表记录 { 在栈中的位置，方便后续处理花括号中的内容。
  • repeat：使用列表保存数字字符，解析多位数。
3. 遍历输入字符串
  • 遍历输入字符串的每一个字符：
    • 如果字符是数字，将其加入 repeat 列表。
    • 如果字符不是数字，且 repeat 列表不为空，说明需要处理数字：
      • 将 repeat 列表中的数字字符拼接成完整的数字 n。
      • 根据栈顶元素决定如何处理：
        • 如果栈顶是 }，说明需要处理花括号中的内容：
          • 取出 { 在栈中的位置。
          • 取出 { 和 } 中间的内容 frag。
          • 移除 { 和 } 中间的内容。
          • 将 frag 重复 n 次后重新压入栈中。
        • 如果栈顶不是 }，说明是单个字符：
          • 将字符重复 n 次后重新压入栈中。
    • 如果字符是 {，记录其在栈中的位置。
    • 将当前字符压入栈中。
4. 最终结果
  • 将栈中的字符拼接成最终的解压缩字符串，并去除末尾的空格。

示例运行

示例 1

输入：

{A3B1{C}3}3

运行过程：

  1. 遍历字符：
    • {：记录位置，压入栈中。
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 1：加入 repeat。
    • {：记录位置，压入栈中。
    • C：压入栈中。
    • 3：加入 repeat。
    • }：处理数字 3，将 C 重复 3 次，压入栈中。
    • 3：加入 repeat。
    • 空格：处理数字 3，将 AAABCCC 重复 3 次，压入栈中。
  2. 最终栈中内容：AAABCCCAAABCCCAAABCCC。

输出：

AAABCCCAAABCCCAAABCCC
示例 2

输入：

A3B2

运行过程：

  1. 遍历字符：
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 2：加入 repeat。
    • 空格：处理数字 2，将 B 重复 2 次，压入栈中。
  2. 最终栈中内容：AAABBB。

输出：

AAABBB

总结

  • 代码通过列表模拟栈结构，能够高效地处理嵌套的压缩规则。
  • 支持多位数数字和嵌套花括号的处理。
  • 时间复杂度为 O(n)，空间复杂度为 O(n)，能够很好地处理最大输入规模。

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

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

C语言代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>// 定义栈结构
typedef struct {char* data;int size;int capacity;
} Stack;// 初始化栈
void initStack(Stack* stack, int capacity) {stack->data = (char*)malloc(capacity * sizeof(char));stack->size = 0;stack->capacity = capacity;
}// 压栈
void pushStack(Stack* stack, char c) {if (stack->size >= stack->capacity) {stack->capacity *= 2;stack->data = (char*)realloc(stack->data, stack->capacity * sizeof(char));}stack->data[stack->size++] = c;
}// 弹栈
char popStack(Stack* stack) {if (stack->size == 0) {return '\0';}return stack->data[--stack->size];
}// 获取栈顶元素
char topStack(Stack* stack) {if (stack->size == 0) {return '\0';}return stack->data[stack->size - 1];
}// 更新栈中从指定位置开始的内容
void updateStack(Stack* stack, int start, int repeat) {int count = stack->size - start;char* frag = (char*)malloc((count + 1) * sizeof(char));for (int i = 0; i < count; i++) {frag[i] = stack->data[start + i];}frag[count] = '\0';stack->size = start;for (int i = 0; i < repeat; i++) {for (int j = 0; j < count; j++) {pushStack(stack, frag[j]);}}free(frag);
}// 解压缩函数
char* getResult(const char* s) {Stack stack;initStack(&stack, 100);Stack idxs;initStack(&idxs, 100);char repeat[10];int repeatLen = 0;int len = strlen(s);for (int i = 0; i <= len; i++) {char c = s[i];if (isdigit(c)) {repeat[repeatLen++] = c;continue;}if (repeatLen > 0) {repeat[repeatLen] = '\0';int n = atoi(repeat);repeatLen = 0;char top = popStack(&stack);if (top == '}') {int start = popStack(&idxs) - '0';updateStack(&stack, start, n);} else {for (int j = 0; j < n; j++) {pushStack(&stack, top);}}}if (c == '{') {pushStack(&idxs, stack.size + '0');}if (c != '\0') {pushStack(&stack, c);}}pushStack(&stack, '\0');return stack.data;
}int main() {char s[10000];scanf("%s", s);char* result = getResult(s);printf("%s\n", result);free(result);return 0;
}

C++代码

#include <iostream>
#include <vector>
#include <string>
using namespace std;// 解压缩函数
string getResult(const string& s) {vector<char> stack;vector<int> idxs;string repeat;for (char c : s + " ") {if (isdigit(c)) {repeat += c;continue;}if (!repeat.empty()) {int n = stoi(repeat);repeat.clear();char top = stack.back();stack.pop_back();if (top == '}') {int start = idxs.back();idxs.pop_back();string frag(stack.begin() + start + 1, stack.end());stack.resize(start);for (int i = 0; i < n; i++) {stack.insert(stack.end(), frag.begin(), frag.end());}} else {for (int i = 0; i < n; i++) {stack.push_back(top);}}}if (c == '{') {idxs.push_back(stack.size());}stack.push_back(c);}return string(stack.begin(), stack.end() - 1);
}int main() {string s;cin >> s;string result = getResult(s);cout << result << endl;return 0;
}

代码逻辑讲解

1. 输入处理
  • C语言：使用 scanf 从标准输入读取字符串。
  • C++：使用 cin 从标准输入读取字符串。
2. 栈结构的使用
  • C语言：使用自定义的 Stack 结构体模拟栈。
  • C++：使用 vector<char> 模拟栈。
3. 遍历输入字符串
  • 遍历输入字符串的每一个字符：
    • 如果字符是数字，将其加入 repeat。
    • 如果字符不是数字，且 repeat 不为空，说明需要处理数字：
      • 将 repeat 中的数字字符拼接成完整的数字 n。
      • 根据栈顶元素决定如何处理：
        • 如果栈顶是 }，说明需要处理花括号中的内容：
          • 取出 { 在栈中的位置。
          • 取出 { 和 } 中间的内容 frag。
          • 移除 { 和 } 中间的内容。
          • 将 frag 重复 n 次后重新压入栈中。
        • 如果栈顶不是 }，说明是单个字符：
          • 将字符重复 n 次后重新压入栈中。
    • 如果字符是 {，记录其在栈中的位置。
    • 将当前字符压入栈中。
4. 最终结果
  • 将栈中的字符拼接成最终的解压缩字符串。

示例运行

示例 1

输入：

{A3B1{C}3}3

运行过程：

  1. 遍历字符：
    • {：记录位置，压入栈中。
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 1：加入 repeat。
    • {：记录位置，压入栈中。
    • C：压入栈中。
    • 3：加入 repeat。
    • }：处理数字 3，将 C 重复 3 次，压入栈中。
    • 3：加入 repeat。
    • 空格：处理数字 3，将 AAABCCC 重复 3 次，压入栈中。
  2. 最终栈中内容：AAABCCCAAABCCCAAABCCC。

输出：

AAABCCCAAABCCCAAABCCC
示例 2

输入：

A3B2

运行过程：

  1. 遍历字符：
    • A：压入栈中。
    • 3：加入 repeat。
    • B：处理数字 3，将 A 重复 3 次，压入栈中。
    • 2：加入 repeat。
    • 空格：处理数字 2，将 B 重复 2 次，压入栈中。
  2. 最终栈中内容：AAABBB。

输出：

AAABBB

总结

  • C语言 和 C++ 版本的实现逻辑完全一致，只是语法和数据结构略有不同。
  • 代码通过栈结构处理嵌套的压缩规则，能够高效地解压缩字符串。
  • 支持多位数数字和嵌套花括号的处理。
  • 时间复杂度为 O(n)，空间复杂度为 O(n)，能够很好地处理最大输入规模。

六、尾言

什么是华为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.rhkb.cn/news/6187.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

K8S中Service详解（一）

K8S中Service详解（一）

Service介绍 在Kubernetes中&#xff0c;Service资源解决了Pod IP地址不固定的问题&#xff0c;提供了一种更稳定和可靠的服务访问方式。以下是Service的一些关键特性和工作原理&#xff1a; Service的稳定性&#xff1a;由于Pod可能会因为故障、重启或扩容而获得新的IP地址&a…
阅读更多...
jenkins-k8s pod方式动态生成slave节点

jenkins-k8s pod方式动态生成slave节点

一. 简述&#xff1a; 使用 Jenkins 和 Kubernetes (k8s) 动态生成 Slave 节点是一种高效且灵活的方式来管理 CI/CD 流水线。通过这种方式&#xff0c;Jenkins 可以根据需要在 Kubernetes 集群中创建和销毁 Pod 来执行任务&#xff0c;从而充分利用集群资源并实现更好的隔离性…
阅读更多...
LabVIEW滤波器选择与参数设置

LabVIEW滤波器选择与参数设置

在信号处理应用中&#xff0c;滤波器是去除噪声、提取目标信号的重要工具。LabVIEW 提供多种类型的滤波器&#xff08;如低通、高通、带通、带阻&#xff09;&#xff0c;用户需要根据采样频率、信号特性和应用需求合理选择滤波器类型及参数设置。本文以 采样率 100kHz&#xf…
阅读更多...
iOS中的设计模式（四）- 抽象工厂

iOS中的设计模式（四）- 抽象工厂

引言 在软件设计中&#xff0c;创建一个类的对象通常需要客户端知道该类的所有细节。而当需要同时创建一组相关对象时&#xff0c;且这些对象在运行时会根据不同的标准有所变化&#xff0c;这会变得更加复杂。此时&#xff0c;抽象工厂模式能够有效地简化这一过程。 抽象工厂…
阅读更多...
deeplabv3+街景图片语义分割，无需训练模型，看不懂也没有影响，直接使用，cityscapes数据集_12

deeplabv3+街景图片语义分割，无需训练模型，看不懂也没有影响，直接使用，cityscapes数据集_12

目录 1、下载链接1.1、CSDN链接&#xff0c;含权重文件直接使用&#xff0c;建议直接下这个&#xff0c;还不限速。1.2 Github链接&#xff1a;2、下载代码&#xff0c;下载预训练好的权重3、预测代码4、像素提取&#xff0c;或者说类别提取5、文档部分内容截图6、其他数据处理…
阅读更多...
Java 基于 SpringBoot 的校园外卖点餐平台微信小程序（附源码，部署，文档）

Java 基于 SpringBoot 的校园外卖点餐平台微信小程序（附源码，部署，文档）

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
Jetson Xavier NX 安装 CUDA 支持的 PyTorch 指南

Jetson Xavier NX 安装 CUDA 支持的 PyTorch 指南

本指南将帮助开发者完成在 Jetson Xavier NX 上安装 CUDA 支持的 PyTorch。 安装方法 在 Jetson 上安装 Pytorch 只有两种方法。 一种是直接安装他人已经编译好的 PyTorch 轮子&#xff1b;一种是自己从头开始开始构建 PyTorch 轮子并且安装。 使用轮子安装 可以从我的 Gi…
阅读更多...
怎样使用树莓派自己搭建一套ADS-B信号接收系统

怎样使用树莓派自己搭建一套ADS-B信号接收系统

0 我们知道&#xff0c;ADS-B全称广播式自动相关监视系统&#xff0c;其实就是飞机发出的广播信号&#xff0c;用明码来对外发送自己的位置、高度、速度、航向等信息&#xff0c;是公开信息。连续接收到一架飞机发出的ADS-B信息后&#xff0c;可以通过其坐标点来描绘出飞机的航…
阅读更多...
KETTLE-SAP抽数报错RFC_ERROR_SYSTEM_FAILURE

KETTLE-SAP抽数报错RFC_ERROR_SYSTEM_FAILURE

KETTLE调SAP 合并ECCS相关的函数时报错 2025/01/23 17:56:02 - SAP input.0 - ERROR (version 8.2.0.0-342, build 8.2.0.0-342 from 2018-11-14 10.30.55 by buildguy) : Unexpected error 2025/01/23 17:56:02 - SAP input.0 - ERROR (version 8.2.0.0-342, build 8.2.0.0-3…
阅读更多...
困境如雾路难寻，心若清明步自轻---2024年创作回顾

困境如雾路难寻，心若清明步自轻---2024年创作回顾

文章目录 前言博客创作回顾第一次被催更第一次获得证书周榜几篇博客互动最多的最满意的引发思考的 写博契机 碎碎念时也运也部分经验 尾 前言 今年三月份&#xff0c;我已写下一篇《近一年多个人总结》&#xff0c;当时还没开始写博客。四月份写博后&#xff0c;就顺手将那篇总…
阅读更多...
2024 行远自迩，笃行不怠

2024 行远自迩，笃行不怠

2024年是充满变化与挑战的一年&#xff0c;我的开发方向经历了从智能驾驶到工业智能检测&#xff0c;再到机器人感知交互与决策的不断演进。 这一年&#xff0c;我不断拓宽技术视野&#xff0c;深入探索不同领域的技术挑战和应用场景。 最初&#xff0c;我希望专注于单一领域…
阅读更多...
【Linux】19.基础IO（1）

【Linux】19.基础IO（1）

文章目录 1. 基础IO1. 文件2. 回顾C文件接口2.1 hello.c写文件2.2 hello.c读文件2.3 接口介绍 3. open函数返回值3.1 文件描述符fd3.2 文件描述符的分配规则3.2.1 代码13.2.2 代码23.2.3 重定向底层原理代码示例3.2.4 使用 dup2 系统调用 3.3 缓冲区刷新问题3.4 FILE 1. 基础IO…
阅读更多...
客户案例：向导ERP与金蝶云星空集成方案

客户案例：向导ERP与金蝶云星空集成方案

一、客户背景 该客户公司主要致力于黄金、铂金、金镶玉首饰的研发设计、生产加工、批发及直营加盟业务。公司总部占地面积目前已达6000多平方米&#xff0c;拥有标准生产厂房和现代化生产设施&#xff0c;拥有一支完善的企业管理团队和专业技工队伍。 该企业目前同时采用向导 E…
阅读更多...
RabbitMQ 在实际应用时要注意的问题

RabbitMQ 在实际应用时要注意的问题

1. 幂等性保障 1.1 幂等性介绍 幂等性是数学和计算机科学中某些运算的性质,它们可以被多次应⽤,⽽不会改变初始应⽤的结果. 应⽤程序的幂等性介绍 在应⽤程序中,幂等性就是指对⼀个系统进⾏重复调⽤(相同参数),不论请求多少次,这些请求对系统的影响都是相同的效果. ⽐如数据库…
阅读更多...
Cesium特效——城市白模的科技动效的各种效果

Cesium特效——城市白模的科技动效的各种效果

最终效果图如下&#xff1a; 实现方法&#xff1a; 步骤一&#xff1a;使用cesiumlib生产白模&#xff0c;格式为3dtiles 注意事项&#xff1a;采用其他方式可能导致白模贴地&#xff0c;从而导致不能实现该效果&#xff0c;例如把步骤二的服务地址改为Cesium Sandcastle 里的…
阅读更多...
4_高并发内存池项目_高并发池内存释放设计_ThreadCache/CentralCache/PageCache回收并释放内存

4_高并发内存池项目_高并发池内存释放设计_ThreadCache/CentralCache/PageCache回收并释放内存

高并发池内存释放设计 对各缓存层释放内存的设计&#xff0c;不仅仅是从上一层回收内存&#xff0c;还包括对回收回来的内存怎样处理更有利于下一缓存层的回收&#xff0c;提高效率。 高并发内存池内存释放步骤&#xff1a; 线程对象释放内存 ↓↓↓↓↓ ThreadCache(1.回收线…
阅读更多...
centos9编译安装opensips 二【进阶篇-定制目录+模块】推荐

centos9编译安装opensips 二【进阶篇-定制目录+模块】推荐

环境&#xff1a;centos9 last opensips -V version: opensips 3.6.0-dev (x86_64/linux) flags: STATS: On, DISABLE_NAGLE, USE_MCAST, SHM_MMAP, PKG_MALLOC, Q_MALLOC, F_MALLOC, HP_MALLOC, DBG_MALLOC, CC_O0, FAST_LOCK-ADAPTIVE_WAIT ADAPTIVE_WAIT_LOOPS1024, MAX_RE…
阅读更多...
分子动力学模拟里的术语：leap-frog蛙跳算法和‌Velocity-Verlet算法

分子动力学模拟里的术语：leap-frog蛙跳算法和‌Velocity-Verlet算法

分子动力学模拟&#xff08;Molecular Dynamics Simulation&#xff0c;简称MD&#xff09;是一种基于经典力学原理的计算物理方法&#xff0c;用于模拟原子和分子在给定时间内的运动和相互作用‌。以下是关于分子动力学模拟的一些核心术语和概念&#xff1a; ‌定义系统‌&am…
阅读更多...
iOS开发设计模式篇第二篇MVVM设计模式

iOS开发设计模式篇第二篇MVVM设计模式

目录 一、什么是MVVM 二、MVVM 的主要特点 三、MVVM 的架构图 四、MVVM 与其他模式的对比 五、如何在iOS中实现MVVM 1.Model 2.ViewModel 3.View (ViewController) 4.双向绑定 5.文中完整的代码地址 六、MVVM 的优缺点 1.优点 2.缺点 七、MVVM 的应用场景 八、结…
阅读更多...
【C++图论 并集查找】2492. 两个城市间路径的最小分数|1679

【C++图论 并集查找】2492. 两个城市间路径的最小分数|1679

本文涉及知识点 C图论 并集查找&#xff08;并查集) LeetCode2492. 两个城市间路径的最小分数 给你一个正整数 n &#xff0c;表示总共有 n 个城市&#xff0c;城市从 1 到 n 编号。给你一个二维数组 roads &#xff0c;其中 roads[i] [ai, bi, distancei] 表示城市 ai 和 …
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023