Smallest Missing Integer Greater Than Sequential Prefix Sum

Smallest Missing Integer Greater Than Sequential Prefix Sum - Problem

You're given a 0-indexed array of integers nums. Your task is to find the smallest missing integer that meets a specific condition.

What makes a prefix "sequential"?
A prefix nums[0..i] is sequential if each element (starting from index 1) is exactly one more than the previous element. In other words, nums[j] = nums[j-1] + 1 for all 1 ≤ j ≤ i.

Your Mission:
Find the longest sequential prefix, calculate its sum, then return the smallest integer missing from the array that is greater than or equal to this sum.

Example walkthrough:
For [4, 5, 6, 7, 6, 1, 1]:
• Longest sequential prefix: [4, 5, 6, 7] (length 4)
• Sum: 4 + 5 + 6 + 7 = 22
• Missing integers ≥ 22: We need to check 22, 23, 24... until we find one not in the array
• Answer: The first missing integer ≥ 22

Input & Output

example_1.py — Basic Sequential Prefix

$ Input: [4, 5, 6, 7, 6, 1, 1]

› Output: 22

💡 Note: The longest sequential prefix is [4, 5, 6, 7] with sum 22. Since 22 is not in the array, it's the smallest missing integer ≥ 22.

example_2.py — Single Element Prefix

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

› Output: 2

💡 Note: The longest sequential prefix is just [1] with sum 1. The smallest missing integer ≥ 1 is 2 (since 1 exists but 2 doesn't).

example_3.py — All Elements Sequential

$ Input: [3, 4, 5, 6]

› Output: 18

💡 Note: The entire array [3, 4, 5, 6] is sequential with sum 18. Since 18 is not in the array, it's the answer.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
The array is 0-indexed
A prefix consisting only of nums[0] is always considered sequential

Visualization

Tap to expand

Understanding the Visualization

Find Consecutive Evidence

Starting from the first file, count how many files are numbered consecutively: [4,5,6,7] then breaks at 6

Calculate Evidence Sum

Sum up all the consecutive file numbers: 4+5+6+7 = 22

Create Evidence Catalog

List all available file numbers in a quick-lookup catalog: {4,5,6,7,6,1,1}

Find Missing File

Starting from sum=22, check catalog for first missing file number: 22 is missing!

Key Takeaway

🎯 Key Insight: The problem becomes much simpler when we realize that after finding the sequential prefix sum, we only need to check consecutive integers starting from that sum. Using a hash set for O(1) lookups makes this extremely efficient, giving us the optimal O(n) solution!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a hash set approach with O(n) time complexity. First, identify the longest sequential prefix and calculate its sum. Then, build a hash set of all array elements for O(1) lookups. Finally, check consecutive integers starting from the prefix sum until finding the first missing integer. This approach efficiently combines prefix identification with fast missing element detection.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n²)	O(1)	Find sequential prefix sum, then check each integer starting from sum until we find one missing
One-Pass Hash Table (Optimal)	O(n)	O(n)	Find sequential prefix and build hash set simultaneously, then efficiently search for missing integer
Two-Pass Hash Table	O(n)	O(n)	Build hash set first, then efficiently search for missing integers starting from prefix sum

Brute Force (Linear Search) — Algorithm Steps

Iterate through array to find longest sequential prefix
Calculate sum of the sequential prefix
Starting from the sum, check each integer sequentially
For each integer, scan entire array to see if it exists
Return the first integer that doesn't exist in the array

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Sequential Prefix

Scan array from start until sequence breaks

Calculate Sum

Sum all elements in the sequential prefix

Search for Missing

Check each integer starting from sum until we find one not in array

Code -

solution.c — C

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

int smallestMissingIntegerGreaterThanPrefixSum(int* nums, int numsSize) {
    // Find longest sequential prefix sum
    int prefixSum = nums[0];
    int i = 1;
    while (i < numsSize && nums[i] == nums[i-1] + 1) {
        prefixSum += nums[i];
        i++;
    }
    
    // Find smallest missing integer >= prefixSum
    int candidate = prefixSum;
    while (true) {
        // Check if candidate exists in array
        bool found = false;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == candidate) {
                found = true;
                break;
            }
        }
        if (!found) {
            return candidate;
        }
        candidate++;
    }
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    bool inNumber = false;
    
    while ((c = getchar()) != '\n') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = true;
        } else if (inNumber) {
            nums[size++] = num;
            num = 0;
            inNumber = false;
        }
    }
    if (inNumber) nums[size++] = num;
    
    printf("%d\n", smallestMissingIntegerGreaterThanPrefixSum(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to find prefix sum + O(n²) worst case to find missing integer (checking n candidates, each taking O(n) to verify)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track prefix sum and current candidate

✓ Linear Space

26.8K Views

Medium Frequency

~15 min Avg. Time

892 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 (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler