Numbers of pairs from an array whose average is also present in the array
Given an array arr[] consisting of N integers, the task is to count the number of distinct pairs (arr[i], arr[j]) in the array such that the average of pairs is also present in the array.
Note: Consider (arr[i], arr[j]) and (arr[j], arr[i]) as the same pairs.
Examples:
Input: arr[] = {2, 1, 3}
Output: 1
Explanation: The only one pair whose average is present in the given array is (1, 3) (Average = 2).
Input: arr[] = {4, 2, 5, 1, 3, 5}
Output: 7
Naive Approach: Follow the steps below to solve the problem:
- Initialize a variable, say count as 0 to store all the count of pairs whose average exists in the array.
- Insert all the array elements in an set S.
- Traverse over the set S and for every element in the set S, generate all possible pairs of the given array and if the sum of any pairs is same as the current element in the set then increment the value of count by 1.
- After completing the above steps, print the value of count as the resultant count of pairs.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
int getCountPairs(vector< int > arr, int N, int S)
{
int count = 0;
for ( int i = 0; i < arr.size(); i++)
{
for ( int j = i + 1; j < arr.size(); j++)
{
if ((arr[i] + arr[j]) == S)
count++;
}
}
return count;
}
int countPairs(vector< int > arr, int N)
{
int count = 0;
unordered_set< int > S;
for ( int i = 0; i < N; i++)
S.insert(arr[i]);
for ( int ele : S)
{
int sum = 2 * ele;
count += getCountPairs(arr, N, sum);
}
return count;
}
int main()
{
vector< int > arr = { 4, 2, 5, 1, 3, 5 };
int N = arr.size();
cout << countPairs(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
public static int getCountPairs(
int arr[], int N, int S)
{
int count = 0 ;
for ( int i = 0 ;
i < arr.length; i++) {
for ( int j = i + 1 ;
j < arr.length; j++) {
if ((arr[i] + arr[j]) == S)
count++;
}
}
return count;
}
public static int countPairs(
int arr[], int N)
{
int count = 0 ;
HashSet<Integer> S = new HashSet<>();
for ( int i = 0 ; i < N; i++)
S.add(arr[i]);
for ( int ele : S) {
int sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
public static void main(String[] args)
{
int arr[] = { 4 , 2 , 5 , 1 , 3 , 5 };
int N = arr.length;
System.out.print(
countPairs(arr, N));
}
}
|
Python3
def getCountPairs(arr, N, S):
count = 0
for i in range ( len (arr)):
for j in range (i + 1 , len (arr)):
if ((arr[i] + arr[j]) = = S):
count + = 1
return count
def countPairs(arr, N):
count = 0
S = set ([])
for i in range (N):
S.add(arr[i])
for ele in S:
sum = 2 * ele
count + = getCountPairs(arr, N, sum )
return count
if __name__ = = "__main__" :
arr = [ 4 , 2 , 5 , 1 , 3 , 5 ]
N = len (arr)
print (countPairs(arr, N))
|
C#
using System;
using System.Collections.Generic;
public class GFG
{
public static int getCountPairs(
int []arr, int N, int S)
{
int count = 0;
for ( int i = 0;
i < arr.Length; i++) {
for ( int j = i + 1;
j < arr.Length; j++) {
if ((arr[i] + arr[j]) == S)
count++;
}
}
return count;
}
public static int countPairs(
int []arr, int N)
{
int count = 0;
HashSet< int > S = new HashSet< int >();
for ( int i = 0; i < N; i++)
S.Add(arr[i]);
foreach ( int ele in S) {
int sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
public static void Main(String[] args)
{
int []arr = { 4, 2, 5, 1, 3, 5 };
int N = arr.Length;
Console.Write(
countPairs(arr, N));
}
}
|
Javascript
<script>
function getCountPairs(
arr, N, S)
{
let count = 0;
for (let i = 0;
i < arr.length; i++) {
for (let j = i + 1;
j < arr.length; j++) {
if ((arr[i] + arr[j]) == S)
count++;
}
}
return count;
}
function countPairs(arr, N)
{
let count = 0;
let S = [];
for (let i = 0; i < N; i++)
S.push(arr[i]);
for (let ele in S) {
let sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
let arr = [ 4, 2, 5, 1, 3, 5 ];
let N = arr.length;
document.write(
countPairs(arr, N));
</script>
|
Time Complexity: O(N3)
Auxiliary Space: O(N)
Efficient Approach: The above approach can also be optimized by storing the frequency of the sum of all possible pairs in the given array in a HashMap and find the count for each element of the array accordingly. Follow the steps below to solve the problem:
- Initialize a variable, say count as 0 to store all the count of pairs whose average exists in the array.
- Insert all the array elements in an set S.
- Initialize a HashMap, say M that stores the frequency of the sum of all possible pairs in the given array.
- Traverse over the set S and for every element(say X) in the set S update the value of count by the value (M[X]/2).
- After completing the above steps, print the value of count as the resultant count of pairs.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int getCountPairs( int arr[],
int N, int S)
{
map< int , int > mp;
for ( int i = 0; i < N; i++) {
mp[arr[i]]++;
}
int twice_count = 0;
for ( int i = 0; i < N; i++) {
if (mp.find(S - arr[i]) != mp.end()) {
twice_count += mp[S - arr[i]];
}
if (S - arr[i] == arr[i])
twice_count--;
}
return twice_count / 2;
}
int countPairs(
int arr[], int N)
{
int count = 0;
set< int > S;
for ( int i = 0; i < N; i++)
S.insert(arr[i]);
for ( int ele : S) {
int sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
int main()
{
int N = 6;
int arr[] = { 4, 2, 5, 1, 3, 5 };
cout<<(countPairs(arr, N));
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int getCountPairs( int arr[],
int N, int S)
{
HashMap<Integer, Integer> mp
= new HashMap<>();
for ( int i = 0 ; i < N; i++) {
if (!mp.containsKey(arr[i]))
mp.put(arr[i], 0 );
mp.put(arr[i],
mp.get(arr[i]) + 1 );
}
int twice_count = 0 ;
for ( int i = 0 ; i < N; i++) {
if (mp.get(S - arr[i])
!= null ) {
twice_count += mp.get(
S - arr[i]);
}
if (S - arr[i] == arr[i])
twice_count--;
}
return twice_count / 2 ;
}
public static int countPairs(
int arr[], int N)
{
int count = 0 ;
HashSet<Integer> S = new HashSet<>();
for ( int i = 0 ; i < N; i++)
S.add(arr[i]);
for ( int ele : S) {
int sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
public static void main(String[] args)
{
int N = 6 ;
int arr[] = { 4 , 2 , 5 , 1 , 3 , 5 };
System.out.println(
countPairs(arr, N));
}
}
|
Python3
def getCountPairs(arr,N,S):
mp = {}
for i in range (N):
if (arr[i] not in mp):
mp[arr[i]] = 0
mp[arr[i]] + = 1
twice_count = 0
for i in range (N):
if ((S - arr[i]) in mp):
twice_count + = mp[S - arr[i]]
if (S - arr[i] = = arr[i]):
twice_count - = 1
return (twice_count / / 2 )
def countPairs(arr,N):
count = 0
S = set ()
for i in range (N):
S.add(arr[i])
for ele in S:
sum = 2 * ele
count + = getCountPairs(arr, N, sum )
return count
N = 6
arr = [ 4 , 2 , 5 , 1 , 3 , 5 ]
print (countPairs(arr, N))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int GetCountPairs( int [] arr, int N, int S)
{
Dictionary< int , int > mp = new Dictionary< int , int >();
for ( int i = 0; i < N; i++)
{
if (!mp.ContainsKey(arr[i]))
mp[arr[i]] = 0;
mp[arr[i]] = mp[arr[i]] + 1;
}
int twice_count = 0;
for ( int i = 0; i < N; i++)
{
if (mp.ContainsKey(S - arr[i]))
{
twice_count += mp[S - arr[i]];
}
if (S - arr[i] == arr[i])
twice_count--;
}
return twice_count / 2;
}
public static int CountPairs( int [] arr, int N)
{
int count = 0;
HashSet< int > S = new HashSet< int >();
for ( int i = 0; i < N; i++)
S.Add(arr[i]);
foreach ( int ele in S)
{
int sum = 2 * ele;
count += GetCountPairs(
arr, N, sum);
}
return count;
}
public static void Main( string [] args)
{
int N = 6;
int [] arr = { 4, 2, 5, 1, 3, 5 };
Console.WriteLine(
CountPairs(arr, N));
}
}
|
Javascript
<script>
function getCountPairs(arr,N,S)
{
let mp = new Map();
for (let i = 0; i < N; i++) {
if (!mp.has(arr[i]))
mp.set(arr[i], 0);
mp.set(arr[i],
mp.get(arr[i]) + 1);
}
let twice_count = 0;
for (let i = 0; i < N; i++) {
if (mp.get(S - arr[i])
!= null ) {
twice_count += mp.get(
S - arr[i]);
}
if (S - arr[i] == arr[i])
twice_count--;
}
return Math.floor(twice_count / 2);
}
function countPairs(arr,N)
{
let count = 0;
let S = new Set();
for (let i = 0; i < N; i++)
S.add(arr[i]);
for (let ele of S.values()) {
let sum = 2 * ele;
count += getCountPairs(
arr, N, sum);
}
return count;
}
let N = 6;
let arr=[4, 2, 5, 1, 3, 5 ];
document.write(countPairs(arr, N));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N)
Last Updated :
10 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...