Longest Substring Of All Vowels in Order - Problem

A string is considered beautiful if it satisfies the following conditions:

Each of the 5 English vowels ('a', 'e', 'i', 'o', 'u') must appear at least once in it.
The letters must be sorted in alphabetical order (i.e. all 'a's before 'e's, all 'e's before 'i's, etc.).

For example, strings "aeiou" and "aaaaaaeiiiioou" are considered beautiful, but "uaeio", "aeoiu", and "aaaeeeooo" are not beautiful.

Given a string word consisting of English vowels, return the length of the longest beautiful substring of word. If no such substring exists, return 0.

A substring is a contiguous sequence of characters in a string.

Input & Output

Example 1 — Basic Beautiful Substring

$ Input: word = "aeiouaaaeiou"

› Output: 13

💡 Note: The longest beautiful substring is "aeiouaaaeiou" with length 13. It contains all vowels a,e,i,o,u in order.

Example 2 — Multiple Beautiful Substrings

$ Input: word = "aeiou"

› Output: 5

💡 Note: The entire string "aeiou" is beautiful with length 5. It contains each vowel exactly once in alphabetical order.

Example 3 — No Beautiful Substring

$ Input: word = "uaeio"

› Output: 0

💡 Note: No beautiful substring exists because the vowels are not in alphabetical order.

Constraints

1 ≤ word.length ≤ 5 × 10⁴
word consists of only English vowels

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to use a sliding window or state machine approach to track vowel sequences in alphabetical order. We start a new window when we encounter 'a' and expand it while maintaining the correct vowel order. Best approach is sliding window with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

For each starting position, check all substrings to find the longest one that contains all 5 vowels in alphabetical order.

Sliding Window

⏱️ Time: O(n) Space: O(1)

Use a sliding window approach to track consecutive vowels in order. When we encounter a vowel that breaks the sequence, start a new window.

State Machine

⏱️ Time: O(n) Space: O(1)

Implement a state machine that tracks which vowel we're currently expecting. This ensures we only process valid beautiful substring candidates.

Brute Force — Algorithm Steps

Step 1: Try every possible starting position
Step 2: For each start, extend substring and check if beautiful
Step 3: Track maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Starts

Start from each position

Extend Length

Check each possible ending

Validate

Check if substring is beautiful

Code -

solution.c — C

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

int solution(char* word) {
    int n = strlen(word);
    if (n < 5) {
        return 0;
    }
    
    char vowels[] = "aeiou";
    int max_len = 0;
    
    int i = 0;
    while (i < n) {
        if (word[i] != 'a') {
            i++;
            continue;
        }
        
        int start = i;
        int vowel_idx = 0;
        int vowel_count = 0;
        
        while (i < n && vowel_idx < 5) {
            if (word[i] == vowels[vowel_idx]) {
                if (vowel_count == 0 || word[i-1] != vowels[vowel_idx]) {
                    vowel_count++;
                }
                i++;
            } else if (vowel_idx < 4 && word[i] == vowels[vowel_idx + 1]) {
                vowel_idx++;
                if (word[i-1] != vowels[vowel_idx]) {
                    vowel_count++;
                }
                i++;
            } else {
                break;
            }
        }
        
        if (vowel_count == 5) {
            int len = i - start;
            if (len > max_len) {
                max_len = len;
            }
        }
        
        if (i == start) {
            i++;
        }
    }
    
    return max_len;
}

int main() {
    char s[100];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops for start/end positions, plus linear validation for each substring

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

23.0K Views

Medium 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

Longest Substring Of All Vowels in Order - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler