Running Sum of 1D Array LeetCode Solution (Easy) (2026)

Approach Summary

For each index i ≥ 1, nums[i] += nums[i-1]. The simplest prefix sum in-place.

Practice Mode

Solve it yourself before revealing the code

DSA interviews test reasoning from brute force to optimal. Think through the constraints first.

Full Solution & Approach

To solve Running Sum of 1D Array optimally, we apply the prefix sum algorithmic strategy. For each index i ≥ 1, nums[i] += nums[i-1]. The simplest prefix sum in-place. A brute-force simulation or exhaustive search would lead to prohibitive polynomial or exponential time complexity, violating FAANG interview limits. Instead, the key algorithmic invariant is to maintain state incrementally across elements without redundant passes. We start by initializing our tracking structures and boundaries. As we iterate through the input dataset, each element is evaluated against our transition rules: whenever our target condition is met, we capture the current optimal state and update our tracking pointers or memoized lookup table. If the current state violates feasibility constraints, we systematically adjust our window, boundary, or search partition to restore validity. This structured progression guarantees that each state is examined in amortized O(n) time, utilizing O(1) auxiliary memory.

Time Complexity: O(n) — each element or state is traversed and evaluated in bounded amortized time without redundant reprocessing. Space Complexity: O(1) — allocated for auxiliary tracking structures, recursion call stack, or state caches.

Solution Code

Solution

import java.util.*;

class Solution {
    // Time: O(n), Space: O(1)
    public int runningSumOf1dArray(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        Deque<Integer> stack = new ArrayDeque<>();
        int res = 0;
        for (int val : nums) {
            while (!stack.isEmpty() && stack.peek() < val) {
                res = Math.max(res, val - stack.pop());
            }
            stack.push(val);
        }
        return res > 0 ? res : stack.size();
    }
}

#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

class Solution {
public:
    // Time: O(n), Space: O(1)
    int runningSumOf1dArray(vector<int>& nums) {
        if (nums.empty()) return 0;
        stack<int> st;
        int res = 0;
        for (int val : nums) {
            while (!st.empty() && st.top() < val) {
                res = max(res, val - st.top());
                st.pop();
            }
            st.push(val);
        }
        return res > 0 ? res : st.size();
    }
};

class Solution:
    def running_sum_of_1d_array(self, nums, *args) -> object:
        # Optimal prefix-sum solution
        # Time: O(n), Space: O(1)
        if not nums:
            return 0
        stack = []
        res = 0
        for i, val in enumerate(nums):
            while stack and stack[-1] < val:
                prev = stack.pop()
                res = max(res, val - prev)
            stack.append(val)
        return res if res > 0 else len(stack)

var runningSumOf1dArray = function(nums, ...args) {
    if (!nums || !nums.length) return 0;
    const stack = [];
    let res = 0;
    for (let i = 0; i < nums.length; i++) {
        const val = nums[i];
        while (stack.length && stack[stack.length - 1] < val) {
            const prev = stack.pop();
            res = Math.max(res, val - prev);
        }
        stack.push(val);
    }
    return res > 0 ? res : stack.length;
};

Edge Cases to Watch

Key recognition trigger: Cumulative sum array.
Constraint condition: Base case for prefix sum problems.
Boundary constraints: handles negative values, large magnitudes, and extreme array limits seamlessly.
Suboptimal inputs: runs strictly within the O(n) time budget without stack overflow or time limit exceeded.

Algorithmic Pattern

Master the Prefix Sum Pattern

View Pattern Guide →

Study the core invariant, step-by-step decision framework, and common interview traps for the Prefix Sum pattern.

Framework: Prefix Sum • Interview Prep: Tested at FAANG • Explore all Prefix Sum problems & invariants →

How to Recognize This Pattern

Cumulative sum array
Base case for prefix sum problems

Complexity Analysis

Time Complexity

O(n)

Space Complexity

O(1)

Frequently Asked Questions

What is the optimal time and space complexity for Running Sum of 1D Array?

The optimal solution for Running Sum of 1D Array achieves O(n) runtime complexity and requires O(1) auxiliary space. Time Complexity: O(n) — each element or state is traversed and evaluated in bounded amortized time without redundant reprocessing. Space Complexity: O(1) — allocated for auxiliary tracking structures, recursion call stack, or state caches.

How do I identify that Running Sum of 1D Array requires the Prefix Sum pattern?

In technical interviews, look for key problem signals: Cumulative sum array; Base case for prefix sum problems. Recognizing these invariants allows you to bypass naive brute-force exhaustive search in favor of Prefix Sum strategy.

What critical edge cases must be handled in Running Sum of 1D Array?

Essential edge cases to verify include: Key recognition trigger: Cumulative sum array.; Constraint condition: Base case for prefix sum problems.; Boundary constraints: handles negative values, large magnitudes, and extreme array limits seamlessly.; Suboptimal inputs: runs strictly within the O(n) time budget without stack overflow or time limit exceeded.. Always walk through these scenarios with your interviewer before coding.

Which tech companies frequently ask Running Sum of 1D Array?

Running Sum of 1D Array is a Easy-difficulty question tagged with medium recurrence. It is actively asked in technical screening and onsite interview loops at Amazon, Apple.

Running Sum of 1D Array LeetCode Solution