# Solving Leetcode Interviews in Seconds with AI: Minimum Number of Removals to Make Mountain Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1671" 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 may recall that an array arr is a mountain array if and only if:  arr.length >= 3 There exists some index i (0-indexed) with 0 < i < arr.length - 1 such that: 	 arr[0] < arr[1] < ... < arr[i - 1] < arr[i] arr[i] > arr[i + 1] > ... > arr[arr.length - 1]    Given an integer array nums​​​, return the minimum number of elements to remove to make nums​​​ a mountain array.   Example 1:  Input: nums = [1,3,1] Output: 0 Explanation: The array itself is a mountain array so we do not need to remove any elements.  Example 2:  Input: nums = [2,1,1,5,6,2,3,1] Output: 3 Explanation: One solution is to remove the elements at indices 0, 1, and 5, making the array nums = [1,5,6,3,1].    Constraints:  3 <= nums.length <= 1000 1 <= nums[i] <= 109 It is guaranteed that you can make a mountain array out of nums.  

	# Explanation
	*   **Identify Potential Peaks:** Iterate through the array to consider each element as a potential peak of the mountain.
*   **Longest Increasing and Decreasing Subsequences:** For each potential peak, calculate the lengths of the longest increasing subsequence (LIS) ending at that peak and the longest decreasing subsequence (LDS) starting from that peak.
*   **Calculate Removals:** Determine the minimum number of elements to remove by subtracting the sum of LIS and LDS lengths (minus 1 to account for the peak being counted twice) from the total array length. Find the overall minimum removals across all potential peaks.

*   **Runtime Complexity:** O(n<sup>2</sup>), **Storage Complexity:** O(n)

	
	# Code
	```python
	def minimumMountainRemovals(nums):
    n = len(nums)
    min_removals = float('inf')

    for i in range(1, n - 1):
        # Check if nums[i] can be a peak
        if nums[i - 1] < nums[i] and nums[i] > nums[i + 1]:
            # Calculate LIS ending at nums[i]
            lis = [1] * n
            for j in range(i):
                for k in range(j):
                    if nums[j] > nums[k]:
                        lis[j] = max(lis[j], lis[k] + 1)

            # Calculate LDS starting from nums[i]
            lds = [1] * n
            for j in range(i, n):
                for k in range(j + 1, n):
                    if nums[j] > nums[k]:
                        lds[k] = max(lds[k], lds[j] + 1)
            
            # Ensure both increasing and decreasing subsequences have length >= 1
            if max(lis[:i+1]) > 1 and max(lds[i:]) > 1:
              removals = n - (max(lis[:i+1]) + max(lds[i:]) - 1)
              min_removals = min(min_removals, removals)

    return min_removals
	```