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

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++完整代码如下：

  

  

   


 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 
 
 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; 
 
 
      
 return 
 0 
 ; 
 
 
 } 
 
 
 

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。