Find the Longest Substring Containing Vowels in Even Counts - Problem

Given a string s, return the length of the longest substring containing each vowel ('a', 'e', 'i', 'o', 'u') an even number of times.

A substring is a contiguous sequence of characters within a string. For the substring to be valid, every vowel must appear an even number of times (including zero times).

Note: Consonants can appear any number of times and don't affect the validity of the substring.

Input & Output

Example 1 — Basic Case

$ Input: s = "eleetminicoworoep"

› Output: 13

💡 Note: The longest valid substring has length 13. Using the bit manipulation approach, we track vowel parity states and find the longest substring between two positions with the same parity state for all vowels.

Example 2 — No Vowels

$ Input: s = "bcbcbc"

› Output: 6

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

Example 3 — All Odd Counts

$ Input: s = "aeiou"

› Output: 0

💡 Note: Each vowel appears exactly once (odd count). No valid substring exists where all vowels have even counts.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

f Facebook 8 a Amazon 5 M Microsoft 3

The key insight is using bit manipulation to track vowel parity states efficiently. When the same parity pattern repeats, the substring between those positions has all even vowel counts. Best approach uses bitmask with hash map in O(n) time and O(n) space.

Common Approaches

✓ Bit Manipulation with Prefix States

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

Represent vowel parity as a 5-bit mask where each bit indicates if a vowel count is odd. Two positions with the same mask have a valid substring between them.

Brute Force - Check All Substrings

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

For every possible substring, count the occurrences of each vowel and check if all counts are even. Keep track of the maximum length found.

Prefix Sum with State Mapping

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

Maintain running counts of vowels and use their parity as a state. Two positions with identical parity states create a valid substring with all even vowel counts.

Bit Manipulation with Prefix States — Algorithm Steps

Initialize mask = 0 and store position -1
For each character, toggle corresponding vowel bit
If mask seen before, calculate substring length
Update maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with mask=0, store position -1

Toggle Bits

XOR corresponding vowel bit for each character

Find Matches

When mask repeats, calculate substring length

Code -

solution.c — C

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

#define MAX_STATES 1024

struct StateEntry {
    int state;
    int position;
    int valid;
};

int hash_state(int state) {
    return state % MAX_STATES;
}

int findState(struct StateEntry* table, int state) {
    int h = hash_state(state);
    for (int j = 0; j < MAX_STATES; j++) {
        int idx = (h + j) % MAX_STATES;
        if (!table[idx].valid) return -1;
        if (table[idx].state == state) {
            return table[idx].position;
        }
    }
    return -1;
}

void insertState(struct StateEntry* table, int state, int position) {
    int h = hash_state(state);
    for (int j = 0; j < MAX_STATES; j++) {
        int idx = (h + j) % MAX_STATES;
        if (!table[idx].valid) {
            table[idx].state = state;
            table[idx].position = position;
            table[idx].valid = 1;
            return;
        }
        if (table[idx].state == state) {
            return; // already exists, don't overwrite
        }
    }
}

int solution(const char* s) {
    int counts[5] = {0, 0, 0, 0, 0}; // a, e, i, o, u
    struct StateEntry statePositions[MAX_STATES];
    memset(statePositions, 0, sizeof(statePositions));

    int maxLen = 0;

    // Insert initial state (all parities 0) at position 0
    // meaning: before we've read any characters, state=0 at pos 0
    insertState(statePositions, 0, 0);

    int len = strlen(s);
    for (int pos = 0; pos < len; pos++) {
        char c = s[pos];
        if      (c == 'a') counts[0]++;
        else if (c == 'e') counts[1]++;
        else if (c == 'i') counts[2]++;
        else if (c == 'o') counts[3]++;
        else if (c == 'u') counts[4]++;

        // Encode parity state as a 5-bit integer
        int currentState = ((((counts[0] % 2) * 2 + (counts[1] % 2)) * 2 +
                              (counts[2] % 2)) * 2 + (counts[3] % 2)) * 2 +
                             (counts[4] % 2);

        int prevPos = findState(statePositions, currentState);
        if (prevPos != -1) {
            int length = (pos + 1) - prevPos;
            if (length > maxLen) {
                maxLen = length;
            }
        } else {
            insertState(statePositions, currentState, pos + 1);
        }
    }

    return maxLen;
}

int main() {
    char s[100001];
    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)

Single pass through string with O(1) operations per character

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map stores up to n different mask states

✓ Linear Space

22.9K Views

Medium Frequency

~25 min Avg. Time

847 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

Find the Longest Substring Containing Vowels in Even Counts - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation with Prefix States — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler