Sum of Distances

Sum of Distances - Problem

You are given a 0-indexed integer array nums. There exists an array arr of length nums.length, where arr[i] is the sum of |i - j| over all j such that nums[j] == nums[i] and j != i. If there is no such j, set arr[i] to be 0.

Return the array arr.

Input & Output

Example 1 — Mixed Values

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

› Output: [5,0,3,4,0]

💡 Note: For nums[0]=1: distances to indices 2,3 are |0-2|+|0-3| = 2+3 = 5. For nums[1]=3: no other 3s, so 0. For nums[2]=1: distances to indices 0,3 are |2-0|+|2-3| = 2+1 = 3.

Example 2 — All Same

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

› Output: [3,2,3]

💡 Note: All elements are 2. For each index, sum distances to the other two indices: |0-1|+|0-2| = 1+2 = 3, |1-0|+|1-2| = 1+1 = 2, |2-0|+|2-1| = 2+1 = 3.

Example 3 — No Duplicates

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

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

💡 Note: No duplicate values, so no matching elements for any index. All results are 0.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 A Amazon 32 F Facebook 28

The key insight is to group indices by their values and then calculate distances efficiently. For each group of same values, we can use prefix sums to compute all pairwise distances in O(k) time instead of O(k²). Best approach uses hash map grouping with prefix sum optimization: Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

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

For each index i, iterate through all other indices j to find elements with the same value. Calculate |i - j| for each match and sum them up.

Hash Map Grouping

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

First pass creates a hash map where keys are values and values are lists of indices. Second pass calculates distance sums for each group of indices.

Prefix Sum Optimization

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

For each group of indices with the same value, use prefix sums to calculate the sum of distances in linear time instead of quadratic.

Brute Force — Algorithm Steps

For each index i in nums
For each other index j, check if nums[j] == nums[i]
If match found, add |i - j| to result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

For Each Element

Start with element at index i

Find Matches

Check all other indices for same value

Sum Distances

Add |i - j| for each match found

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*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize; j++) {
            if (i != j && nums[i] == nums[j]) {
                result[i] += abs(i - j);
            }
        }
    }
    
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100000];
    int size = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, size, &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²)

Nested loops: for each of n elements, we check all n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler