Count Vowel Substrings of a String - Practice Coding Problems

Count Vowel Substrings of a String - Problem

Imagine you're a linguist studying complete vowel patterns in words! Your task is to find all the special substrings that contain every single vowel in the English language.

A vowel substring is a contiguous sequence of characters that:

Contains only vowels ('a', 'e', 'i', 'o', 'u')
Has all five vowels present at least once

Given a string word, return the count of such magical vowel substrings.

Example: In "aeiouu", the substring "aeiou" qualifies because it contains only vowels and has all five different vowels!

Input & Output

example_1.py — Basic Case

$ Input: word = "aeiouu"

› Output: 2

💡 Note: The vowel substrings are "aeiou" and "aeiouu". Both contain only vowels and have all five vowels present.

example_2.py — With Consonants

$ Input: word = "unicornarihan"

› Output: 0

💡 Note: Although there are vowels, no substring contains only vowels AND has all five vowels present. The consonants break up the vowel sequences.

example_3.py — Complex Pattern

$ Input: word = "cuaeiouueioa"

› Output: 7

💡 Note: Multiple valid substrings exist within the vowel-only section "aeiouueioa". Each must contain all five vowels: aeiou, aeiouu, aeiouue, aeiouuei, aeiouueio, aeiouueioa, uueioa.

Visualization

Tap to expand

Understanding the Visualization

Skip the Noise

Like a detective ignoring irrelevant clues, skip any consonants since they can't be part of our target

Start Collecting Evidence

When you find a vowel, start your evidence collection - track each unique vowel type you encounter

Build Complete Cases

Once you have all 5 evidence types, you've solved one case! Every extension still gives you another complete case

Break on Contamination

If you hit a consonant, your evidence chain is broken - start fresh from the next vowel

Key Takeaway

🎯 Key Insight: The detective approach (optimized sliding window) is like having a smart evidence collection strategy - skip the noise, track unique evidence types, and count complete cases as you build them. This gives us O(n) efficiency instead of checking every possible evidence combination!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using fixed-size hash map for 5 vowels plus a few variables

✓ Linear Space

Constraints

1 ≤ word.length ≤ 100
word consists of lowercase English letters only
All five vowels (a, e, i, o, u) must be present in a valid substring
Valid substrings must contain only vowel characters

Asked in

a Amazon 23 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses a smart sliding window technique that runs in O(n) time. The key insight is that we only need to consider substrings that start with a vowel, and we can skip non-vowel characters entirely. For each starting position, we expand the window while we encounter vowels, tracking unique vowels with a set. Once we have all 5 vowels, every further extension within the current vowel-only section creates another valid substring. This eliminates the need to check all O(n²) possible substrings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's a valid vowel substring
Optimized Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently find all vowel substrings in one pass

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, check if all characters are vowels
If valid, check if all 5 vowels (a,e,i,o,u) are present
Count valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start with each position and extend to create all possible substrings

Check Vowels Only

Verify each substring contains only vowel characters

Check All Five

Count unique vowels to ensure all five are present

Count Valid

Increment counter for each valid vowel substring found

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 countVowelSubstrings(char* word) {
    int count = 0;
    int n = strlen(word);
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if substring contains only vowels
            bool onlyVowels = true;
            bool hasA = false, hasE = false, hasI = false, hasO = false, hasU = false;
            
            for (int k = i; k <= j; k++) {
                char c = word[k];
                if (!isVowel(c)) {
                    onlyVowels = false;
                    break;
                }
                if (c == 'a') hasA = true;
                else if (c == 'e') hasE = true;
                else if (c == 'i') hasI = true;
                else if (c == 'o') hasO = true;
                else if (c == 'u') hasU = true;
            }
            
            if (onlyVowels && hasA && hasE && hasI && hasO && hasU) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char word[1000];
    fgets(word, sizeof(word), stdin);
    // Remove newline and quotes
    word[strcspn(word, "\n")] = 0;
    if (word[0] == '"') {
        memmove(word, word + 1, strlen(word));
        word[strlen(word) - 1] = 0;
    }
    printf("%d\n", countVowelSubstrings(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring validity

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track vowel presence

✓ Linear Space

Constraints

1 ≤ word.length ≤ 100
word consists of lowercase English letters only
All five vowels (a, e, i, o, u) must be present in a valid substring
Valid substrings must contain only vowel characters

28.9K Views

Medium Frequency

~15 min Avg. Time

856 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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler