Vowels Game in a String - Practice Coding Problems

Vowels Game in a String - Problem

Vowels Game in a String is a fascinating strategic game theory problem where two players compete optimally to avoid losing.

🎮 The Game Rules:
• Alice starts first and must remove any non-empty substring containing an odd number of vowels (a, e, i, o, u)
• Bob follows and must remove any non-empty substring containing an even number of vowels
• Players alternate turns until one cannot make a valid move
• The first player unable to move loses the game

🧠 Your Task: Given a string s, determine if Alice wins when both players play optimally. Return true if Alice wins, false if Bob wins.

Key Insight: This isn't about simulating the entire game - it's about finding the mathematical pattern that determines the winner based on the initial string structure.

Input & Output

example_1.py — Basic case with vowels

$ Input: s = "leetcode"

› Output: true

💡 Note: Alice wins because there are vowels in the string. She can make moves like removing "e" (1 vowel, odd) or "ee" (2 vowels, even - wait, this is Bob's move). Alice can remove "e" (1 vowel - odd), then Bob must remove a substring with even vowels, and so on. Since Alice goes first and vowels exist, she can always find a winning strategy.

example_2.py — String with no vowels

$ Input: s = "bbcd"

› Output: false

💡 Note: Alice loses because there are no vowels in the string. She cannot make any valid move (needs odd vowel count ≥ 1), so she loses immediately on her first turn.

example_3.py — Single vowel

$ Input: s = "a"

› Output: true

💡 Note: Alice wins by removing the entire string "a" which contains 1 vowel (odd number). After this move, Bob faces an empty string and cannot make any move, so Alice wins.

Visualization

Tap to expand

Understanding the Visualization

Analyze Game Rules

Alice removes odd-vowel substrings, Bob removes even-vowel substrings

Find Winning Pattern

If vowels exist, Alice can remove entire string (odd count ≥ 1)

Apply Strategy

Alice's optimal first move: take the whole string when possible

Determine Winner

Count vowels: >0 means Alice wins, =0 means Alice loses

Key Takeaway

🎯 Key Insight: This game theory problem has a surprisingly simple solution - Alice wins if and only if there's at least one vowel in the string, because she can always remove the entire string as her winning move!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string to count vowels

✓ Linear Growth

Space Complexity

O(1)

Only storing vowel count variable

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of lowercase English letters
The game assumes both players play optimally

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

This is a game theory problem with an elegant mathematical solution. The key insight is that Alice wins if and only if the string contains at least one vowel. When vowels exist, Alice can always remove the entire string as one substring (which will have an odd vowel count ≥ 1), leaving Bob with an empty string and no valid moves. The optimal solution runs in O(n) time by simply counting vowels.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Analysis (Optimal)	O(n)	O(1)	Analyze the game mathematically - Alice wins if any vowels exist

Mathematical Analysis (Optimal) — Algorithm Steps

Count the total number of vowels in the string
If vowel count > 0, Alice wins (she can take the whole string)
If vowel count = 0, Alice loses (no valid moves)
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Vowels

Scan string once to count total vowels

Check Condition

If vowels > 0, Alice can take entire string

Winning Move

Entire string has odd vowel count ≥ 1

Game Over

Bob faces empty string and loses

Code -

solution.c — C

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

bool doesAliceWin(char* s) {
    // Count vowels in the string
    int vowelCount = 0;
    int n = strlen(s);
    for (int i = 0; i < n; i++) {
        char c = s[i];
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            vowelCount++;
        }
    }
    // Alice wins if there's at least one vowel
    return vowelCount > 0;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        memmove(s, start, strlen(start) + 1);
    }
    
    printf("%s\n", doesAliceWin(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string to count vowels

✓ Linear Growth

Space Complexity

O(1)

Only storing vowel count variable

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of lowercase English letters
The game assumes both players play optimally

24.7K Views

Medium Frequency

~8 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler