- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Length of the smallest substring which contains all vowels
One common issue encountered during string manipulation assignments involves identifying the shortest substring containing every vowel atleast once. This task finds its application amongst varied domains such as data analytics, bioinformatics and natural language processing among others.The goal here is finding out which minimum contiguous section within an existing string has each of these five letters (a,e,i,o,u) atleast once.The selection process for resolving this challenge encompasses multitude techniques like implementing sliding window algorithms or incorporating hashing procedures or utilizing regular expressions etcetera.Finding a robust resolution for this problem typically becomes crucial since numerous real-world scenarios demand reliable text manipulation methods.
Methods
There are various methods to find the length of the smallest substring which contains all vowels.
Method 1. Sliding Window Approach
Method 2. Two Pointer Approach
Method 3. Frequency Array Approach
Method 1: Sliding Window Approach
To quickly determine the size of the shortest substring that contains every vowel in each string, use the sliding window approach. The method makes use of two pointers, commonly known as "left" and "right," to produce a sliding window that slides down the string.
Syntax
Here's the syntax of the Sliding Window approach to finding the length of the smallest substring which contains all vowels −
def find_smallest_substring(string): vowels = {'a', 'e', 'i', 'o', 'u'} unique_vowels = set() start = 0 end = 0 min_length = float('inf') while end < len(string): # Expand the window if string[end] in vowels: unique_vowels.add(string[end]) # Contract the window while len(unique_vowels) == len(vowels): min_length = min(min_length, end - start + 1) if string[start] in vowels: unique_vowels.remove(string[start]) start += 1 end += 1 return min_length
Algorithm
Step 1 − Make a sliding window with an underlying size of n (the length of the string), and then move it from left to right.
Step 2 − At each location in the window, make sure the substring is entirely composed of vowels. Update the minimum length of the substring discovered thus far if it does.
Step 3 − Use a hash table to keep record of the repeatition of each vowel in the substring to find whether the substring contains all of the vowels.
Step 4 − Continue the process until all potential substrings have been tested if the substring does not contain all vowels by moving the window to the right and repeating the process.
Example 1
To determine whether a given character is a vowel in this implementation, we define the helper function isVowel. To depict the sliding window, we also utilise two pointers to the left and right.
If the current character is a vowel, we first expand the window by adding it to the window set within the while loop. The size of the window set is then verified to be 5 (i.e., all vowels are present). If so, we alter the response and reduce the size of the window by eliminating the leftmost character from the window set until it is less than 5.
The length of the smallest substring containing all vowels is returned in the loop's result.
#include <iostream> #include <unordered_set> using namespace std; bool isVowel(char c) { return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; } int smallestSubstring(string s) { unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u'}; unordered_set<char> window; int n = s.length(), left = 0, right = 0, ans = n + 1; while (right < n) { // Expand the window by adding the current character char c = s[right]; if (isVowel(c)) { window.insert(c); } right++; // close the window by removing the leftmost character while (window.size() == 5) { ans = min(ans, right - left); char d = s[left]; if (isVowel(d)) { window.erase(d); } left++; } } return ans <= n ? ans : 0; } int main() { string s = "aeeioubcdfuioaei"; int len = smallestSubstring(s); cout << "Length of smallest substring containing all vowels: " << len << endl; return 0; }
Output
Length of smallest substring containing all vowels: 6
Method 2: Two Pointer Approach
The Two Pointer approach is a well-liked method for quickly resolving a variety of string manipulation issues. The Two Pointer technique can be very helpful in determining the length of the smallest substring that contains all vowels.
Syntax
Here's the syntax of Two Pointer Approach to find length of the smallest substring that contains all vowels −
function findSmallestSubstring(str): vowels = {'a', 'e', 'i', 'o', 'u'} count = 0 left = 0 minLength = infinity for right in range(length of str): if str[right] is a vowel: count += 1 while count is same as the total number of vowels: minLength = minimum (minLength, right - left + 1) if str[left] is a vowel: count -= 1 left += 1 return minLength
Algorithm
Step 1 − Set up the start and end pointers, which point to start of the string, respectively.
Step 2 − Continue to move the end pointer to right until a substring that contains only vowels is discovered.
Step 3 − If we locate a substring that contains all vowels, move the start cursor to the right until it no longer does.
Step 4 − Continue moving end pointer to the right until a new substring is discovered that contains all vowels, then move the start pointer to the right until the substring no longer does.
Step 5 − Refresh the shortest substring length thus far.
Example 2
To represent the sliding window in this example, we retain two pointers, left and right. From left to right, we iterate through the string str, checking each time whether the current character is a vowel. In order to maintain track of the vowels observed thus far, we add it to the set viewed if it is.
We move the left cursor to reduce the length of the substring once seen contains all of the vowels. This procedure is carried on until the right pointer reaches the string's end.
The length of the shortest substring that contains all vowels is then returned. In the not presence of such a substring, we return 0.
#include <iostream> #include <string> #include <unordered_set> using namespace std; int smallestSubstringLength(const string& str) { int n = str.length(); unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u'}; unordered_set<char> seen; int left = 0, right = 0; int smallestLength = n + 1; while (right < n) { if (vowels.find(str[right]) != vowels.end()) { seen.insert(str[right]); } if (seen.size() == vowels.size()) { while (seen.size() == vowels.size()) { if (right - left + 1 < smallestLength) { smallestLength = right - left + 1; } if (vowels.find(str[left]) != vowels.end()) { seen.erase(str[left]); } left++; } } right++; } return (smallestLength == n + 1) ? 0 : smallestLength; } int main() { string str = "aeeiiouuobcdaeiou"; int length = smallestSubstringLength(str); cout << "Length of the smallest substring containing all vowels: " << length << endl; return 0; }
Output
Length of the smallest substring containing all vowels: 7
Method 3. Frequency Array Approach
The shortest substring that contains all the vowels in each string is measured using the Frequency Array Approach. It requires building a frequency array to keep record of the appearance of vowels and then repeatedly iterating through the text to locate the required substring.
Syntax
The syntax for finding length of smallest substring that contains all vowels is as follows −
# Check if all vowels are present in the current substring if all(freq[vowel] > 0 for vowel in vowels): # Update the minimum length if needed min_length = min(min_length, right - left + 1) # Move the left pointer to find a potentially smaller substring while left < right: freq[input_string[left]] -= 1 if freq[input_string[left]] == 0: break left += 1 # Move the right pointer to expand the current substring right += 1
Algorithm
Step 1 − To keep record of the repetition of each vowel (a, e, i, o, u), start with a frequency array of size 5.
Step 2 − Make start and end pointers, which highlight the beginning of the string, individually.
Step 3 − Continue to move the end pointer to the right till every vowel has been heard at least once.
Step 4 − Move start pointer to the right until the substring no longer contains all vowels after at least one repetition of each vowel.
Step 5 − Adjust the minimum length of the substring that has far been identified, and then shift end pointer to the right until a new substring that contains all vowels is discovered.
Step 6 − Update the frequency array at each location to verify that the current substring contains all vowels.
Example 3
In this example, function min Length Substring takes a string as input and calculates length of the smallest substring which contains all five vowels (a, e, i, o, u).
The function counts each vowel in the substring using a frequency array called vowelCount. It keeps track of the number of distinct vowels in the substring by maintaining a count distinctVowels.
With the use of two pointers, start and finish, the function loops through the string, increasing the frequency array's vowelCount for each vowel it encounters. Once every distinct vowel has been located, the substring begins to shrink from the starting place until no distinct vowel remains. If shorter substring is discovered, minimum length of the substring is updated.
The main function make the use of string to show how to use the min Length Substring method by inputing the length of the shortest substring which contains all vowels.
#include <iostream> #include <climits> using namespace std; int minLengthSubstring(const string& str) { const string vowels = "aeiou"; int vowelCount[5] = {0}; // Frequency array for vowels int distinctVowels = 0; // Count of distinct vowels in the substring // Initialize the minimum length to maximum integer value int minLength = INT_MAX; int start = 0, end = 0; while (end < str.length()) { // Increment frequency for vowel at 'end' position for (int i = 0; i < 5; i++) { if (str[end] == vowels[i]) { if (vowelCount[i] == 0) { distinctVowels++; } vowelCount[i]++; break; } } // If all distinct vowels are found if (distinctVowels == 5) { while (start < end) { // Update minimum length if a shorter substring is found if (minLength > end - start + 1) { minLength = end - start + 1; } // Decrement frequency for vowel at 'start' position for (int i = 0; i < 5; i++) { if (str[start] == vowels[i]) { vowelCount[i]--; if (vowelCount[i] == 0) { distinctVowels--; } break; } } start++; // Break if any distinct vowel is missing in the substring if (distinctVowels < 5) { break; } } } end++; } return minLength == INT_MAX ? -1 : minLength; } int main() { string str = "aeeioubcdofu"; int length = minLengthSubstring(str); if (length == -1) { cout << "No substring containing all vowels found." << endl; } else { cout << "Length of the smallest substring containing all vowels: " << length << endl; } return 0; }
Output
Length of the smallest substring containing all vowels: 6
Conclusion
In conclusion, finding the length of the smallest substring that contains all vowels is a problem that can be efficiently solved using various techniques. By employing a sliding window approach or hashing the occurrence of vowels, it is possible to iterate through the string and identify the smallest substring that meets the requirements. The time complexity of these methods is typically linear, making them suitable for large inputs. However, it is important to handle edge cases and consider additional constraints that may affect the solution. Overall, with the right algorithmic approach, it is possible to determine the length of the smallest substring containing all vowels effectively.