Find if Digit Game Can Be Won - Practice Coding Problems

Find if Digit Game Can Be Won - Problem

Array Math Easy

Welcome to an exciting number strategy game between Alice and Bob! 🎲

You are given an array of positive integers nums. Alice and Bob are competing in a clever digit-based game where Alice gets to make the first strategic choice:

Alice can choose either all single-digit numbers (1-9) OR all double-digit numbers (10-99) from the array
Bob automatically gets all the remaining numbers
Alice wins if her sum is strictly greater than Bob's sum

Your task is to determine if Alice has a winning strategy. Return true if Alice can guarantee a win by choosing optimally, otherwise return false.

Example: If nums = [1, 2, 3, 10, 20, 30]
• Option 1: Alice takes single-digits [1,2,3] (sum=6), Bob gets [10,20,30] (sum=60) → Alice loses
• Option 2: Alice takes double-digits [10,20,30] (sum=60), Bob gets [1,2,3] (sum=6) → Alice wins!

Input & Output

example_1.py — Basic Win Scenario

$ Input: nums = [1, 2, 3, 10, 20, 30]

› Output: true

💡 Note: Alice can choose double-digit numbers [10, 20, 30] with sum 60, while Bob gets single-digit numbers [1, 2, 3] with sum 6. Since 60 > 6, Alice wins.

example_2.py — No Win Scenario

$ Input: nums = [1, 2, 3, 4, 10, 11, 12]

› Output: false

💡 Note: Single-digits sum: 1+2+3+4=10, Bob gets 33-10=23. Double-digits sum: 10+11+12=33, Bob gets 33-33=0. Alice loses with single-digits (10 < 23) but would win with double-digits (33 > 0), so Alice can win.

example_3.py — Equal Distribution

$ Input: nums = [5, 5, 10, 10]

› Output: false

💡 Note: Single-digits sum: 5+5=10, Bob gets 30-10=20. Double-digits sum: 10+10=20, Bob gets 30-20=10. Alice cannot win either way: 10 < 20 and 20 > 10 but she needs strictly greater, so she can win with double-digits.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 99
All numbers are positive integers
Array contains only single-digit (1-9) and double-digit (10-99) numbers

Visualization

Tap to expand

Understanding the Visualization

Separate Numbers

Sort all numbers into single-digit (1-9) and double-digit (10-99) groups

Calculate Group Sums

Sum up each group to see their total values

Evaluate Alice's Options

For each group Alice could choose, calculate what Bob would get (remaining numbers)

Find Winning Strategy

Alice wins if either choice gives her strictly more than Bob

Return Result

Return true if Alice has a winning strategy, false otherwise

Key Takeaway

🎯 Key Insight: This is a classic optimization problem where Alice must choose between exactly two strategies. The algorithm efficiently calculates both possibilities in a single pass and selects the winning strategy if one exists.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 29 f Meta 22

The optimal solution uses a single-pass approach to calculate both possible sums simultaneously. Alice has two strategies: take all single-digit numbers (1-9) OR take all double-digit numbers (10-99). We calculate both sums in O(n) time and determine if either strategy gives Alice more than half the total sum, ensuring she beats Bob.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n)	O(1)	Calculate both possible sums by iterating through the array twice
One-Pass Calculation (Optimal)	O(n)	O(1)	Calculate both sums simultaneously in a single pass through the array

Brute Force (Multiple Passes) — Algorithm Steps

First pass: iterate through array and sum all single-digit numbers (1-9)
Calculate Bob's sum if Alice takes single-digits (total - single_digit_sum)
Second pass: iterate through array and sum all double-digit numbers (10-99)
Calculate Bob's sum if Alice takes double-digits (total - double_digit_sum)
Return true if either strategy gives Alice a strictly greater sum than Bob

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Count Single Digits

Iterate through array, sum all numbers from 1-9

Calculate Bob's First Option

Bob would get total_sum - single_digit_sum

Second Pass - Count Double Digits

Iterate through array again, sum all numbers from 10-99

Calculate Bob's Second Option

Bob would get total_sum - double_digit_sum

Compare Both Strategies

Alice wins if either choice gives her more than Bob

Code -

solution.c — C

#include <stdbool.h>

bool canAliceWin(int* nums, int numsSize) {
    // First pass: calculate sum of single-digit numbers
    int singleDigitSum = 0;
    int totalSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
        if (nums[i] >= 1 && nums[i] <= 9) {
            singleDigitSum += nums[i];
        }
    }
    
    // Bob gets remaining if Alice takes single-digits
    int bobSumIfAliceTakesSingle = totalSum - singleDigitSum;
    
    // Second pass: calculate sum of double-digit numbers
    int doubleDigitSum = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] >= 10 && nums[i] <= 99) {
            doubleDigitSum += nums[i];
        }
    }
    
    // Bob gets remaining if Alice takes double-digits
    int bobSumIfAliceTakesDouble = totalSum - doubleDigitSum;
    
    // Alice wins if either strategy gives her more than Bob
    return (singleDigitSum > bobSumIfAliceTakesSingle || 
            doubleDigitSum > bobSumIfAliceTakesDouble);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array twice, but this is still linear time

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store sums

✓ Linear Space

42.3K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler