Find the Longest Substring Containing Vowels in Even Counts

Find the Longest Substring Containing Vowels in Even Counts - Problem

Given a string s, find the longest substring where each vowel appears an even number of times.

The vowels are: 'a', 'e', 'i', 'o', and 'u'. A vowel appears an even number of times if it occurs 0, 2, 4, 6, ... times in the substring.

Example: In the string "eleetminicoworoep", the substring "leetminicoworo" has each vowel appearing an even number of times: e appears 2 times, i appears 2 times, o appears 4 times, while a and u appear 0 times each.

Goal: Return the length of the longest such substring.

Input & Output

example_1.py — Basic Case

$ Input: s = "eleetminicoworoep"

› Output: 13

💡 Note: The substring "leetminicoworo" (indices 1-13) contains: e=2, i=2, o=4, a=0, u=0. All vowels appear an even number of times.

example_2.py — All Consonants

$ Input: s = "bcbcbc"

› Output: 6

💡 Note: The entire string contains no vowels, so all vowels appear 0 times (even). The answer is the length of the entire string.

example_3.py — Single Vowel

$ Input: s = "a"

› Output: 0

💡 Note: The string contains only one 'a' (odd count), so there's no valid substring. The longest valid substring has length 0.

Visualization

Tap to expand

Understanding the Visualization

Initialize State

Start with all switches OFF (bitmask 0), record this state at position -1

Process Each Character

For vowels, flip the corresponding bit. For consonants, keep state unchanged

Check for Repeated State

If we've seen this exact switch configuration before, we found a valid substring

Calculate Length

Substring from previous occurrence to current position has all vowels even

Key Takeaway

🎯 Key Insight: Bitmask elegantly tracks vowel parity. When the same state appears twice, everything between has even vowel counts!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(min(n, 32))

Hash map stores at most 32 different bitmask states (2^5 vowels)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s contains only lowercase English letters
Only vowels 'a', 'e', 'i', 'o', 'u' need to be tracked

Asked in

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

The optimal solution uses bit manipulation with a hash map. Each bit in a bitmask represents whether a vowel appears an odd number of times. When the same bitmask appears twice, the substring between those positions has all vowels in even counts. This achieves O(n) time complexity with elegant mathematical insight.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring and count vowel occurrences
Bit Manipulation with Hash Map (Optimal)	O(n)	O(min(n, 32))	Use bitmask to track vowel parity states and find matching states

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through all possible starting positions
For each start, iterate through all possible ending positions
Count vowel occurrences in current substring
Check if all vowel counts are even
Update maximum length if valid substring found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start from each position and extend to create all possible substrings

Count Vowels

For each substring, count occurrences of each vowel

Check Even Counts

Verify if all vowel counts are even numbers

Track Maximum

Keep track of the longest valid 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 findTheLongestSubstring(char* s) {
    int n = strlen(s);
    int maxLen = 0;
    
    for (int i = 0; i < n; i++) {
        int vowelCount[5] = {0}; // a, e, i, o, u
        
        for (int j = i; j < n; j++) {
            // Count vowels
            switch(s[j]) {
                case 'a': vowelCount[0]++; break;
                case 'e': vowelCount[1]++; break;
                case 'i': vowelCount[2]++; break;
                case 'o': vowelCount[3]++; break;
                case 'u': vowelCount[4]++; break;
            }
            
            // Check if all vowels have even count
            bool allEven = true;
            for (int k = 0; k < 5; k++) {
                if (vowelCount[k] % 2 != 0) {
                    allEven = false;
                    break;
                }
            }
            
            if (allEven && j - i + 1 > maxLen) {
                maxLen = j - i + 1;
            }
        }
    }
    
    return maxLen;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings, each taking O(n) time to count vowels

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing vowel counts and result variables

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s contains only lowercase English letters
Only vowels 'a', 'e', 'i', 'o', 'u' need to be tracked

43.2K Views

Medium Frequency

~25 min Avg. Time

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