Given an array of numbers, our task is to find the length of the longest continuous subarray where the numbers are strictly decreasing.

Example:

Input:
const arr = [7, 4, 7, 6, 5, 4, 6, 8, 9]
Output: 4
Explanation: The longest continuous decreasing subarray in this array is [7, 6, 5, 4], and its length is 4.

Below are the approaches to Find the length of the longest continuous decreasing subarray:

Iterative Approach

The code initializes maxLength and currentLength. It iterates through the array, incrementing currentLength if the current element is less than the previous one; otherwise, it updates maxLength with the max of maxLength and currentLength, and resets currentLength to 1 for a new subarray. Finally, it returns maxLength, representing the length of the longest decreasing subarray.

Example: The example below shows how to Find the length of the longest continuous decreasing subarray using Iterative Approach.

function longestDec(arr) {
    let max = 0;
    let cur = 1;
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
            cur++;
        } else {
            max = Math.max(max, cur);
            cur = 1;
        }
    }
    max = Math.max(max, cur);
    return max;
}

const arr = [7, 4, 7, 6, 5, 4, 6, 8, 9];
console.log(longestDec(arr));

4

Time Complexity: O(n), where n is the size of the input array.

Auxiliary Space: O(1), which means it requires a constant amount of extra space.

Dynamic Programming Approach

Initialize an array dp of the same length as the input array. Each element dp[i] will be initially set to 1. Iterate through the array starting from the second element. For each element at index i, compare it with the previous element. If the current element is less than the previous element, extend the longest decreasing subarray ending at index i by setting dp[i] = dp[i – 1] + 1. If current ≥ previous, it marks the beginning of a new decreasing subarray, setting dp[i] to 1. Then, after the loop, the maximum value in dp denotes the longest decreasing subarray length, returned as the result.

Example: The example below shows how to Find the length of the longest continuous decreasing subarray using Dynamic Programming Approach.

function longestDecSub(arr) {
    const n = arr.length;
    const dp = new Array(n).fill(1);
    for (let i = 1; i < n; i++) {
        if (arr[i] < arr[i - 1]) {
            dp[i] = dp[i - 1] + 1;
        }
    }
    const maxLen = Math.max(...dp);
    return maxLen;
}

const arr = [9, 6, 9, 8, 7, 6, 5, 10, 12];
console.log(longestDecSub(arr));

5

Time Complexity: O(n), where n is the size of the input array.

Auxiliary Space: O(n), where n is the size of the input array.

Using Single Pass Approach with a Counter Variable

This single-pass approach iterates through the array, updating a counter for the current decreasing sequence length. It tracks the maximum length encountered, resetting when a non-decreasing element is found, ensuring efficient identification of the longest continuous decreasing subarray.

Example:

function longestDecreasingSubarraySinglePass(arr) {
    if (arr.length === 0) {
        return 0;
    }

    let maxLength = 1;
    let currentLength = 1;

    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
            currentLength++;
        } else {
            maxLength = Math.max(maxLength, currentLength);
            currentLength = 1;
        }
    }

    maxLength = Math.max(maxLength, currentLength);

    return maxLength;
}

let arr = [9, 8, 7, 3, 2, 1, 4, 3, 2, 1, 0];
console.log(`The length of the longest continuous decreasing subarray is: 
${longestDecreasingSubarraySinglePass(arr)}`);

The length of the longest continuous decreasing subarray is: 
6