Count of K length substrings containing exactly X vowels

In this problem, we need to find a total number of substrings of length K containing exactly K vowels. We will see two different approaches to solving the problem. We can use a naïve approach that checks the number of vowels in each substring of length K. Also, we can use the sliding window approach to solve the problem.

Problem statement – We have given a string str of length N containing lowercase and uppercase alphabetical characters. We need to count the total number of substrings of length K which contains exactly X vowels.

Sample examples

Input– str = "TutorialsPoint", K = 3, X = 2

Output– 6

Explanation– The substrings of length 3 containing exactly 2 vowels are: ‘uto’, ‘ori’, ‘ria’, ‘ial’, ‘Poi’, and ‘oin’.

Input– str = ‘aeiou’, K = 2, X = 2

Output– 4

Explanation– The substrings of length 2 containing exactly 2 vowels are: ‘ae’, ‘ei’, ‘io’, and ‘ou’.

Input– str = ‘fghjsdfdffg’, K = 5, X = 1

Output– 0

Explanation– The string str doesn’t contain any vowel, so we can’t find any substring containing 1 vowel.

Approach 1

In this approach, we will find each substring of the length K of str. After that, we will count the total number of vowels in a particular substring, and if we find them equal to X, we can increase the count by 1.

Algorithm

• In the cntSubStr() function, initialize the ‘cnt’ variable with zero to store a total number of substrings.

• Use the loop to make iterations starting from the 0th index to the len – K index, where ‘len’ is the length of the string.

• In the loop, use the substr() method to get the substring of length K starting from the ith index.

• Execute the countVowel() function to count total vowels in the substring.

• In the countVowel() function, initialize the ‘vowels’ variable with zero to store a total number of vowels.

• Traverse the substring, and the current character is a vowel, increasing the value of ‘vowels’ by 1.

• Return ‘vowels’.

• In the cntSubStr() function, if the total vowels in the substring are equal to X, increase the value of ‘cnt’ by 1.

• Return the value of ‘cnt’.

Example

#include <bits/stdc++.h>
using namespace std;

// function to count the total number of vowels in a string
int cntVowels(string alpha) {
   int vows = 0;
   for (int i = 0; i < alpha.length(); i++) {
      if (alpha[i] == 'a' || alpha[i] == 'e' || alpha[i] == 'i' || alpha[i] == 'o' ||
          alpha[i] == 'u' || alpha[i] == 'A' || alpha[i] == 'E' || alpha[i] == 'I' ||
          alpha[i] == 'O' || alpha[i] == 'U')
          vows++;
   }
   return vows;
}
int cntSubstr(string str, int K, int X) {
   int cnt = 0;
   // traverse the string and check for the total number of vowels in each substring of length K
    for (int i = 0; i <= str.length() - K; i++) {
       // get the substring of length K starting from index i
       string sub = str.substr(i, K);
       // check if the total number of vowels in the substring is equal to X, then increment cnt
       if (cntVowels(sub) == X)
          cnt++;
   }
   return cnt;
}
// Driver code
int main(void) {
   string str = "TutorialsPoint";
   int K = 3, X = 2;
   cout << "The total number of substrings of length " << K << " containing " << X << " vowels is " << cntSubstr(str, K, X);
   return 0;
}

Output

The total number of substrings of length 3 containing 2 vowels is 6

Time complexity – O(N*K), as we traverse the str, traverse the substring in the countVowel() function.

Space complexity – O(K), as we store the substring

Approach 2

We will use the sliding window technique to solve the problem in this approach. We will remove the first character from the substring and add 1 character at the end. Also, we will keep track of the count of vowels in the current substring, and if it is equal to X, we can increase the count by 1.

Algorithm

• Define the isVowel() function returning the boolean value based on whether the particular character is a vowel.

• In the cntSubStr() function, Define the ‘total_vow’ and initialize with zero to store the total vowels in the current window.

• Find the total number of vowels in the substring of length K starting from the 0th index, representing the first window.

• Initialize the ‘cnt’ variable with 1 or 0 based on the value of ‘vow’ is equal to X.

• Start traversing the string from the 1st to the len – K index.

• If (i-1) character is a vowel, decrease the value of ‘total_vow’ by 1.

• If the character at (i - 1 + K)th index is a vowel, increase the value of ‘total_vow’ by 1.

• If ‘total_vow’ is equal to X, increment ‘cnt’ by 1.

• Return the value of ‘cnt’.

Example

#include <bits/stdc++.h>
using namespace std;
bool isVowel(char ch) {
   // convert character to lowercase
   ch = tolower(ch);
   return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u');
}
int cntSubstr(string str, int K, int X) {
   // To store total vowels
   int total_vow = 0;
   // Count the number of vowels in the first window
   for (int p = 0; p < K; p++)
       if (isVowel(str[p]))
            total_vow++;
   // to store the total number of substrings of length K containing X vowels
   int cnt = 0;
   // If the first window contains exactly X vowels, initialize cnt as 1
   cnt = total_vow == X ? 1 : 0;
   // traverse the string
   for (int i = 1; i <= str.length() - K; i++) {
      // exclude the (i - 1)th character from the window and update the total_vow
      total_vow = isVowel(str[i - 1]) ? total_vow - 1 : total_vow;
      // Add [i-1+K]th character to the current window and update total_vow
      total_vow = isVowel(str[i - 1 + K]) ? total_vow + 1 : total_vow;
      // If the current window contains exactly X vowels, increment cnt
      if (total_vow == X)
          cnt++;
   }
   return cnt;
}
int main(void) {
   string str = "TutorialsPoint";
   int K = 3, X = 2;
   cout << "The total number of substrings of length " << K << " containing " << X << " vowels is " << cntSubstr(str, K, X);
   return 0;
}

Output

The total number of substrings of length 3 containing 2 vowels is 6

Time complexity – O(N) as we traverse the string.

Space complexity – O(1), as we don’t use any extra space.

We have optimized the second approach and decreased the code's time complexity. Also, we have optimized the space complexity in the second approach. Here, we found a total number of substrings of length K containing exactly X vowels, but programmers can try to find a total number of substrings of any length containing exactly K vowels.