Running Sum of 1d Array

Running Sum of 1d Array - Problem

Given an array nums, we define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).

Return the running sum of nums.

Input & Output

Example 1 — Basic Case

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

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

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

Example 2 — Single Element

$ Input: nums = [1]

› Output: [1]

💡 Note: Only one element, so running sum is just [1]

Example 3 — With Negative Numbers

$ Input: nums = [1,1,1,1,1]

› Output: [1,2,3,4,5]

💡 Note: Running sums of identical elements: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1]

Constraints

1 ≤ nums.length ≤ 1000
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8 G Google 6

The key insight is that each running sum can be calculated from the previous running sum: runningSum[i] = runningSum[i-1] + nums[i]. Best approach is prefix sum in single pass with Time: O(n), Space: O(1) if modifying in-place.

Common Approaches

✓ Brute Force - Recalculate Each Sum

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

For each index i, iterate from 0 to i and calculate the sum of all elements. This means we're recalculating overlapping sums repeatedly.

In-Place Modification

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

Instead of using extra space for a result array, we can modify the input array in-place. Each element becomes the running sum up to that position.

Prefix Sum - Single Pass

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

Use the key insight that runningSum[i] = runningSum[i-1] + nums[i]. We can calculate each running sum by adding the current element to the previous running sum.

Brute Force - Recalculate Each Sum — Algorithm Steps

For each position i from 0 to n-1
Sum all elements from index 0 to i
Store the sum in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Sum from 0 to 0: 1

Position 1

Sum from 0 to 1: 1+2=3

Position 2

Sum from 0 to 2: 1+2+3=6

Result

Running sums: [1,3,6,10]

Code -

solution.c — C

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

int* solution(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() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array [1,2,3] format
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]"); // Skip opening bracket
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    // Print result in [1,2,3] format
    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²)

Nested loops: outer loop runs n times, inner loop averages n/2 iterations

✓ Linear Growth

Space Complexity

O(n)

Extra array to store n running sum values

⚡ Linearithmic Space

85.0K Views

High Frequency

~10 min Avg. Time

4.2K 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 - Recalculate Each Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler