Given an array **arr[]** of **N** integers, the task is to find the count of elements from the array such that after removing them individually (only a single element can be deleted) from the array will not disturb the initial mean of the array.

**Examples:**

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

Output:1

3 is the only element removing which

will not affect the mean of the array.

i.e. (1 + 2 + 4 + 5) / 4 = 12 / 4 = 3

which is the mean of the original array.

Input:arr[] = {5, 4, 3, 6}

Output:0

**Approach:**

- Find the initial mean and the sum of the array elements and store them in the variables
**mean**and**sum**respectively. - Now, initialise
**count = 0**and for every element**arr[i]**if**(sum – arr[i]) / (N – 1) = mean**then increment the count. - Print the count in the end.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Funcion to find the elements ` `// which do not change the mean on removal ` `int` `countElements(` `int` `arr[], ` `int` `n) ` `{ ` ` ` ` ` `// To store the sum of the array elements ` ` ` `int` `sum = 0; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `sum += arr[i]; ` ` ` ` ` `// To store the initial mean ` ` ` `float` `mean = (` `float` `)sum / n; ` ` ` ` ` `// to store the count of required elements ` ` ` `int` `cnt = 0; ` ` ` `// Iterate over the array ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Finding the new mean ` ` ` `float` `newMean = (` `float` `)(sum - arr[i]) / (n - 1); ` ` ` ` ` `// If the new mean equals to the initial mean ` ` ` `if` `(newMean == mean) ` ` ` `cnt++; ` ` ` `} ` ` ` ` ` `return` `cnt; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 2, 3, 4, 5 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `cout << countElements(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `class` `GFG ` `{ ` ` ` `// Funcion to find the elements ` `// which do not change the mean on removal ` `static` `int` `countElements(` `int` `arr[], ` `int` `n) ` `{ ` ` ` ` ` `// To store the sum of the array elements ` ` ` `int` `sum = ` `0` `; ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `sum += arr[i]; ` ` ` ` ` `// To store the initial mean ` ` ` `float` `mean = (` `float` `)sum / n; ` ` ` ` ` `// to store the count of required elements ` ` ` `int` `cnt = ` `0` `; ` ` ` ` ` `// Iterate over the array ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` ` ` `// Finding the new mean ` ` ` `float` `newMean = (` `float` `)(sum - arr[i]) / ` ` ` `(n - ` `1` `); ` ` ` ` ` `// If the new mean equals to ` ` ` `// the initial mean ` ` ` `if` `(newMean == mean) ` ` ` `cnt++; ` ` ` `} ` ` ` `return` `cnt; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `}; ` ` ` `int` `n = arr.length; ` ` ` `System.out.println(countElements(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `# Funcion to find the elements ` `# which do not change the mean on removal ` `def` `countElements(arr, n): ` ` ` ` ` `# To store the Sum of the array elements ` ` ` `Sum` `=` `0` ` ` `for` `i ` `in` `range` `(n): ` ` ` `Sum` `+` `=` `arr[i] ` ` ` ` ` `# To store the initial mean ` ` ` `mean ` `=` `Sum` `/` `n ` ` ` ` ` `# to store the count of required elements ` ` ` `cnt ` `=` `0` ` ` ` ` `# Iterate over the array ` ` ` `for` `i ` `in` `range` `(n): ` ` ` ` ` `# Finding the new mean ` ` ` `newMean ` `=` `(` `Sum` `-` `arr[i]) ` `/` `(n ` `-` `1` `) ` ` ` ` ` `# If the new mean equals to ` ` ` `# the initial mean ` ` ` `if` `(newMean ` `=` `=` `mean): ` ` ` `cnt ` `+` `=` `1` ` ` ` ` `return` `cnt ` ` ` `# Driver code ` `arr ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `] ` `n ` `=` `len` `(arr) ` ` ` `print` `(countElements(arr, n)) ` ` ` `# This code is contributed by Mohit Kumar ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the approach ` `using` `System; ` `class` `GFG ` `{ ` ` ` `// Funcion to find the elements ` `// which do not change the mean on removal ` `static` `int` `countElements(` `int` `[]arr, ` `int` `n) ` `{ ` ` ` ` ` `// To store the sum of the array elements ` ` ` `int` `sum = 0; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `sum += arr[i]; ` ` ` ` ` `// To store the initial mean ` ` ` `float` `mean = (` `float` `)sum / n; ` ` ` ` ` `// to store the count of required elements ` ` ` `int` `cnt = 0; ` ` ` ` ` `// Iterate over the array ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` ` ` `// Finding the new mean ` ` ` `float` `newMean = (` `float` `)(sum - arr[i]) / ` ` ` `(n - 1); ` ` ` ` ` `// If the new mean equals to ` ` ` `// the initial mean ` ` ` `if` `(newMean == mean) ` ` ` `cnt++; ` ` ` `} ` ` ` `return` `cnt; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `int` `[]arr = { 1, 2, 3, 4, 5 }; ` ` ` `int` `n = arr.Length; ` ` ` `Console.WriteLine(countElements(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

**Output:**

1

**Time Complexity:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Find the deleted value from the array when average of original elements is given
- Count of Array elements greater than or equal to twice the Median of K trailing Array elements
- Minimum value to be assigned to the elements so that sum becomes greater than initial sum
- Count of Array elements greater than all elements on its left and at least K elements on its right
- Count of Array elements greater than all elements on its left and next K elements on its right
- Generate array with minimum sum which can be deleted in P steps
- Find the Initial Array from given array after range sum queries
- Count of Array elements to be divided by 2 to make at least K elements equal
- Count of array elements which are greater than all elements on its left
- Count of array elements which is smaller than both its adjacent elements
- Count number of elements between two given elements in array
- Count array elements that divide the sum of all other elements
- Count of elements not divisible by any other elements of Array
- Count elements in first Array with absolute difference greater than K with an element in second Array
- Count distinct elements after adding each element of First Array with Second Array
- Count of elements in first Array greater than second Array with each element considered only once
- Count of elements to be inserted to make Array sum twice the XOR of Array
- For each element in 1st array count elements less than or equal to it in 2nd array
- For each element in 1st array count elements less than or equal to it in 2nd array | Set 2
- Find initial sequence that produces a given Array by cyclic increments upto index P

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.