【2024年华为OD机试】(C卷,100分)- 单词加密（Java JS PythonC/C++）

一、问题描述

题目描述

1. 输入一个英文句子，句子中包含若干个单词，每个单词间有一个空格。
2. 需要将句子中的每个单词按照要求加密输出。

要求：

1. 单词中包括元音字符（‘aeuio’、‘AEUIO’，大小写都算），则将元音字符替换成‘*’。
2. 单词中不包括元音字符，将单词首尾字符进行对换。

输入描述

输入只有一行，包含一个长度都不超过100的字符串，表示英文句子。

输出描述

输出只有一行，即按要求输出加密处理后的英文句子。

用例

用例 1

输入:

Hello world

输出:

H*ll* w*rld

解题思路

1. 分割句子：

   • 使用 split(' ') 方法将句子按空格分割成单词数组。

2. 处理每个单词：

   • 遍历单词数组，对每个单词进行处理。
   • 检查单词中是否包含元音字符（‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘A’, ‘E’, ‘I’, ‘O’, ‘U’）。
   • 如果包含元音字符，将所有元音字符替换成 ‘*’。
   • 如果不包含元音字符，将单词的首尾字符对换。

3. 拼接结果：

   • 使用 join(' ') 方法将处理后的单词数组重新拼接成一个字符串。

详细步骤

1. 读取输入：

   • 从标准输入读取一个字符串，表示英文句子。

2. 分割句子：

   • 使用 split(' ') 方法将句子按空格分割成单词数组。

3. 处理每个单词：

   • 遍历单词数组，对每个单词进行处理。
   • 使用正则表达式 /[aeiouAEIOU]/ 检查单词中是否包含元音字符。
   • 如果包含元音字符，使用 replace 方法将所有元音字符替换成 ‘*’。
   • 如果不包含元音字符，将单词的首尾字符对换。

4. 拼接结果：

   • 使用 join(' ') 方法将处理后的单词数组重新拼接成一个字符串。

5. 输出结果：

   • 输出处理后的字符串。

用例解释

用例 1

• 输入：
  • Hello world
• 输出：
  • H*ll* w*rld

解释：

• 单词 Hello 包含元音字符 e 和 o，将它们替换成 *，得到 H*ll*。
• 单词 world 包含元音字符 o，将它替换成 *，得到 w*rld。

通过上述步骤，我们可以高效地对句子中的每个单词进行加密处理，确保结果符合要求。这种方法的时间复杂度主要由字符串操作决定，为 O(n)，其中 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) => {
  // 调用算法函数并输出结果
  console.log(getResult(line));
});

// 算法函数
function getResult(s) {
  // 将输入字符串按空格分隔成单词数组
  const words = s.split(" ");

  // 遍历每个单词
  for (let i = 0; i < words.length; i++) {
    // 检查当前单词是否包含元音字母（a, e, i, o, u，不区分大小写）
    if (/[aeiouAEIOU]/.test(words[i])) {
      // 如果包含元音字母，将所有元音字母替换为 "*"
      words[i] = words[i].replaceAll(/[aeiouAEIOU]/g, "*");
    } else {
      // 如果不包含元音字母，交换单词的首尾字母
      const arr = [...words[i]]; // 将单词拆分为字符数组

      // 交换首尾字母
      const tmp = arr[0];
      arr[0] = arr[arr.length - 1];
      arr[arr.length - 1] = tmp;

      // 将字符数组重新组合成单词
      words[i] = arr.join("");
    }
  }

  // 将处理后的单词数组用空格拼接成字符串并返回
  return words.join(" ");
}

代码逻辑讲解

1. 输入处理

• 使用 readline 模块读取控制台输入。
• 监听 line 事件，当用户输入一行内容时触发。

2. 算法逻辑

• 将输入字符串按空格分隔成单词数组 words。
• 遍历每个单词：
  • 如果单词包含元音字母（a, e, i, o, u，不区分大小写），将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 将处理后的单词数组用空格拼接成字符串并返回。

代码细节解析

1. readline 模块

• 用于读取控制台输入。
• rl.on("line", (line) => { ... })：监听输入事件，line 是用户输入的内容。

2. 字符串分割

• s.split(" ")：将输入字符串按空格分隔成单词数组。

3. 正则表达式

• /[aeiouAEIOU]/.test(words[i])：检查当前单词是否包含元音字母。
• replaceAll(/[aeiouAEIOU]/g, "*")：将所有元音字母替换为 *。

4. 字符数组操作

• [...words[i]]：将单词拆分为字符数组。
• 交换首尾字母：
  • 使用临时变量 tmp 存储首字母。
  • 将尾字母赋值给首字母位置。
  • 将 tmp 赋值给尾字母位置。

5. 字符串拼接

• arr.join("")：将字符数组重新组合成单词。
• words.join(" ")：将单词数组用空格拼接成字符串。

示例运行

输入

hello world code

步骤解析

1. 输入字符串按空格分隔成数组：
   • words = ["hello", "world", "code"]
2. 遍历每个单词：
   • hello 包含元音字母 e 和 o，替换为 h*ll*。
   • world 不包含元音字母，交换首尾字母为 dorlw。
   • code 包含元音字母 o 和 e，替换为 c*d*。
3. 处理后的单词数组：
   • ["h*ll*", "dorlw", "c*d*"]
4. 拼接成字符串：
   • "h*ll* dorlw c*d*"
5. 输出结果：h*ll* dorlw c*d*

总结

• 功能：对输入字符串中的每个单词进行处理：
  • 如果单词包含元音字母，将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 适用场景：字符串处理和字符替换问题。
• 注意事项：
  • 如果输入为空，结果为空字符串。
  • 如果单词长度为 1，交换首尾字母后结果不变。

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

三、Java算法源码

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

Java 代码

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

public class Main {
  public static void main(String[] args) {
    // 创建 Scanner 对象，用于读取控制台输入
    Scanner sc = new Scanner(System.in);
    // 读取一行输入
    String s = sc.nextLine();
    // 调用算法函数并输出结果
    System.out.println(getResult(s));
  }

  // 算法函数
  public static String getResult(String s) {
    // 将输入字符串按空格分隔成单词数组
    String[] words = s.split(" ");

    // 遍历每个单词
    for (int i = 0; i < words.length; i++) {
      // 使用正则表达式匹配元音字母（a, e, i, o, u，不区分大小写）
      Matcher matcher = Pattern.compile("[aeiouAEIOU]").matcher(words[i]);

      // 如果单词中包含元音字母
      if (matcher.find()) {
        // 将所有元音字母替换为 "*"
        words[i] = matcher.replaceAll("*");
      } else {
        // 如果单词中不包含元音字母，交换单词的首尾字母
        char[] cArr = words[i].toCharArray(); // 将单词转换为字符数组

        // 交换首尾字母
        char tmp = cArr[0];
        cArr[0] = cArr[cArr.length - 1];
        cArr[cArr.length - 1] = tmp;

        // 将字符数组重新组合成单词
        words[i] = new String(cArr);
      }
    }

    // 将处理后的单词数组用空格拼接成字符串并返回
    return String.join(" ", words);
  }
}

代码逻辑讲解

1. 输入处理

• 使用 Scanner 类读取控制台输入。
• 调用 sc.nextLine() 读取一行输入。

2. 算法逻辑

• 将输入字符串按空格分隔成单词数组 words。
• 遍历每个单词：
  • 如果单词包含元音字母（a, e, i, o, u，不区分大小写），将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 将处理后的单词数组用空格拼接成字符串并返回。

代码细节解析

1. Scanner 类

• 用于读取控制台输入。
• sc.nextLine()：读取一行输入。

2. 字符串分割

• s.split(" ")：将输入字符串按空格分隔成单词数组。

3. 正则表达式

• Pattern.compile("[aeiouAEIOU]")：编译正则表达式，匹配元音字母。
• matcher.find()：检查单词中是否包含元音字母。
• matcher.replaceAll("*")：将所有元音字母替换为 *。

4. 字符数组操作

• words[i].toCharArray()：将单词转换为字符数组。
• 交换首尾字母：
  • 使用临时变量 tmp 存储首字母。
  • 将尾字母赋值给首字母位置。
  • 将 tmp 赋值给尾字母位置。
• new String(cArr)：将字符数组重新组合成单词。

5. 字符串拼接

• String.join(" ", words)：将单词数组用空格拼接成字符串。

示例运行

输入

hello world code

步骤解析

1. 输入字符串按空格分隔成数组：
   • words = ["hello", "world", "code"]
2. 遍历每个单词：
   • hello 包含元音字母 e 和 o，替换为 h*ll*。
   • world 不包含元音字母，交换首尾字母为 dorlw。
   • code 包含元音字母 o 和 e，替换为 c*d*。
3. 处理后的单词数组：
   • ["h*ll*", "dorlw", "c*d*"]
4. 拼接成字符串：
   • "h*ll* dorlw c*d*"
5. 输出结果：h*ll* dorlw c*d*

总结

• 功能：对输入字符串中的每个单词进行处理：
  • 如果单词包含元音字母，将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 适用场景：字符串处理和字符替换问题。
• 注意事项：
  • 如果输入为空，结果为空字符串。
  • 如果单词长度为 1，交换首尾字母后结果不变。

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

四、Python算法源码

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

Python 代码

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

# 输入获取
s = input()  # 从控制台读取一行输入

# 算法入口
def getResult():
    # 将输入字符串按空格分隔成单词列表
    words = s.split()

    # 定义正则表达式，匹配元音字母（a, e, i, o, u，不区分大小写）
    letter = "[aeiouAEIOU]"

    # 遍历每个单词
    for i in range(len(words)):
        # 检查当前单词是否包含元音字母
        if re.search(letter, words[i]):
            # 如果包含元音字母，将所有元音字母替换为 "*"
            words[i] = re.sub(letter, "*", words[i])
        else:
            # 如果不包含元音字母，交换单词的首尾字母
            lst = list(words[i])  # 将单词转换为字符列表
            lst[0], lst[-1] = lst[-1], lst[0]  # 交换首尾字母
            words[i] = "".join(lst)  # 将字符列表重新组合成单词

    # 将处理后的单词列表用空格拼接成字符串并返回
    return " ".join(words)

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

代码逻辑讲解

1. 输入处理

• 使用 input() 函数读取控制台输入。

2. 算法逻辑

• 将输入字符串按空格分隔成单词列表 words。
• 遍历每个单词：
  • 如果单词包含元音字母（a, e, i, o, u，不区分大小写），将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 将处理后的单词列表用空格拼接成字符串并返回。

代码细节解析

1. 字符串分割

• s.split()：将输入字符串按空格分隔成单词列表。

2. 正则表达式

• re.search(letter, words[i])：检查当前单词是否包含元音字母。
• re.sub(letter, "*", words[i])：将所有元音字母替换为 *。

3. 字符列表操作

• list(words[i])：将单词转换为字符列表。
• lst[0], lst[-1] = lst[-1], lst[0]：交换首尾字母。
• "".join(lst)：将字符列表重新组合成单词。

4. 字符串拼接

• " ".join(words)：将单词列表用空格拼接成字符串。

示例运行

输入

hello world code

步骤解析

1. 输入字符串按空格分隔成列表：
   • words = ["hello", "world", "code"]
2. 遍历每个单词：
   • hello 包含元音字母 e 和 o，替换为 h*ll*。
   • world 不包含元音字母，交换首尾字母为 dorlw。
   • code 包含元音字母 o 和 e，替换为 c*d*。
3. 处理后的单词列表：
   • ["h*ll*", "dorlw", "c*d*"]
4. 拼接成字符串：
   • "h*ll* dorlw c*d*"
5. 输出结果：h*ll* dorlw c*d*

总结

• 功能：对输入字符串中的每个单词进行处理：
  • 如果单词包含元音字母，将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 适用场景：字符串处理和字符替换问题。
• 注意事项：
  • 如果输入为空，结果为空字符串。
  • 如果单词长度为 1，交换首尾字母后结果不变。

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

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

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

C++ 代码

#include <iostream>
#include <string>
#include <vector>
#include <regex>  // 正则表达式库

using namespace std;

// 算法入口
string getResult(string s) {
    // 将输入字符串按空格分隔成单词列表
    vector<string> words;
    string word;
    for (char ch : s) {
        if (ch == ' ') {
            words.push_back(word);  // 将当前单词加入列表
            word = "";  // 清空当前单词
        } else {
            word += ch;  // 拼接字符形成单词
        }
    }
    words.push_back(word);  // 添加最后一个单词

    // 定义正则表达式，匹配元音字母（a, e, i, o, u，不区分大小写）
    regex letter("[aeiouAEIOU]");

    // 遍历每个单词
    for (int i = 0; i < words.size(); i++) {
        // 检查当前单词是否包含元音字母
        if (regex_search(words[i], letter)) {
            // 如果包含元音字母，将所有元音字母替换为 "*"
            words[i] = regex_replace(words[i], letter, "*");
        } else {
            // 如果不包含元音字母，交换单词的首尾字母
            if (words[i].length() > 1) {  // 确保单词长度大于1
                swap(words[i][0], words[i][words[i].length() - 1]);  // 交换首尾字母
            }
        }
    }

    // 将处理后的单词列表用空格拼接成字符串并返回
    string result;
    for (int i = 0; i < words.size(); i++) {
        result += words[i];
        if (i != words.size() - 1) {
            result += " ";  // 添加空格分隔单词
        }
    }
    return result;
}

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

    // 算法调用
    cout << getResult(s) << endl;  // 输出结果

    return 0;
}

代码逻辑讲解

1. 输入处理

• 使用 getline(cin, s) 读取一行输入。

2. 算法逻辑

• 将输入字符串按空格分隔成单词列表 words。
• 遍历每个单词：
  • 如果单词包含元音字母（a, e, i, o, u，不区分大小写），将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 将处理后的单词列表用空格拼接成字符串并返回。

代码细节解析

1. 字符串分割

• 使用循环遍历输入字符串，按空格分隔成单词列表 words。

2. 正则表达式

• regex letter("[aeiouAEIOU]")：定义正则表达式，匹配元音字母。
• regex_search(words[i], letter)：检查当前单词是否包含元音字母。
• regex_replace(words[i], letter, "*")：将所有元音字母替换为 *。

3. 字符交换

• swap(words[i][0], words[i][words[i].length() - 1])：交换单词的首尾字母。

4. 字符串拼接

• 使用循环将处理后的单词列表用空格拼接成字符串。

示例运行

输入

hello world code

步骤解析

1. 输入字符串按空格分隔成列表：
   • words = ["hello", "world", "code"]
2. 遍历每个单词：
   • hello 包含元音字母 e 和 o，替换为 h*ll*。
   • world 不包含元音字母，交换首尾字母为 dorlw。
   • code 包含元音字母 o 和 e，替换为 c*d*。
3. 处理后的单词列表：
   • ["h*ll*", "dorlw", "c*d*"]
4. 拼接成字符串：
   • "h*ll* dorlw c*d*"
5. 输出结果：h*ll* dorlw c*d*

总结

• 功能：对输入字符串中的每个单词进行处理：
  • 如果单词包含元音字母，将所有元音字母替换为 *。
  • 如果单词不包含元音字母，交换单词的首尾字母。
• 适用场景：字符串处理和字符替换问题。
• 注意事项：
  • 如果输入为空，结果为空字符串。
  • 如果单词长度为 1，交换首尾字母后结果不变。

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