Predict the Winner

Predict the Winner - Problem

Array Math Dynamic Programming Recursion Game Theory Medium

You are given an integer array nums. Two players are playing a game with this array: player 1 and player 2.

Player 1 and player 2 take turns, with player 1 starting first. Both players start the game with a score of 0. At each turn, the player takes one of the numbers from either end of the array (i.e., nums[0] or nums[nums.length - 1]) which reduces the size of the array by 1. The player adds the chosen number to their score.

The game ends when there are no more elements in the array. Return true if Player 1 can win the game. If the scores of both players are equal, then player 1 is still the winner, and you should also return true. You may assume that both players are playing optimally.

Input & Output

Example 1 — Player 1 Wins

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

› Output: false

💡 Note: Player 1 takes 2, Player 2 takes 5, Player 1 takes 1. Player 1 gets 3, Player 2 gets 5. Player 2 wins.

Example 2 — Player 1 Wins Optimally

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

› Output: true

💡 Note: Player 1 takes 1, Player 2 takes 7, Player 1 takes 233, Player 2 takes 5. Player 1 gets 234, Player 2 gets 12. Player 1 wins.

Example 3 — Equal Scores

$ Input: nums = [1,1]

› Output: true

💡 Note: Player 1 takes any element and gets 1, Player 2 gets 1. Tie goes to Player 1.

Constraints

1 ≤ nums.length ≤ 20
-10⁷ ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to track the maximum score difference (advantage) a player can achieve rather than absolute scores. The optimal approach uses dynamic programming to compute this difference for all subarrays. Time: O(n²), Space: O(n) with space optimization.

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(n²) Space: O(n²)

Build a 2D DP table where dp[i][j] represents the maximum score difference the current player can achieve over their opponent when playing optimally on subarray from index i to j.

Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

Try every possible sequence of moves by simulating both players' optimal choices. For each turn, check both possible moves (taking from left or right end) and choose the one that maximizes the current player's advantage.

Memoized Recursion

⏱️ Time: O(n²) Space: O(n²)

Same recursive logic as brute force, but store results of subproblems in a cache. Since there are only O(n²) possible game states (defined by left and right boundaries), memoization dramatically improves performance.

Space-Optimized DP

⏱️ Time: O(n²) Space: O(n)

Since we only need the previous row to compute the current row in our DP table, we can optimize space by using just a 1D array and updating it in-place.

2D Dynamic Programming — Algorithm Steps

Create 2D DP table for all subarray ranges
Fill base case: single elements (no opponent)
For each subarray length, compute optimal score difference
Final answer is whether dp[0][n-1] >= 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Single elements: player takes the number

Build Up

Fill longer subarrays using optimal choices

Final Answer

dp[0][n-1] tells if Player 1 wins

Code -

solution.c — C

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

#define MAX_N 1000

bool solution(int* nums, int n) {
    static int dp[MAX_N][MAX_N];
    
    // Initialize dp table
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Base case: single elements
    for (int i = 0; i < n; i++) {
        dp[i][i] = nums[i];
    }
    
    // Fill for increasing lengths
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            int takeLeft = nums[i] - dp[i + 1][j];
            int takeRight = nums[j] - dp[i][j - 1];
            dp[i][j] = takeLeft > takeRight ? takeLeft : takeRight;
        }
    }
    
    return dp[0][n - 1] >= 0;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops iterate through all possible subarray ranges

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table stores results for all subarray combinations

⚠ Quadratic Space

78.0K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler