Predict the Winner - Practice Coding Problems

Predict the Winner - Problem

Array Math Dynamic Programming Recursion Game Theory Medium

Predict the Winner is a classic game theory problem where two strategic players compete for the highest score.

You're given an integer array nums representing numbered cards arranged in a line. Two players take turns picking cards, but there's a catch: they can only pick from either end of the array (leftmost or rightmost card).

Game Rules:
• Player 1 starts first
• Both players begin with score 0
• On each turn, a player picks one card from either end
• The picked card's value is added to their score
• Both players play optimally (always make the best possible move)

Goal: Return true if Player 1 can win or tie the game, false otherwise.

Example: With cards [1, 5, 2], Player 1 can pick 2, then Player 2 picks 5, then Player 1 picks 1. Final scores: Player 1 = 3, Player 2 = 5. Player 1 loses!

Input & Output

example_1.py — Simple Case

$ Input: nums = [1, 5, 2]

› Output: false

💡 Note: Player 1 starts and can pick either 1 or 2. If Player 1 picks 1, Player 2 picks 5, then Player 1 gets 2. Final scores: Player 1 = 3, Player 2 = 5. If Player 1 picks 2, Player 2 picks 5, then Player 1 gets 1. Final scores: Player 1 = 3, Player 2 = 5. Either way, Player 2 wins.

example_2.py — Player 1 Wins

$ Input: nums = [1, 5, 233, 7]

› Output: true

💡 Note: Player 1 picks 7, Player 2 must pick from [1, 5, 233]. If Player 2 picks 1, Player 1 picks 233, Player 2 gets 5. Scores: Player 1 = 240, Player 2 = 6. If Player 2 picks 233, Player 1 picks 5, Player 2 gets 1. Scores: Player 1 = 12, Player 2 = 234. Player 1 should pick 7, then Player 2's best is to pick 233, giving Player 1 the win with smart subsequent moves.

example_3.py — Single Element

$ Input: nums = [10]

› Output: true

💡 Note: Only one element exists. Player 1 picks it and wins with score 10 vs Player 2's score 0.

Visualization

Tap to expand

Understanding the Visualization

Model the Problem

Represent as a minimax game where each player optimizes their advantage

Recursive Structure

Each game state depends on optimal play in smaller subgames

Add Memoization

Cache results to avoid recalculating the same subgame scenarios

Return Final Decision

Player 1 wins if their optimal advantage is ≥ 0

Key Takeaway

🎯 Key Insight: This is a minimax problem where Player 1 maximizes their score advantage while Player 2 minimizes it. Memoization transforms an exponential solution into a polynomial one by avoiding redundant subproblem calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each unique subarray (left,right) is computed only once, and there are O(n²) possible subarrays

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for all possible (left,right) pairs, plus O(n) recursion stack

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 20
-10⁷ ≤ nums[i] ≤ 10⁷
Both players play optimally

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming with memoization to achieve O(n²) time complexity. The key insight is that this is a minimax game theory problem where Player 1 tries to maximize their score advantage while Player 2 tries to minimize it. By caching results of subproblems (subarrays defined by left and right indices), we eliminate exponential redundant calculations and achieve polynomial time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Simulation (Brute Force)	O(2^n)	O(n)	Recursively try all possible game scenarios to find optimal play
Dynamic Programming with Memoization (Optimal)	O(n²)	O(n²)	Cache recursive results to avoid recalculating same subproblems

Recursive Simulation (Brute Force) — Algorithm Steps

Start with the full array and Player 1's turn
For current player, try picking from left end or right end
Recursively solve the remaining subarray with the other player's turn
Current player chooses the option that gives them maximum advantage
Base case: when array is empty, return 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with full array [1,5,233,7] and Player 1's turn

Player 1 Choices

Player 1 can pick 1 (left) or 7 (right), explore both branches

Recursive Exploration

For each choice, recursively solve the remaining subproblem

Backtrack & Choose

Compare results and choose the option that maximizes advantage

Code -

solution.c — C

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

int helper(int* nums, int left, int right, int isPlayer1Turn) {
    if (left > right) return 0;
    
    if (isPlayer1Turn) {
        int pickLeft = nums[left] + helper(nums, left + 1, right, 0);
        int pickRight = nums[right] + helper(nums, left, right - 1, 0);
        return pickLeft > pickRight ? pickLeft : pickRight;
    } else {
        int pickLeft = helper(nums, left + 1, right, 1) - nums[left];
        int pickRight = helper(nums, left, right - 1, 1) - nums[right];
        return pickLeft < pickRight ? pickLeft : pickRight;
    }
}

int predictTheWinner(int* nums, int numsSize) {
    return helper(nums, 0, numsSize - 1, 1) >= 0;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%s\n", predictTheWinner(nums, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each recursive call branches into 2 choices, creating a binary tree of height n

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth equals the number of elements in the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 20
-10⁷ ≤ nums[i] ≤ 10⁷
Both players play optimally

89.2K Views

Medium-High Frequency

~25 min Avg. Time

2.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

Recursive Simulation (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler