Left and Right Sum Differences

Left and Right Sum Differences - Problem

You are given a 0-indexed integer array nums of size n.

Define two arrays leftSum and rightSum where:

leftSum[i] is the sum of elements to the left of the index i in the array nums. If there is no such element, leftSum[i] = 0.
rightSum[i] is the sum of elements to the right of the index i in the array nums. If there is no such element, rightSum[i] = 0.

Return an integer array answer of size n where answer[i] = |leftSum[i] - rightSum[i]|.

Input & Output

Example 1 — Basic Four Elements

$ Input: nums = [10,4,8,3]

› Output: [15,1,11,22]

💡 Note: At i=0: leftSum=0, rightSum=4+8+3=15, |0-15|=15. At i=1: leftSum=10, rightSum=8+3=11, |10-11|=1. At i=2: leftSum=10+4=14, rightSum=3, |14-3|=11. At i=3: leftSum=10+4+8=22, rightSum=0, |22-0|=22.

Example 2 — Single Element

$ Input: nums = [1]

› Output: [0]

💡 Note: Only one element, so leftSum=0 and rightSum=0, difference is |0-0|=0.

Example 3 — Two Elements

$ Input: nums = [2,3]

› Output: [3,2]

💡 Note: At i=0: leftSum=0, rightSum=3, |0-3|=3. At i=1: leftSum=2, rightSum=0, |2-0|=2.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is that rightSum can be calculated as totalSum - leftSum - currentElement, avoiding redundant calculations. The optimal approach uses prefix sums to solve in a single pass. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Calculate Left and Right Sums Separately

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

For each index i, iterate through all elements to the left to calculate leftSum[i], then iterate through all elements to the right to calculate rightSum[i], and compute the absolute difference.

Prefix Sum - Single Pass Optimization

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

Calculate prefix sums in one pass, then use the relationship: rightSum[i] = totalSum - leftSum[i] - nums[i] to avoid redundant calculations.

Brute Force - Calculate Left and Right Sums Separately — Algorithm Steps

Step 1: For each index i, calculate sum of elements from 0 to i-1
Step 2: For each index i, calculate sum of elements from i+1 to n-1
Step 3: Calculate |leftSum[i] - rightSum[i]| for each position

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Calculate left sum (0) and right sum (7+11+15=33)

Position 1

Calculate left sum (2) and right sum (11+15=26)

Result

Compute |leftSum - rightSum| for each position

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int* result) {
    for (int i = 0; i < numsSize; i++) {
        // Calculate left sum
        int leftSum = 0;
        for (int j = 0; j < i; j++) {
            leftSum += nums[j];
        }
        
        // Calculate right sum
        int rightSum = 0;
        for (int j = i + 1; j < numsSize; j++) {
            rightSum += nums[j];
        }
        
        // Calculate absolute difference
        result[i] = abs(leftSum - rightSum);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    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* result = (int*)malloc(size * sizeof(int));
    solution(nums, size, result);
    
    // Print result
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", result[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we iterate through up to n elements to calculate sums

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, result array not counted

✓ Linear Space

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

Brute Force - Calculate Left and Right Sums Separately — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler