Program to find Smallest and Largest Word in a String

// CPP Program to find Smallest and 
// Largest Word in a String
#include<iostream>
#include<cstring>
using namespace std;

void minMaxLengthWords(string input, string &minWord, string &maxWord) 
{
    // minWord and maxWord are received by reference 
    // and not by value
    // will be used to store and return output
    int len = input.length();
    int si = 0, ei = 0;
  
  
    int min_length = len, min_start_index = 0, max_length = 0, max_start_index = 0;

    // Loop while input string is not empty
    while (ei <= len) 
    {
        if (ei < len && input[ei] != ' ')
            ei++;
        
        else 
        {
            // end of a word
            // find curr word length
            int curr_length = ei - si;
        
            if (curr_length < min_length) 
            {
                min_length = curr_length;
                min_start_index = si;
            }
            
            if (curr_length > max_length)
            {
                max_length = curr_length;
                max_start_index = si;
            }
            ei++;
            si = ei;
        }
    }
    
    // store minimum and maximum length words
    minWord = input.substr(min_start_index, min_length);
    maxWord = input.substr(max_start_index, max_length); 
}

// Driver code
int main() 
{
    string a = "GeeksforGeeks A Computer Science portal for Geeks";
    string minWord, maxWord;
    minMaxLengthWords(a, minWord, maxWord);
    
    // to take input in string use getline(cin, a);
    cout << "Minimum length word: "
        << minWord << endl
        << "Maximum length word: "
        << maxWord << endl;
} 

#include <iostream>
#include <string>
#include <regex>
#include <iterator>

// Function to find the smallest and largest words in a string using regular expressions
void findSmallestLargestWordsRegex(const std::string& input) {
    // Define a regular expression pattern to match words
    std::regex wordRegex("\\b\\w+\\b");

    // Create iterators to search for words within the input string
    std::sregex_iterator wordsBegin(input.begin(), input.end(), wordRegex);
    std::sregex_iterator wordsEnd;

    // Initialize variables to store the smallest and largest words
    std::string smallestWord, largestWord;

    // Iterate through the words in the string
    for (std::sregex_iterator it = wordsBegin; it != wordsEnd; ++it) {
        std::smatch match = *it;
        std::string word = match.str();

        // Check if the current word is smaller than the smallest word found so far
        if (word.length() < smallestWord.length() || smallestWord.empty()) {
            smallestWord = word;
        }

        // Check if the current word is larger than the largest word found so far
        if (word.length() > largestWord.length()) {
            largestWord = word;
        }
    }

    // Print the smallest and largest words
    std::cout << "Minimum length word: " << smallestWord << std::endl;
    std::cout << "Maximum length word: " << largestWord << std::endl;
}

int main() {
    // Input string
    std::string input = "This is a test string";

    // Call the function to find and display the smallest and largest words
    findSmallestLargestWordsRegex(input);

    return 0;
}
// Siddhesh 

// CPP program to find Smallest and Largest Word in a String
// using stack
#include <bits/stdc++.h>
using namespace std;

pair<string, string> smallestAndLargestWord(string& str)
{
    // Pair to store the smallest and largest words
    pair<string, string> stringPair;
    // Stack to temporarily store characters of a word
    stack<char> stk;
    int n = str.size();
    // Variables to store the smallest and largest words
    string minWord = "";
    string maxWord = "";
    // Temporary variable to store each word
    string temp = "";

    // Loop through the characters of the string
    for (int i = 0; i < n; i++) {
        if (str[i] != ' ') {
            // Push characters onto the stack until a space
            // is encountered
            stk.push(str[i]);
        }
        else {
            // When a space is encountered, extract the word
            // from the stack
            while (!stk.empty()) {
                temp += stk.top();
                stk.pop();
            }

            // Compare the length of the current word with
            // the smallest and largest words found so far
            if (minWord == ""
                || temp.size() < minWord.size()) {
                minWord = temp;
            }

            if (maxWord == ""
                || temp.size() > maxWord.size()) {
                maxWord = temp;
            }

            // Reset the temporary variable for the next
            // word
            temp = "";
        }
    }

    // Extract the last word from the stack
    while (!stk.empty()) {
        temp += stk.top();
        stk.pop();
    }

    // Compare the length of the last word with the smallest
    // and largest words found so far
    if (minWord == "" || temp.size() < minWord.size()) {
        minWord = temp;
    }

    if (maxWord == "" || temp.size() > maxWord.size()) {
        maxWord = temp;
    }

    // Reverse both the strings as stack reverses them
    // already
    reverse(minWord.begin(), minWord.end());
    reverse(maxWord.begin(), maxWord.end());

    // Store the smallest and largest words in the pair
    stringPair.first = minWord;
    stringPair.second = maxWord;

    return stringPair;
}

int main()
{
    string str = "GeeksforGeeks A computer Science portal "
                 "for Geeks";
    // Call the function to find the smallest and largest
    // words
    pair<string, string> stringPair
        = smallestAndLargestWord(str);
    // Print the results
    cout << "Minimum length word: " << stringPair.first
         << endl;
    cout << "Maximum length word: " << stringPair.second
         << endl;

    return 0;
}