Sum of Consecutive Subarrays

Sum of Consecutive Subarrays - Problem

We call an array consecutive if one of the following holds:

arr[i] - arr[i - 1] == 1 for all 1 <= i < n (increasing by 1)
arr[i] - arr[i - 1] == -1 for all 1 <= i < n (decreasing by 1)

The value of an array is the sum of its elements.

For example, [3, 4, 5] is a consecutive array of value 12 and [9, 8] is another of value 17. While [3, 4, 3] and [8, 6] are not consecutive.

Given an array of integers nums, return the sum of the values of all consecutive subarrays. Since the answer may be very large, return it modulo 10^9 + 7.

Note that an array of length 1 is also considered consecutive.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,4,5,3]

› Output: 43

💡 Note: Consecutive subarrays: [3] (sum=3), [4] (sum=4), [5] (sum=5), [3] (sum=3), [3,4] (sum=7), [4,5] (sum=9), [3,4,5] (sum=12). Total: 3+4+5+3+7+9+12 = 43

Example 2 — Decreasing Sequence

$ Input: nums = [9,8]

› Output: 34

💡 Note: Consecutive subarrays: [9] (sum=9), [8] (sum=8), [9,8] (sum=17). Total: 9+8+17 = 34

Example 3 — Single Element

$ Input: nums = [5]

› Output: 5

💡 Note: Only one subarray [5] with sum 5. Single elements are always consecutive.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 M Microsoft 18 f Facebook 15

The key insight is identifying consecutive segments where elements increase or decrease by exactly 1. The optimal approach uses a single pass to find these segments and calculates their contributions efficiently. Best approach is optimized segment processing with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

For each starting position, try all possible ending positions and check if the subarray is consecutive (either strictly increasing by 1 or strictly decreasing by 1). If consecutive, add its sum to the result.

Optimized - Extend Consecutive Segments

⏱️ Time: O(n) Space: O(1)

Instead of checking every subarray, identify consecutive segments that can't be extended further. For each segment, calculate how many subarrays it contributes and their total sum using arithmetic progression formulas.

Brute Force - Check All Subarrays — Algorithm Steps

For each starting index i
For each ending index j >= i
Check if subarray from i to j is consecutive
If consecutive, add sum of elements to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Subarrays

For each start position, check all possible end positions

Validate Consecutive

Check if elements increase or decrease by exactly 1

Sum Valid Subarrays

Add sum of each consecutive subarray to result

Code -

solution.c — C

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

int solution(int* nums, int n) {
    const int MOD = 1000000007;
    long long totalSum = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if subarray from i to j is consecutive
            int isConsecutive = 1;
            
            if (j > i) {  // More than one element
                int diff = nums[i+1] - nums[i];
                if (diff != 1 && diff != -1) {
                    isConsecutive = 0;
                } else {
                    for (int k = i+2; k <= j; k++) {
                        if (nums[k] - nums[k-1] != diff) {
                            isConsecutive = 0;
                            break;
                        }
                    }
                }
            }
            
            if (isConsecutive) {
                // Calculate sum of subarray
                long long subarraySum = 0;
                for (int k = i; k <= j; k++) {
                    subarraySum += nums[k];
                }
                totalSum = (totalSum + subarraySum) % MOD;
            }
        }
    }
    
    return (int) totalSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: n positions for start, n for end, n to check if consecutive and calculate sum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking indices and sums

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

845 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