2026-04-25：反转元音数相同的单词。用go语言，给定一个由小写英文单词组成的字符串，各单词之间用单空格分隔。先统计第一个单词里出现

福大大架构师每日一题

发布于 2026-04-28 19:35:42

100

文章被收录于专栏：福大大架构师每日一题福大大架构师每日一题

2026-04-25：反转元音数相同的单词。用go语言，给定一个由小写英文单词组成的字符串，各单词之间用单空格分隔。

先统计第一个单词里出现的元音字母数量（元音为 a/e/i/o/u）。记这个数量为 k。

然后从第二个单词开始逐个处理：如果某个单词的元音数量也等于 k，就把该单词反转字母顺序；否则保持该单词不变。

最后把所有单词按原有顺序重新用空格拼接，输出结果字符串。

1 <= s.length <= 100000。

s 仅由小写的英文字母和空格组成。

s 中的单词由单个空格隔开。

s 不包含前导或尾随空格。

输入： s = "cat and mice"。

输出： "cat dna mice"。

解释：

第一个单词 "cat" 包含 1 个元音字母。

"and" 包含 1 个元音字母，因此将其反转为 "dna"。

"mice" 包含 2 个元音字母，因此保持不变。

最终结果字符串为 "cat dna mice"。

题目来自力扣3775。

代码执行过程详细分步描述

第一步：定义元音统计函数（countVowel）

这是一个辅助函数，作用是统计一个字符串中元音字母（a/e/i/o/u）的总个数：

1. 遍历字符串里的每一个字符；
2. 逐个判断字符是否是元音字母；
3. 每找到一个元音字母，计数加1；
4. 遍历完成后，返回最终的元音计数结果。

第二步：执行核心逻辑函数（reverseWords）

子步骤1：拆分字符串为单词数组

代码将输入的完整字符串按单个空格切割，把连续的字符串拆分成独立的单词列表：

• 输入："cat and mice"
• 切割后得到单词数组：["cat", "and", "mice"]

子步骤2：统计第一个单词的元音数（确定k值）

1. 取出单词数组的第一个单词：cat；
2. 调用元音统计函数计算元音数：
- • 字符c：非元音；
- • 字符a：元音，计数+1；
- • 字符t：非元音；
3. 最终第一个单词元音数 k = 1，并把这个值固定下来。

子步骤3：遍历处理第二个及之后的所有单词

从第二个单词开始（数组下标为1），逐个判断、处理：

1. 处理第二个单词：and
- • 调用函数统计元音数：a是元音，n/d非元音，元音数=1；
- • 判断：元音数（1）等于k（1），满足反转条件；
- • 执行反转操作：将单词and的字母顺序颠倒，变成dna；
- • 用反转后的单词替换原单词，数组变为：["cat", "dna", "mice"]。
2. 处理第三个单词：mice
- • 调用函数统计元音数：i和e是元音，元音数=2；
- • 判断：元音数（2）不等于k（1），不满足反转条件；
- • 保持原单词不变，数组仍为：["cat", "dna", "mice"]。

子步骤4：拼接单词数组为完整字符串

将处理后的单词数组，按单个空格重新拼接成一个完整字符串：

• 拼接结果：cat dna mice。

第三步：主函数输出结果

1. 定义输入字符串 s = "cat and mice"；
2. 调用核心处理函数得到结果；
3. 打印输出最终结果：cat dna mice。

时间复杂度与额外空间复杂度分析

1. 总时间复杂度

时间复杂度描述代码执行的总操作次数与输入数据规模的关系：

1. 字符串拆分、拼接：操作次数与字符串总长度n成正比，复杂度为 O(n)；
2. 元音统计：遍历整个字符串的所有字符一次，复杂度为 O(n)；
3. 单词反转：仅反转符合条件的单词，总操作次数不超过字符串总长度n，复杂度为 O(n)；

所有步骤都是线性操作，总时间复杂度为 O(n)（n 为输入字符串的总长度）。

2. 总额外空间复杂度

额外空间复杂度描述代码执行过程中，除了输入和输出外，额外占用的内存空间：

1. 代码需要创建单词数组存储所有单词，空间大小与字符串长度n成正比；
2. 反转单词时需要创建临时字节切片，空间大小不超过单词总长度；
3. 所有临时变量的空间占用均为线性级别；

总额外空间复杂度为 O(n)（n 为输入字符串的总长度）。

总结

1. 执行流程：拆分字符串→统计首单词元音数→遍历判断并反转符合条件的单词→拼接字符串→输出结果；
2. 时间复杂度：O(n)，处理效率高，可满足题目中最长10万字符的输入要求；
3. 额外空间复杂度：O(n)，需要线性空间存储单词和临时数据。

Go完整代码如下：

package main

import (
    "fmt"
    "slices"
    "strings"
)

func countVowel(s string) (vowel int) {
    for _, c := range s {
        if strings.IndexRune("aeiou", c) >= 0 {
            vowel++
        }
    }
    return
}

func reverseWords(s string)string {
    a := strings.Split(s, " ")
    cnt0 := countVowel(a[0])
    for i := 1; i < len(a); i++ {
        if countVowel(a[i]) == cnt0 {
            t := []byte(a[i])
            slices.Reverse(t)
            a[i] = string(t)
        }
    }
    return strings.Join(a, " ")
}

func main() {
    s := "cat and mice"
    result := reverseWords(s)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def count_vowel(s: str) -> int:
    """Count vowels in a string"""
    vowel = 0
    for c in s:
        if c in "aeiou":
            vowel += 1
    return vowel

def reverse_words(s: str) -> str:
    """Reverse words that have the same vowel count as the first word"""
    words = s.split(" ")
    cnt0 = count_vowel(words[0])
    
    for i in range(1, len(words)):
        if count_vowel(words[i]) == cnt0:
            # Reverse the word
            words[i] = words[i][::-1]
    
    return" ".join(words)

def main():
    s = "cat and mice"
    result = reverse_words(s)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>

int countVowel(const std::string& s) {
    int vowel = 0;
    std::string vowels = "aeiou";
    for (char c : s) {
        if (vowels.find(c) != std::string::npos) {
            vowel++;
        }
    }
    return vowel;
}

std::string reverseWords(const std::string& s) {
    // Split string into words
    std::vector<std::string> words;
    std::stringstream ss(s);
    std::string word;

    while (ss >> word) {
        words.push_back(word);
    }

    if (words.empty()) {
        return"";
    }

    int cnt0 = countVowel(words[0]);

    for (size_t i = 1; i < words.size(); i++) {
        if (countVowel(words[i]) == cnt0) {
            // Reverse the word
            std::reverse(words[i].begin(), words[i].end());
        }
    }

    // Join the words back
    std::string result;
    for (size_t i = 0; i < words.size(); i++) {
        if (i > 0) {
            result += " ";
        }
        result += words[i];
    }

    return result;
}

int main() {
    std::string s = "cat and mice";
    std::string result = reverseWords(s);
    std::cout << result << std::endl;
    return0;
}