 Open in App
Not now

# Count of pairs that can be removed from Array without changing the Mean

• Last Updated : 28 Apr, 2022

Given an array arr[] of size N, the task is to find the number of pairs of the array upon removing which the mean (i.e. the average of all elements) of the array remains unchanged.

Examples:

Input: N = 5, arr[] = {1, 4, 7, 3, 5}
Output:  2
Explanation:  The required pairs of positions are – {0, 2} and {3, 4}.
Mean of original array = (1 + 4 + 7 + 3 + 5) / 5 = 4.
On deletion of elements at positions 0 and 2, array becomes {4, 3, 5}.
Mean of the new array = (4 + 3 + 5) / 3 = 4. which is same as the mean of original array.
On deletion of elements at positions 3 and 4, array becomes {1, 4, 7}.
Mean of the new array = (1 + 4 + 7) / 3 = 4. which is same as the mean of original array.

Input: N = 3, A = {50, 20, 10}
Output: 0
Explanation: No such pair is possible.

Approach: Consider the below observation:

Observation:

If a sum (S = 2*mean) is subtracted from the original array (with initial mean = M), the mean of the new updated array will still remains as M.

Derivation:

• Sum of array (of size N) = N * mean = N * M
• new mean = (sum of array – 2 * M) / (N – 2)
=(N*M – 2*M)/(N – 2)
= M.

The following steps can be followed to solve the problem –

• Calculate mean of the given array.
• Calculate required sum S i.e. 2*mean.
• If S is not an integer, return 0, since there will not be any pair with a nonintegral sum.
• Else, find a number of required pairs by hashing.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach``#include ``using` `namespace` `std;` `// Function to calculate the number``// of pairs of positions [i, j] (i 0) {``        ``return` `0;``    ``}``    ``else` `{` `        ``// Initialising count variable to``        ``// store total number of valid pairs``        ``int` `count = 0;` `        ``// Declaring a map to calculate``        ``// number of pairs with required sum``        ``map<``int``, ``int``> mp;` `        ``// Standard procedure to calculate``        ``// total number of pairs``        ``// of required sum``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(i > 0) {``                ``count += mp[required_sum``                            ``- A[i]];``            ``}``            ``mp[A[i]]++;``        ``}` `        ``// Returning count``        ``return` `count;``    ``}` `    ``// If no pairs with required sum``    ``return` `0;``}` `// Driver code``int` `main()``{``    ``int` `N = 5;``    ``int` `arr[] = { 1, 4, 7, 3, 5 };``    ``int` `numberOfPairs = countPairs(N, arr);``    ``cout << numberOfPairs;``    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// Function to calculate the number``  ``// of pairs of positions [i, j] (i ``0``) {``      ``return` `0``;``    ``}``    ``else` `{` `      ``// Initialising count variable to``      ``// store total number of valid pairs``      ``int` `count = ``0``;` `      ``// Declaring a map to calculate``      ``// number of pairs with required sum``      ``TreeMap mp``        ``= ``new` `TreeMap();` `      ``// Standard procedure to calculate``      ``// total number of pairs``      ``// of required sum``      ``for` `(``int` `i = ``0``; i < n; i++) {``        ``if` `(i > ``0``) {``          ``if` `(mp.get((``int``)required_sum - A[i]) != ``null``)``          ``{``            ``count += mp.get((``int``)required_sum - A[i]);``          ``}` `        ``}``        ``if` `(mp.get(A[i]) != ``null``)``        ``{``          ``mp.put(A[i],mp.get(A[i])+``1``);``        ``}``        ``else``        ``{``          ``mp.put(A[i],``1``);``        ``}``      ``}` `      ``// Returning count``      ``return` `count;``    ``}` `  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``5``;``    ``int` `arr[] = { ``1``, ``4``, ``7``, ``3``, ``5` `};``    ``int` `numberOfPairs = countPairs(N, arr);``    ``System.out.print(numberOfPairs);``  ``}``}` `// This code is contributed by Pushpesh Raj`

## Python

 `# Python code to implement the above approach` `# Function to calculate the number``# of pairs of positions [i, j] (i ``0``):``        ``return` `0``        ` `    ``else``:` `        ``# Initialising count variable to``        ``# store total number of valid pairs``        ``count ``=` `0` `        ``# Declaring a map to calculate``        ``# number of pairs with required sum``        ``mp ``=` `{}` `        ``# Standard procedure to calculate``        ``# total number of pairs``        ``# of required sum``        ``for` `i ``in` `range``(``0``, n):``            ``if` `(i > ``0` `and` `required_sum ``-` `A[i] ``in` `mp):``                ``count ``+``=` `mp[required_sum ``-` `A[i]]``            ` `            ``if` `arr[i] ``in` `mp:``                ``mp[arr[i]] ``+``=` `1``            ``else``:``                ``mp[arr[i]] ``=` `1` `        ``# Returning count``        ``return` `count` `    ``# If no pairs with required sum``    ``return` `0` `# Driver code` `N ``=` `5``arr ``=` `[ ``1``, ``4``, ``7``, ``3``, ``5` `]``numberOfPairs ``=` `countPairs(N, arr)``print``(numberOfPairs)` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `  ``// Function to calculate the number``  ``// of pairs of positions [i, j] (i 0) {``      ``return` `0;``    ``}``    ``else` `{` `      ``// Initialising count variable to``      ``// store total number of valid pairs``      ``int` `count = 0;` `      ``// Declaring a map to calculate``      ``// number of pairs with required sum``      ``Dictionary<``int``,``      ``int``> mp = ``new` `Dictionary<``int``,``      ``int``>();` `      ``// Standard procedure to calculate``      ``// total number of pairs``      ``// of required sum``      ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(i > 0 && ( mp.ContainsKey((``int``)required_sum - A[i]))) {``          ``count += mp[(``int``)required_sum``                      ``- A[i]];``        ``}` `        ``if` `(mp.ContainsKey(A[i]))``        ``{``          ``int` `x = mp[A[i]];``          ``mp[A[i]]= x + 1;``        ``}``        ``else``          ``mp.Add(A[i], 1);``      ``}` `      ``// Returning count``      ``return` `count;``    ``}` `    ``// If no pairs with required sum``    ``return` `0;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 5;``    ``int``[] arr = { 1, 4, 7, 3, 5 };``    ``int` `numberOfPairs = countPairs(N, arr);``    ``Console.Write(numberOfPairs);``  ``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`2`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up