Vowels Game in a String

Vowels Game in a String - Problem

Alice and Bob are playing a game on a string. You are given a string s, and Alice and Bob will take turns playing the following game where Alice starts first:

On Alice's turn, she has to remove any non-empty substring from s that contains an odd number of vowels.
On Bob's turn, he has to remove any non-empty substring from s that contains an even number of vowels.

The first player who cannot make a move on their turn loses the game. We assume that both Alice and Bob play optimally.

Return true if Alice wins the game, and false otherwise.

The English vowels are: a, e, i, o, and u.

Input & Output

Example 1 — String with vowels

$ Input: s = "leetcodeisgreat"

› Output: true

💡 Note: Alice can remove any single vowel (like 'e') which has odd count 1, forcing the game to continue until she wins

Example 2 — String with no vowels

$ Input: s = "bbcd"

› Output: false

💡 Note: No vowels in string, so Alice cannot make any move and loses immediately

Example 3 — Single vowel

$ Input: s = "a"

› Output: true

💡 Note: Alice takes the single vowel 'a' (odd count = 1), Bob has no moves left, Alice wins

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20

The key insight is that Alice wins if and only if the string contains at least one vowel. This is because Alice can always remove any single vowel (which has odd count = 1), while Bob needs even-count substrings. Best approach uses simple vowel detection: Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^n) Space: O(n²)

Generate all possible substrings, count vowels in each, and simulate the game by tracking available moves for Alice (odd vowel count) and Bob (even vowel count). Use recursive game theory to determine the winner.

Mathematical Insight

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

The key insight is that Alice can always win if there's at least one vowel, because she can take any single vowel (odd count = 1) and force Bob into a difficult position. If no vowels exist, no one can move and Alice loses.

Brute Force Simulation — Algorithm Steps

Generate all substrings and count vowels
Recursively simulate game states
Track whose turn it is and available moves

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Moves

Find all valid substrings for current player

Recursive Simulation

Try each move and check if opponent loses

Backtrack

Return true if any move leads to opponent loss

Code -

solution.c — C

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

int countVowels(const char* substr, int len) {
    int count = 0;
    for (int i = 0; i < len; i++) {
        if (substr[i] == 'a' || substr[i] == 'e' || substr[i] == 'i' || substr[i] == 'o' || substr[i] == 'u') {
            count++;
        }
    }
    return count;
}

bool canWin(char* currentS, bool aliceTurn) {
    int n = strlen(currentS);
    bool foundMove = false;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int vowelCount = countVowels(currentS + i, j - i);
            if ((aliceTurn && vowelCount % 2 == 1) || (!aliceTurn && vowelCount % 2 == 0)) {
                foundMove = true;
                char* newS = malloc(n + 1);
                strncpy(newS, currentS, i);
                strcpy(newS + i, currentS + j);
                if (!canWin(newS, !aliceTurn)) {
                    free(newS);
                    return true;
                }
                free(newS);
            }
        }
    }
    
    return false;
}

bool solution(char* s) {
    return canWin(s, true);
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    bool result = solution(s);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Recursive game tree explores exponential number of states

✓ Linear Growth

Space Complexity

O(n²)

Stores all substrings and recursive call stack

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler