You are given an integer array nums.

Two players, Alice and Bob, play a game in turns, with Alice playing first.

• In each turn, the current player chooses any subarray nums[l..r] such that r - l + 1 < m, where m is the current length of the array.
• The selected subarray is removed, and the remaining elements are concatenated to form the new array.
• The game continues until only one element remains.

Alice aims to maximize the final element, while Bob aims to minimize it. Assuming both play optimally, return the value of the final remaining element.

Explanation:

Let's understand what each move allows. On any turn, a player must remove a subarray (a contiguous block of elements) whose length is strictly less than the current array length m. This means a player cannot remove the entire array in one move, but they can remove any contiguous portion as long as at least one element is left behind.

The key observation comes from focusing on the first and last elements of the array:

• Since Alice plays first, she has the power to remove a large contiguous chunk. In particular, Alice can remove every element except the first and last elements in a single move. After such a move, only nums[0] and nums[n - 1] remain. From there, removing one of the two leaves the larger as the final element. This shows the result can be at least max(nums[0], nums[n - 1]).

• Now consider the middle elements at indices 1, 2, ..., n - 2. Suppose Alice wanted to preserve one of these middle values to be the final answer. Whenever it gets down to a small array containing that middle element, Bob can simply remove a subarray that includes it. Because the element is in the middle, it is never "protected" by being at an end, so Bob can always eliminate it. This shows the result can be at most max(nums[0], nums[n - 1]).

Combining both bounds, the final remaining element is exactly max(nums[0], nums[n - 1]).

At first glance this looks like a complicated game-theory problem where we might need to simulate every possible move for both Alice and Bob. But before jumping into complex search or dynamic programming, it helps to ask a simpler question: which elements can each player actually control?

Notice the special role of the two endpoints, nums[0] and nums[n - 1]. These elements are different from the rest because they sit at the boundaries of the array. A middle element can always be "surrounded" and swallowed up inside a removed subarray, but the endpoints are harder to get rid of without removing a large piece of the array.

Now think about Alice's advantage: she moves first, and the rule only forbids removing the entire array at once. So on her very first turn, Alice can remove the whole middle section, leaving just nums[0] and nums[n - 1]. With only two elements left, whoever moves next must remove exactly one of them, leaving the other. This means Alice can guarantee a result of at least max(nums[0], nums[n - 1]) — she steers the game straight toward the better of the two endpoints.

Next, think about whether Alice could ever do better than the endpoints by keeping some large middle value. Here Bob steps in. Any middle element is reachable by a subarray removal that doesn't touch both ends, so Bob can always cut out a chunk containing that middle value whenever it's his turn. Because Bob wants to minimize, he will never let a middle element survive to the end. So Alice can never force a middle value to be the answer, meaning the result is at most max(nums[0], nums[n - 1]).

Putting the two ideas together — Alice can guarantee at least max(nums[0], nums[n - 1]), and Bob prevents anything larger — the game must settle exactly at max(nums[0], nums[n - 1]). The seemingly complex game collapses into a single comparison between the two endpoints, no simulation needed.

Pattern Learn more about Math patterns.

Based on the intuition above, the implementation becomes remarkably simple — we don't need any game simulation, recursion, or dynamic programming. The entire problem reduces to a single comparison.

Algorithm / Pattern used: This is a brain teaser (math observation) problem. The whole "game" is a distraction; once we prove that the answer is always max(nums[0], nums[n - 1]), the coding part is trivial.

Steps:

1. Identify the first element of the array, nums[0].
2. Identify the last element of the array, nums[n - 1] (written as nums[-1] in Python).
3. Return the larger of these two values using max.

Data structures: None are needed beyond the input array itself. We only access two positions by index.

The code directly mirrors these three steps:

class Solution:
    def finalElement(self, nums: List[int]) -> int:
        return max(nums[0], nums[-1])

Why this works:

• nums[0] and nums[-1] give us constant-time access to the two endpoints.
• max(...) picks the bigger endpoint, which we proved is exactly the value both players are forced into when playing optimally.

Complexity Analysis:

• Time complexity: O(1), since we only read two array elements and perform one comparison, regardless of the array's size.
• Space complexity: O(1), as no extra space proportional to the input is used.

This is a good reminder that some "game" problems hide a simple closed-form answer behind a complicated-sounding setup — recognizing the controlling structure (here, the two endpoints) lets us skip any heavy computation entirely.