Count of Substrings Containing Every Vowel and K Consonants II

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

You're tasked with finding all perfect substrings in a given word. A perfect substring is one that contains every vowel (a, e, i, o, u) at least once and has exactly k consonants.

Given a string word and a non-negative integer k, return the total count of such perfect substrings.

Example: For word = "aeioqq" and k = 2, the substring "aeioqq" contains all vowels (a, e, i, o) and exactly 2 consonants (q, q), making it a perfect substring.

This problem tests your ability to efficiently track character frequencies while exploring all possible substring combinations using advanced string manipulation techniques.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: The entire string "aeioqq" contains vowels a,e,i,o (missing u) and 2 consonants (q,q). Since it's missing vowel 'u', it's not valid. However, the substring "aeioqu" would be valid if 'u' was present.

example_2.py — Perfect Match

$ Input: word = "aeiou", k = 0

› Output: 1

💡 Note: The string "aeiou" contains all 5 vowels exactly once and 0 consonants. This matches our requirement of k=0 consonants, so there's exactly 1 valid substring.

example_3.py — Multiple Valid Substrings

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

› Output: 3

💡 Note: Multiple substrings contain all vowels and exactly 2 consonants: "aeioubcae", "eioubcaei", "ioubcaeio". Each sliding window position creates valid substrings.

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with empty counters for vowels and consonants

Expand Window

Move right pointer, updating character counts

Shrink When Needed

If consonants exceed limit, shrink from left

Count Valid Windows

When all vowels present, count valid substrings

Apply Math Transform

Use atMost(k) - atMost(k-1) = exactly(k)

Key Takeaway

🎯 Key Insight: The sliding window with at-most transformation efficiently solves the exact counting problem by leveraging the mathematical relationship: exactly(k) = atMost(k) - atMost(k-1)

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 constant extra space for vowel and consonant counters

✓ Linear Space

Constraints

1 ≤ word.length ≤ 10⁵
0 ≤ k ≤ word.length
word consists only of lowercase English letters
All vowels must be present at least once
Exactly k consonants are required

Asked in

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

The optimal solution uses a sliding window technique with a key mathematical insight: to count substrings with exactly k consonants, we calculate substrings with at most k consonants minus substrings with at most k-1 consonants. This transforms a complex counting problem into two simpler ones, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique with the key insight: count(≤k) - count(≤k-1)
Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible substring by examining all start-end combinations

Sliding Window (Optimal) — Algorithm Steps

Create helper function to count substrings with all vowels and ≤ maxConsonants
Use sliding window: expand right pointer to include characters
Track vowel counts and consonant count in current window
When consonants exceed limit, shrink window from left
For each valid window position, add (right - left + 1) to count
Return atMost(k) - atMost(k-1) for exactly k consonants

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with left and right pointers at position 0

Expand Right

Move right pointer and update character counts

Check Constraints

If consonants exceed limit, shrink from left

Count Valid Substrings

If all vowels present, add window size to result

Apply Transform

Return atMost(k) - atMost(k-1) for exactly k

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

int getVowelIndex(char c) {
    switch(c) {
        case 'a': return 0;
        case 'e': return 1;
        case 'i': return 2;
        case 'o': return 3;
        case 'u': return 4;
        default: return -1;
    }
}

int atMost(char* word, int maxConsonants) {
    if (maxConsonants < 0) return 0;
    
    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 (isVowel(c)) {
            vowels[getVowelIndex(c)]++;
        } else {
            consonants++;
        }
        
        while (consonants > maxConsonants) {
            char leftChar = word[left];
            if (isVowel(leftChar)) {
                vowels[getVowelIndex(leftChar)]--;
            } else {
                consonants--;
            }
            left++;
        }
        
        bool allVowelsPresent = true;
        for (int i = 0; i < 5; i++) {
            if (vowels[i] == 0) {
                allVowelsPresent = false;
                break;
            }
        }
        
        if (allVowelsPresent) {
            result += right - left + 1;
        }
    }
    
    return result;
}

int countOfSubstrings(char* word, int k) {
    return atMost(word, k) - atMost(word, k - 1);
}

int main() {
    char word[] = "aeioqq";
    printf("%d\n", countOfSubstrings(word, 2));
    return 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 constant extra space for vowel and consonant counters

✓ Linear Space

Constraints

1 ≤ word.length ≤ 10⁵
0 ≤ k ≤ word.length
word consists only of lowercase English letters
All vowels must be present at least once
Exactly k consonants are required

23.8K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler