# Count of triplets that can be removed without changing Mean of given Array

• Difficulty Level : Medium
• Last Updated : 18 Jan, 2022

Given an array arr[], the task is to calculate the count of possible triplets such that they can be removed from the array without changing the arithmetic mean of the array.

Example:

Input: arr[] = {8, 7, 4, 6, 3, 0, 7}
Output: 3
Explanation: The given array has 3 possible triplets such that removing them will not affect the arithmetic mean of the array. There are {7, 3, 0}, {4, 6, 0} and {3, 0, 7}.

Input: arr[] = {5, 5, 5, 5}
Output:

Approach:  The given problem can be solved using the observation that for the mean of the remaining array to be constant, the mean of the removed triplet must be equal to the mean of the initial array. Hence the given problem is reduced to finding the count of triplets with the given sum which can be solved using hashing by following the below steps:

• Iterate the given array arr[] for all possible values of pairs (a, b) and insert their sum into a map.
• While iterating the array, check if (TargetSum – (a + b)) already exists in the map. If yes, then increment the value of the required count by its frequency.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Function to count the number of``// triplets with the given sum``int` `countTriplets(``int` `arr[], ``int` `n, ``int` `sum)``{``    ``// Stores the final count``    ``int` `cnt = 0;` `    ``// Map to store occurred elements``    ``unordered_map<``int``, ``int``> m;` `    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``// Check if Sum - (a + b)``            ``// is present in map``            ``int` `k = sum - (arr[i] + arr[j]);``            ``if` `(m.find(k) != m.end())` `                ``// Increment count``                ``cnt += m[k];``        ``}` `        ``// Store the occurrences``        ``m[arr[i]]++;``    ``}` `    ``// Return Answer``    ``return` `cnt;``}` `// Function to C=find count of triplets``// that can be removed without changing``// arithmetic mean of the given array``int` `count_triplets(``int` `arr[], ``int` `n)``{``    ``// Stores sum of all elements``    ``// of the given array``    ``int` `sum = 0;` `    ``// Calculate the sum of the array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``sum = sum + arr[i];``    ``}``    ``// Store the arithmetic mean``    ``int` `mean = sum / n;``    ``int` `reqSum = 3 * mean;` `    ``if` `((3 * sum) % n != 0)``        ``return` `0;` `    ``// Return count``    ``return` `countTriplets(arr, n, reqSum);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 5, 5, 5 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << count_triplets(arr, N);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.util.HashMap;` `class` `GFG {` `  ``// Function to count the number of``  ``// triplets with the given sum``  ``static` `int` `countTriplets(``int``[] arr, ``int` `n, ``int` `sum)``  ``{``    ``// Stores the final count``    ``int` `cnt = ``0``;` `    ``// Map to store occurred elements``    ``HashMap m = ``new` `HashMap<>();` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``      ``for` `(``int` `j = i + ``1``; j < n; j++) {` `        ``// Check if Sum - (a + b)``        ``// is present in map``        ``int` `k = sum - (arr[i] + arr[j]);``        ``if` `(m.containsKey(k))` `          ``// Increment count``          ``cnt += m.get(k);``      ``}` `      ``// Store the occurrences``      ``if` `(m.containsKey(arr[i]))``        ``m.put(arr[i],m.get(arr[i])+``1``);``      ``else``        ``m.put(arr[i],``1``);``    ``}` `    ``// Return Answer``    ``return` `cnt;``  ``}` `  ``// Function to C=find count of triplets``  ``// that can be removed without changing``  ``// arithmetic mean of the given array``  ``static` `int` `count_triplets(``int``[] arr, ``int` `n)``  ``{``    ``// Stores sum of all elements``    ``// of the given array``    ``int` `sum = ``0``;` `    ``// Calculate the sum of the array``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``sum = sum + arr[i];``    ``}``    ``// Store the arithmetic mean``    ``int` `mean = sum / n;``    ``int` `reqSum = ``3` `* mean;` `    ``if` `((``3` `* sum) % n != ``0``)``      ``return` `0``;` `    ``// Return count``    ``return` `countTriplets(arr, n, reqSum);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``int``[] arr = { ``5``, ``5``, ``5``, ``5` `};``    ``int` `N = arr.length;``    ``System.out.println(count_triplets(arr, N));``  ``}``}` `// This code is contributed by Shubham Singh.`

## Python3

 `# python code for the above approach` `# Function to count the number of``# triplets with the given sum``def` `countTriplets(arr, n, ``sum``):` `    ``# Stores the final count``    ``cnt ``=` `0` `    ``# Map to store occurred elements``    ``m ``=` `{}` `    ``for` `i ``in` `range``(``0``, n``-``1``):``        ``for` `j ``in` `range``(i``+``1``, n):` `            ``# Check if Sum - (a + b)``            ``# is present in map``            ``k ``=` `sum` `-` `(arr[i] ``+` `arr[j])``          ` `            ``if` `(k ``in` `m):` `                ``# Increment count``                ``cnt ``+``=` `m[k]` `        ``# Store the occurrences``        ``if` `arr[i] ``in` `m:``            ``m[arr[i]] ``+``=` `1``        ``else``:``            ``m[arr[i]] ``=` `1` `    ``# Return Answer``    ``return` `cnt` `# Function to C=find count of triplets``# that can be removed without changing``# arithmetic mean of the given array``def` `count_triplets(arr, n):` `    ``# Stores sum of all elements``    ``# of the given array``    ``sum` `=` `0` `    ``# Calculate the sum of the array``    ``for` `i ``in` `range``(``0``, n):``        ``sum` `=` `sum` `+` `arr[i]` `    ``# Store the arithmetic mean``    ``mean ``=` `sum` `/``/` `n``    ``reqSum ``=` `3` `*` `mean` `    ``if` `((``3` `*` `sum``) ``%` `n !``=` `0``):``        ``return` `0` `    ``# Return count``    ``return` `countTriplets(arr, n, reqSum)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``5``, ``5``, ``5``, ``5``]``    ``N ``=` `len``(arr)``    ``print``(count_triplets(arr, N))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `    ``// Function to count the number of``    ``// triplets with the given sum``    ``static` `int` `countTriplets(``int``[] arr, ``int` `n, ``int` `sum)``    ``{``        ``// Stores the final count``        ``int` `cnt = 0;` `        ``// Map to store occurred elements``        ``Dictionary<``int``, ``int``> m = ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n - 1; i++) {``            ``for` `(``int` `j = i + 1; j < n; j++) {` `                ``// Check if Sum - (a + b)``                ``// is present in map``                ``int` `k = sum - (arr[i] + arr[j]);``                ``if` `(m.ContainsKey(k))` `                    ``// Increment count``                    ``cnt += m[k];``            ``}` `            ``// Store the occurrences``            ``if` `(m.ContainsKey(arr[i]))``                ``m[arr[i]]++;``            ``else``                ``m[arr[i]] = 1;``        ``}` `        ``// Return Answer``        ``return` `cnt;``    ``}` `    ``// Function to C=find count of triplets``    ``// that can be removed without changing``    ``// arithmetic mean of the given array``    ``static` `int` `count_triplets(``int``[] arr, ``int` `n)``    ``{``        ``// Stores sum of all elements``        ``// of the given array``        ``int` `sum = 0;` `        ``// Calculate the sum of the array``        ``for` `(``int` `i = 0; i < n; i++) {``            ``sum = sum + arr[i];``        ``}``        ``// Store the arithmetic mean``        ``int` `mean = sum / n;``        ``int` `reqSum = 3 * mean;` `        ``if` `((3 * sum) % n != 0)``            ``return` `0;` `        ``// Return count``        ``return` `countTriplets(arr, n, reqSum);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 5, 5, 5, 5 };``        ``int` `N = arr.Length;``        ``Console.WriteLine(count_triplets(arr, N));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`4 `

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

My Personal Notes arrow_drop_up