Sum of Consecutive Subsequences - Practice Coding Problems

Sum of Consecutive Subsequences - Problem

Imagine you're analyzing stock price patterns where consecutive sequences represent trending periods. A sequence is consecutive if it's either:

Increasing: Each element is exactly 1 more than the previous (arr[i] - arr[i-1] == 1)
Decreasing: Each element is exactly 1 less than the previous (arr[i] - arr[i-1] == -1)

For example: [3, 4, 5] is consecutive (increasing) with value 12, and [9, 8] is consecutive (decreasing) with value 17. However, [3, 4, 3] and [8, 6] are not consecutive.

Goal: Find the sum of values of all consecutive non-empty subsequences (not subarrays) in the given array. Since the result can be massive, return it modulo 10⁹ + 7.

Note: A single element is always considered consecutive.

Input & Output

example_1.py — Basic Consecutive Sequences

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

› Output: 20

💡 Note: Consecutive subsequences: [1]=1, [2]=2, [4]=4, [3]=3, [1,2]=3, [4,3]=7. Total: 1+2+4+3+3+7=20

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: Only one subsequence possible: [5] with value 5

example_3.py — No Multi-Element Consecutives

$ Input: [1, 3, 5, 7]

› Output: 16

💡 Note: No consecutive subsequences of length > 1 possible. Only singles: [1]=1, [3]=3, [5]=5, [7]=7. Total: 1+3+5+7=16

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Answer fits in 32-bit integer after modulo operation
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Scan through floor levels and identify which ones can form valid staircases

Track Endpoints

For each floor level, remember how many staircases end there and their total heights

Extend Sequences

When processing a new floor, extend existing staircases that can reach it (differ by ±1)

Accumulate Results

Sum up all staircase heights to get the final inspection score

Key Takeaway

🎯 Key Insight: Use dynamic programming to track consecutive sequences by their endpoints. For each element, extend existing sequences that can reach it (differ by ±1) and start new single-element sequences. This avoids generating all 2^n subsequences explicitly!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with hash maps to efficiently track consecutive subsequences. For each element, we maintain count and sum of increasing and decreasing sequences ending at that position. Key insight: sequences ending at position x can extend sequences ending at x±1. This achieves O(n) time and O(n) space complexity, much better than the brute force O(2^n) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Hash Map (Optimal)	O(n)	O(n)	Track consecutive sequences ending at each position using DP with hash maps
Brute Force (Generate All Subsequences)	O(2^n * n)	O(n)	Generate all possible subsequences and check if each is consecutive

Dynamic Programming with Hash Map (Optimal) — Algorithm Steps

Create hash maps to track count and sum of sequences ending at each value
For each element, calculate sequences ending at current position
Update sequences that can extend to current element (value±1)
Add single element as new sequence starting point
Accumulate total sum from all valid sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Tables

Create hash maps to track count and sum of sequences ending at each value

Process Each Element

For each number, extend existing sequences and start new ones

Update DP State

Update count and sum for sequences ending at current position

Accumulate Results

Sum contributions from all sequence endpoints

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 100000

typedef struct {
    int key;
    long long count, sum;
} HashEntry;

HashEntry dpInc[MAXN * 2];
HashEntry dpDec[MAXN * 2];
int incSize = 0, decSize = 0;

int findInc(int key) {
    for (int i = 0; i < incSize; i++) {
        if (dpInc[i].key == key) return i;
    }
    return -1;
}

int findDec(int key) {
    for (int i = 0; i < decSize; i++) {
        if (dpDec[i].key == key) return i;
    }
    return -1;
}

long long sumOfConsecutiveSubsequences(int* nums, int n) {
    incSize = decSize = 0;
    long long totalSum = 0;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        long long newIncCount = 1;
        long long newIncSum = num;
        long long newDecCount = 1;
        long long newDecSum = num;
        
        // Extend increasing sequences
        int prevIncIdx = findInc(num - 1);
        if (prevIncIdx != -1) {
            long long prevCount = dpInc[prevIncIdx].count;
            long long prevSum = dpInc[prevIncIdx].sum;
            newIncCount = (newIncCount + prevCount) % MOD;
            newIncSum = (newIncSum + prevSum + prevCount * num) % MOD;
        }
        
        // Extend decreasing sequences
        int prevDecIdx = findDec(num + 1);
        if (prevDecIdx != -1) {
            long long prevCount = dpDec[prevDecIdx].count;
            long long prevSum = dpDec[prevDecIdx].sum;
            newDecCount = (newDecCount + prevCount) % MOD;
            newDecSum = (newDecSum + prevSum + prevCount * num) % MOD;
        }
        
        // Update DP tables
        int incIdx = findInc(num);
        if (incIdx != -1) {
            dpInc[incIdx].count = (dpInc[incIdx].count + newIncCount) % MOD;
            dpInc[incIdx].sum = (dpInc[incIdx].sum + newIncSum) % MOD;
        } else {
            dpInc[incSize].key = num;
            dpInc[incSize].count = newIncCount;
            dpInc[incSize].sum = newIncSum;
            incSize++;
        }
        
        int decIdx = findDec(num);
        if (decIdx != -1) {
            dpDec[decIdx].count = (dpDec[decIdx].count + newDecCount) % MOD;
            dpDec[decIdx].sum = (dpDec[decIdx].sum + newDecSum) % MOD;
        } else {
            dpDec[decSize].key = num;
            dpDec[decSize].count = newDecCount;
            dpDec[decSize].sum = newDecSum;
            decSize++;
        }
    }
    
    // Sum all sequences
    for (int i = 0; i < incSize; i++) {
        totalSum = (totalSum + dpInc[i].sum) % MOD;
    }
    
    for (int i = 0; i < decSize; i++) {
        totalSum = (totalSum + dpDec[i].sum) % MOD;
    }
    
    // Subtract double-counted single elements
    long long singleSum = 0;
    for (int i = 0; i < n; i++) {
        singleSum = (singleSum + nums[i]) % MOD;
    }
    totalSum = (totalSum - singleSum + MOD) % MOD;
    
    return totalSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, constant hash map operations per element

✓ Linear Growth

Space Complexity

O(n)

Hash maps store at most n unique elements with their counts/sums

⚡ Linearithmic Space

43.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Dynamic Programming with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler