Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit

Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit - Problem

Array Queue Sliding Window Heap (Priority Queue) Ordered Set Monotonic Queue Medium

Imagine you're a quality control manager at a manufacturing plant. You need to find the longest continuous sequence of product measurements where the difference between the highest and lowest values doesn't exceed your quality tolerance limit.

Given an array of integers nums representing measurements and an integer limit representing your tolerance threshold, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is at most limit.

In other words, for a valid subarray, max(subarray) - min(subarray) ≤ limit.

Example: If nums = [8,2,4,7] and limit = 4, the longest valid subarray is [2,4] with length 2, because |4-2| = 2 ≤ 4.

Input & Output

example_1.py — Basic case

$ Input: nums = [8,2,4,7], limit = 4

› Output: 2

💡 Note: The longest valid subarray is [2,4] with length 2, since |4-2| = 2 ≤ 4. Other valid subarrays include [8], [2], [4], [7], but they are shorter.

example_2.py — Larger limit

$ Input: nums = [10,1,2,4,7,2], limit = 5

› Output: 4

💡 Note: The longest valid subarray is [2,4,7,2] with length 4, since max-min = 7-2 = 5 ≤ 5.

example_3.py — Large limit

$ Input: nums = [4,2,2,2,4,4,2,2], limit = 0

› Output: 3

💡 Note: With limit = 0, all elements in a valid subarray must be equal. The longest such subarray is [2,2,2] with length 3.

Visualization

Tap to expand

Understanding the Visualization

Initialize inspection window

Start with an empty quality control window and two tracking systems for max/min values

Expand window and track extremes

As products enter the window, efficiently update max/min using monotonic deques

Shrink when quality drops

When variance exceeds limit, remove products from left until quality is restored

Record best section

Track the longest section that maintained quality standards throughout

Key Takeaway

🎯 Key Insight: Monotonic deques allow O(1) max/min tracking in sliding windows, making this O(n) instead of O(n²)

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops - outer loop for starting position, inner loop to extend subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track max, min, and result length

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ limit ≤ 10⁹
Follow up: Can you solve this in O(n) time?

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses sliding window with monotonic deques to maintain maximum and minimum values in O(1) time. This achieves O(n) time complexity by ensuring each element is processed at most twice (once when added, once when removed).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays and find max/min for each
Sliding Window with Monotonic Deques	O(n)	O(n)	Use sliding window with deques to efficiently track max/min

Brute Force (Nested Loops) — Algorithm Steps

For each starting index i, initialize max and min with nums[i]
Extend the subarray by adding elements one by one
Update max and min for each new element
If max - min > limit, break and try next starting position
Track the maximum valid subarray length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Check subarrays [8], [8,2], [8,2,4], [8,2,4,7]

Start from index 1

Check subarrays [2], [2,4], [2,4,7]

Continue for all positions

Track the maximum valid length found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int longestSubarray(int* nums, int numsSize, int limit) {
    int maxLen = 1;
    
    for (int i = 0; i < numsSize; i++) {
        int minVal = nums[i];
        int maxVal = nums[i];
        
        for (int j = i; j < numsSize; j++) {
            minVal = min(minVal, nums[j]);
            maxVal = max(maxVal, nums[j]);
            
            if (maxVal - minVal <= limit) {
                maxLen = max(maxLen, j - i + 1);
            } else {
                break;
            }
        }
    }
    
    return maxLen;
}

int main() {
    int nums[] = {8, 2, 4, 7};
    int limit = 4;
    printf("%d\n", longestSubarray(nums, 4, limit));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops - outer loop for starting position, inner loop to extend subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track max, min, and result length

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ limit ≤ 10⁹
Follow up: Can you solve this in O(n) time?

32.0K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler