当前位置： 首页 > article >正文

【2024年华为OD机试】(B卷,100分)- 相对开音节 （Java JS PythonC/C++）

article 2025/1/18 1:50:35

在这里插入图片描述

一、问题描述

题目描述

相对开音节构成的结构为：辅音 + 元音（aeiou）+ 辅音(r除外) + e。

常见的单词有bike、cake等。

给定一个字符串，以空格为分隔符，反转每个单词中的字母，若单词中包含如数字等其他非字母时不进行反转。

反转后计算其中含有相对开音节结构的子串个数（连续的子串中部分字符可以重复）。

输入描述

字符串，以空格分割的多个单词，字符串长度<10000，字母只考虑小写

输出描述

含有相对开音节结构的子串个数，注：个数<10000

用例

用例1

输入

ekam a ekac

输出

2

说明
反转后为 make a cake 其中make、cake为相对开音节子串，返回2。

用例2

输入

!ekam a ekekac

输出

2

说明
反转后为!ekam a cakeke 因!ekam含非英文字符所以未反转，其中 cake、keke为相对开音节子串，返回2。

题目解析

考察点

考察字符串操作、正则表达式和滑动窗口算法。

解析思路

  1. 反转操作：
    • 遍历每个单词，检查单词中是否包含非小写字母。
    • 如果单词中包含非小写字母，则不进行反转。
    • 如果单词中只包含小写字母，则反转该单词。
  2. 反转后的处理：
    • 对每个反转后的单词，使用滑动窗口算法检查其中的子串是否符合相对开音节结构。
    • 相对开音节结构的正则表达式为 [^aeiou][aeiou][^aeiour]e。
    • 使用滑动窗口遍历单词中的每个子串，检查子串是否匹配上述正则表达式。
    • 如果匹配，则计数器加1。
  3. 优化逻辑：
    • 如果不进行单词反转，可以将正则表达式反转为 e[^aeiour][aeiou][^aeiou]。
    • 在检查子串是否为相对开音节之前，先检查子串是否包含非字母字符。如果包含非字母字符，则该子串不可能是相对开音节，直接跳过。
  4. 输出结果：
    • 遍历完所有单词后，输出计数器的值，即为含有相对开音节结构的子串个数。

注意事项

  • 正则表达式：[^aeiou] 匹配的是非元音的所有字符，而不是非元音字母。因此，需要先检查子串是否包含非字母字符。
  • 滑动窗口：滑动窗口的大小固定为4，因为相对开音节结构的长度为4。
  • 效率：虽然字符串长度可能达到10000，但每个单词的处理时间复杂度为O(n)，总体效率是可以接受的。

二、JavaScript算法源码

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

JavaScript 代码

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

// 创建 readline 接口，用于从控制台读取输入
const rl = readline.createInterface({
  input: process.stdin,  // 输入流
  output: process.stdout, // 输出流
});

// 监听输入事件
rl.on("line", (line) => {
  // 将输入内容按空格分割成单词数组
  const words = line.split(" ");

  // 调用算法函数并输出结果
  console.log(getResult(words));
});

// 算法函数：统计满足条件的子串数量
function getResult(words) {
  let count = 0; // 记录满足条件的子串数量

  // 定义正则表达式：
  // 1. 匹配非字母字符
  const nonLetter = /[^a-z]/;
  // 2. 匹配满足条件的子串模式 1
  const reg1 = /[^aeiou][aeiou][^aeiour]e/;
  // 3. 匹配满足条件的子串模式 2
  const reg2 = /e[^aeiour][aeiou][^aeiou]/;

  // 遍历每个单词
  words.forEach((word) => {
    // 判断当前单词是否包含非字母字符
    const hasNonLetter = nonLetter.test(word);

    // 根据是否包含非字母字符，选择正则表达式
    const reg = hasNonLetter ? reg1 : reg2;

    // 遍历单词中的每个可能的 4 字符子串
    for (let i = 0; i <= word.length - 4; i++) {
      // 截取 4 字符子串
      const seg = word.substr(i, 4);

      // 如果子串包含非字母字符，跳过
      if (nonLetter.test(seg)) continue;

      // 如果子串匹配正则表达式，计数加 1
      if (reg.test(seg)) count++;
    }
  });

  // 返回满足条件的子串总数
  return count;
}

详细讲解

1. 输入获取
const readline = require("readline");

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

// 监听输入事件
rl.on("line", (line) => {
  // 将输入内容按空格分割成单词数组
  const words = line.split(" ");

  // 调用算法函数并输出结果
  console.log(getResult(words));
});
  • 功能：
    • 使用 readline 模块从控制台读取输入。
    • 将输入内容按空格分割成单词数组 words。
  • 说明：
    • readline.createInterface 创建接口，用于读取输入和输出。
    • rl.on("line", ...) 监听输入事件，每次输入一行时触发。
2. 正则表达式定义
// 定义正则表达式：
// 1. 匹配非字母字符
const nonLetter = /[^a-z]/;
// 2. 匹配满足条件的子串模式 1
const reg1 = /[^aeiou][aeiou][^aeiour]e/;
// 3. 匹配满足条件的子串模式 2
const reg2 = /e[^aeiour][aeiou][^aeiou]/;
  • 功能：
    • nonLetter：匹配非字母字符（a-z 以外的字符）。
    • reg1：匹配满足条件的子串模式 1。
    • reg2：匹配满足条件的子串模式 2。
  • 说明：
    • [^a-z]：匹配非小写字母。
    • [^aeiou]：匹配非元音字母。
    • [aeiou]：匹配元音字母。
    • e：匹配字母 e。
3. 遍历单词
words.forEach((word) => {
  // 判断当前单词是否包含非字母字符
  const hasNonLetter = nonLetter.test(word);

  // 根据是否包含非字母字符，选择正则表达式
  const reg = hasNonLetter ? reg1 : reg2;

  // 遍历单词中的每个可能的 4 字符子串
  for (let i = 0; i <= word.length - 4; i++) {
    // 截取 4 字符子串
    const seg = word.substr(i, 4);

    // 如果子串包含非字母字符，跳过
    if (nonLetter.test(seg)) continue;

    // 如果子串匹配正则表达式，计数加 1
    if (reg.test(seg)) count++;
  }
});
  • 功能：
    • 遍历每个单词，检查其中是否包含满足条件的 4 字符子串。
  • 说明：
    • hasNonLetter：判断当前单词是否包含非字母字符。
    • reg：根据是否包含非字母字符，选择正则表达式。
    • substr(i, 4)：截取从位置 i 开始的 4 字符子串。
    • nonLetter.test(seg)：检查子串是否包含非字母字符。
    • reg.test(seg)：检查子串是否匹配正则表达式。
4. 返回结果
return count; // 返回满足条件的子串总数
  • 功能：
    • 返回满足条件的子串总数。

代码运行示例

示例 1：

输入：

hello world

输出：

1

解释：

  • 单词 hello 中的子串 hell 匹配模式 1。
  • 单词 world 中没有满足条件的子串。
  • 总计数为 1。
示例 2：

输入：

example test

输出：

2

解释：

  • 单词 example 中的子串 exam 和 xamp 匹配模式 1。
  • 单词 test 中没有满足条件的子串。
  • 总计数为 2。

总结

  1. 功能：

    • 统计单词中满足特定条件的 4 字符子串数量。
    • 条件由正则表达式定义。

  2. 优点：

    • 使用正则表达式，逻辑清晰。
    • 适用于处理字符串匹配问题。

  3. 适用场景：

    • 适用于需要统计特定模式子串的场景。

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

三、Java算法源码

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

Java 代码

import java.util.Scanner;
import java.util.regex.Pattern;

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

        // 读取一行输入，并按空格分割成单词数组
        String[] words = sc.nextLine().split(" ");

        // 调用算法函数并输出结果
        System.out.println(getResult(words));
    }

    // 算法函数：统计满足条件的子串数量
    public static int getResult(String[] words) {
        int count = 0; // 记录满足条件的子串数量

        // 定义正则表达式：
        // 1. 匹配非字母字符
        Pattern nonLetter = Pattern.compile("[^a-z]");
        // 2. 匹配满足条件的子串模式 1
        Pattern reg1 = Pattern.compile("[^aeiou][aeiou][^aeiour]e");
        // 3. 匹配满足条件的子串模式 2
        Pattern reg2 = Pattern.compile("e[^aeiour][aeiou][^aeiou]");

        // 遍历每个单词
        for (String word : words) {
            // 判断当前单词是否包含非字母字符
            boolean hasNonLetter = nonLetter.matcher(word).find();

            // 根据是否包含非字母字符，选择正则表达式
            Pattern reg = hasNonLetter ? reg1 : reg2;

            // 遍历单词中的每个可能的 4 字符子串
            for (int i = 0; i <= word.length() - 4; i++) {
                // 截取 4 字符子串
                String seg = word.substring(i, i + 4);

                // 如果子串包含非字母字符，跳过
                if (nonLetter.matcher(seg).find()) continue;

                // 如果子串匹配正则表达式，计数加 1
                if (reg.matcher(seg).find()) count++;
            }
        }

        // 返回满足条件的子串总数
        return count;
    }
}

详细讲解

1. 输入获取
Scanner sc = new Scanner(System.in); // 创建 Scanner 对象
String[] words = sc.nextLine().split(" "); // 读取一行输入，按空格分割成单词数组
  • 功能：
    • 使用 Scanner 从标准输入读取一行内容。
    • 将输入内容按空格分割成单词数组 words。
  • 说明：
    • sc.nextLine() 读取一行输入。
    • split(" ") 按空格分割字符串。
2. 正则表达式定义
Pattern nonLetter = Pattern.compile("[^a-z]"); // 匹配非字母字符
Pattern reg1 = Pattern.compile("[^aeiou][aeiou][^aeiour]e"); // 模式 1
Pattern reg2 = Pattern.compile("e[^aeiour][aeiou][^aeiou]"); // 模式 2
  • 功能：
    • nonLetter：匹配非字母字符（a-z 以外的字符）。
    • reg1：匹配满足条件的子串模式 1。
    • reg2：匹配满足条件的子串模式 2。
  • 说明：
    • [^a-z]：匹配非小写字母。
    • [^aeiou]：匹配非元音字母。
    • [aeiou]：匹配元音字母。
    • e：匹配字母 e。
3. 遍历单词
for (String word : words) {
    // 判断当前单词是否包含非字母字符
    boolean hasNonLetter = nonLetter.matcher(word).find();

    // 根据是否包含非字母字符，选择正则表达式
    Pattern reg = hasNonLetter ? reg1 : reg2;

    // 遍历单词中的每个可能的 4 字符子串
    for (int i = 0; i <= word.length() - 4; i++) {
        // 截取 4 字符子串
        String seg = word.substring(i, i + 4);

        // 如果子串包含非字母字符，跳过
        if (nonLetter.matcher(seg).find()) continue;

        // 如果子串匹配正则表达式，计数加 1
        if (reg.matcher(seg).find()) count++;
    }
}
  • 功能：
    • 遍历每个单词，检查其中是否包含满足条件的 4 字符子串。
  • 说明：
    • hasNonLetter：判断当前单词是否包含非字母字符。
    • reg：根据是否包含非字母字符，选择正则表达式。
    • substring(i, i + 4)：截取从位置 i 开始的 4 字符子串。
    • nonLetter.matcher(seg).find()：检查子串是否包含非字母字符。
    • reg.matcher(seg).find()：检查子串是否匹配正则表达式。
4. 返回结果
return count; // 返回满足条件的子串总数
  • 功能：
    • 返回满足条件的子串总数。

代码运行示例

示例 1：

输入：

hello world

输出：

1

解释：

  • 单词 hello 中的子串 hell 匹配模式 1。
  • 单词 world 中没有满足条件的子串。
  • 总计数为 1。
示例 2：

输入：

example test

输出：

2

解释：

  • 单词 example 中的子串 exam 和 xamp 匹配模式 1。
  • 单词 test 中没有满足条件的子串。
  • 总计数为 2。

总结

  1. 功能：

    • 统计单词中满足特定条件的 4 字符子串数量。
    • 条件由正则表达式定义。

  2. 优点：

    • 使用正则表达式，逻辑清晰。
    • 适用于处理字符串匹配问题。

  3. 适用场景：

    • 适用于需要统计特定模式子串的场景。

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

四、Python算法源码

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

Python 代码

# 输入获取
import re  # 导入正则表达式模块

# 读取一行输入，并按空格分割成单词列表
words = input().split()

# 算法入口
def getResult():
    count = 0  # 记录满足条件的子串数量

    # 定义正则表达式：
    # 1. 匹配非字母字符
    nonLetter = re.compile(r"[^a-z]")
    # 2. 匹配满足条件的子串模式 1
    reg1 = re.compile(r"[^aeiou][aeiou][^aeiour]e")
    # 3. 匹配满足条件的子串模式 2
    reg2 = re.compile(r"e[^aeiour][aeiou][^aeiou]")

    # 遍历每个单词
    for word in words:
        # 判断当前单词是否包含非字母字符
        hasNonLetter = nonLetter.search(word)

        # 根据是否包含非字母字符，选择正则表达式
        reg = reg1 if hasNonLetter else reg2

        # 遍历单词中的每个可能的 4 字符子串
        for i in range(len(word) - 3):
            # 截取 4 字符子串
            seg = word[i:i + 4]

            # 如果子串包含非字母字符，跳过
            if nonLetter.search(seg):
                continue

            # 如果子串匹配正则表达式，计数加 1
            if reg.match(seg):
                count += 1

    # 返回满足条件的子串总数
    return count

# 算法调用
print(getResult())

详细讲解

1. 输入获取
import re  # 导入正则表达式模块

# 读取一行输入，并按空格分割成单词列表
words = input().split()
  • 功能：
    • 使用 input() 从标准输入读取一行内容。
    • 使用 split() 按空格分割字符串，生成单词列表 words。
  • 说明：
    • input() 读取一行输入。
    • split() 默认按空格分割字符串。
2. 正则表达式定义
# 定义正则表达式：
# 1. 匹配非字母字符
nonLetter = re.compile(r"[^a-z]")
# 2. 匹配满足条件的子串模式 1
reg1 = re.compile(r"[^aeiou][aeiou][^aeiour]e")
# 3. 匹配满足条件的子串模式 2
reg2 = re.compile(r"e[^aeiour][aeiou][^aeiou]")
  • 功能：
    • nonLetter：匹配非字母字符（a-z 以外的字符）。
    • reg1：匹配满足条件的子串模式 1。
    • reg2：匹配满足条件的子串模式 2。
  • 说明：
    • [^a-z]：匹配非小写字母。
    • [^aeiou]：匹配非元音字母。
    • [aeiou]：匹配元音字母。
    • e：匹配字母 e。
3. 遍历单词
# 遍历每个单词
for word in words:
    # 判断当前单词是否包含非字母字符
    hasNonLetter = nonLetter.search(word)

    # 根据是否包含非字母字符，选择正则表达式
    reg = reg1 if hasNonLetter else reg2

    # 遍历单词中的每个可能的 4 字符子串
    for i in range(len(word) - 3):
        # 截取 4 字符子串
        seg = word[i:i + 4]

        # 如果子串包含非字母字符，跳过
        if nonLetter.search(seg):
            continue

        # 如果子串匹配正则表达式，计数加 1
        if reg.match(seg):
            count += 1
  • 功能：
    • 遍历每个单词，检查其中是否包含满足条件的 4 字符子串。
  • 说明：
    • hasNonLetter：判断当前单词是否包含非字母字符。
    • reg：根据是否包含非字母字符，选择正则表达式。
    • word[i:i + 4]：截取从位置 i 开始的 4 字符子串。
    • nonLetter.search(seg)：检查子串是否包含非字母字符。
    • reg.match(seg)：检查子串是否匹配正则表达式。
4. 返回结果
# 返回满足条件的子串总数
return count
  • 功能：
    • 返回满足条件的子串总数。
5. 算法调用
# 算法调用
print(getResult())
  • 功能：
    • 调用算法函数并输出结果。

代码运行示例

示例 1：

输入：

hello world

输出：

1

解释：

  • 单词 hello 中的子串 hell 匹配模式 1。
  • 单词 world 中没有满足条件的子串。
  • 总计数为 1。
示例 2：

输入：

example test

输出：

2

解释：

  • 单词 example 中的子串 exam 和 xamp 匹配模式 1。
  • 单词 test 中没有满足条件的子串。
  • 总计数为 2。

总结

  1. 功能：

    • 统计单词中满足特定条件的 4 字符子串数量。
    • 条件由正则表达式定义。

  2. 优点：

    • 使用正则表达式，逻辑清晰。
    • 适用于处理字符串匹配问题。

  3. 适用场景：

    • 适用于需要统计特定模式子串的场景。

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

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

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

C++ 代码

#include <iostream>
#include <string>
#include <vector>
#include <regex>

using namespace std;

