#3392

Easy

auto_awesomeArray-driven solution strategy

LeetCode Problem Workspace

Count Subarrays of Length Three With a Condition

Determine how many subarrays of length three satisfy a sum condition on their first and third elements in an array.

Problem Statement

You are given an integer array nums. Your task is to count all subarrays of length three where the sum of the first and third elements equals exactly half of the second element. Return the total number of such valid subarrays.

For example, given nums = [1,2,1,4,1], only the subarray [1,4,1] meets the condition. For nums = [1,1,1], no subarray satisfies the requirement. Constraints: 3 <= nums.length <= 100, -100 <= nums[i] <= 100.

Examples

Example 1

Input: nums = [1,2,1,4,1]

Output: 1

Only the subarray [1,4,1] contains exactly 3 elements where the sum of the first and third numbers equals half the middle number.

Example 2

Input: nums = [1,1,1]

Output: 0

[1,1,1] is the only subarray of length 3. However, its first and third numbers do not add to half the middle number.

Constraints

3 <= nums.length <= 100
-100 <= nums[i] <= 100

Solution Approach

Direct Iteration Over Subarrays

Loop through the array from index 0 to n-3, extracting each subarray of length three. Check the condition that the sum of the first and third equals half the second, incrementing a counter when true. This leverages the array-driven pattern directly.

Boundary and Index Checks

Ensure that your loop does not exceed nums.length - 3 to prevent out-of-bounds access. Carefully use nums[i], nums[i+1], and nums[i+2] to represent first, middle, and third elements, aligning with the problem's sum condition.

Constant Space Optimization

Use only a single counter variable to track valid subarrays. No extra arrays or data structures are needed since the pattern focuses purely on contiguous triplets, keeping space complexity O(1).

Complexity Analysis

Metric	Value
Time	O(n)
Space	O(1)

Time complexity is O(n) because each subarray of length three is checked once. Space complexity is O(1) since only a counter is used, and no additional data structures grow with input size.

What Interviewers Usually Probe

Check whether you are correctly identifying subarrays of exactly length three.
Consider off-by-one errors when looping over the array.
Expect clarification on handling sums that require integer division carefully.

Common Pitfalls or Variants

Common pitfalls

Including subarrays of length other than three, which violates the condition.
Using incorrect indices leading to out-of-bounds errors.
Forgetting integer division when comparing sums to half the middle element.

Follow-up variants

Count subarrays of length k where a custom sum condition holds for specific positions.
Find subarrays where the sum of first and last elements is equal to the middle element without division.
Modify the problem to return the actual valid subarrays instead of just counting them.

FAQ

What is the main pattern to recognize in Count Subarrays of Length Three With a Condition?

The main pattern is array-driven iteration over contiguous triplets, checking a condition involving the first, middle, and last elements.

Can this problem be solved with nested loops?

Yes, but a single loop from index 0 to n-3 suffices since only subarrays of length three are needed.

What should I be careful about when summing elements?

Ensure integer division is handled correctly when comparing the sum of the first and third elements to half the middle element.

Is extra space needed to solve this problem?

No, you only need a counter variable since the array-driven pattern allows O(1) space usage.

How does array size affect performance?

Because the constraints are small (3 <= nums.length <= 100), iterating all triplets is efficient and falls within O(n) time complexity.

terminal

Solution

Solution 1: Single Pass

We traverse each subarray of length $3$ in the array $\textit{nums}$ and check if twice the sum of the first and third numbers equals the second number. If it does, we increment the answer by $1$.

1

2

3

4

5

class Solution:
    def countSubarrays(self, nums: List[int]) -> int:
        return sum(
            (nums[i - 1] + nums[i + 1]) * 2 == nums[i] for i in range(1, len(nums) - 1)
        )

Continue Practicing

#3393 count paths with the given xor value #3394 check if grid can be cut into sections #3395 subsequences with a unique middle mode i