Last updated on February 2nd, 2025 at 04:50 am
Here, we see a Predict the Winner LeetCode Solution. This Leetcode problem is solved using different approaches in many programming languages, such as C++, Java, JavaScript, Python, etc.
List of all LeetCode Solution
Topics
Dynamic Programming, Minimax
Companies
Level of Question
Medium
Predict the Winner LeetCode Solution
Table of Contents
1. Problem Statement
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.
Example 1:
Input: nums = [1,5,2]
Output: false
Explanation: Initially, player 1 can choose between 1 and 2. If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. Hence, player 1 will never be the winner and you need to return false.
Example 2:
Input: nums = [1,5,233,7]
Output: true
Explanation: Player 1 first chooses 1. Then player 2 has to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233. Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.
2. Coding Pattern Used in Solution
The coding pattern used in this code is “Dynamic Programming with Minimax”. This pattern involves using dynamic programming to solve a two-player game where each player tries to maximize their score while minimizing the opponent’s score.
3. Code Implementation in Different Languages
3.1 Predict the Winner LeetCode C++
class Solution {
bool checkWin(int ans,int total){
return ans>=total-ans;
}
int maxScore(vector<int>&A,int total,int i,int j){
if(i>j)
return 0;
return total-min(maxScore(A,total-A[i],i+1,j),maxScore(A,total-A[j],i,j-1));
}
public:
bool predictTheWinner(vector<int>& nums) {
int total=0;
for(auto x:nums)
total+=x;
return checkWin(maxScore(nums,total,0,nums.size()-1),total);
}
};
3.2 Predict the Winner LeetCode Java
class Solution {
int[][] dp;
private int score(int[] nums, int l, int r) {
if (dp[l][r] != -1) {
return dp[l][r];
}
if (l == r) {
return nums[l];
}
int left = nums[l] - score(nums, l + 1, r);
int right = nums[r] - score(nums, l, r - 1);
dp[l][r] = Math.max(left, right);
return dp[l][r];
}
public boolean predictTheWinner(int[] nums) {
int n = nums.length;
dp = new int[n][n];
for (int i = 0; i < n; ++i) {
Arrays.fill(dp[i], -1);
}
return score(nums, 0, n - 1) >= 0;
}
}
3.3 Predict the Winner Leetcode JavaScript
var predictTheWinner = function(nums) {
const n = nums.length;
const dp = Array.from(Array(n), () => Array(n).fill(0));
for (let i = n-1; i >= 0; --i) {
for (let j = i; j < n; ++j) {
if (i == j) {
dp[i][j] = nums[i];
} else {
dp[i][j] = Math.max(nums[i] - dp[i+1][j], nums[j] - dp[i][j-1]);
}
}
}
return dp[0][n-1] >= 0;
};
3.4 Predict the Winner Leetcode Python
class Solution(object):
def predictTheWinner(self, nums):
n = len(nums)
dp = [[-1 for _ in range(n)] for _ in range(n)]
return self.score(nums, 0, n - 1, dp) >= 0
def score(self, nums, l, r, dp):
if dp[l][r] != -1:
return dp[l][r]
if l == r:
return nums[l]
left = nums[l] - self.score(nums, l + 1, r, dp)
right = nums[r] - self.score(nums, l, r - 1, dp)
dp[l][r] = max(left, right)
return dp[l][r]
4. Time and Space Complexity
| Time Complexity | Space Complexity | |
| C++ | O(2^n) (Recursive) | O(n) |
| Java | O(n²) | O(n²) |
| JavaScript | O(n²) | O(n²) |
| Python | O(n²) | O(n²) |
- The code uses a Dynamic Programming with Minimax pattern to solve the problem.
- It calculates the maximum score difference for all subarrays, assuming both players play optimally.
- The time complexity is O(n²) for the DP implementations, and the space complexity is O(n²) due to the DP table.