Sum Game - Practice Coding Problems

Sum Game - Problem

Sum Game is a strategic two-player game where Alice and Bob compete to control the outcome of a mathematical equation.

You're given a string num of even length containing digits and '?' characters. Alice starts first, and players alternate turns. On each turn, a player must:

1. Choose an index i where num[i] == '?'
2. Replace it with any digit from '0' to '9'

The game ends when all '?' characters are filled. Bob wins if the sum of digits in the first half equals the sum of digits in the second half. Alice wins if the sums are different.

Example: If the final string is "243801", Bob wins because 2+4+3 = 8+0+1 = 9. If it's "243803", Alice wins because 2+4+3 ≠ 8+0+3.

Assuming both players play optimally, determine if Alice will win.

Input & Output

example_1.py — Basic case

$ Input: num = "5023"

› Output: false

💡 Note: No question marks exist, so the game ends immediately. Left sum = 5+0 = 5, Right sum = 2+3 = 5. Since the sums are equal, Bob wins, so Alice does not win (return false).

example_2.py — Alice advantage

$ Input: num = "25??"

› Output: true

💡 Note: Left sum = 2+5 = 7, Right sum = 0 (both are ?). Alice goes first and will place a small digit (0) in the right half. Bob must place a digit, but Alice's second move can ensure the sums remain unequal. Alice wins.

example_3.py — Balanced scenario

$ Input: num = "?3?2"

› Output: true

💡 Note: Left: ?+3, Right: ?+2. Current difference is 1 (3-2). With optimal play, Alice can prevent Bob from achieving perfect balance by strategically choosing her digits.

Constraints

2 ≤ num.length ≤ 10⁵
num.length is even
num consists of digits and '?' characters only

Visualization

Tap to expand

Understanding the Visualization

Initial Assessment

Examine the current state: sum each half and count the question marks

Calculate Advantage

Determine the current imbalance and how question marks are distributed

Optimal Strategy

Alice maximizes differences, Bob minimizes them - both play optimally

Mathematical Formula

Apply the game theory formula to predict the outcome instantly

Key Takeaway

🎯 Key Insight: Game theory allows us to predict optimal play outcomes through mathematical analysis rather than expensive simulation, turning an exponential problem into a linear one.

Asked in

G Google 23 ⊞ Microsoft 15 a Amazon 12 f Meta 8

This game theory problem can be solved optimally using mathematical analysis rather than game simulation. The key insight is that with optimal play, we can determine the winner by analyzing the current state: calculate the sum difference between halves and the distribution of question marks, then apply the formula 2*diff + netQ*9 ≠ 0 to determine if Alice wins. This eliminates the need for expensive recursive simulation and provides an O(n) time, O(1) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Game Theory Analysis (Optimal)	O(n)	O(1)	Analyze the mathematical conditions for optimal play without simulating the game

Mathematical Game Theory Analysis (Optimal) — Algorithm Steps

Calculate current sum difference between left and right halves
Count question marks in left half (leftQ) and right half (rightQ)
Determine total question marks and who gets the last move
Analyze if Bob can achieve balance given the turn order
Use mathematical formula to determine if Alice can prevent Bob's victory

Visualization

Tap to expand

Step-by-Step Walkthrough

Split and Count

Divide string into halves, count existing digits and question marks

Calculate Difference

Find current sum difference between left and right halves

Analyze Turn Order

Determine how question marks will be filled with optimal play

Apply Formula

Use the mathematical condition: 2*diff + netQ*9 ≠ 0 means Alice wins

Return Result

Alice wins if she can prevent Bob from achieving balance

Code -

solution.c — C

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

bool sumGame(char* num) {
    int n = strlen(num);
    int half = n / 2;
    
    // Calculate current sums and count question marks
    int leftSum = 0, leftQ = 0, rightSum = 0, rightQ = 0;
    
    for (int i = 0; i < half; i++) {
        if (num[i] == '?') {
            leftQ++;
        } else {
            leftSum += num[i] - '0';
        }
    }
    
    for (int i = half; i < n; i++) {
        if (num[i] == '?') {
            rightQ++;
        } else {
            rightSum += num[i] - '0';
        }
    }
    
    // Current difference (left - right)
    int diff = leftSum - rightSum;
    
    // Net question marks (right - left)
    int netQ = rightQ - leftQ;
    
    // Bob wins iff 2*diff + netQ*9 = 0
    return 2 * diff + netQ * 9 != 0;
}

int main() {
    char num[100001];
    scanf("%s", num);
    printf("%s\n", sumGame(num) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to calculate sums and count question marks

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store counts and sums

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Mathematical Game Theory Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler