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

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)
Auxiliary Space: O(N), where N is the length of the given string.

Time Optimized Approach :

we are using sliding window concept by means of mapping (map stl cpp).

let’s see approach/algorithm:

•  first declare a map.
• go on traversing and mapping each character.
• if i>=k then remove i-kth element in map then.
• count all vowels in substr or map.
• take max of count if count is greater then max then traverse over string (i-k)+1 to i then store substr.

## C++

 `#include ``#include ``using` `namespace` `std;` ` ``bool` `isVowel(``char` `ch){``        ``return` `(ch==``'a'``||ch==``'e'``||ch==``'i'``||ch==``'o'``||ch==``'u'``);``  ``}` `int` `main() {``      ``string s=``"geeksforgeeks"``;``      ``int` `k=4;``      ``unordered_map<``char``,``int``>mp;``      ``int` `maxelement=INT_MIN;``      ``string res;``      ``for``(``int` `i=0;i=k){``                ``--mp[s[i-k]];``            ``}``            ``for``(``auto` `&it:mp){``                ``if``(isVowel(it.first)){``                  ``cnt+=it.second;``                ``}``            ``}``        ``if``(maxelement=k){``           ``maxelement=cnt;``           ``temp=s.substr((i-k)+1,i);``          ``// for(int j=(i-k)+1;j<=i;j++)temp.push_back(s[j]);``           ``res=temp;``        ``}``      ``}``     ``cout<

## Java

 `import` `java.util.HashMap;``import` `java.util.Map;` `public` `class` `Main {``    ``public` `static` `boolean` `isVowel(``char` `ch) {``        ``return` `(ch == ``'a'` `|| ch == ``'e'` `|| ch == ``'i'` `|| ch == ``'o'` `|| ch == ``'u'``);``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"geeksforgeeks"``;``        ``int` `k = ``4``;``        ``Map mp = ``new` `HashMap<>();``        ``int` `maxElement = Integer.MIN_VALUE;``        ``String res = ``""``;` `        ``for` `(``int` `i = ``0``; i < s.length(); i++) {``            ``mp.put(s.charAt(i), mp.getOrDefault(s.charAt(i), ``0``) + ``1``);``            ``int` `cnt = ``0``;``            ``String temp = ``""``;` `            ``if` `(i >= k) {``                ``char` `removedChar = s.charAt(i - k);``                ``mp.put(removedChar, mp.get(removedChar) - ``1``);``                ``if` `(mp.get(removedChar) == ``0``) {``                    ``mp.remove(removedChar);``                ``}``            ``}` `            ``for` `(Map.Entry entry : mp.entrySet()) {``                ``if` `(isVowel(entry.getKey())) {``                    ``cnt += entry.getValue();``                ``}``            ``}` `            ``if` `(maxElement < cnt && i >= k) {``                ``maxElement = cnt;``                ``temp = s.substring(i - k + ``1``, i + ``1``);``                ``res = temp;``            ``}``        ``}` `        ``System.out.println(res);``        ``System.out.println(maxElement);``    ``}``}`

## Python3

 `def` `isVowel(ch):``    ``return` `ch ``=``=` `'a'` `or` `ch ``=``=` `'e'` `or` `ch ``=``=` `'i'` `or` `ch ``=``=` `'o'` `or` `ch ``=``=` `'u'` `s ``=` `"geeksforgeeks"``k ``=` `4``mp ``=` `{}``maxelement ``=` `float``(``'-inf'``)``res ``=` `""``for` `i ``in` `range``(``len``(s)):``    ``if` `s[i] ``not` `in` `mp:``        ``mp[s[i]] ``=` `0``    ``mp[s[i]] ``+``=` `1``    ``cnt ``=` `0``    ``temp ``=` `""``    ``if` `i >``=` `k:``        ``mp[s[i``-``k]] ``-``=` `1``        ``if` `mp[s[i``-``k]] ``=``=` `0``:``            ``del` `mp[s[i``-``k]]``    ``for` `key ``in` `mp:``        ``if` `isVowel(key):``            ``cnt ``+``=` `mp[key]``    ``if` `maxelement < cnt ``and` `i >``=` `k:``        ``maxelement ``=` `cnt``        ``temp ``=` `s[(i``-``k``+``1``):(i``+``1``)]``        ``res ``=` `temp` `print``(res)``print``(maxelement)`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `Program``{``    ``// Function to check if a character is a vowel``    ``static` `bool` `IsVowel(``char` `ch)``    ``{``        ``return` `(ch == ``'a'` `|| ch == ``'e'` `|| ch == ``'i'` `|| ch == ``'o'` `|| ch == ``'u'``);``    ``}` `    ``static` `void` `Main()``    ``{``        ``string` `s = ``"geeksforgeeks"``;``        ``int` `k = 4;``        ``Dictionary<``char``, ``int``> mp = ``new` `Dictionary<``char``, ``int``>(); ``// Create a dictionary to store character frequencies``        ``int` `maxelement = ``int``.MinValue;``        ``string` `res = ``""``;` `        ``for` `(``int` `i = 0; i < s.Length; i++)``        ``{``            ``// Update character frequency in the dictionary``            ``if` `(!mp.ContainsKey(s[i]))``                ``mp[s[i]] = 0;``            ` `            ``mp[s[i]]++;` `            ``int` `cnt = 0; ``// Initialize a count for vowel frequencies``            ``string` `temp = ``""``; ``// Initialize a temporary string to store the current substring` `            ``if` `(i >= k)``            ``{``                ``char` `toRemove = s[i - k];``                ``mp[toRemove]--; ``// Reduce the frequency of the character being removed``                ``if` `(mp[toRemove] == 0)``                    ``mp.Remove(toRemove); ``// Remove the character from the dictionary if its frequency becomes zero``            ``}` `            ``// Calculate the count of vowels in the current substring``            ``foreach` `(``var` `item ``in` `mp)``            ``{``                ``if` `(IsVowel(item.Key))``                ``{``                    ``cnt += item.Value;``                ``}``            ``}` `            ``// Update the result if the current substring has more vowels``            ``if` `(maxelement < cnt && i >= k)``            ``{``                ``maxelement = cnt;``                ``temp = s.Substring(i - k + 1, k);``                ``res = temp;``            ``}``        ``}` `        ``// Print the result and the maximum vowel count``        ``Console.WriteLine(res);``        ``Console.WriteLine(maxelement);``    ``}``}`

## Javascript

 `function` `isVowel(ch){``        ``return` `(ch==``'a'``||ch==``'e'``||ch==``'i'``||ch==``'o'``||ch==``'u'``);``  ``}` `let s=``"geeksforgeeks"``;``let k=4;``let mp=``new` `Map();``let maxelement=Number.MIN_VALUE;``let res=``""``;``for``(let i=0;i=k){``        ``const charToRemove = s[i - k];``        ``mp.set(charToRemove, mp.get(charToRemove) - 1);``        ``if` `(mp.get(charToRemove) === 0) {``            ``mp.``delete``(charToRemove);``        ``}``    ``}``    ``for` `(const [key, value] of mp) {``        ``if` `(isVowel(key)) {``            ``cnt += value;``        ``}``    ``}` `    ``if``(maxelement=k){``       ``maxelement=cnt;``       ``temp=s.substring((i-k)+1,i+1);``      ``// for(int j=(i-k)+1;j<=i;j++)temp.push_back(s[j]);``       ``res=temp;``    ``}``}``console.log(res);``console.log(maxelement);`

Output
```eeks
2

```

Complexity Analysis:

Time Complexity : O(n*k).

Space Complexity : O(k).

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`

## C#

 `// C# code for above approach``using` `System;` `class` `GFG``{``    ``static` `bool` `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[i])) ``// if current character is a vowel``                ``count++; ``// then increase count``            ``if` `(i >= k && 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.Substring(i - k + 1, k); ``// 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, k);``                ``if` `(``string``.Compare(t, res) < 0) ``// then check if it is``                ``// lexicographically smaller than``                ``// current result and update it``                ``{``                    ``res = t;``                ``}``            ``}``        ``}``        ``return` `res;``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``string` `str = ``"geeksforgeeks"``;``        ``int` `k = 4;``        ``Console.WriteLine(maxVowelSubString(str, k));``    ``}``}` `// This code is contributed by Pushpesh Raj.`

## Javascript

 ``

Output
```eeks

```

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

Previous
Next