Question

编写一个c ++程序，查找字符串中使用的元音数量。

对于上述问题，我编写了如下程序：

int main()
{   
    char x[10];
    int n,i,s=0;
    cout<<"Enter any string\n";
    cin>>x;
    n=strlen(x);
    for(i=0;i<n;++i)
    {
        if(x[i]=='a'||x[i]=='e'||x[i]=='i'||x[i]=='o'||x[i]=='u')
        {
            s=s+1;
       }
    }
    cout<<s;
    return 0;
}

该计划的输出如下：

输入任何字符串
elephant
3

这里的'elephant'在三个地方使用了元音，但使用的元音总数是2（e和a）而不是3

我要求改进程序，以便计算元音的总数并打印总数。（例如，如果是象，必须给出2）

Answer 1

创建另一个数组（），带有5个索引，如

 vowels[5] = array(0,0,0,0,0);

然后使用eache元音制作if else，并添加

 if(x[i] == 'a') vowels[0] =1;
 elseIf(x[i] == 'e') vowels[1] =1;

等，然后检查元音数组是否设置为1或0，并且仅计数，这些是5。

int count=0;
foreach vowels as item {
  if(item == 1) count++

}
return count;

Answer 2

最简单的解决方案是插入您看到的每个元音进入std::set，并在您使用时使用size函数完成。

为了天堂的缘故，使用表格查找来确定是否某事是元音（并将逻辑放在一个单独的函数中，所以当你需要处理“有时y”时你可以纠正它一部分）。

或者，不使用标准算法：

int charCount[UCHAR_MAX + 1];

//  and for each character:

++ charCount[static_cast<unsigned char>( ch )];

（当然，如果你使用C ++，你会读到这些字符进入std::string，并迭代，而不是几乎可以保证缓冲区溢出。）

然后，只需查看表格中的每个元音，并计算那些计数非零的人：

int results = 0;
std::string vowels( "aeiou" );  //  Handling the sometimes "y" is left as an exercise for the reader.
for ( auto current = vowels.begin(); current != vowels.end(); ++ current ) {
    if ( charCount[static_cast<unsigned char>( *current )] != 0 ) {
        ++ results;
    }
}

当然，这些都不是天真地实施的大小写正确（“E”和“e”相同元音）;使用tolower( static_cast<unsigned char>( ch ) )会解决这个问题。

编辑：

由于其他人提出解决方案（仅部分解决方案）正确的）：

bool
isVowel( unsigned char ch )
{
    static std::set<int> const vowels{ 'a', 'e', 'i', 'o', 'u' };
    return vowels.find( tolower( ch ) ) != vowels.end();
}

int
main()
{
    std::string text;
    std::cout << "Enter any word:";
    std::cin >> text;
    std::set<unsigned char> vowelsPresent;
    for ( unsigned char ch: text ) {
        if ( isVowel( ch ) ) {
            vowelsPresent.insert( tolower( ch ) );
        }
    }
    std::cout << vowelsPresent.size() << std::endl;
}

将元音的定义分成单独的函数是在编写良好的代码中实际上是必不可少的至少，您需要掩盖案例中的差异。（这个代码也是关于“y”问题的解决方案，这将使isVowel成为几个数量级更难。它也忽略了人物在基本字符集之外，"naïve"将报告两个不同的元音。）

Answer 3

设置已经消除重复，因此不要在遇到元音时计算元音，而是将它们添加到集合中。然后，最后，通过查询该组的大小来计算[非重复]元音的数量。

#include <set>
#include <string>
#include <iostream>

int main()
{   
    std::string x;
    int n = 0;
    std::set<char> vowels;

    std::cout << "Enter any string\n";
    std::cin >> x;
    n = x.size();

    for (int i = 0; i < n; ++i)
        if (x[i] == 'a' || x[i] == 'e' || x[i] == 'i' || x[i] == 'o' || x[i] == 'u')
           vowels.insert(x[i]);

    std::cout << vowels.size() <<'\n';
}

Live demo

g ++ - 4.8 -std = c ++ 11 -O2 -Wall -pedantic -pthread main.cpp＆amp;＆amp;回声“大象”| ./a.out
  输入任何字符串
  2

请注意，我还使用std::string交换了对固定大小数组的使用，这样当有人输入超过9个字符时，您就不会有危险情况。

Answer 4

我发现使用map <char, int>解决此问题的一种非常简单的方法。这将允许您制作成对，由char索引，即。元音，并将整数计数器连接到它们。

#include <iostream>
#include <map>
#include <string>

using namespace std;

int main()
{
    map <char, int> vowels;
    int n,i,s=0;
    string x;
    cout<<"Enter any string\n";
    cin>>x;
    for(i=0;i< x.length();++i)
    {
        if(x[i]=='a'||x[i]=='e'||x[i]=='i'||x[i]=='o'||x[i]=='u')
        {
            vowels[x[i]]++;
       }
    }

    for (map<char,int>::const_iterator print = vowels.begin(); print != vowels.end(); ++print){
        cout << print -> first << " " << print -> second << endl;
    }
    return 0;
}

对于字符串elephant，我们将得到以下输出：

a 1
e 2

通过说vowels[x[i]]++;我们将找到的元音添加到我们的地图中，如果它尚未添加，并将其配对的int增加一个。因此，当我们找到第一个e时，它会将e添加到我们的地图中，并将其计数器增加1。然后它将继续，直到它找到下一个e，并且会看到它已经有索引，所以它只是将计数器增加到2.这样我们就可以避免重复的问题了。当然，如果你想得到一个数字，我们就可以打印出地图的大小：

cout << vowels.size() << endl;

Answer 5

好。轮到我了。为了处理大写和小写，我们将转换为更低的：

std::string x("Elephant");
std::transform(x.begin(), x.end(), x.begin(), std::function<int(char)>(std::tolower));

现在删除重复项：

std::sort(x.begin(), x.end());
std::unique(x.begin(), x.end());

现在计算元音。我希望在某个地方有特定的东西，但是唉......没关系，我们可以自己创造。有点复杂，但不过分：

struct vowel : public std::ctype<char>
{
    static const mask* make_table()
    {
        static std::vector<mask> v(classic_table(), classic_table() + table_size);
        v['a'] |= upper;
        v['e'] |= upper;
        // etc.
        return &v[0];
    }
    vowel(std::size_t refs = 0) : ctype(make_table(), false, refs){}
};

虽然我确信你可以创建自己的，但不能完全弄清楚如何通过cppreference上的文档，所以我说小写元音是大写的。随着之前对std :: tolower的调用，这应该是安全的。

有了这个，我们可以很容易地使用它：

int i = std::count_if(x.begin(), x.end(), [](const char c)
{ 
    return std::isupper(c, std::locale(std::locale(""), new vowel)); 
});

std::cout << "Number of vowels:" << i << std::endl;

但是我对这两个std::locale彼此不是特别满意。

Answer 6

我能想到的最简单的解决方案是代表每个元音的一系列bool，以及它们是否已被计算在内。

bool vowelCounted[5] = { false };

现在，当你计算元音时：

if (x[i]=='a' && !vowelCounted[0]) {
    vowelCounted[0] = true;
    s += 1;
} else if (x[i]=='e' && !vowelCounted[1]) {
    vowelCounted[1] = true;
    s += 1;
}

只需对所有5个元音重复此结构。

使用enum而非0，1，2，3，4作为索引，可以提高可读性...但你正在使用名为x[]和s的变量，所以它可能很好......

Answer 7

如果你使用其中一个标准容器（vector，list）在那里添加元音，请执行与现在相同的检查，如果存在则将其删除。当你完成获得剩余元素的数量时，你的答案将是元音的原始数量减去其余元素。

Answer 8

你可以创建：

std::vector< char> vowels;

并且在迭代字符串时将你遇到的所有元音都加入其中：

if(x[i]=='a'||x[i]=='e'||x[i]=='i'||x[i]=='o'||x[i]=='u')
                                               vowels.push_back( x[i]);

然后你可以对此进行排序并消除重复：

std::sort( vowels.begin(), vowels.end());
std::vector< char> vowels_unique( vowels.size());
std::vector< char>::iterator it;
it = std::unique_copy( vowels.begin(), vowels.end(), vowels_unique.begin());
vowels_unique.resize( std::distance( vowels_unique.begin(), it));

更好的是，使用set属性 - 它包含唯一数据，如下所示：

std::set< char> unique_vowels;
if(x[i]=='a'||x[i]=='e'||x[i]=='i'||x[i]=='o'||x[i]=='u')
                                               unique_vowels.insert( x[i]);
//...
int unique = unique_vowels.size();

Answer 9

试试这个

for( string text; getline( cin, text ) && text != "q"; )
{
    set< char > vowels;
    copy_if( begin(text), end(text), inserter( vowels, begin(vowels) ), 
        []( char c ) { return std::char_traits< char >::find( "aeiou", 5, c ) != nullptr; } );
    cout << "the string [" << text << "] contains " << vowels.size() << " vowels" << endl;
}

您需要包含字符串，iostream，set，algorithm和iterator。你想对上面的“AEIOU”做什么？

Answer 10

C ++代码段：

#include <bits/stdc++.h>
using namespace std;


int main()
{
    char s[100];
    int cnt;

    cnt=0;
    cin>>s;
    for(int i=0;s[i];i++)
    {
      char c =s[i];
      if(s[i]=='A' || s[i] =='E' || s[i]=='I' ||s[i]=='O'|| s[i]=='U')   cnt++;
      else if(s[i]=='a' || s[i] =='e' || s[i]=='i'||s[i]=='o' || s[i]=='u')  cnt++;
    }
    cout<<cnt<<endl;

    return 0;
}

Answer 11

使用std::find()和std::transform()的版本：

#include <string>
#include <iostream>
#include <algorithm>

using std::string;
using std::cout;
using std::cin;
using std::getline;
using std::transform;

int main()
{
    cout << " Type sentence: ";
    string sentence;
    getline(cin, sentence);
    transform(sentence.begin(), sentence.end(), sentence.begin(), toupper);

    string vowels = "AEIOU";
    size_t vowCount = 0;
    for (int i = 0; i < vowels.length(); ++i)
    {
        if (sentence.find(vowels[i], 0) != string::npos)
        {
            ++vowCount;
        }
    }

    cout << "There is " << vowCount << " vowels in the sentence.\n";

    return 0;
}

<强>赞成

std::find()仅搜索给定元音的第一次次出现，因此对给定字符串的其余部分没有迭代
使用std

<强> CONS

std::transform()转换每个小写字母，无论其是什么＆＃34; vowelness＆＃34;

Answer 12

#include<iostream>   //std::cout
#include<string>     //std::string
#include<cctype>     //tolower()
#include<algorithm>  //std::for_each

using namespace std;

int main()

{

    string s;
    getline(cin, s);
    int count = 0;
    for_each(s.begin(), s.end(), [&count](char & c) //use of lambda func
    {
        c = tolower(c); //you can count upper and lower vowels
        switch (c)
        {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                count++;
                break;
        }
    });
    cout << count << endl;

    return 0;

}

Answer 13

#include<iostream>
using namespace std;
int main()
{
char vowels[5] = {'a','e','i','o','u'};
char x[8] = {'e','l','e','p','h','a','n','t'};
int counts[5] = {0,0,0,0,0};
int i,j;

for(i=0;i<8;i=i+1)
{
    for(j=0;j<5;j=j+1)
    {
        if(x[i]==vowels[j])
        {
            counts[j] = counts[j] + 1;
        }
    }
}
for(i=0;i<5;i=i+1)
{
    cout<<counts[i]<<endl;
}
return 0;
}

由于我使用的是'elephant'的例子所以我刚刚初始化了它。

如果仍然可以进行任何修改，请编辑它并使其更加用户友好。

编写一个c ++程序，查找字符串中使用的元音数量

13 个答案:

Live demo

C ++代码段：