Can the first player win?

def predict_the_winner(nums):
    n = len(nums)
    diff = nums[:]                        # diff[j] for the interval [i, j]; length 1: the number itself
    for i in range(n - 2, -1, -1):
        for j in range(i + 1, n):
            # take the left end (opponent then leads by the old diff[j]) or the right end
            diff[j] = max(nums[i] - diff[j], nums[j] - diff[j - 1])
    return diff[n - 1] >= 0

#include <algorithm>
#include <vector>

bool solve(const std::vector<int>& nums) {
    const int n = nums.size();
    std::vector<long long> diff(nums.begin(), nums.end());
    for (int i = n - 2; i >= 0; --i)
        for (int j = i + 1; j < n; ++j) diff[j] = std::max(nums[i] - diff[j], nums[j] - diff[j - 1]);   // left or right end
    return diff[n - 1] >= 0;
}

class Solution {
    public boolean predictTheWinner(int[] nums) {
        int n = nums.length;
        long[] diff = new long[n];
        for (int i = 0; i < n; i++) diff[i] = nums[i];
        for (int i = n - 2; i >= 0; i--)
            for (int j = i + 1; j < n; j++) diff[j] = Math.max(nums[i] - diff[j], nums[j] - diff[j - 1]);   // left or right end
        return diff[n - 1] >= 0;
    }
}

function predictTheWinner(nums) {
  const n = nums.length, diff = [...nums];
  for (let i = n - 2; i >= 0; i--)
    for (let j = i + 1; j < n; j++) diff[j] = Math.max(nums[i] - diff[j], nums[j] - diff[j - 1]);   // left or right end
  return diff[n - 1] >= 0;
}

fn solve(nums: &[i64]) -> bool {
    let n = nums.len();
    let mut diff = nums.to_vec();
    for i in (0..n.saturating_sub(1)).rev() {
        for j in i + 1..n {
            diff[j] = (nums[i] - diff[j]).max(nums[j] - diff[j - 1]);   // left or right end
        }
    }
    diff[n - 1] >= 0
}

import Data.Array

solve :: [Int] -> Bool
solve nums = diff ! (0, n - 1) >= 0
  where
    n = length nums
    a = listArray (0, n - 1) nums
    -- diff ! (i, j): the most the player to move can lead by on nums[i..j]
    diff = array ((0, 0), (n - 1, n - 1)) [((i, j), go i j) | i <- [0 .. n - 1], j <- [0 .. n - 1]] :: Array (Int, Int) Int
    go i j
      | i > j = 0
      | i == j = a ! i
      | otherwise = max (a ! i - diff ! (i + 1, j)) (a ! j - diff ! (i, j - 1))