find the maximum number of words in a sentence from a paragraph with C++

Question

I am trying to find out the maximum number of words in a sentence (Separated by a dot) from a paragraph. and I am completely stuck into how to sort and output to stdout.

Eg: Given a string S: {"Program to split strings. By using custom split function. In C++"};

The expected output should be : 5

#define max 8 // define the max string  

string strings[max]; // define max string  
string words[max];
int count = 0;

 
void split (string str, char seperator)  // custom split() function 
{  
    int currIndex = 0, i = 0;  
    int startIndex = 0, endIndex = 0;  
    while (i <= str.size())  
    {  
        if (str[i] == seperator || i == str.size())  
        {  
            endIndex = i;  
            string subStr = "";  
            subStr.append(str, startIndex, endIndex - startIndex);  
            strings[currIndex] = subStr;  
            currIndex += 1;  
            startIndex = endIndex + 1;  
        }  
        i++;  
        }     
}  

void countWords(string str) // Count The words 
{
    int count = 0, i; 

    for (i = 0; str[i] != '\0';i++)
    {
        if (str[i] == ' ')
            count++;    
    }
 
    cout << "\n- Number of words in the string are: " << count +1 <<" -";
}

//Sort the array in descending order by the number of words
void sortByWordNumber(int num[30])
{
   /* CODE str::sort? std::*/
}

int main()  
{  
    string str = "Program to split strings. By using custom split function. In C++";  
    char seperator = '.'; // dot  
    int numberOfWords;
    
    split(str, seperator);  
    cout <<" The split string is: ";  
    for (int i = 0; i < max; i++)  
    {  
        cout << "\n initial array index: " << i << " " << strings[i];
        countWords(strings[i]);
        
    }  
    return 0;  
}  

Count + 1 in countWords() is giving the numbers correctly only on the first result then it adds the " " whitespace to the word count.

Please take into consideration answering with the easiest solution to understand first. (std::sort, making a new function, lambda)

Answer 1

JavaScript solution

var mostWordsFound = function(sentences) {
    let result = 0;

    sentences.forEach((item) => {
        length = item.split(' ').length
        result = result > length ? result : length;
    })

    return result;
};

Answer 2

Your code does not make a sense. For example the meaning of this declaration

string strings[max];

is unclear.

And to find the maximum number of words in sentences of a paragraph there is no need to sort the sentences themselves by the number of words.

If I have understood correctly what you need is something like the following.

#include <iostream>
#include <sstream>
#include <iterator>

int main() 
{
    std::string s;
    
    std::cout << "Enter a paragraph of sentences: ";
    
    std::getline( std::cin, s );
    
    size_t max_words = 0;
    
    std::istringstream is( s );
    std::string sentence;
    
    while ( std::getline( is, sentence, '.' ) )
    {
        std::istringstream iss( sentence );
    
        auto n = std::distance( std::istream_iterator<std::string>( iss ), 
                                std::istream_iterator<std::string>() );

        if ( max_words < n ) max_words = n;                             
    }
    
    std::cout << "The maximum number of words in sentences is " 
              << max_words <<  '\n';
    
    return 0;
}

If to enter the paragraph

Here is a paragraph. It contains several sentences. For example, how to use string streams.

then the output will be

The maximum number of words in sentences is 7

If you are not yet familiar with string streams then you could use member functions find, find_first_of, find_first_not_of with objects of the type std::string to split a string into sentences and to count words in a sentence.

Answer 3

vector<string> split(string str, char seperator)  // custom split() function
{
    size_t i = 0;
    size_t seperator_pos = 0;

    vector<string> sentences;
    int word_count = 0;


    for (; i < str.size(); i++)
    {
        if (str[i] == seperator)
        {
            i++;
            sentences.push_back(str.substr(seperator_pos, i - seperator_pos));
            seperator_pos = i;
        }
    }


    if (str[str.size() - 1] != seperator)
    {
        sentences.push_back(str.substr(seperator_pos + 1, str.size() - seperator_pos));
    }

    return sentences;
}

Answer 4

Your use case sounds like a reduction. Essentially you can have a state machine (parser) that goes through the string and updates some state (e.g. counters) when it encounters the word and sentence delimiters. Special care should be given for corner cases, e.g. when having continuous multiple white-spaces or >1 continous full stops (.). A reduction handling these cases is shown below:

int max_words_in(std::string const& str)
{
    // p is the current and max word count.
    auto parser = [in_space = false] (std::pair<int, int> p, char c) mutable {
        switch (c) {
        case '.': // Sentence ends.
            if (!in_space && p.second <= p.first) p.second = p.first + 1;
            p.first = 0;
            in_space = true;
            break;
        case ' ': // Word ends.
            if (!in_space) ++p.first;
            in_space = true;
            break;
        default: // Other character encountered.
            in_space = false;
        }
        return p; // Return the updated accumulation value.
    };

    return std::accumulate(
        str.begin(), str.end(), std::make_pair(0, 0), parser).second;
}

Demo

The tricky part is deciding how to handle degenerate cases, e.g. what should the output be for "This is a , ,tricky .. .. string to count" where different types of delimiters alternate in arbitrary ways. Having a state machine implementation of the parsing logic allows you to easily adjust your solution (e.g. you can pass an "ignore list" to the parser and update the default case to not reset the in_space variable when c belongs to that list).