JavaScript program for Shortest Un-Ordered SubarrayJavaScript program for Shortest Un-Ordered Subarray

The problem statement requires finding the shortest un-ordered subarray in an array of integers. In other words, we need to identify the smallest subarray in which the elements are not sorted in ascending or descending order. This problem can be solved through various approaches, but in this article, we will discuss a simple and efficient solution using JavaScript.

So first we will start by defining what an un-ordered Subarray is, then understand the problem statement in detail and then proceed to explain the step-by-step solution using examples and code snippets. By the end of this article, you will have a clear understanding of how to solve this problem in JavaScript. So let's get started!

What is an Un-Ordered Subarray?

An un-ordered subarray is a contiguous subarray of an array in which the elements are not in ascending or descending order. In other words, the elements in the subarray are not arranged in a sequence that is either increasing or decreasing.

For example: [1, 2, 3, 5, 4, 6, 7] - here the subarray [3, 5, 4, 6] contains elements that are not in sorted order.

Problem Statement

Given an array of integers, we need to find the shortest un-ordered subarray. In other words, we need to identify the smallest subarray in which the elements are not sorted in ascending or descending order.

For example, let's consider the following array: const arr = [1, 2, 5, 4, 3, 6, 7]

In this case, the subarray [5, 4, 3] is the shortest un-ordered subarray with length 3.

Algorithm for Shortest Un-Ordered Subarray

Input ? An array of n integers

Output ? The length of the shortest subarray that is un-ordered

STEP 1 ? Initialize start = 0, end = n-1

STEP 2 ? Traverse the array from left to right and find the first element that is greater than its right neighbour. Set its index to start.

STEP 3 ? Traverse the array from right to left and find the first element that is smaller than its left neighbour. Set its index to end.

STEP 4 ? Find the minimum and maximum element in the subarray starting from start to end.

STEP 5 ? Traverse the array from 0 to start-1 and find the index of the first element that is greater than the minimum element found in step 4. Set its index to the left.

STEP 6 ? Traverse the array from end+1 to n-1 and find the index of the first element that is smaller than the maximum element found in step 4. Set its index to the right.

STEP 7 ? The length of the shortest un-ordered subarray is (right - left + 1).

Implementation

In the below example, we first find the starting and ending indices of the un-ordered subarray by iterating through the array from the beginning and end respectively. We then find the minimum and maximum elements in the subarray, and finally calculate the correct boundaries by expanding left and right as needed.

function shortestUnorderedSubarray(arr) {
   let n = arr.length;
   let start = -1, end = -1;
   
   // Find start index - first element out of order from left
   for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
         start = i;
         break;
      }
   }
   
   // Find end index - first element out of order from right
   for (let i = n - 1; i > 0; i--) {
      if (arr[i] < arr[i - 1]) {
         end = i;
         break;
      }
   }
   
   // If array is already sorted
   if (start === -1) {
      return 0;
   }
   
   // Find min and max element in the unsorted subarray
   let min = Math.min(...arr.slice(start, end + 1));
   let max = Math.max(...arr.slice(start, end + 1));
   
   // Expand left boundary
   let left = start;
   for (let i = 0; i < start; i++) {
      if (arr[i] > min) {
         left = i;
         break;
      }
   }
   
   // Expand right boundary  
   let right = end;
   for (let i = n - 1; i > end; i--) {
      if (arr[i] < max) {
         right = i;
         break;
      }
   }
   
   return right - left + 1;
}

// Example usage
const arr1 = [1, 2, 5, 4, 3, 6, 7];
const arr2 = [1, 2, 3, 4, 5];
const arr3 = [5, 4, 3, 2, 1];

console.log("Array 1:", JSON.stringify(arr1));
console.log("Shortest un-ordered subarray length:", shortestUnorderedSubarray(arr1));

console.log("Array 2:", JSON.stringify(arr2)); 
console.log("Shortest un-ordered subarray length:", shortestUnorderedSubarray(arr2));

console.log("Array 3:", JSON.stringify(arr3));
console.log("Shortest un-ordered subarray length:", shortestUnorderedSubarray(arr3));

Array 1: [1,2,5,4,3,6,7]
Shortest un-ordered subarray length: 3
Array 2: [1,2,3,4,5]
Shortest un-ordered subarray length: 0
Array 3: [5,4,3,2,1]
Shortest un-ordered subarray length: 5

How It Works

The algorithm works in several phases:

• Phase 1: Find the first disruption from left (where arr[i] > arr[i+1])
• Phase 2: Find the first disruption from right (where arr[i]
• Phase 3: Find min/max values in the disrupted region
• Phase 4: Expand boundaries to include all elements that would be affected by sorting

Time and Space Complexity

• Time Complexity: O(n) where n is the length of the array
• Space Complexity: O(1) as we only use constant extra space

Conclusion

We discussed how to find the shortest un-ordered subarray using an efficient O(n) algorithm. The key insight is to identify disruptions from both ends and then expand the boundaries based on min/max values in the unsorted region.