# Sum of absolute differences of indices of occurrences of each array element

• Difficulty Level : Easy
• Last Updated : 18 Jan, 2023

Given an array arr[] consisting of N integers, the task for each array element arr[i] is to print the sum of |i – j| for all possible indices j such that arr[i] = arr[j].

Examples:

Input: arr[] = {1, 3, 1, 1, 2}
Output: 5 0 3 4 0
Explanation:
For arr[0], sum = |0 – 0| + |0 – 2| + |0 – 3| = 5.
For arr[1], sum = |1 – 1| = 0.
For arr[2], sum = |2 – 0| + |2 – 2| + |2 – 3| = 3.
For arr[3], sum = |3 – 0| + |3 – 2| + |3 – 3| = 4.
For arr[4], sum = |4 – 4| = 0.
Therefore, the required output is 5 0 3 4 0.

Input: arr[] = {1, 1, 1}
Output: 3 2 3

Naive approach: The simplest approach is to traverse the given array and for each element arr[i] ( 0 â‰¤ i â‰¤ N ), traverse the array and check if arr[i] is same as arr[j] ( 0 â‰¤ j â‰¤ N ). If found to be true, add abs(i – j) to the sum print the sum obtained for each array element.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find sum of differences``// of indices of occurrences of each``// unique array element``void` `sum(``int` `arr[], ``int` `n)``{``    ``// Traverse over the array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `sum = 0;` `        ``// Check for every other elements of the array``        ``for` `(``int` `j = 0; j < n; j++) {` `            ``// Add into sum if such pair found``            ``if` `(arr[i] == arr[j]) {``                ``sum += ``abs``(i - j);``            ``}``        ``}` `        ``// Print the sum``        ``cout << sum << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``int` `arr[] = { 1, 3, 1, 1, 2 };` `    ``// Given size``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``sum(arr, n);` `    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;` `public` `class` `Main {``    ``// Function to find sum of differences``    ``// of indices of occurrences of each``    ``// unique array element``    ``public` `static` `void` `sum(``int``[] arr, ``int` `n) {``        ``// Traverse over the array``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``int` `sum = ``0``;` `            ``// Check for every other elements of the array``            ``for` `(``int` `j = ``0``; j < n; j++) {` `                ``// Add into sum if such pair found``                ``if` `(arr[i] == arr[j]) {``                    ``sum += Math.abs(i - j);``                ``}``            ``}` `            ``// Print the sum``            ``System.out.print(sum + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) {``        ``// Given array``        ``int``[] arr = {``1``, ``3``, ``1``, ``1``, ``2``};` `        ``// Given size``        ``int` `n = arr.length;` `        ``// Function call``        ``sum(arr, n);``    ``}``}`

Output

`5 0 3 4 0 `

Time Complexity: O(N2) where N is the size of the given array.
Auxiliary Space: O(1)

Efficient Approach: The idea is to use Map data structure to optimize the above approach. Follow the steps below to solve the problem:

1. Initialize a Map to store the vector of indices for repetitions of each unique element present in the array.
2. Traverse the given array from i = 0 to N – 1 and for each array element arr[i], initialize the sum with 0 and traverse the vector map[arr[i]] which stores the indices of the occurrences of the element arr[i].
3. For each value j present in the vector, increment the sum by abs(i – j).
4. After traversing the vector, store the sum for the element at index i and print the sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find sum of differences``// of indices of occurrences of each``// unique array element``void` `sum(``int` `arr[], ``int` `n)``{``    ``// Stores indices of each``    ``// array element``    ``map<``int``, vector<``int``> > mp;` `    ``// Store the indices``    ``for` `(``int` `i = 0; i < n; i++) {``        ``mp[arr[i]].push_back(i);``    ``}` `    ``// Stores the sums``    ``int` `ans[n];` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Find sum for each element``        ``int` `sum = 0;` `        ``// Iterate over the Map``        ``for` `(``auto` `it : mp[arr[i]]) {` `            ``// Calculate sum of``            ``// occurrences of arr[i]``            ``sum += ``abs``(it - i);``        ` `        ``}` `        ``// Store sum for``        ``// current element``        ``ans[i] = sum;``    ``}` `    ``// Print answer for each element``    ``for` `(``int` `i = 0; i < n; i++) {``        ``cout << ans[i] << ``" "``;``    ``}``    ``return``;``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``int` `arr[] = { 1, 3, 1, 1, 2 };` `    ``// Given size``    ``int` `n = ``sizeof``(arr)``            ``/ ``sizeof``(arr[0]);` `    ``// Function call``    ``sum(arr, n);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find sum of differences``// of indices of occurrences of each``// unique array element``static` `void` `sum(``int` `arr[], ``int` `n)``{``    ` `    ``// Stores indices of each``    ``// array element``    ``HashMap> mp = ``new` `HashMap<>();` `    ``// Store the indices``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``Vector v = ``new` `Vector<>();``        ``v.add(i);``        ` `        ``if` `(mp.containsKey(arr[i]))``            ``v.addAll(mp.get(arr[i]));``        ` `        ``mp.put(arr[i], v);``    ``}` `    ``// Stores the sums``    ``int` `[]ans = ``new` `int``[n];` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// Find sum for each element``        ``int` `sum = ``0``;``        ` `        ``// Iterate over the Map``        ``for``(``int` `it : mp.get(arr[i]))``        ``{``            ` `            ``// Calculate sum of``            ``// occurrences of arr[i]``            ``sum += Math.abs(it - i);``        ``}` `        ``// Store sum for``        ``// current element``        ``ans[i] = sum;``    ``}` `    ``// Print answer for each element``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``System.out.print(ans[i] + ``" "``);``    ``}``    ``return``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array``    ``int` `arr[] = { ``1``, ``3``, ``1``, ``1``, ``2` `};` `    ``// Given size``    ``int` `n = arr.length;` `    ``// Function call``    ``sum(arr, n);``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program for the above approach``from` `collections ``import` `defaultdict` `# Function to find sum of differences``# of indices of occurrences of each``# unique array element``def` `sum_i(arr, n):``  ` `    ``# Stores indices of each``    ``# array element``    ``mp ``=` `defaultdict(``lambda` `: [])` `    ``# Store the indices``    ``for` `i ``in` `range``(n):``        ``mp[arr[i]].append(i)` `    ``# Stores the sums``    ``ans ``=` `[``0``] ``*` `n` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``# Find sum for each element``        ``sum` `=` `0` `        ``# Iterate over the Map``        ``for` `it ``in` `mp[arr[i]]:` `            ``# Calculate sum of``            ``# occurrences of arr[i]``            ``sum` `+``=` `abs``(it ``-` `i)` `            ``# Store sum for``            ``# current element``            ``ans[i] ``=` `sum` `    ``# Print answer for each element``    ``for` `i ``in` `range``(n):``        ``print``(ans[i], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[ ``1``, ``3``, ``1``, ``1``, ``2` `]` `    ``# Given size``    ``n ``=` `len``(arr)` `    ``# Function Call``    ``sum_i(arr, n)` `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find sum of differences``// of indices of occurrences of each``// unique array element``static` `void` `sum(``int` `[]arr, ``int` `n)``{``    ` `    ``// Stores indices of each``    ``// array element``    ``Dictionary<``int``,``          ``List<``int``>> mp = ``new` `Dictionary<``int``,``                                    ``List<``int``>>();` `    ``// Store the indices``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``List<``int``> v = ``new` `List<``int``>();``        ``v.Add(i);``        ` `        ``if` `(mp.ContainsKey(arr[i]))``            ``v.AddRange(mp[arr[i]]);``        ` `        ``mp[arr[i]]= v;``    ``}` `    ``// Stores the sums``    ``int` `[]ans = ``new` `int``[n];` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Find sum for each element``        ``int` `sum = 0;``        ` `        ``// Iterate over the Map``        ``foreach``(``int` `it ``in` `mp[arr[i]])``        ``{``            ` `            ``// Calculate sum of``            ``// occurrences of arr[i]``            ``sum += Math.Abs(it - i);``        ``}` `        ``// Store sum for``        ``// current element``        ``ans[i] = sum;``    ``}` `    ``// Print answer for each element``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``Console.Write(ans[i] + ``" "``);``    ``}``    ``return``;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 1, 3, 1, 1, 2 };` `    ``// Given size``    ``int` `n = arr.Length;` `    ``// Function call``    ``sum(arr, n);``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`5 0 3 4 0`

Time Complexity: O(N * L) where N is the size of the given array and L is the maximum frequency of any array element.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up