Find the Winning Player in Coin Game - Practice Coding Problems

Find the Winning Player in Coin Game - Problem

Alice and Bob are playing an exciting strategic coin game where each player must collect exactly 115 points worth of coins on their turn!

You have two types of coins available:

Gold coins: Worth 75 points each (you have x of these)
Silver coins: Worth 10 points each (you have y of these)

Game Rules:

Alice goes first, then players alternate turns
On each turn, a player must pick coins that total exactly 115 points
The first player who cannot make exactly 115 points loses the game
Both players play optimally (they make the best possible moves)

Your task is to determine who wins this strategic battle! 🎯

Key insight: To make 115 points, a player can use a gold coins (75 each) and b silver coins (10 each) where 75a + 10b = 115

Input & Output

example_1.py — Basic Case

$ Input: x = 2, y = 8

› Output: Alice

💡 Note: Alice can make 2 turns (using all coins: 2 gold + 8 silver), Bob can make 0 turns. Since Alice makes the last move, she wins.

example_2.py — Bob Wins

$ Input: x = 4, y = 11

› Output: Bob

💡 Note: Max turns = min(4, 11÷4) = min(4, 2) = 2. Since 2 is even, Bob makes the last move and wins.

example_3.py — Edge Case

$ Input: x = 1, y = 3

› Output: Bob

💡 Note: Not enough silver coins! Need 4 silver per turn but only have 3. Max turns = min(1, 3÷4) = min(1, 0) = 0. Alice cannot move, so Bob wins immediately.

Visualization

Tap to expand

Understanding the Visualization

Setup

Start with x gold coins ($75 each) and y silver coins ($10 each)

Valid Moves

Only one way to make $115: take 1 gold + 4 silver coins

Count Turns

Calculate maximum possible turns: min(x, y÷4)

Determine Winner

Odd total turns = Alice wins, Even total turns = Bob wins

Key Takeaway

🎯 Key Insight: The equation 75a + 10b = 115 has only one integer solution: a=1, b=4. This makes the game predictable - each turn always consumes exactly 1 gold and 4 silver coins!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Just a few arithmetic operations regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra variables

✓ Linear Space

Constraints

1 ≤ x, y ≤ 10⁵
Both x and y are positive integers
Each turn must total exactly 115 points

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses mathematical analysis to solve the linear Diophantine equation 75a + 10b = 115. The key insight is that there's only one valid combination: 1 gold coin + 4 silver coins per turn. Therefore, the maximum number of turns is min(x, y÷4), and Alice wins if this number is odd (she makes the last move).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(x * y)	O(x * y)	Simulate the entire game by checking all possible moves each turn
Mathematical Analysis (Optimal)	O(1)	O(1)	Solve the linear equation 75a + 10b = 115 to find the pattern

Brute Force Simulation — Algorithm Steps

Find all valid combinations (a, b) where 75*a + 10*b = 115
For each game state (x, y, turn), try all valid moves
Recursively determine if the current player can force a win
Use memoization to cache results for efficiency

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with x gold coins and y silver coins, Alice's turn

Find Valid Moves

Calculate all ways to make exactly 115 points

Try Each Move

For each valid move, see if opponent loses in resulting state

Memoization

Cache results to avoid recalculating same states

Code -

solution.c — C

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

int memo[100001][100001];
bool initialized = false;

void initMemo() {
    if (!initialized) {
        memset(memo, -1, sizeof(memo));
        initialized = true;
    }
}

bool canWin(int gold, int silver) {
    if (gold > 100000 || silver > 100000) return false;
    if (memo[gold][silver] != -1) {
        return memo[gold][silver];
    }
    
    // Try valid moves: only (1,4) works for 75*a + 10*b = 115
    if (gold >= 1 && silver >= 4) {
        if (!canWin(gold - 1, silver - 4)) {
            memo[gold][silver] = 1;
            return true;
        }
    }
    
    memo[gold][silver] = 0;
    return false;
}

int main() {
    int x, y;
    scanf("%d %d", &x, &y);
    
    initMemo();
    
    if (canWin(x, y)) {
        printf("Alice\n");
    } else {
        printf("Bob\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(x * y)

In worst case, we might visit every possible game state (x, y) once due to memoization

✓ Linear Growth

Space Complexity

O(x * y)

Memoization table stores results for up to x * y different game states

✓ Linear Space

Constraints

1 ≤ x, y ≤ 10⁵
Both x and y are positive integers
Each turn must total exactly 115 points

42.6K Views

Medium Frequency

~12 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler