Sum of f(a[i], a[j]) over all pairs in an array of n integers
Last Updated :
12 Jul, 2022
Given an array of n integers, find the sum of f(a[i], a[j]) of all pairs (i, j) such that (1 <= i < j <= n).
f(a[i], a[j]):
If |a[j]-a[i]| > 1
f(a[i], a[j]) = a[j] - a[i]
Else // if |a[j]-a[i]| <= 1
f(a[i], a[j]) = 0
Examples:
Input : 6 6 4 4
Output : -8
Explanation:
All pairs are: (6 - 6) + (6 - 6) +
(6 - 6) + (4 - 6) + (4 - 6) + (4 - 6) +
(4 - 6) + (4 - 4) + (4 - 4) = -8
Input: 1 2 3 1 3
Output: 4
Explanation: the pairs that add up are:
(3, 1), (3, 1) to give 4, rest all pairs
according to condition gives 0.
A naive approach is to iterate through all pairs and calculate f(a[i], a[j]), and summing it up while traversing two nested loops will give us our answer.
Time Complexity: O(n^2)
An efficient approach would be to use a map/hash function to keep a count of every occurring number and then traverse through the list. While traversing through the list, we multiply the count of numbers that are before it and the number itself. Then subtract this result with the pre-sum of the number before that number to get the sum of the difference of all pairs possible with that number. To remove all pairs whose absolute difference is <=1, simply subtract the count of occurrence of (number-1) and (number+1) from the previously computed sum. Here we subtract the count of (number-1) from the computed sum as it had been previously added to the sum, and we add the (number+1) count since the negative has been added to the pre-computed sum of all pairs.
Time Complexity: O(n)
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int sum( int a[], int n)
{
unordered_map< int , int > cnt;
int ans = 0, pre_sum = 0;
for ( int i = 0; i < n; i++) {
ans += (i * a[i]) - pre_sum;
pre_sum += a[i];
if (cnt[a[i] - 1])
ans -= cnt[a[i] - 1];
if (cnt[a[i] + 1])
ans += cnt[a[i] + 1];
cnt[a[i]]++;
}
return ans;
}
int main()
{
int a[] = { 1, 2, 3, 1, 3 };
int n = sizeof (a) / sizeof (a[0]);
cout << sum(a, n);
return 0;
}
|
Java
import java.util.*;
public class GfG {
public static int sum( int a[], int n)
{
Map<Integer,Integer> cnt = new HashMap<Integer,Integer>();
int ans = 0 , pre_sum = 0 ;
for ( int i = 0 ; i < n; i++) {
ans += (i * a[i]) - pre_sum;
pre_sum += a[i];
if (cnt.containsKey(a[i] - 1 ))
ans -= cnt.get(a[i] - 1 );
if (cnt.containsKey(a[i] + 1 ))
ans += cnt.get(a[i] + 1 );
if (cnt.containsKey(a[i])) {
cnt.put(a[i], cnt.get(a[i]) + 1 );
}
else {
cnt.put(a[i], 1 );
}
}
return ans;
}
public static void main(String args[])
{
int a[] = { 1 , 2 , 3 , 1 , 3 };
int n = a.length;
System.out.println(sum(a, n));
}
}
|
Python3
def sum (a, n):
cnt = dict ()
ans = 0
pre_sum = 0
for i in range (n):
ans + = (i * a[i]) - pre_sum
pre_sum + = a[i]
if (a[i] - 1 ) in cnt:
ans - = cnt[a[i] - 1 ]
if (a[i] + 1 ) in cnt:
ans + = cnt[a[i] + 1 ]
if a[i] not in cnt:
cnt[a[i]] = 0
cnt[a[i]] + = 1
return ans
if __name__ = = '__main__' :
a = [ 1 , 2 , 3 , 1 , 3 ]
n = len (a)
print ( sum (a, n))
|
C#
using System;
using System.Collections.Generic;
public class GfG
{
public static int sum( int [] a, int n)
{
IDictionary< int , int > cnt = new Dictionary< int , int >();
int ans = 0, pre_sum = 0;
for ( int i = 0; i < n; i++)
{
ans += (i * a[i]) - pre_sum;
pre_sum += a[i];
if (cnt.ContainsKey(a[i] - 1))
{
ans -= cnt[a[i] - 1];
}
if (cnt.ContainsKey(a[i] + 1))
{
ans += cnt[a[i] + 1];
}
if (cnt.ContainsKey(a[i]))
{
cnt[a[i]] = cnt[a[i]] + 1;
}
else
{
cnt[a[i]] = 1;
}
}
return ans;
}
public static void Main( string [] args)
{
int [] a = new int [] {1, 2, 3, 1, 3};
int n = a.Length;
Console.WriteLine(sum(a, n));
}
}
|
Javascript
<script>
function sum(a, n)
{
var cnt = new Map();
var ans = 0, pre_sum = 0;
for ( var i = 0; i < n; i++) {
ans += (i * a[i]) - pre_sum;
pre_sum += a[i];
if (cnt.has(a[i] - 1))
ans -= cnt.get(a[i] - 1);
if (cnt.has(a[i] + 1))
ans += cnt.get(a[i] + 1);
if (cnt.has(a[i]))
cnt.set(a[i], cnt.get(a[i])+1)
else
cnt.set(a[i], 1)
}
return ans;
}
var a = [1, 2, 3, 1, 3];
var n = a.length;
document.write( sum(a, n));
</script>
|
Output:
4
Time Complexity: O(n)
Auxiliary Space: O(n)
Share your thoughts in the comments
Please Login to comment...