Count the Hidden Sequences

Count the Hidden Sequences - Problem

You are given a 0-indexed array of n integers differences, which describes the differences between each pair of consecutive integers of a hidden sequence of length (n + 1). More formally, call the hidden sequence hidden, then we have that differences[i] = hidden[i + 1] - hidden[i].

You are further given two integers lower and upper that describe the inclusive range of values [lower, upper] that the hidden sequence can contain.

For example, given differences = [1, -3, 4], lower = 1, upper = 6, the hidden sequence is a sequence of length 4 whose elements are in between 1 and 6 (inclusive).

[3, 4, 1, 5] and [4, 5, 2, 6] are possible hidden sequences.
[5, 6, 3, 7] is not possible since it contains an element greater than 6.
[1, 2, 3, 4] is not possible since the differences are not correct.

Return the number of possible hidden sequences there are. If there are no possible sequences, return 0.

Input & Output

Example 1 — Basic Case

$ Input: differences = [1,-3,4], lower = 1, upper = 6

› Output: 2

💡 Note: Hidden sequences of length 4. Starting with 3: [3,4,1,5] ✓. Starting with 4: [4,5,2,6] ✓. Starting with 5: [5,6,3,7] ✗ (7 > 6). Valid sequences: 2

Example 2 — No Valid Sequences

$ Input: differences = [4,-7,2], lower = 3, upper = 6

› Output: 0

💡 Note: Any sequence will go outside bounds. For example, start=3: [3,7,0,2] has 7>6 and 0<3. No valid starting position exists.

Example 3 — Single Valid Start

$ Input: differences = [1,-1,1], lower = 1, upper = 3

› Output: 1

💡 Note: Only starting with 2 works: [2,3,2,3]. All values stay within [1,3]. Other starts go out of bounds.

Constraints

1 ≤ differences.length ≤ 10⁵
-10⁵ ≤ differences[i] ≤ 10⁵
-10⁸ ≤ lower ≤ upper ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we can use prefix sums to determine the valid range of starting positions without simulating every sequence. Calculate prefix sums to find min/max relative positions, then compute how many starting values keep all sequence elements within bounds. Best approach uses prefix sum optimization: Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O((upper - lower) × n) Space: O(1)

For each potential starting value in [lower, upper], simulate building the entire hidden sequence using the differences array and check if all values stay within bounds.

Prefix Sum Optimization

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

Calculate prefix sums to determine the minimum and maximum values the sequence will reach relative to the starting position. Then find how many starting positions keep all values within bounds.

Brute Force — Algorithm Steps

Iterate through all possible starting values from lower to upper
For each start, build the sequence by adding differences
Check if all sequence values are within [lower, upper]
Count valid sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Start=1

Build sequence [1,2,-1,3] - valid

Try Start=2

Build sequence [2,3,0,4] - valid

Count Valid

Count all sequences that stay in bounds

Code -

solution.c — C

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

int solution(int* differences, int n, int lower, int upper) {
    int count = 0;
    for (int start = lower; start <= upper; start++) {
        int current = start;
        int valid = 1;
        for (int i = 0; i < n; i++) {
            current += differences[i];
            if (current < lower || current > upper) {
                valid = 0;
                break;
            }
        }
        if (valid) count++;
    }
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int differences[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] != '\n' && token[0] != ' ' && token[0] != '\0') {
            differences[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int lower, upper;
    scanf("%d", &lower);
    scanf("%d", &upper);
    
    printf("%d\n", solution(differences, n, lower, upper));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((upper - lower) × n)

For each of (upper-lower+1) starting values, we simulate n steps

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current position and count

✓ Linear Space

28.0K Views

Medium Frequency

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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler