Left and Right Sum Differences - Practice Coding Problems

Left and Right Sum Differences - Problem

You're given a 0-indexed integer array nums of size n. Your task is to calculate the balance at each position by finding the absolute difference between the sum of elements to the left and the sum of elements to the right.

Here's what you need to do:

For each index i, calculate leftSum[i] = sum of all elements before index i
For each index i, calculate rightSum[i] = sum of all elements after index i
Return an array where answer[i] = |leftSum[i] - rightSum[i]|

Example: For array [10, 4, 8, 3], at index 1 (value 4):
• Left sum = 10 (elements before index 1)
• Right sum = 8 + 3 = 11 (elements after index 1)
• Difference = |10 - 11| = 1

Input & Output

example_1.py — Basic Array

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

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

💡 Note: At index 0: left=0, right=4+8+3=15, diff=15. At index 1: left=10, right=8+3=11, diff=1. At index 2: left=10+4=14, right=3, diff=11. At index 3: left=10+4+8=22, right=0, diff=22.

example_2.py — Single Element

$ Input: [1]

› Output: [0]

💡 Note: With only one element, there are no elements to the left or right, so leftSum=0, rightSum=0, and the difference is |0-0|=0.

example_3.py — All Zeros

$ Input: [0, 0, 0, 0]

› Output: [0, 0, 0, 0]

💡 Note: Since all elements are 0, all left sums and right sums are 0, resulting in differences of 0 at every position.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Setup

We have weights [10, 4, 8, 3] arranged in a line

Position 0

Standing at 10: left side empty (0), right side has 4+8+3=15, imbalance = 15

Position 1

Standing at 4: left side has 10, right side has 8+3=11, imbalance = |10-11| = 1

Position 2

Standing at 8: left side has 10+4=14, right side has 3, imbalance = |14-3| = 11

Position 3

Standing at 3: left side has 10+4+8=22, right side empty (0), imbalance = 22

Key Takeaway

🎯 Key Insight: Instead of recalculating sums repeatedly, we use the mathematical relationship that at any position, the right sum equals the total sum minus the left sum minus the current element. This transforms an O(n²) problem into an elegant O(n) solution!

Asked in

a Amazon 15 G Google 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a one-pass approach: calculate the total sum first, then iterate through the array maintaining a running left sum. For each position, the right sum equals total - leftSum - currentElement. This achieves O(n) time and O(1) space complexity, making it the most efficient approach for this prefix sum problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Calculate left and right sums from scratch for each position
One-Pass Optimal Solution	O(n)	O(1)	Calculate total sum once, then maintain running left sum as we iterate
Two-Pass Prefix Sum	O(n)	O(n)	Build prefix and suffix sum arrays, then calculate differences

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array of same size as input
For each index i in the array:
Calculate leftSum by summing all elements from index 0 to i-1
Calculate rightSum by summing all elements from index i+1 to n-1
Store |leftSum - rightSum| in result[i]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

No left elements, sum right elements [4,8,3] = 15

Position 1

Left: [10] = 10, Right: [8,3] = 11, Diff: |10-11| = 1

Position 2

Left: [10,4] = 14, Right: [3] = 3, Diff: |14-3| = 11

Position 3

Left: [10,4,8] = 22, No right elements, Diff: |22-0| = 22

Code -

solution.c — C

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

int* leftRightDifference(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    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];
        }
        
        // Store absolute difference
        result[i] = abs(leftSum - rightSum);
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    int returnSize;
    int* result = leftRightDifference(nums, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(", ");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(nums);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we sum up to n elements, giving us n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for temporary calculations, not counting output array

✓ Linear Space

52.3K Views

Medium Frequency

~8 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler