Count of Substrings Containing Every Vowel and K Consonants I

Count of Substrings Containing Every Vowel and K Consonants I - Problem

Given a string word and a non-negative integer k, you need to find the total number of substrings that satisfy two conditions:

The substring contains every vowel ('a', 'e', 'i', 'o', and 'u') at least once
The substring contains exactly k consonants

A substring is a contiguous sequence of characters within a string. Vowels are the letters 'a', 'e', 'i', 'o', and 'u'. All other lowercase English letters are consonants.

Example: For word = "aeiouk" and k = 1, the substring "aeiouk" contains all vowels and exactly 1 consonant ('k'), so it counts toward our answer.

Input & Output

example_1.py — Basic Case

$ Input: word = "aeioqq", k = 1

› Output: 0

💡 Note: No substring contains all vowels (a,e,i,o,u) and exactly 1 consonant. The string is missing 'u' vowel.

example_2.py — Valid Substring

$ Input: word = "aeiouqq", k = 1

› Output: 1

💡 Note: The substring "aeiouq" (indices 0-5) contains all vowels and exactly 1 consonant 'q'.

example_3.py — Multiple Valid Substrings

$ Input: word = "aeioubac", k = 2

› Output: 1

💡 Note: The substring "aeioubac" contains all vowels (a,e,i,o,u) and exactly 2 consonants (b,c).

Constraints

5 ≤ word.length ≤ 5 × 10⁴
word consists only of lowercase English letters
0 ≤ k ≤ word.length - 5
Note: Since we need all 5 vowels, minimum substring length is 5

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with an empty window at the beginning of the string

Expand Right

Extend the window to the right, counting vowels and consonants

Check Consonants

If consonants exceed k, shrink window from the left

Count Valid

When we have all vowels and ≤k consonants, count valid substrings

Use Difference

Use 'at most k' - 'at most k-1' to get exactly k consonants

Key Takeaway

🎯 Key Insight: Using the mathematical relationship (exactly k) = (at most k) - (at most k-1) allows us to solve this efficiently with sliding window technique in O(n) time.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a sliding window technique with hash maps to efficiently track vowel presence and consonant count. The key insight is to use the difference between "at most k consonants" and "at most k-1 consonants" to get exactly k consonants, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(1)	Use sliding window technique with hash maps to efficiently track vowel presence and consonant count
Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible substring to see if it meets both vowel and consonant requirements

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Initialize vowel count map and consonant counter
Use two pointers (left and right) to maintain a sliding window
Expand window by moving right pointer, updating counts
When consonant count exceeds k, shrink window from left
Count valid substrings when we have exactly k consonants and all vowels
Use helper function to count substrings with at most k consonants

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Set left=0, right=0, initialize vowel and consonant counters

Expand Window

Move right pointer, update character counts

Check Constraints

If consonants > k, shrink window from left

Count Valid

If all vowels present and consonants ≤ k, count substrings

Continue

Repeat until right pointer reaches end

Code -

solution.c — C

int atMostK(char* word, int kVal) {
    int vowels[5] = {0}; // a, e, i, o, u
    int consonants = 0;
    int left = 0;
    int result = 0;
    int n = strlen(word);
    
    for (int right = 0; right < n; right++) {
        char c = word[right];
        if (c == 'a') vowels[0]++;
        else if (c == 'e') vowels[1]++;
        else if (c == 'i') vowels[2]++;
        else if (c == 'o') vowels[3]++;
        else if (c == 'u') vowels[4]++;
        else consonants++;
        
        while (consonants > kVal) {
            char leftChar = word[left];
            if (leftChar == 'a') vowels[0]--;
            else if (leftChar == 'e') vowels[1]--;
            else if (leftChar == 'i') vowels[2]--;
            else if (leftChar == 'o') vowels[3]--;
            else if (leftChar == 'u') vowels[4]--;
            else consonants--;
            left++;
        }
        
        int allVowels = 1;
        for (int i = 0; i < 5; i++) {
            if (vowels[i] == 0) {
                allVowels = 0;
                break;
            }
        }
        if (allVowels) {
            result += right - left + 1;
        }
    }
    
    return result;
}

int countOfSubstrings(char* word, int k) {
    return atMostK(word, k) - (k > 0 ? atMostK(word, k - 1) : 0);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

Only using fixed-size hash maps for vowels (5 elements) and a few integer variables

✓ Linear Space

47.2K Views

Medium-High Frequency

~25 min Avg. Time

1.7K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler