Sum of Absolute Differences in a Sorted Array

Sum of Absolute Differences in a Sorted Array - Problem

You're given an integer array nums that's already sorted in non-decreasing order. Your task is to build a result array where each element represents the sum of absolute differences between the current element and all other elements in the array.

For each position i, calculate result[i] = sum(|nums[i] - nums[j]|) where j ranges from 0 to nums.length - 1 and j ≠ i.

Example: If nums = [2, 3, 5], then for nums[1] = 3:

|3 - 2| = 1
|3 - 5| = 2
result[1] = 1 + 2 = 3

The key insight is that since the array is already sorted, we can leverage mathematical properties to avoid the naive O(n²) approach and solve this efficiently using prefix sums.

Input & Output

example_1.py — Basic Case

$ Input: [2,3,5]

› Output: [4,3,5]

💡 Note: For nums[0]=2: |2-3|+|2-5| = 1+3 = 4. For nums[1]=3: |3-2|+|3-5| = 1+2 = 3. For nums[2]=5: |5-2|+|5-3| = 3+2 = 5.

example_2.py — Single Element

$ Input: [1]

› Output: [0]

💡 Note: With only one element, there are no other elements to compare with, so the sum of absolute differences is 0.

example_3.py — Equal Elements

$ Input: [1,4,6,8,10]

› Output: [24,15,13,15,24]

💡 Note: For nums[0]=1: |1-4|+|1-6|+|1-8|+|1-10| = 3+5+7+9 = 24. The middle elements have smaller sums as they're closer to other elements.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ nums[i + 1] ≤ 10⁴
Array is guaranteed to be sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Recognize Sorted Property

Since array is sorted, all elements left of index i are ≤ nums[i], all elements right are ≥ nums[i]

Simplify Absolute Values

For left elements: |nums[i] - left| = nums[i] - left. For right elements: |nums[i] - right| = right - nums[i]

Apply Mathematical Formula

Sum = (nums[i] × count_left - left_sum) + (right_sum - nums[i] × count_right)

Optimize with Running Sums

Track left_sum as we iterate, calculate right_sum = total_sum - left_sum - nums[i]

Key Takeaway

🎯 Key Insight: The sorted property eliminates the need for absolute value calculations—we know the relationship between current element and its neighbors, allowing us to use mathematical formulas instead of nested loops.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses prefix sum optimization to achieve O(n) time complexity. Since the array is sorted, we can mathematically calculate the sum of absolute differences using the formula: result[i] = nums[i] * (2*i - n + 1) + rightSum - leftSum, where leftSum and rightSum are the sums of elements to the left and right of index i respectively.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Calculate absolute differences for each element against all others directly
Prefix Sum Optimization	O(n)	O(1)	Use prefix sums to calculate absolute differences efficiently in O(n) time

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array of same length as input
For each element at index i, initialize sum to 0
For each other element at index j (where j ≠ i), add |nums[i] - nums[j]| to sum
Store the sum in result[i]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Choose current element nums[i]

Compare with All

Calculate |nums[i] - nums[j]| for all j ≠ i

Sum Differences

Add all absolute differences together

Store Result

Save the sum in result[i]

Code -

solution.c — C

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

int* getSumAbsoluteDifferences(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize; j++) {
            if (i != j) {
                result[i] += abs(nums[i] - nums[j]);
            }
        }
    }
    
    return result;
}

int main() {
    int nums[] = {2, 3, 5};
    int numsSize = 3;
    int returnSize;
    
    int* result = getSumAbsoluteDifferences(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 n elements, we iterate through n-1 other elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space beyond the result array

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

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