Count Subarrays of Length Three With a Condition

Count Subarrays of Length Three With a Condition - Problem

Array Easy

Given an integer array nums, you need to find all subarrays of exactly length 3 that satisfy a special arithmetic condition.

The condition is: the sum of the first and third elements must equal exactly half of the second element.

In mathematical terms, for a subarray [a, b, c], we need:

a + c = b / 2

Goal: Return the total count of such subarrays.

Example: In array [1, 4, 2], we have subarray [1, 4, 2] where 1 + 2 = 3 and 4 / 2 = 2. Since 3 ≠ 2, this doesn't satisfy our condition.

Input & Output

example_1.py — Basic Case

$ Input: [2, 8, 2]

› Output: 1

💡 Note: The subarray [2, 8, 2] satisfies the condition: 2 + 2 = 4, and 8 / 2 = 4, so 4 = 4 ✓

example_2.py — Multiple Subarrays

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

› Output: 2

💡 Note: Two subarrays satisfy the condition: [1, 2, 1] where 1 + 1 = 2 and 2 / 2 = 1, but 2 ≠ 1. Actually [2, 4, 2] where 2 + 2 = 4 and 4 / 2 = 2, so 4 ≠ 2. Wait - let me recalculate: we need a + c = b/2, so for [1, 2, 1]: 1 + 1 = 2, but 2/2 = 1, so 2 ≠ 1. None satisfy the condition.

example_3.py — Edge Case

$ Input: [1, 1]

› Output: 0

💡 Note: Array has less than 3 elements, so no subarrays of length 3 are possible.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
The array can contain negative numbers

Visualization

Tap to expand

Understanding the Visualization

Setup the Scale

Place first and third numbers on left side, half of middle number on right side

Check Balance

See if both sides are equal - if yes, count this triplet

Move to Next

Slide the window to check next consecutive triplet

Final Count

Return total number of balanced configurations found

Key Takeaway

🎯 Key Insight: Use sliding window with integer arithmetic (multiply by 2) to avoid floating-point precision issues while checking the balance condition.

Asked in

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

The optimal solution uses a sliding window approach with O(n) time complexity. We iterate through the array once, checking each consecutive triplet to see if the sum of first and third elements equals half of the second element. The key insight is to multiply both sides by 2 to avoid floating-point arithmetic: 2 * (a + c) == b.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Slide a window of size 3 through the array and check the condition

Sliding Window (Optimal) — Algorithm Steps

Initialize counter to 0
Iterate from index 0 to n-3 (where n is array length)
For each position i, check if nums[i] + nums[i+2] == nums[i+1] / 2
If condition is met, increment counter
Return the final counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with window at position 0, covering first 3 elements

Check Condition

Test if first + third == second / 2

Slide Window

Move window one position right and repeat

Continue

Keep sliding until we reach the end

Code -

solution.c — C

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

int countSubarrays(int* nums, int numsSize) {
    if (numsSize < 3) {
        return 0;
    }
    
    int count = 0;
    for (int i = 0; i < numsSize - 2; i++) {
        // Check if nums[i] + nums[i+2] == nums[i+1] / 2
        if (2 * (nums[i] + nums[i + 2]) == nums[i + 1]) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    
    while ((c = getchar()) != EOF && c != '\n') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            sign = -1;
        } else if (c == ',' || c == ']') {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
        }
    }
    
    printf("%d\n", countSubarrays(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once, checking each possible triplet

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter

✓ Linear Space

28.4K Views

Medium Frequency

~12 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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler