# Solving Leetcode Interviews in Seconds with AI: Shortest Unsorted Continuous Subarray


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "581" 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
	> Given an integer array nums, you need to find one continuous subarray such that if you only sort this subarray in non-decreasing order, then the whole array will be sorted in non-decreasing order. Return the shortest such subarray and output its length.   Example 1:  Input: nums = [2,6,4,8,10,9,15] Output: 5 Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.  Example 2:  Input: nums = [1,2,3,4] Output: 0  Example 3:  Input: nums = [1] Output: 0    Constraints:  1 <= nums.length <= 104 -105 <= nums[i] <= 105    Follow up: Can you solve it in O(n) time complexity?

	# Explanation
	Here's an efficient solution to find the shortest unsorted continuous subarray, along with an explanation:

*   **Identify the Boundaries:** The core idea is to find the leftmost and rightmost elements that are out of order. These elements define the boundaries of the subarray that needs to be sorted.
*   **Finding the Minimum and Maximum Out-of-Order Elements:** Scan from left to right to find the rightmost out-of-order element (end index). Simultaneously, scan from right to left to find the leftmost out-of-order element (start index). Then, identify the minimum and maximum values within this potential unsorted subarray.
*   **Extend Boundaries:** Finally, extend the boundaries further. The start index should move to the left until we find an element smaller than the minimum out-of-order value.  Similarly, the end index should move to the right until we find an element greater than the maximum out-of-order value.

*   **Runtime & Storage Complexity:** O(n) time complexity, O(1) space complexity.

	
	# Code
	```python
	def findUnsortedSubarray(nums: list[int]) -> int:
    """
    Finds the length of the shortest unsorted continuous subarray that,
    if sorted, would make the entire array sorted.
    """

    n = len(nums)
    if n <= 1:
        return 0

    # Find the end of the unsorted subarray
    end = -1
    for i in range(n - 1):
        if nums[i] > nums[i + 1]:
            end = i + 1
    
    # If the array is already sorted
    if end == -1:
        return 0
    
    # Find the start of the unsorted subarray
    start = 0
    for i in range(n - 1, 0, -1):
        if nums[i] < nums[i - 1]:
            start = i - 1
            break
    
    # Find the minimum and maximum values within the unsorted subarray
    min_val = min(nums[start : end+1])
    max_val = max(nums[start : end+1])

    # Extend the start index to the left if necessary
    while start > 0 and nums[start - 1] > min_val:
        start -= 1
    
    # Extend the end index to the right if necessary
    while end < n - 1 and nums[end + 1] < max_val:
        end += 1
    
    return end - start + 1
	```