# Solving Leetcode Interviews in Seconds with AI: Maximize the Topmost Element After K Moves


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2202" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a 0-indexed integer array nums representing the contents of a pile, where nums[0] is the topmost element of the pile. In one move, you can perform either of the following:  If the pile is not empty, remove the topmost element of the pile. If there are one or more removed elements, add any one of them back onto the pile. This element becomes the new topmost element.  You are also given an integer k, which denotes the total number of moves to be made. Return the maximum value of the topmost element of the pile possible after exactly k moves. In case it is not possible to obtain a non-empty pile after k moves, return -1.   Example 1:  Input: nums = [5,2,2,4,0,6], k = 4 Output: 5 Explanation: One of the ways we can end with 5 at the top of the pile after 4 moves is as follows: - Step 1: Remove the topmost element = 5. The pile becomes [2,2,4,0,6]. - Step 2: Remove the topmost element = 2. The pile becomes [2,4,0,6]. - Step 3: Remove the topmost element = 2. The pile becomes [4,0,6]. - Step 4: Add 5 back onto the pile. The pile becomes [5,4,0,6]. Note that this is not the only way to end with 5 at the top of the pile. It can be shown that 5 is the largest answer possible after 4 moves.  Example 2:  Input: nums = [2], k = 1 Output: -1 Explanation:  In the first move, our only option is to pop the topmost element of the pile. Since it is not possible to obtain a non-empty pile after one move, we return -1.    Constraints:  1 <= nums.length <= 105 0 <= nums[i], k <= 109  

	# Explanation
	Here's the breakdown of the approach, complexity, and code for the problem:

*   **High-Level Approach:**
    *   If `k` is greater than the number of elements in `nums`, and `nums` has more than one element, we can always retrieve the maximum value from the array.
    *   If `k` is equal to the length of `nums`, the only element we cannot retrieve is the last one. So we retrieve the maximum of the first `k-1` elements.
    *   If `k` is less than the length of `nums`, we can remove the first `k` elements and return the maximum of the `k`th element and the maximum of the first `k - 1` elements.

*   **Complexity:**
    *   Runtime Complexity: O(min(n, k)), where n is the size of nums. In the worst case, we might need to iterate up to k elements of the array once.
    *   Storage Complexity: O(1). We use a constant amount of extra space.

	
	# Code
	```python
	def maximumTop(nums, k):
    n = len(nums)

    if n == 1:
        if k % 2 == 0:
            return nums[0]
        else:
            return -1

    if k > n:
        return max(nums)

    if k == n:
        return max(nums[:n-1])

    max_val = -1
    for i in range(min(k - 1, n)):
        max_val = max(max_val, nums[i])
    
    if k < n:
      max_val = max(max_val, nums[k])

    return max_val
	```