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

Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to limit.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The longest subarray is [2,4] with absolute difference |4-2| = 2 ≤ 4. Length is 2.

Example 2 — Larger Limit

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

› Output: 4

💡 Note: The longest subarray is [2,4,7,2] with max difference |7-2| = 5 ≤ 5. Length is 4.

Example 3 — Single Element

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

› Output: 3

💡 Note: The longest subarray with all equal elements is [2,2,2]. Length is 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ limit ≤ 10⁹
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Array [8,2,4,7] with limit = 4

Process

Find longest subarray where max - min ≤ 4

Output

Return length of longest valid subarray

Key Takeaway

🎯 Key Insight: Use sliding window with monotonic deques to efficiently track min/max values

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a sliding window approach with monotonic deques to efficiently track the minimum and maximum values in the current window. The optimal solution uses two deques and achieves O(n) time complexity by processing each element only once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Check all possible subarrays and find their min/max difference
Sliding Window with Deques	O(n)	O(n)	Use two deques to efficiently track min/max in sliding window

Brute Force — Algorithm Steps

For each starting index i
Expand subarray from i to j
Track min and max in current subarray
If max - min <= limit, update result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Fix starting index and expand

Track Min/Max

Update minimum and maximum values

Check Condition

Verify if max - min <= limit

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' || token[0] == '-') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int limit;
    scanf("%d", &limit);
    
    int result = solution(nums, numsSize, limit);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop n times, inner loop up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track min, max, and result

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler