Running Sum of 1d Array - Practice Coding Problems

Running Sum of 1d Array - Problem

Given an array nums, we need to compute the running sum (also known as cumulative sum or prefix sum) of the array.

The running sum at position i is defined as: runningSum[i] = sum(nums[0] + nums[1] + ... + nums[i])

Goal: Transform the input array so that each element becomes the sum of all elements from the start up to that position.

Example: If nums = [1, 2, 3, 4], then:
• Position 0: sum of [1] = 1
• Position 1: sum of [1, 2] = 3
• Position 2: sum of [1, 2, 3] = 6
• Position 3: sum of [1, 2, 3, 4] = 10
So the result is [1, 3, 6, 10]

Input & Output

example_1.py — Basic case

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

› Output: [1,3,6,10]

💡 Note: Running sums: 1, 1+2=3, 1+2+3=6, 1+2+3+4=10

example_2.py — Single element

$ Input: nums = [5]

› Output: [5]

💡 Note: Only one element, so running sum is just that element

example_3.py — With negative numbers

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

› Output: [1,-1,2,-2,3]

💡 Note: Running sums: 1, 1+(-2)=-1, -1+3=2, 2+(-4)=-2, -2+5=3

Visualization

Tap to expand

Understanding the Visualization

Initial Balance

Start with first transaction: balance = $1

Transaction 2

Add $2 to existing balance: $1 + $2 = $3

Transaction 3

Add $3 to current balance: $3 + $3 = $6

Final Balance

Add $4 to current balance: $6 + $4 = $10

Key Takeaway

🎯 Key Insight: Instead of recalculating the entire sum for each position, maintain a running total by adding the current element to the previous sum. This transforms an O(n²) problem into an elegant O(n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we sum up to i elements, giving us 1+2+3+...+n = n(n+1)/2 operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space (excluding the output array which is required)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-10⁶ ≤ nums[i] ≤ 10⁶
Follow-up: Can you solve this in-place with O(1) extra space?

Asked in

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

The optimal solution uses the prefix sum technique with O(n) time and O(1) space. Instead of recalculating sums from scratch, we maintain a running total by adding each element to the previous sum: nums[i] += nums[i-1].

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each position, calculate sum from beginning by iterating through all previous elements
Prefix Sum (Optimal)	O(n)	O(1)	Keep a running total by adding current element to previous sum

Brute Force (Nested Loops) — Algorithm Steps

Create result array of same size as input
For each position i from 0 to n-1:
Calculate sum from index 0 to i using inner loop
Store the sum in result[i]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Calculate sum from index 0 to 0: nums[0] = 1

Position 1

Calculate sum from index 0 to 1: nums[0] + nums[1] = 1 + 2 = 3

Position 2

Calculate sum from index 0 to 2: nums[0] + nums[1] + nums[2] = 1 + 2 + 3 = 6

Position 3

Calculate sum from index 0 to 3: nums[0] + nums[1] + nums[2] + nums[3] = 1 + 2 + 3 + 4 = 10

Code -

solution.c — C

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

int* runningSum(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        for (int j = 0; j <= i; j++) {
            currentSum += nums[j];
        }
        result[i] = currentSum;
    }
    return result;
}

int main() {
    int nums[] = {1, 2, 3, 4};
    int numsSize = 4;
    int returnSize;
    int* result = runningSum(nums, numsSize, &returnSize);
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we sum up to i elements, giving us 1+2+3+...+n = n(n+1)/2 operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space (excluding the output array which is required)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-10⁶ ≤ nums[i] ≤ 10⁶
Follow-up: Can you solve this in-place with O(1) extra space?

125.0K Views

High Frequency

~8 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler