Minimum Value to Get Positive Step by Step Sum

Minimum Value to Get Positive Step by Step Sum - Problem

Imagine you're managing a bank account that must never go below $1. You know exactly what deposits and withdrawals are coming, but you need to determine the minimum starting balance to keep your account positive throughout all transactions.

Given an array of integers nums representing your upcoming transactions (positive for deposits, negative for withdrawals), find the minimum positive starting value such that your running balance never drops below 1 after any transaction.

Example: If your transactions are [-3, 2, -3, 4, 2] and you start with $5:

After -3: balance = 5 + (-3) = 2 ✓
After +2: balance = 2 + 2 = 4 ✓
After -3: balance = 4 + (-3) = 1 ✓
After +4: balance = 1 + 4 = 5 ✓
After +2: balance = 5 + 2 = 7 ✓

Your task is to find the minimum starting value that keeps all step-by-step sums ≥ 1.

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: Starting with 5: 5→2→4→1→5→7. The minimum value reached is 1, which satisfies our constraint.

example_2.py — All Positive

$ Input: nums = [1,2]

› Output: 1

💡 Note: All elements are positive, so starting with 1 gives us: 1→2→4. All values stay above 1.

example_3.py — Large Negative

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

› Output: 5

💡 Note: Need to handle the cumulative negative impact: 5→6→4→1. Minimum reached is 1.

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
The answer is guaranteed to fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Start tracking

Begin with balance = startValue, track minimum balance reached

Process transactions

For each transaction, update balance and track minimum

Calculate minimum start

Ensure minimum balance reached is at least $1

Key Takeaway

🎯 Key Insight: Track the minimum running sum during simulation. The minimum starting value is simply `max(1, 1 - minimum_running_sum)` to ensure the lowest point never drops below 1.

Asked in

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

The optimal solution uses a one-pass prefix sum approach in O(n) time. Track the minimum running sum encountered, then return max(1, 1 - minSum) to ensure all step-by-step sums stay ≥ 1.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Track minimum prefix sum in single pass, then calculate required start value
Brute Force (Try All Start Values)	O(k × n)	O(1)	Test each possible starting value until finding one that works

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Initialize minSum to track the minimum prefix sum seen so far
Iterate through array, maintaining running sum
Update minSum whenever running sum is smaller
Return max(1, 1 - minSum) to ensure all steps stay ≥ 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize tracking

Set minSum = 0, currentSum = 0

Track minimum

For each element, update running sum and track minimum

Calculate result

Return max(1, 1 - minSum) to ensure all sums ≥ 1

Code -

solution.c — C

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

int findMinStartValue(int* nums, int numsSize) {
    int minSum = 0;
    int currentSum = 0;
    
    // Find the minimum prefix sum
    for (int i = 0; i < numsSize; i++) {
        currentSum += nums[i];
        if (currentSum < minSum) {
            minSum = currentSum;
        }
    }
    
    // If minSum is negative, we need to start with |minSum| + 1
    // If minSum is non-negative, starting with 1 is sufficient
    return (1 - minSum > 1) ? 1 - minSum : 1;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int negative = 0;
    
    while ((c = getchar()) != '\n') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            negative = 1;
        } else if (c == ',' || c == ']') {
            nums[size++] = negative ? -num : num;
            num = 0;
            negative = 0;
        }
    }
    
    printf("%d\n", findMinStartValue(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array of length n

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

18.6K Views

Medium Frequency

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

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler