Longest Substring Of All Vowels in Order - Practice Coding Problems

Longest Substring Of All Vowels in Order - Problem

Imagine you're a linguist searching for the most beautiful vowel patterns in ancient texts! Your task is to find the longest substring that contains all 5 English vowels in perfect alphabetical order.

A substring is considered beautiful if it meets these criteria:

Contains all 5 vowels: 'a', 'e', 'i', 'o', 'u' at least once
Vowels appear in strict alphabetical order (all 'a's before any 'e', all 'e's before any 'i', etc.)

Examples:

✅ "aeiou" - Perfect order, all vowels present
✅ "aaaaeeeiiiooouu" - Multiple occurrences in order
❌ "uaeio" - Wrong order (u comes before a)
❌ "aaaeeeooo" - Missing vowels (i, u)

Given a string containing only English vowels, return the length of the longest beautiful substring. If no beautiful substring exists, return 0.

Input & Output

example_1.py — Python

$ Input: word = "aeiaaioaaaaeiiiiouuuooaauuaeiu"

› Output: 13

💡 Note: The longest beautiful substring is "aaaaeiiiiouuu" which has length 13. It contains all vowels (a,e,i,o,u) in alphabetical order.

example_2.py — Python

$ Input: word = "aeeeiiiioooauuuaeiou"

› Output: 5

💡 Note: The longest beautiful substring is "aeiou" at the end, which has length 5. The first part "aeeeiiiioooauuu" breaks the order when 'a' appears after 'o'.

example_3.py — Python

$ Input: word = "a"

› Output: 0

💡 Note: A single vowel cannot form a beautiful substring since we need all 5 vowels. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Start the Scale

Every beautiful performance must begin with note 'A' - scan until we find a starting point

Progress Through Notes

Allow the singer to hold each note (repeat vowels) but advance to next note when ready

Track Completion

Monitor which notes have been sung - we need all 5 for a complete performance

Reset on Wrong Note

If singer goes backwards or skips ahead incorrectly, start looking for a new performance

Key Takeaway

🎯 Key Insight: Use sliding window with state tracking - every beautiful sequence starts with 'a' and progresses through vowels in order. Reset the window whenever the musical scale breaks!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track window state

✓ Linear Space

Constraints

1 ≤ word.length ≤ 5 × 10⁵
word consists of vowels only: 'a', 'e', 'i', 'o', and 'u'
Beautiful substring requires all 5 vowels in alphabetical order

Asked in

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

The optimal sliding window approach tracks vowel progression state in a single pass. Key insight: beautiful substrings must start with 'a' and progress through vowels in order. Use state tracking to monitor current vowel phase and reset when sequence breaks. This achieves O(n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window with state tracking to find beautiful substrings in one pass
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's beautiful

Sliding Window (Optimal) — Algorithm Steps

Initialize sliding window with left and right pointers
Track current vowel state and count of unique vowels seen
Expand window when vowel is in correct order
Reset window when vowel sequence breaks
Update maximum length when we have all 5 vowels
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start window at first 'a' character

Expand Window

Extend window while vowels remain in order

Track Progress

Monitor which vowels have been seen

Reset on Break

Start new window when sequence breaks

Code -

solution.c — C

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

int longestBeautifulSubstring(char* word) {
    int len = strlen(word);
    if (len < 5) return 0;
    
    char vowels[] = "aeiou";
    int maxLength = 0;
    int left = 0;
    
    while (left < len) {
        if (word[left] != 'a') {
            left++;
            continue;
        }
        
        int right = left;
        int vowelIndex = 0;
        
        while (right < len) {
            char currentChar = word[right];
            
            if (vowelIndex < 5 && currentChar == vowels[vowelIndex]) {
                right++;
            } else if (vowelIndex < 4 && currentChar == vowels[vowelIndex + 1]) {
                vowelIndex++;
                right++;
            } else if (vowelIndex > 0 && currentChar == vowels[vowelIndex]) {
                right++;
            } else {
                break;
            }
        }
        
        if (vowelIndex == 4) {
            int currentLength = right - left;
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        }
        
        left++;
    }
    
    return maxLength;
}

int main() {
    char word[100001];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    if (word[0] == '"') {
        memmove(word, word + 1, strlen(word));
        word[strlen(word) - 1] = 0;
    }
    printf("%d\n", longestBeautifulSubstring(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track window state

✓ Linear Space

Constraints

1 ≤ word.length ≤ 5 × 10⁵
word consists of vowels only: 'a', 'e', 'i', 'o', and 'u'
Beautiful substring requires all 5 vowels in alphabetical order

67.4K Views

Medium-High Frequency

~18 min Avg. Time

1.9K 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