Open In App

Program to find Smallest and Largest Word in a String

Last Updated : 17 Dec, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given a string, find the minimum and the maximum length words in it. 

Examples: 

Input : "This is a test string"
Output : Minimum length word: a
Maximum length word: string
Input : "GeeksforGeeks A computer Science portal for Geeks"
Output : Minimum length word: A
Maximum length word: GeeksforGeeks

Method 1: The idea is to keep a starting index si and an ending index ei

  • si points to the starting of a new word and we traverse the string using ei.
  • Whenever a space or ‘\0’ character is encountered,we compute the length of the current word using (ei – si) and compare it with the minimum and the maximum length so far. 
    • If it is less, update the min_length and the min_start_index( which points to the starting of the minimum length word).
    • If it is greater, update the max_length and the max_start_index( which points to the starting of the maximum length word).
  • Finally, update minWord and maxWord which are output strings that have been sent by reference with the substrings starting at min_start_index and max_start_index of length min_length and max_length respectively.

Below is the implementation of the above approach:

C++




// 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;
}


Java




// Java Program to find Smallest and
// Largest Word in a String
import java.io.*;
class GFG
{
 
    static String minWord = "", maxWord = "";
 
    static void minMaxLengthWords(String input)
    {
          input=input.trim();//Triming any space before the String else space at start would be consider as smallest word     
        // 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.charAt(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.substring(min_start_index, min_start_index + min_length);
        maxWord = input.substring(max_start_index, max_start_index+max_length);//Earlier  code was not working if the largests word is inbetween String
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String a = "GeeksforGeeks A Computer Science portal for Geeks";
 
        minMaxLengthWords(a);
 
        // to take input in string use getline(cin, a);
        System.out.print("Minimum length word: "
                + minWord
                + "\nMaximum length word: "
                + maxWord);
    }
}
 
// This code contributed by Rajput-Ji


Python 3




# Python3 program to find Smallest and
# Largest Word in a String
 
# defining the method to find the longest
# word and the shortest word
def minMaxLengthWords(inp):
    length = len(inp)
    si = ei = 0
    min_length = length
    min_start_index = max_length = max_start_index = 0
     
    # loop to find the length and stating index
    # of both longest and shortest words
    while ei <= length:
        if (ei < length) and (inp[ei] != " "):
            ei += 1
        else:
            curr_length = ei - si
             
            # condition checking for the shortest word
            if curr_length < min_length:
                min_length = curr_length
                min_start_index = si
                 
            # condition for the longest word
            if curr_length > max_length:
                max_length = curr_length
                max_start_index = si
            ei += 1
            si = ei
             
    # extracting the shortest word using
    # it's starting index and length    
    minWord = inp[min_start_index :
                  min_start_index + min_length]
     
    # extracting the longest word using
    # it's starting index and length    
    maxWord = inp[max_start_index : max_length]
     
    # printing the final result
    print("Minimum length word: ", minWord)
    print ("Maximum length word: ", maxWord)
     
# Driver Code
 
# Using this string to test our code
a = "GeeksforGeeks A Computer Science portal for Geeks"
minMaxLengthWords(a)
 
# This code is contributed by Animesh_Gupta


C#




// C# Program to find Smallest and
// Largest Word in a String
using System;
 
class GFG
{
 
    static String minWord = "", maxWord = "";
 
    static void minMaxLengthWords(String input)
    {
        // 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.Substring(min_start_index, min_length);
        maxWord = input.Substring(max_start_index, max_length);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        String a = "GeeksforGeeks A Computer Science portal for Geeks";
 
        minMaxLengthWords(a);
 
        // to take input in string use getline(cin, a);
        Console.Write("Minimum length word: "
                + minWord
                + "\nMaximum length word: "
                + maxWord);
    }
}
 
// This code has been contributed by 29AjayKumar


Javascript




<script>
 
// JavaScript Program to find Smallest and
// Largest Word in a String
 
let minWord = "";
let maxWord = "";
 
function minMaxLengthWords(input)
{
    // minWord and maxWord are received by reference
    // and not by value
    // will be used to store and return output
    let len = input.length;
    let si = 0, ei = 0;
    let min_length = len;
    let min_start_index = 0;
    let max_length = 0;
    let 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
            let 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.substring(min_start_index,min_start_index + min_length);
     
    maxWord =
    input.substring(max_start_index, max_length);
     
}
 
// Driver code
 
let a = "GeeksforGeeks A Computer Science portal for Geeks";
 
minMaxLengthWords(a);
 
// to take input in string use getline(cin, a);
document.write("Minimum length word: "
        + minWord+"<br>"
        + "Maximum length word:  "
        + maxWord);
 
</script>


Output

Minimum length word: A
Maximum length word: GeeksforGeeks


Time Complexity: O(n), where n is the length of string.
Auxiliary Space: O(n), where n is the length of string. This is because when string is passed in the function it creates a copy of itself in stack.

Method 2: By Using Regular Expressions

In this approach we uses regular expressions to find words in a given input string and iterates through them. It keeps track of the smallest and largest words based on their lengths and prints them.

  • First, Define a regular expression pattern to match words.
  • Then, Create iterators to search for words within the input string.
  • Initialize variables to store the smallest and largest words.
  • Iterate through the words in the string.
  • Check if the current word is smaller than the smallest word.
  • Check if the current word is larger than the largest word .
  • At the end ,print the smallest and largest words.

C++




#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


Java




import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class SmallestLargestWords {
    // Function to find the smallest and largest words in a string using regular expressions
    public static void findSmallestLargestWordsRegex(String input) {
        // Define a regular expression pattern to match words
        String wordRegex = "\\b\\w+\\b";
        Pattern pattern = Pattern.compile(wordRegex);
        Matcher matcher = pattern.matcher(input);
 
        // Initialize variables to store the smallest and largest words
        String smallestWord = "";
        String largestWord = "";
 
        // Iterate through the words in the string
        while (matcher.find()) {
            String word = matcher.group();
 
            // Check if the current word is smaller than the smallest word found so far
            if (word.length() < smallestWord.length() || smallestWord.isEmpty()) {
                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
        System.out.println("Minimum length word: " + smallestWord);
        System.out.println("Maximum length word: " + largestWord);
    }
 
    public static void main(String[] args) {
        // Input string
        String input = "This is a test string";
 
        // Call the function to find and display the smallest and largest words
        findSmallestLargestWordsRegex(input);
    }
}
// Siddhesh


Python3




import re
 
# Function to find the smallest and largest words in a string using regular expressions
def find_smallest_largest_words_regex(input_str):
    # Define a regular expression pattern to match words
    word_regex = r'\b\w+\b'
    words = re.findall(word_regex, input_str)
 
    # Initialize variables to store the smallest and largest words
    smallest_word = ""
    largest_word = ""
 
    # Iterate through the words in the string
    for word in words:
        # Check if the current word is smaller than the smallest word found so far
        if len(word) < len(smallest_word) or not smallest_word:
            smallest_word = word
 
        # Check if the current word is larger than the largest word found so far
        if len(word) > len(largest_word):
            largest_word = word
 
    # Print the smallest and largest words
    print("Minimum length word:", smallest_word)
    print("Maximum length word:", largest_word)
 
# Input string
input_str = "This is a test string"
 
# Call the function to find and display the smallest and largest words
find_smallest_largest_words_regex(input_str)
 
# Siddhesh


C#




using System;
using System.Text.RegularExpressions;
 
class Program
{
    // Function to find the smallest and largest words in a string using regular expressions
    static void FindSmallestLargestWordsRegex(string input)
    {
        // Define a regular expression pattern to match words
        string wordPattern = @"\b\w+\b";
 
        // Use Regex.Matches to get a collection of words
        MatchCollection words = Regex.Matches(input, wordPattern);
 
        // Initialize variables to store the smallest and largest words
        string smallestWord = null, largestWord = null;
 
        // Iterate through the words in the collection
        foreach (Match match in words)
        {
            string word = match.Value;
 
            // Check if the current word is smaller than the smallest word found so far
            if (string.IsNullOrEmpty(smallestWord) || word.Length < smallestWord.Length)
            {
                smallestWord = word;
            }
 
            // Check if the current word is larger than the largest word found so far
            if (string.IsNullOrEmpty(largestWord) || word.Length > largestWord.Length)
            {
                largestWord = word;
            }
        }
 
        // Print the smallest and largest words
        Console.WriteLine("Minimum length word: " + smallestWord);
        Console.WriteLine("Maximum length word: " + largestWord);
    }
 
    static void Main()
    {
        // Input string
        string input = "This is a test string";
 
        // Call the function to find and display the smallest and largest words
        FindSmallestLargestWordsRegex(input);
    }
}
 
// This code is contributed by shivamgupta310570


Javascript




// Function to find the smallest and largest words in a string using regular expressions
function findSmallestLargestWordsRegex(input) {
    // Define a regular expression pattern to match words
    const wordRegex = /\b\w+\b/g;
 
    // Create an array of words by matching the regular expression
    const words = input.match(wordRegex) || [];
 
    // Initialize variables to store the smallest and largest words
    let smallestWord = '', largestWord = '';
 
    // Iterate through the words in the array
    for (const word of words) {
        // Check if the current word is smaller than the smallest word found so far
        if (word.length < smallestWord.length || smallestWord.length === 0) {
            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
    console.log("Minimum length word:", smallestWord);
    console.log("Maximum length word:", largestWord);
}
 
// Input string
const input = "This is a test string";
 
// Call the function to find and display the smallest and largest words
findSmallestLargestWordsRegex(input);
 
// This code is contributed by shivamgupta0987654321


Output

Minimum length word: a

Maximum length word: string

Time complexity is O(n), n is length of string

Space complexity is O(m), m is the length of the longest word.



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads