# Lexicographically smallest K-length substring containing maximum number of vowels

• Difficulty Level : Medium
• Last Updated : 12 May, 2022

Given string str containing only the lowercase English alphabet and an integer K, the task is to find a K length substring that contains the maximum number of vowels (i.e. ‘a’, ‘e’, ‘i’, ‘o’, ‘u’). If there are multiple such substrings, return the substring which is lexicographically smallest.

Examples:

Input: str = “geeksforgeeks”, K = 4
Output: eeks
Explanation:
The substrings with the maximum count of vowels are “geek”, “eeks” which includes 2 vowels. But “eeks” is lexicographically smallest.
Input: str = “ceebbaceeffo”, K = 3
Output: ace
Explanation:
Lexicographically, substrings with the maximum count of vowels are “ace”.

Naive Approach:
To solve the problem mentioned above, we have to generate all the substrings of length K and store the lexicographically smallest of all such substrings which contain the maximum number of vowels.
Time Complexity: O(N2)

Efficient Approach:
The above-mentioned procedure can be optimized by creating a prefix sum array pref[] of vowels where the ith index contains the count of vowels from 0 to the ith index. The count of vowels for any substring str[l : r] can be given by pref[r]-pref[l-1]. Then, find the lexicographically smallest substring with the maximum count of vowels.
Below is the implementation of the above approach:

## C++

 `// C++ program to find``// lexicographically smallest``// K-length substring containing``// maximum number of vowels` `#include ``using` `namespace` `std;` `// Function that prints the``// lexicographically smallest``// K-length substring containing``// maximum number of vowels``string maxVowelSubString(``    ``string str, ``int` `K)``{``    ``// Store the length of the string``    ``int` `N = str.length();` `    ``// Initialize a prefix sum array``    ``int` `pref[N];` `    ``// Loop through the string to``    ``// create the prefix sum array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Store 1 at the index``        ``// if it is a vowel``        ``if` `(str[i] == ``'a'``            ``or str[i] == ``'e'``            ``or str[i] == ``'i'``            ``or str[i] == ``'o'``            ``or str[i] == ``'u'``)``            ``pref[i] = 1;` `        ``// Otherwise, store 0``        ``else``            ``pref[i] = 0;` `        ``// Process the prefix array``        ``if` `(i)``            ``pref[i] += pref[i - 1];``    ``}` `    ``// Initialize the variable to store``    ``// maximum count of vowels``    ``int` `maxCount = pref[K - 1];` `    ``// Initialize the variable``    ``// to store substring``    ``// with maximum count of vowels``    ``string res = str.substr(0, K);` `    ``// Loop through the prefix array``    ``for` `(``int` `i = K; i < N; i++) {` `        ``// Store the current``        ``// count of vowels``        ``int` `currCount``            ``= pref[i]``              ``- pref[i - K];` `        ``// Update the result if current count``        ``// is greater than maximum count``        ``if` `(currCount > maxCount) {` `            ``maxCount = currCount;``            ``res = str.substr(i - K + 1, K);``        ``}` `        ``// Update lexicographically smallest``        ``// substring if the current count``        ``// is equal to the maximum count``        ``else` `if` `(currCount == maxCount) {` `            ``string temp``                ``= str.substr(``                    ``i - K + 1, K);` `            ``if` `(temp < res)``                ``res = temp;``        ``}``    ``}` `    ``// Return the result``    ``return` `res;``}` `// Driver Program``int` `main()``{``    ``string str = ``"ceebbaceeffo"``;``    ``int` `K = 3;` `    ``cout << maxVowelSubString(str, K);` `    ``return` `0;``}`

## Java

 `// Java program to find``// lexicographically smallest``// K-length substring containing``// maximum number of vowels``class` `GFG{` `// Function that prints the``// lexicographically smallest``// K-length substring containing``// maximum number of vowels``static` `String maxVowelSubString(String str,``                                ``int` `K)``{``  ``// Store the length of the string``  ``int` `N = str.length();` `  ``// Initialize a prefix sum array``  ``int` `[]pref = ``new` `int``[N];` `  ``// Loop through the string to``  ``// create the prefix sum array``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``// Store 1 at the index``    ``// if it is a vowel``    ``if` `(str.charAt(i) == ``'a'` `||``        ``str.charAt(i) == ``'e'` `||``        ``str.charAt(i) == ``'i'` `||``        ``str.charAt(i) == ``'o'` `||``        ``str.charAt(i) == ``'u'``)``      ``pref[i] = ``1``;` `    ``// Otherwise, store 0``    ``else``      ``pref[i] = ``0``;` `    ``// Process the prefix array``    ``if` `(i != ``0``)``      ``pref[i] += pref[i - ``1``];``  ``}` `  ``// Initialize the variable to store``  ``// maximum count of vowels``  ``int` `maxCount = pref[K - ``1``];` `  ``// Initialize the variable``  ``// to store substring``  ``// with maximum count of vowels``  ``String res = str.substring(``0``, K);` `  ``// Loop through the prefix array``  ``for` `(``int` `i = K; i < N; i++)``  ``{``    ``// Store the current``    ``// count of vowels``    ``int` `currCount = pref[i] -``                    ``pref[i - K];` `    ``// Update the result if current count``    ``// is greater than maximum count``    ``if` `(currCount > maxCount)``    ``{``      ``maxCount = currCount;``      ``res = str.substring(i - K + ``1``,``                          ``i + ``1``);``    ``}` `    ``// Update lexicographically smallest``    ``// substring if the current count``    ``// is equal to the maximum count``    ``else` `if` `(currCount == maxCount)``    ``{``      ``String temp = str.substring(i - K + ``1``,``                                  ``i + ``1``);` `      ``if` `(temp.compareTo(res) < ``0``)``        ``res = temp;``    ``}``  ``}` `  ``// Return the result``  ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String []args)``{``  ``String str = ``"ceebbaceeffo"``;``  ``int` `K = ``3``;``  ``System.out.print(maxVowelSubString(str, K));``}``}` `// This code is contributed by Chitranayal`

## Python3

 `# Python3 program to find``# lexicographically smallest``# K-length substring containing``# maximum number of vowels` `# Function that prints the``# lexicographically smallest``# K-length substring containing``# maximum number of vowels``def` `maxVowelSubString(str1, K):``    ` `    ``# Store the length of the string``    ``N ``=` `len``(str1)` `    ``# Initialize a prefix sum array``    ``pref ``=` `[``0` `for` `i ``in` `range``(N)]` `    ``# Loop through the string to``    ``# create the prefix sum array``    ``for` `i ``in` `range``(N):``        ` `        ``# Store 1 at the index``        ``# if it is a vowel``        ``if` `(str1[i] ``=``=` `'a'` `or``            ``str1[i] ``=``=` `'e'` `or``            ``str1[i] ``=``=` `'i'` `or``            ``str1[i] ``=``=` `'o'` `or``            ``str1[i] ``=``=` `'u'``):``            ``pref[i] ``=` `1` `        ``# Otherwise, store 0``        ``else``:``            ``pref[i] ``=` `0` `        ``# Process the prefix array``        ``if` `(i):``            ``pref[i] ``+``=` `pref[i ``-` `1``]` `    ``# Initialize the variable to``    ``# store maximum count of vowels``    ``maxCount ``=` `pref[K ``-` `1``]` `    ``# Initialize the variable``    ``# to store substring with``    ``# maximum count of vowels``    ``res ``=` `str1[``0``:K]` `    ``# Loop through the prefix array``    ``for` `i ``in` `range``(K, N):``        ` `        ``# Store the current``        ``# count of vowels``        ``currCount ``=` `pref[i] ``-` `pref[i ``-` `K]` `        ``# Update the result if current count``        ``# is greater than maximum count``        ``if` `(currCount > maxCount):``            ``maxCount ``=` `currCount``            ``res ``=` `str1[i ``-` `K ``+` `1` `: i ``+` `1``]` `        ``# Update lexicographically smallest``        ``# substring if the current count``        ``# is equal to the maximum count``        ``elif` `(currCount ``=``=` `maxCount):``            ``temp ``=` `str1[i ``-` `K ``+` `1` `: i ``+` `1``]` `            ``if` `(temp < res):``                ``res ``=` `temp` `    ``# Return the result``    ``return` `res` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``str1 ``=` `"ceebbaceeffo"``    ``K ``=` `3` `    ``print``(maxVowelSubString(str1, K))` `# This code is contributed by Surendra_Gangwar`

## C#

 `// C# program to find``// lexicographically smallest``// K-length substring containing``// maximum number of vowels``using` `System;``class` `GFG{` `// Function that prints the``// lexicographically smallest``// K-length substring containing``// maximum number of vowels``static` `string` `maxVowelSubString(``string` `str,``                                ``int` `K)``{``    ``// Store the length of the string``    ``int` `N = str.Length;` `    ``// Initialize a prefix sum array``    ``int` `[]pref = ``new` `int``[N];` `    ``// Loop through the string to``    ``// create the prefix sum array``    ``for` `(``int` `i = 0; i < N; i++)``    ``{` `        ``// Store 1 at the index``        ``// if it is a vowel``        ``if` `(str[i] == ``'a'` `||``            ``str[i] == ``'e'` `||``            ``str[i] == ``'i'` `||``            ``str[i] == ``'o'` `||``            ``str[i] == ``'u'``)``            ``pref[i] = 1;` `        ``// Otherwise, store 0``        ``else``            ``pref[i] = 0;` `        ``// Process the prefix array``        ``if` `(i != 0)``            ``pref[i] += pref[i - 1];``    ``}` `    ``// Initialize the variable to store``    ``// maximum count of vowels``    ``int` `maxCount = pref[K - 1];` `    ``// Initialize the variable``    ``// to store substring``    ``// with maximum count of vowels``    ``string` `res = str.Substring(0, K);` `    ``// Loop through the prefix array``    ``for` `(``int` `i = K; i < N; i++)``    ``{` `        ``// Store the current``        ``// count of vowels``        ``int` `currCount = pref[i] -``                        ``pref[i - K];` `        ``// Update the result if current count``        ``// is greater than maximum count``        ``if` `(currCount > maxCount)``        ``{``            ``maxCount = currCount;``            ``res = str.Substring(i - K + 1, K);``        ``}` `        ``// Update lexicographically smallest``        ``// substring if the current count``        ``// is equal to the maximum count``        ``else` `if` `(currCount == maxCount)``        ``{``            ``string` `temp = str.Substring(i - K + 1, K);` `            ``if` `(``string``.Compare(temp, res) == -1)``                ``res = temp;``        ``}``    ``}` `    ``// Return the result``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``string` `str = ``"ceebbaceeffo"``;``    ``int` `K = 3;` `    ``Console.Write(maxVowelSubString(str, K));``}``}` `// This code is contributed by Code_Mech`

## Javascript

 ``

Output

`ace`

Time Complexity: O(N)

Space Optimized Approach :

Instead of storing prefix sums, we can use a sliding window and update our result at each maximum.

## C++

 `#include ``using` `namespace` `std;` `// Helper function to check if a character is a vowel``bool` `isVowel(``char` `c)``{``    ``return` `c == ``'a'` `or c == ``'e'` `or c == ``'i'` `or c == ``'o'``           ``or c == ``'u'``;``}` `// Function to find the maximum vowel substring``string maxVowelSubstring(string s, ``int` `k)``{``    ``int` `maxCount = 0; ``// initialize maxCount as 0``    ``string res = s.substr(``        ``0, k); ``// and result as first substring of size k``    ``for` `(``int` `i = 0, count = 0; i < s.size();``         ``i++) ``// iterate through the string``    ``{``        ``if` `(isVowel(``                ``s[i])) ``// if current character is a vowel``            ``count++; ``// then increase count``        ``if` `(i >= k``            ``and isVowel(``                ``s[i - k])) ``// if character that is leaving``                           ``// the window is a vowel``            ``count--; ``// then decrease count` `        ``if` `(count > maxCount) ``// if we get a substring``                              ``// having more vowels``        ``{``            ``maxCount = count; ``// update count``            ``if` `(i >= k)``                ``res = s.substr(i - k + 1,``                               ``k); ``// and update result``        ``}``        ``if` `(count == maxCount``            ``and i >= k) ``// if we get a substring with same``                        ``// maximum number of vowels``        ``{``            ``string t = s.substr(i - k + 1, k);``            ``if` `(t < res) ``// then check if it is``                         ``// lexicographically smaller than``                         ``// current result and update it``                ``res = t;``        ``}``    ``}``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``string str = ``"geeksforgeeks"``;``    ``int` `k = 4;``    ``cout << maxVowelSubstring(str, k);``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {` `  ``static` `boolean` `isVowel(``char` `c){``    ``return` `c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'``      ``|| c == ``'u'``;``  ``}` `  ``// Function to find the maximum vowel subString``  ``static` `String maxVowelSubString(String s, ``int` `k)``  ``{``    ``int` `maxCount = ``0``; ``// initialize maxCount as 0``    ``String res = s.substring(``0``, k); ``// and result as first subString of size k``    ``for` `(``int` `i = ``0``, count = ``0``; i < s.length();i++) ``// iterate through the String``    ``{``      ``if` `(isVowel(s.charAt(i))) ``// if current character is a vowel``        ``count++; ``// then increase count``      ``if` `(i >= k && isVowel(s.charAt(i - k))) ``// if character that is leaving``        ``// the window is a vowel``        ``count--; ``// then decrease count` `      ``if` `(count > maxCount) ``// if we get a subString``        ``// having more vowels``      ``{``        ``maxCount = count; ``// update count``        ``if` `(i >= k)``          ``res = s.substring(i - k + ``1``,i + ``1``); ``// and update result``      ``}``      ``if` `(count == maxCount && i >= k) ``// if we get a subString with same``        ``// maximum number of vowels``      ``{``        ``String t = s.substring(i - k + ``1``, i + ``1``);``        ``if` `(t.compareTo(res) < ``0``){ ``// then check if it is``          ``// lexicographically smaller than``          ``// current result and update it``          ``res = t;``        ``}``      ``}``    ``}``    ``return` `res;``  ``}` `  ``public` `static` `void` `main (String[] args) {``    ``String str = ``"geeksforgeeks"``;``    ``int` `k = ``4``;``    ``System.out.println(maxVowelSubString(str, k));``  ``}``}` `// This code is contributed by shinjanpatra.`

## Python3

 `# Helper function to check if a character is a vowel``def` `isVowel(c):``   ``return` `(c ``=``=` `'a'` `or` `c ``=``=` `'e'` `or` `c ``=``=` `'i'` `or` `c ``=``=` `'o'` `or` `c ``=``=` `'u'``)``    ` `# Function to find the maximum vowel substring``def` `maxVowelSubstring(s, k):` `   ``# initialize maxCount as 0``   ``maxCount ``=` `0``  ` `   ``# and result as first substring of size k``   ``res ``=` `s[``0``:k]``  ` `   ``# iterate through the string``   ``count ``=` `0``   ``for` `i ``in` `range``(``len``(s)):``      ` `      ``# if current character is a vowel``      ``if` `(isVowel(s[i])):``         ``count ``+``=` `1` `# then increase count``                ` `         ``# if character that is leaving ``      ``if` `(i >``=` `k ``and` `isVowel(s[i ``-` `k])): ``# the window is a vowel``         ``count ``-``=` `1` `# then decrease count` `      ``if` `(count > maxCount): ``# if we get a substring``                                  ``# having more vowels``         ``maxCount ``=` `count ``# update count``         ``if` `(i >``=` `k):``            ` `            ``# and update result``            ``res ``=` `s[i ``-` `k ``+` `1``: i ``+` `1``]``            ` `            ``# if we get a substring with same``      ``if` `(count ``=``=` `maxCount ``and` `i >``=` `k):``                            ``# maximum number of vowels``         ``t ``=` `s[i ``-` `k ``+` `1``: i``+``1``]``         ``if` `(t < res): ``# then check if it is``                             ``# lexicographically smaller than``                             ``# current result and update it``            ``res ``=` `t``   ``return` `res``    ` `# driver code``str` `=` `"geeksforgeeks"``k ``=` `4``print``(maxVowelSubstring(``str``, k))` `# This code is contributed by shinjanpatra`

## Javascript

 ``

Output

`eeks`

Time Complexity: O(N)
Space Complexity: O(1)

My Personal Notes arrow_drop_up