在c++中删除字符串中的所有元音

cld4siwp  于 2023-06-25  发布在  其他
关注(0)|答案(4)|浏览(232)

我写了一段代码，可以从c++中删除字符串中的所有元音，但由于某种原因，它没有删除一个特定输入的元音'o'：zjuotps。
代码如下：

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. int main(){
  6.     string s;
  7.     cin >> s;
  9.     string a = "aeiouyAEIOUY";
  11.     for (int i = 0; i < s.length(); i++){
  12.         for(int j = 0; j < a.length(); j++){
  13.             if(s[i] == a[j]){
  14.                 s.erase(s.begin() + i);
  15.             }
  16.         }
  17.     }
  18.     cout << s;
  20.     return 0;
  21. }

当我输入：zjuotps
我得到的输出是：zjotps

c++

4条答案

按热度按时间
jmp7cifd

jmp7cifd1#

这是一种使用C++标准库的更简洁的方法：

  1. #include <algorithm>
  2. #include <iostream>
  3. #include <string>
  5. using namespace std;
  7. int main()
  8. {
  9.     std::string input = "zjuotps";
  10.     std::string vowels = "aeiouyAEIOUY";
  12.     auto predicate = [&vowels](char c) { return vowels.find(c) != std::string::npos; };
  13.     auto iterator = std::remove_if(input.begin(), input.end(), predicate);
  14.     input.erase(iterator, input.end());
  16.     cout << input << endl;
  17. }

编辑：

正如@RemyLebeau指出的，可以使用c++20中引入的std::erase_if，答案变成了一行代码：

  1. std::erase_if(input, [&vowels](char c) { return vowels.find(c) != std::string::npos; });
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
pxq42qpu

pxq42qpu2#

您可以通过将匹配字符添加到新的string对象来开发解决方案。如果input对象中的字符与remove对象中的字符不匹配，则eliminate()方法将字符写入result对象。

  1. #include <iostream>
  3. /**
  4.  * @brief This method scans the characters in the "input" object and writes
  5.  *        the characters not in the "remove" object to the "result" object.
  6.  * @param input This object contains the characters to be scanned.
  7.  * @param remove This object contains characters that will not match.
  8.  * @param result Non-match result data is writed to this object.
  9.  */
  10. void eliminate(std::string input, std::string remove, std::string &result);
  12. int main()
  13. {
  14.     std::string input = "zjuotpsUK", remove = "aeiouyAEIOUY", result;
  15.     eliminate(input, remove, result);
  16.     std::cout << result << std::endl;
  17.     return 0;
  18. }
  20. void eliminate(std::string input, std::string remove, std::string &result)
  21. {
  22.     for (size_t i = 0, j = 0; i < input.length(); i++)
  23.     {
  24.         for(j = 0; j < remove.length(); j++)
  25.             if(input[i] == remove[j])
  26.                 break;
  28.         if(j == remove.length())
  29.             result += input[i];
  30.     }
  31. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
7hiiyaii

7hiiyaii3#

在这里的代码中，为了可读性，我将s替换为input_str，将a替换为vowels：

  1. for (int i = 0; i < input_str.length(); i++){
  2.     for(int j = 0; j < vowels.length(); j++){
  3.         if(input_str[i] == vowels[j]){
  4.             input_str.erase(input_str.begin() + i);
  5.         }
  6.     }
  7. }

上述代码的问题在于，每次删除输入字符串中的字符时，都应该跳出元音j循环，并在输入字符串中 * 相同的i位置 * 重新开始，再次检查j循环中的所有元音。这是因为擦除一个字符会左移所有位于右侧的字符，这意味着同一个i位置现在将包含一个新的字符进行检查，因为它只是从一个位置左移到该位置。错误地允许i递增意味着您跳过该新字符以检查相同的i位置，从而在字符串中留下第二个元音（例如，如果两个元音在一行中）。下面是对问题中的直接代码的修复：

  1. int i = 0;
  2. while (i < s.length()){
  3.     bool char_is_a_vowel = false;
  4.     for(int j = 0; j < a.length(); j++){
  5.         if(s[i] == a[j]){
  6.             char_is_a_vowel = true;
  7.             break; // exit j loop
  8.         }
  9.     }
  10.     if (char_is_a_vowel){
  11.         s.erase(s.begin() + i);
  12.         continue; // Do NOT increment i below! Skip that.
  13.     }
  14.     i++;
  15. }

但是，还有许多其他更好的方法可以做到这一点。我会在下面介绍一些。我个人认为this most-upvoted code difficult to read。它需要额外的研究和查找的东西做这么简单的事情。所以，我将展示一些替代方法来回答这个问题。

方法1：复制非元音字符到新字符串：

所以，这里有一个替代的，简单的，更可读的方法，你只需扫描输入字符串中的所有字符，检查字符是否在元音字符串中，如果不是，你将其复制到输出字符串，因为它不是元音：
只是算法：

  1. std::string output_str;
  2. for (const char c : input_str) {
  3.     if (vowels.find(c) == std::string::npos) {
  4.         output_str.push_back(c);
  5.     }
  6. }

完整的可运行示例：

  1. #include <iostream>  // For `std::cin`, `std::cout`, `std::endl`, etc.
  2. #include <string>
  4. int main()
  5. {
  6.     std::string input_str = "zjuotps";
  7.     std::string vowels = "aeiouyAEIOUY";
  9.     std::string output_str;
  10.     for (const char c : input_str)
  11.     {
  12.         if (vowels.find(c) == std::string::npos)
  13.         {
  14.             // char `c` is NOT in the `vowels` string, so append it to the 
  15.             // output string
  16.             output_str.push_back(c);
  17.         }
  18.     }
  20.     std::cout << "input_str  = " << input_str << std::endl;
  21.     std::cout << "output_str = " << output_str << std::endl;
  22. }

输出：

  1. input_str  = zjuotps
  2. output_str = zjtps

方法2：删除输入字符串中的元音字符：

或者，您可以像最初尝试的那样就地删除元音字符。但是，如果字符被擦除，你不能增加输入字符串的索引i，因为擦除元音字符会左移字符串中剩余的字符，这意味着我们需要在下一次迭代中再次检查 * 相同的 * 索引位置，以便读取下一个字符。请参阅下面评论中的注解。
只是算法：

  1. size_t i = 0;
  2. while (i < input_str.length()) {
  3.     char c = input_str[i];
  4.     if (vowels.find(c) != std::string::npos) {
  5.         input_str.erase(input_str.begin() + i);
  6.         continue;
  7.     }
  8.     i++;
  9. }

完整的可运行示例：

  1. #include <iostream>  // For `std::cin`, `std::cout`, `std::endl`, etc.
  2. #include <string>
  4. int main()
  5. {
  6.     std::string input_str = "zjuotps";
  7.     std::string vowels = "aeiouyAEIOUY";
  9.     std::cout << "BEFORE: input_str = " << input_str << std::endl;
  11.     size_t i = 0;
  12.     while (i < input_str.length())
  13.     {
  14.         char c = input_str[i];
  15.         if (vowels.find(c) != std::string::npos)
  16.         {
  17.             // char `c` IS in the `vowels` string, so remove it from the
  18.             // `input_str`
  19.             input_str.erase(input_str.begin() + i);
  20.             // do NOT increment `i` here since erasing the vowel char above just
  21.             // left-shifted the remaining chars in the string, meaning that we
  22.             // need to check the *same* index location again the next
  23.             // iteration!
  24.             continue;
  25.         }
  26.         i++;
  27.     }
  29.     std::cout << "AFTER:  input_str = " << input_str << std::endl;
  30. }

输出：

  1. BEFORE: input_str = zjuotps
  2. AFTER:  input_str = zjtps

方法三：高速C型阵列：就地修改输入字符串

我借用了我之前回答的“方法1”的方法：在C中删除数组元素
如果你曾经处于需要高速的情况下，我敢打赌这可能是最快的方法之一。它使用C风格的字符串（char数组）。它扫描输入字符串，检测任何元音。如果它看到一个不是元音的char，它会将它复制到输入字符串的最左边，从而就地修改字符串，过滤掉所有元音。完成后，它将在新位置中空终止输入字符串。如果你最后需要一个C++ std::string类型，我在完成后从C字符串创建一个。
只是算法：

  1. size_t i_write = 0;
  2. for (size_t i_read = 0; i_read < ARRAY_LEN(input_str); i_read++) {
  3.     bool char_is_a_vowel = false;
  4.     for (size_t j = 0; j < ARRAY_LEN(input_str); j++) {
  5.         if (input_str[i_read] == vowels[j]) {
  6.             char_is_a_vowel = true;
  7.             break;
  8.         }
  9.     }
  10.     if (!char_is_a_vowel) {
  11.         input_str[i_write] = input_str[i_read];
  12.         i_write++;
  13.     }
  14. }
  15. input_str[i_write] = '\n';

完整的可运行示例：

  1. #include <iostream>  // For `std::cin`, `std::cout`, `std::endl`, etc.
  2. #include <string>
  4. /// Get the number of elements in an array
  5. #define ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
  7. int main()
  8. {
  9.     char input_str[] = "zjuotps";
  10.     char vowels[] = "aeiouyAEIOUY";
  12.     std::cout << "BEFORE: input_str = " << input_str << std::endl;
  14.     // Iterate over all chars in the input string
  15.     size_t i_write = 0;
  16.     for (size_t i_read = 0; i_read < ARRAY_LEN(input_str); i_read++)
  17.     {
  18.         // Iterate over all chars in the vowels string. Only retain in the input
  19.         // string (copying chars into the left side of the input string) all
  20.         // chars which are NOT vowels!
  21.         bool char_is_a_vowel = false;
  22.         for (size_t j = 0; j < ARRAY_LEN(input_str); j++)
  23.         {
  24.             if (input_str[i_read] == vowels[j])
  25.             {
  26.                 char_is_a_vowel = true;
  27.                 break;
  28.             }
  29.         }
  30.         if (!char_is_a_vowel)
  31.         {
  32.             input_str[i_write] = input_str[i_read];
  33.             i_write++;
  34.         }
  35.     }
  36.     // null-terminate the input string at its new end location; the number of
  37.     // chars in it (its new length) is now equal to `i_write`!
  38.     input_str[i_write] = '\n';
  40.     std::cout << "AFTER:  input_str = " << input_str << std::endl;
  41.     // Just in case you need it back in this form now:
  42.     std::string str(input_str);
  43.     std::cout << "          C++ str = " << str << std::endl;
  44. }

输出：

  1. BEFORE: input_str = zjuotps
  2. AFTER:  input_str = zjtps
  3.           C++ str = zjtps

另请参阅：

1.[C语言中类似的答案]从数组中删除元素

展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
js5cn81o

js5cn81o4#

试试这个简单的方法

  1. #include <iostream>
  2. #include<string>
  3. using namespace std;
  5. int main()
  6. {
  7.     string L;
  8.     
  9.     std::cout << "Enter the string" << std::endl;
  10.     std::cin >> L;
  11.     for(int i=0;L[i];i++){
  12.         if(L[i]=='i' || L[i]=='a' || L[i]=='e' || L[i]=='o' || L[i]=='u' || L[i]=='A' || L[i]=='E' || L[i]=='I' || L[i]=='O' || L[i]=='U'){
  13.             L[i]='\0'; //replacing with null
  14.         }
  15.      
  16.     }
  17.     std::cout << L << std::endl;
  18.     return 0;
  19. }

我可以看到这有点混乱，裸着我。空值用于终止字符串。对于常规的C风格字符串，空值意味着“结束”，但C字符串是类std：：string的示例，该类是C标准库的一部分。Std：：string可以包含空字符。

所以std：：string可以在其中包含嵌入的空字符，但C- string不能这样做，因为它在第一个空字符处结束。

展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com