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] is an un-ordered subarray.

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.

Now let’s understand the algorithm for solving this problem and then we move to the implementation of this algorithm using JavaScript.

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).

Example

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 then we find the left and right indices of the subarray by iterating through the array from the beginning and end respectively.

Finally, we return the length of the shortest un-ordered subarray by subtracting the right index from the left index and adding 1.

function shortestUnorderedSubarray(arr) {
   let n = arr.length;
   let start = 0, end = n - 1;
   // find start index
   for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
         start = i;
         break;
      }
   }
   // find end index
   for (let i = n - 1; i > 0; i--) {
      if (arr[i] < arr[i - 1]) {
         end = i;
         break;
      }
   }
   // find min and max element in subarray
   let min = arr[start], max = arr[start];
   for (let i = start + 1; i <= end; i++) {
      if (arr[i] < min) {
         min = arr[i];
      }
      if (arr[i] > max) {
         max = arr[i];
      }
   }
   // find left index
   let left = 0;
   for (let i = 0; i <= start; i++) {
      if (arr[i] > min) {
         left = i;
         break;
      }
   }
   // find right index
   let right = n - 1;
   for (let i = n - 1; i >= end; i--) {
      if (arr[i] < max) {
         right = i;
         break;
      }
   }
   // return length of shortest un-ordered subarray
   return right - left + 1;
}
// Example usage:
const arr = [1, 2, 5, 4, 3, 6, 7]
console.log("Array:", JSON.stringify(arr))
const len = shortestUnorderedSubarray(arr)
console.log("The length shortest un-ordered subarray: ", len);
// Output: 3, as [5, 4, 3] is the shortest un-ordered subarray with length 3.

Conclusion

We discussed every nuance of how we can execute the Shortest Un-Ordered Subarray problem using JavaScript. We hope with this article, one can easily find and fix issues related to un-ordered subarrays in their code.