// 算法函数：统计满足条件的子串数量
int getResult(vector<string>& words) {
    int count = 0; // 记录满足条件的子串数量

    // 定义正则表达式：
    // 1. 匹配非字母字符
    regex nonLetter("[^a-z]");
    // 2. 匹配满足条件的子串模式 1
    regex reg1("[^aeiou][aeiou][^aeiour]e");
    // 3. 匹配满足条件的子串模式 2
    regex reg2("e[^aeiour][aeiou][^aeiou]");

    // 遍历每个单词
    for (const string& word : words) {
        // 判断当前单词是否包含非字母字符
        bool hasNonLetter = regex_search(word, nonLetter);

        // 根据是否包含非字母字符，选择正则表达式
        regex reg = hasNonLetter ? reg1 : reg2;

        // 遍历单词中的每个可能的 4 字符子串
        for (int i = 0; i <= word.length() - 4; i++) {
            // 截取 4 字符子串
            string seg = word.substr(i, 4);

            // 如果子串包含非字母字符，跳过
            if (regex_search(seg, nonLetter)) continue;

            // 如果子串匹配正则表达式，计数加 1
            if (regex_match(seg, reg)) count++;
        }
    }

    // 返回满足条件的子串总数
    return count;
}

int main() {
    // 读取一行输入
    string input;
    getline(cin, input);

    // 将输入内容按空格分割成单词数组
    vector<string> words;
    size_t pos = 0;
    while ((pos = input.find(' ')) != string::npos) {
        words.push_back(input.substr(0, pos));
        input.erase(0, pos + 1);
    }
    words.push_back(input); // 添加最后一个单词

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

    return 0;
}

C 语言代码

#include <stdio.h>
#include <string.h>
#include <regex.h>

// 算法函数：统计满足条件的子串数量
int getResult(char words[][100], int wordCount) {
    int count = 0; // 记录满足条件的子串数量

    // 定义正则表达式：
    // 1. 匹配非字母字符
    regex_t nonLetter;
    regcomp(&nonLetter, "[^a-z]", REG_EXTENDED);
    // 2. 匹配满足条件的子串模式 1
    regex_t reg1;
    regcomp(&reg1, "[^aeiou][aeiou][^aeiour]e", REG_EXTENDED);
    // 3. 匹配满足条件的子串模式 2
    regex_t reg2;
    regcomp(&reg2, "e[^aeiour][aeiou][^aeiou]", REG_EXTENDED);

    // 遍历每个单词
    for (int i = 0; i < wordCount; i++) {
        char* word = words[i];

        // 判断当前单词是否包含非字母字符
        int hasNonLetter = regexec(&nonLetter, word, 0, NULL, 0) == 0;

        // 根据是否包含非字母字符，选择正则表达式
        regex_t* reg = hasNonLetter ? &reg1 : &reg2;

        // 遍历单词中的每个可能的 4 字符子串
        for (int j = 0; j <= strlen(word) - 4; j++) {
            char seg[5]; // 4 字符子串 + 1 个空字符
            strncpy(seg, word + j, 4);
            seg[4] = '\0'; // 添加字符串结束符

            // 如果子串包含非字母字符，跳过
            if (regexec(&nonLetter, seg, 0, NULL, 0) == 0) continue;

            // 如果子串匹配正则表达式，计数加 1
            if (regexec(reg, seg, 0, NULL, 0) == 0) count++;
        }
    }

    // 释放正则表达式资源
    regfree(&nonLetter);
    regfree(&reg1);
    regfree(&reg2);

    // 返回满足条件的子串总数
    return count;
}

int main() {
    // 读取一行输入
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = '\0'; // 去掉换行符

    // 将输入内容按空格分割成单词数组
    char words[100][100];
    int wordCount = 0;
    char* token = strtok(input, " ");
    while (token != NULL) {
        strcpy(words[wordCount++], token);
        token = strtok(NULL, " ");
    }

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

    return 0;
}

详细讲解

1. 输入获取

  • C++：

    string input;
getline(cin, input); // 读取一行输入
vector<string> words; // 存储单词
size_t pos = 0;
while ((pos = input.find(' ')) != string::npos) {
    words.push_back(input.substr(0, pos)); // 分割单词
    input.erase(0, pos + 1);
}
words.push_back(input); // 添加最后一个单词

  • C：

    char input[1000];
fgets(input, sizeof(input), stdin); // 读取一行输入
input[strcspn(input, "\n")] = '\0'; // 去掉换行符
char words[100][100]; // 存储单词
int wordCount = 0;
char* token = strtok(input, " "); // 分割单词
while (token != NULL) {
    strcpy(words[wordCount++], token);
    token = strtok(NULL, " ");
}

  • 功能：

    • 从标准输入读取一行内容。
    • 按空格分割成单词数组。
2. 正则表达式定义

  • C++：

    regex nonLetter("[^a-z]"); // 匹配非字母字符
regex reg1("[^aeiou][aeiou][^aeiour]e"); // 模式 1
regex reg2("e[^aeiour][aeiou][^aeiou]"); // 模式 2

  • C：

    regex_t nonLetter;
regcomp(&nonLetter, "[^a-z]", REG_EXTENDED); // 匹配非字母字符
regex_t reg1;
regcomp(&reg1, "[^aeiou][aeiou][^aeiour]e", REG_EXTENDED); // 模式 1
regex_t reg2;
regcomp(&reg2, "e[^aeiour][aeiou][^aeiou]", REG_EXTENDED); // 模式 2

  • 功能：

    • 定义正则表达式，用于匹配特定模式的子串。
3. 遍历单词

  • C++：

    for (const string& word : words) {
    bool hasNonLetter = regex_search(word, nonLetter); // 判断是否包含非字母字符
    regex reg = hasNonLetter ? reg1 : reg2; // 选择正则表达式
    for (int i = 0; i <= word.length() - 4; i++) {
        string seg = word.substr(i, 4); // 截取 4 字符子串
        if (regex_search(seg, nonLetter)) continue; // 跳过非字母字符
        if (regex_match(seg, reg)) count++; // 匹配正则表达式
    }
}

  • C：

    for (int i = 0; i < wordCount; i++) {
    char* word = words[i];
    int hasNonLetter = regexec(&nonLetter, word, 0, NULL, 0) == 0; // 判断是否包含非字母字符
    regex_t* reg = hasNonLetter ? &reg1 : &reg2; // 选择正则表达式
    for (int j = 0; j <= strlen(word) - 4; j++) {
        char seg[5];
        strncpy(seg, word + j, 4); // 截取 4 字符子串
        seg[4] = '\0';
        if (regexec(&nonLetter, seg, 0, NULL, 0) == 0) continue; // 跳过非字母字符
        if (regexec(reg, seg, 0, NULL, 0) == 0) count++; // 匹配正则表达式
    }
}

  • 功能：

    • 遍历每个单词，检查其中是否包含满足条件的 4 字符子串。
4. 返回结果

  • C++：

    return count; // 返回满足条件的子串总数

  • C：

    return count; // 返回满足条件的子串总数

  • 功能：

    • 返回满足条件的子串总数。

总结

  1. 功能：

    • 统计单词中满足特定条件的 4 字符子串数量。
    • 条件由正则表达式定义。

  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.kler.cn/a/507196.html

相关文章：

  • 如何攻击一个服务器（仅用于教育及娱乐实验目的）
  • LLMs之RAG：《EdgeRAG: Online-Indexed RAG for Edge Devices》翻译与解读
  • 【Git版本控制器--1】Git的基本操作--本地仓库
  • 【C语言】_求字符串长度函数strlen
  • Android面试题
  • 使用Newtonsoft.Json插件，打包至Windows平台显示不支持
  • java常用开发工具类
  • uniapp 自定义日历组件 源码
  • Spring Boot中的自动配置原理是什么
  • 2025智能网联汽车数据分类分级白皮书
  • redis(2:数据结构)
  • 【云岚到家】-day03-门户缓存方案选择
  • 策略模式详解与应用
  • npm : 无法加载文件 D:\phpdev\nodejs\npm.ps1
  • 【数模学习笔记】插值算法和拟合算法
  • springBoot项目使用Elasticsearch教程
  • docker hello world
  • leetcode 115. 不同的子序列
  • JWT在线解密/解码 - 加菲工具
  • 【人工智能】Python中的自动化机器学习（AutoML）：如何使用TPOT优化模型选择
  • 【MySQL实战】mysql_exporter+Prometheus+Grafana
  • 关于jwt和security
  • java day04-面向对象基础(内存 封装 继承 修饰符 工具类 )
  • 【Excel笔记_3】execl的单元格是#DIV/0!，判断如果是这个，则该单元格等于空
  • SAP -最简单smartforms打印保存到本地pdf方法
  • PostCSS安装与基本使用?