Sum of Distances - Practice Coding Problems

Sum of Distances - Problem

You're given an array of numbers where some values might appear multiple times. For each element in the array, imagine you want to calculate how far away it is from all other elements that have the same value.

More specifically, for each position i in the array, you need to find all other positions j where the values are equal (nums[i] == nums[j] but i ≠ j), then sum up all the distances |i - j| between these positions.

Goal: Return an array where each element represents the sum of distances from that position to all other positions with the same value.

Example: If nums = [1, 3, 1, 1, 2], then for the first element (value 1 at index 0), it appears again at indices 2 and 4. So the sum of distances is |0-2| + |0-4| = 2 + 4 = 6.

Input & Output

example_1.py — Basic case with repeated values

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

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

💡 Note: For index 0 (value 1): distances to indices 2,3 are |0-2|+|0-3| = 2+3 = 5. For index 1 (value 3): no other 3s, so 0. For index 2 (value 1): distances to indices 0,3 are |2-0|+|2-3| = 2+1 = 3. For index 3 (value 1): distances to indices 0,2 are |3-0|+|3-2| = 3+1 = 4. For index 4 (value 2): no other 2s, so 0.

example_2.py — All unique elements

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

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

💡 Note: Since all elements are unique, there are no other elements with the same value for any position, so all distances are 0.

example_3.py — All same elements

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

› Output: [3, 2, 3]

💡 Note: For index 0: distances to indices 1,2 are |0-1|+|0-2| = 1+2 = 3. For index 1: distances to indices 0,2 are |1-0|+|1-2| = 1+1 = 2. For index 2: distances to indices 0,1 are |2-0|+|2-1| = 2+1 = 3.

Visualization

Tap to expand

Understanding the Visualization

Group Same Values

Create groups of indices that have the same value, like grouping friends by shirt color

Use Prefix Sums

For each group, calculate prefix sums to enable efficient distance calculations

Mathematical Formula

For each position, calculate sum of distances using: left_distances + right_distances

Linear Time Result

Each element is processed once, achieving O(n) complexity instead of O(n²)

Key Takeaway

🎯 Key Insight: By grouping same values and using prefix sums with mathematical formulas, we can calculate all distances in linear time instead of the naive quadratic approach.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan through all n elements to find matches

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, excluding output array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
All array indices are 0-based

Asked in

G Google 42 a Amazon 31 f Meta 28 ⊞ Microsoft 19

The optimal solution uses a two-pass hash table approach with mathematical optimization. First pass groups indices by their values, second pass uses prefix sums to calculate distances efficiently in O(n) time instead of the naive O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each element, scan entire array to find matches and sum distances
Two-Pass Hash Table	O(n)	O(n)	Group indices by value, then calculate distances using mathematical formulas

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array with zeros
For each index i, iterate through all other indices j
If nums[i] equals nums[j] and i != j, add |i - j| to result[i]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Check element at index 0 against all other elements

Find matches

When values match, calculate |i - j| distance

Sum distances

Add all distances for elements with same value

Repeat for all indices

Process each index in the array similarly

Code -

solution.c — C

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

int* sumOfDistances(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() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int reading_num = 0;
    
    while ((c = getchar()) != '\n') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading_num = 1;
        } else if (reading_num) {
            nums[size++] = num;
            num = 0;
            reading_num = 0;
        }
    }
    if (reading_num) nums[size++] = num;
    
    int returnSize;
    int* result = sumOfDistances(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²)

For each of n elements, we scan through all n elements to find matches

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, excluding output array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
All array indices are 0-based

42.8K Views

Medium-High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler