Codestin Search App

Continuous Subarrays - Problem

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

🎯 Count Continuous Subarrays

You're given a 0-indexed integer array nums. Your task is to find the total number of continuous subarrays.

A subarray is called continuous if for any two elements in the subarray, their absolute difference is at most 2. In other words, if we have indices i, i+1, ..., j in the subarray, then for every pair of indices i1, i2 where i ≤ i1, i2 ≤ j, we need |nums[i1] - nums[i2]| ≤ 2.

Example: In array [5, 4, 2, 4], the subarray [5, 4] is continuous because |5-4| = 1 ≤ 2, but [5, 4, 2] is not continuous because |5-2| = 3 > 2.

Return the total count of all such continuous subarrays.

Input & Output

example_1.py — Basic Case

$ Input: [5, 4, 2, 4]

› Output: 8

💡 Note: The continuous subarrays are: [5], [4], [2], [4], [5,4], [2,4], [4,2], [4,2,4]. Total count = 8. Note that [5,4,2] is not continuous because |5-2| = 3 > 2.

example_2.py — All Same Elements

$ Input: [1, 1, 1]

› Output: 6

💡 Note: When all elements are the same, every possible subarray is continuous. For array of length n, total subarrays = n*(n+1)/2 = 3*4/2 = 6. The subarrays are: [1], [1], [1], [1,1], [1,1], [1,1,1].

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: With only one element, there's exactly one subarray: [1]. Single element subarrays are always continuous.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Important: The absolute difference condition must hold for ALL pairs in the subarray, not just adjacent elements

Visualization

Tap to expand

Expand Window: Add chocolate to right side of quality window2. Update Sensors: Maintain min/max deques efficiently (O(1) amortized)3. Check Quality: If max_weight - min_weight > 2g, shrink window from left4. Count Groups: Add (window_size) valid quality groups ending at current position✅ Current Status: Max(5g) - Min(4g) = 1g ≤ 2g → Valid Window!Valid groups: [5g], [4g], [5g,4g] → Count = 3

Understanding the Visualization

Setup Quality Station

Place chocolates on conveyor belt with weight sensors

Sliding Quality Window

Use a quality window that expands when weights are within range

Track Min/Max Efficiently

Use specialized sensors (deques) to quickly know lightest and heaviest chocolate in current group

Count Valid Groups

For each position, count all valid groups ending at that chocolate

Key Takeaway

🎯 Key Insight: Instead of checking every pair in every subarray (O(n³)), we use sliding window with efficient min/max tracking to achieve O(n) time complexity. The deques maintain sorted order of indices, allowing us to quickly determine if the current window satisfies the continuity condition.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses a sliding window approach with deques to efficiently track minimum and maximum values. The key insight is that a subarray is continuous if max - min ≤ 2. By maintaining this condition and counting valid subarrays ending at each position, we achieve O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Deque (Optimal)	O(n)	O(n)	Use sliding window technique with deque to efficiently track min/max values
Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray by examining all pairs of elements

Sliding Window with Deque (Optimal) — Algorithm Steps

Initialize two deques: one for tracking minimum values, one for maximum
Use two pointers (left and right) to maintain a sliding window
Expand the right pointer and update deques with current element
If max - min > 2, shrink window from left until condition is satisfied
For each valid window ending at right, add (right - left + 1) to count
Continue until right pointer reaches the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with empty deques and pointers at beginning

Expand Window

Add elements to right, maintain deque properties

Check Condition

If max - min > 2, shrink from left

Count Subarrays

Add (right - left + 1) to total count

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front, rear, size, capacity;
} Deque;

Deque* createDeque(int capacity) {
    Deque* dq = (Deque*)malloc(sizeof(Deque));
    dq->data = (int*)malloc(capacity * sizeof(int));
    dq->front = 0;
    dq->rear = -1;
    dq->size = 0;
    dq->capacity = capacity;
    return dq;
}

void pushBack(Deque* dq, int val) {
    dq->rear = (dq->rear + 1) % dq->capacity;
    dq->data[dq->rear] = val;
    dq->size++;
}

void popBack(Deque* dq) {
    if (dq->size > 0) {
        dq->rear = (dq->rear - 1 + dq->capacity) % dq->capacity;
        dq->size--;
    }
}

void popFront(Deque* dq) {
    if (dq->size > 0) {
        dq->front = (dq->front + 1) % dq->capacity;
        dq->size--;
    }
}

int getFront(Deque* dq) {
    return dq->data[dq->front];
}

int getBack(Deque* dq) {
    return dq->data[dq->rear];
}

int isEmpty(Deque* dq) {
    return dq->size == 0;
}

long long countContinuousSubarrays(int* nums, int n) {
    long long count = 0;
    int left = 0;
    
    Deque* minDq = createDeque(n);
    Deque* maxDq = createDeque(n);
    
    for (int right = 0; right < n; right++) {
        while (!isEmpty(minDq) && nums[getBack(minDq)] >= nums[right]) {
            popBack(minDq);
        }
        while (!isEmpty(maxDq) && nums[getBack(maxDq)] <= nums[right]) {
            popBack(maxDq);
        }
        
        pushBack(minDq, right);
        pushBack(maxDq, right);
        
        while (nums[getFront(maxDq)] - nums[getFront(minDq)] > 2) {
            if (getFront(minDq) == left) {
                popFront(minDq);
            }
            if (getFront(maxDq) == left) {
                popFront(maxDq);
            }
            left++;
        }
        
        count += right - left + 1;
    }
    
    free(minDq->data);
    free(maxDq->data);
    free(minDq);
    free(maxDq);
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%lld\n", countContinuousSubarrays(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deques at most once, and each element is processed once

✓ Linear Growth

Space Complexity

O(n)

In worst case, deques can store up to O(n) elements

⚡ Linearithmic Space

52.0K Views

High 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

🎯 Count Continuous Subarrays

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Deque (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler