Here, We see ** Predict the Winner LeetCode Solution**. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

*List of all LeetCode Solution*

*List of all LeetCode Solution*

**Predict the Winner LeetCode Solution**

## Table of Contents

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

*Predict the Winner LeetCode Solution* *C++*

*Predict the Winner LeetCode Solution*

*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);
}
};
```

Code language: PHP (php)

*Predict the Winner LeetCode Solution* *Java*

*Predict the Winner LeetCode Solution*

*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;
}
}
```

Code language: PHP (php)

*Predict the Winner Solution* *JavaScript*

*Predict the Winner Solution*

*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;
};
```

Code language: JavaScript (javascript)

*Predict the Winner Solution* *Python*

*Predict the Winner Solution*

*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]
```