Sum of Consecutive Subarrays - Practice Coding Problems

Sum of Consecutive Subarrays - Problem

Imagine you're analyzing number sequences to find patterns! A consecutive subarray is one where each element either increases or decreases by exactly 1 from the previous element.

More formally, an array is consecutive if:

arr[i] - arr[i-1] == 1 for all valid indices (ascending), OR
arr[i] - arr[i-1] == -1 for all valid indices (descending)

For example:

[3, 4, 5] is consecutive (ascending) with sum = 12
[9, 8] is consecutive (descending) with sum = 17
[7] is consecutive (single element) with sum = 7
[3, 4, 3] is NOT consecutive (direction changes)
[8, 6] is NOT consecutive (gap of 2)

Goal: Find all consecutive subarrays within the given array and return the sum of their values modulo 10⁹ + 7.

Input & Output

example_1.py — Basic consecutive sequence

$ Input: nums = [1, 2, 3]

› Output: 20

💡 Note: All subarrays are consecutive: [1]=1, [1,2]=3, [1,2,3]=6, [2]=2, [2,3]=5, [3]=3. Sum = 1+3+6+2+5+3 = 20

example_2.py — Mixed sequences

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

› Output: 16

💡 Note: Consecutive subarrays: [1]=1, [3]=3, [3,2]=5, [2]=2, [4]=4, single elements plus [3,2]. Sum = 1+3+5+2+4+1 = 16

example_3.py — Single element

$ Input: nums = [5]

› Output: 5

💡 Note: Only one subarray [5] with sum 5

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Scan the array to find where consecutive patterns start and end

Calculate Contributions

For each element in a consecutive segment, determine how many subarrays it participates in

Sum Efficiently

Use mathematical formulas instead of generating all subarrays explicitly

Key Takeaway

🎯 Key Insight: Instead of checking every possible subarray, identify maximal consecutive segments and calculate each element's contribution using the formula (left_positions × right_positions), achieving O(n) time complexity.

Asked in

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

The optimal approach uses a sliding window technique to find consecutive segments in O(n) time. For each maximal consecutive segment, we calculate how many subarrays each element contributes to using the formula (left_count × right_count), avoiding the need to generate all subarrays explicitly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if it's consecutive
Sliding Window (Optimal)	O(n)	O(1)	Extend consecutive segments using sliding window technique

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through all possible starting positions
For each start, try all possible ending positions
Check if the subarray from start to end is consecutive
If consecutive, calculate sum and add to result
Return total sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Check every possible subarray [i,j]

Validate Consecutive

Verify if differences are all +1 or all -1

Sum Valid Subarrays

Add sum of consecutive subarrays to result

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int sumOfConsecutiveSubarrays(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long total = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Check if subarray from i to j is consecutive
            int isConsecutive = 1;
            int direction = 0;
            int directionSet = 0;
            
            for (int k = i + 1; k <= j; k++) {
                int diff = nums[k] - nums[k - 1];
                if (abs_val(diff) != 1) {
                    isConsecutive = 0;
                    break;
                }
                if (!directionSet) {
                    direction = diff;
                    directionSet = 1;
                } else if (direction != diff) {
                    isConsecutive = 0;
                    break;
                }
            }
            
            if (isConsecutive) {
                long long subarraySum = 0;
                for (int k = i; k <= j; k++) {
                    subarraySum += nums[k];
                }
                total = (total + subarraySum) % MOD;
            }
        }
    }
    
    return (int) total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays to check, O(n) time to verify each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler