Find all indices of Array having value same as average of other elements

Given an array arr[] of N integers, the task is to find all indices in the array, such that for each index i the arithmetic mean of all elements except arr[i] is equal to the value of the element at that index.

Examples :

Input: N = 5, arr[] = {1, 2, 3, 4, 5}
Output : {2}
Explanation : Upon removing array element at index 2 (i.e. 3),  
arithmetic mean of rest of the array equals (1 + 2 + 4 + 5) / 4 = 3, which is equal to the element at index 2. 
It can be seen that 2 is the only such index.

Input : N = 6, arr[] = {5, 5, 5, 5, 5, 5}
Output : {0, 1, 2, 3, 4, 5}

Approach: The problem can be solved by the following idea:

Calculate the total sum of the array and for each element (arr[i]) check if the average of all the other elements is same as arr[i].

Follow the steps to solve the problem:

• Find sum of all elements of the array and store in a variable say sum.
• Traverse the array and,
• At each iteration, find the sum of the array without current element by subtracting current element value from the sum. say, current_sum
• Find the mean of current_sum, by dividing it with N-1
• If mean is equal to the value at current index, push the index in answer vector, else continue.
• Return the answer vector.

Following is the code based on above approach :

C++

// C++ code for above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find indices such that
// elements at those indices equals to the
// mean of the array except those indices
vector<int> findIndices(int N, int A[])
{

    // Vector to store answer (i.e. indices)
    vector<int> answer;

    // Calculation of sum of all elements
    int sum = 0;
    for (int i = 0; i < N; i++) {
        sum += A[i];
    }

    // For each element checking if its
    // value is equal to the mean of the
    // array except the current element
    for (int i = 0; i < N; i++) {
        int curr_sum = sum - A[i];

        if (curr_sum % (N - 1) == 0
            && curr_sum / (N - 1) == A[i]) {
            answer.push_back(i);
        }
    }

    // returning answer
    return answer;
}

// Driver Code
int main()
{
    int N = 5;
    int A[] = { 5, 5, 5, 5, 5 };

    vector<int> ans = findIndices(N, A);
    for (int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    }
}

Java

// Java code for above approach
import java.util.*;

class GFG {

  // Function to find indices such that
  // elements at those indices equals to the
  // mean of the array except those indices
  static  Vector<Integer> findIndices(int N, int[] A)
  {

    // Vector to store answer (i.e. indices)
    Vector<Integer> answer = new Vector<Integer>();

    // Calculation of sum of all elements
    int sum = 0;
    for (int i = 0; i < N; i++) {
      sum += A[i];
    }

    // For each element checking if its
    // value is equal to the mean of the
    // array except the current element
    for (int i = 0; i < N; i++) {
      int curr_sum = sum - A[i];

      if (curr_sum % (N - 1) == 0
          && curr_sum / (N - 1) == A[i]) {
        answer.add(i);
      }
    }

    // returning answer
    return answer;
  }

  // Driver Code
  public static void main (String[] args) {
    int N = 5;
    int A[] = { 5, 5, 5, 5, 5 };

    Vector<Integer> ans = findIndices(N, A);

    for (int i = 0; i < ans.size(); i++) {
      System.out.print(ans.get(i) + " ");
    }
  }
}

// This code is contributed by hrithikgarg03188.

Python3

# Python code for above approach

# Function to find indices such that
# elements at those indices equals to the
# mean of the array except those indices
def findIndices(N, A):

    # Vector to store answer (i.e. indices)
    answer = []

    # Calculation of sum of all elements
    sum = 0
    for i in range(0, N):
        sum += A[i]

    # For each element checking if its
    # value is equal to the mean of the
    # array except the current element
    for i in range(0, N):
        curr_sum = sum - A[i]

        if (curr_sum % (N - 1) == 0 and curr_sum // (N - 1) == A[i]):
            answer.append(i)

    # returning answer
    return answer

# Driver Code
N = 5
A = [5, 5, 5, 5, 5]

ans = findIndices(N, A)
print(*ans)

# This code is contributed by Samim Hossain Mondal.

C#

// C# code for above approach
using System;
using System.Collections;

class GFG {

  // Function to find indices such that
  // elements at those indices equals to the
  // mean of the array except those indices
  static ArrayList findIndices(int N, int[] A)
  {

    // Vector to store answer (i.e. indices)
    ArrayList answer = new ArrayList();

    // Calculation of sum of all elements
    int sum = 0;
    for (int i = 0; i < N; i++) {
      sum += A[i];
    }

    // For each element checking if its
    // value is equal to the mean of the
    // array except the current element
    for (int i = 0; i < N; i++) {
      int curr_sum = sum - A[i];

      if (curr_sum % (N - 1) == 0
          && curr_sum / (N - 1) == A[i]) {
        answer.Add(i);
      }
    }

    // returning answer
    return answer;
  }

  // Driver Code
  public static void Main()
  {
    int N = 5;
    int[] A = { 5, 5, 5, 5, 5 };

    ArrayList ans = findIndices(N, A);
    for (int i = 0; i < ans.Count; i++) {
      Console.Write(ans[i] + " ");
    }
  }
}

// This code is contributed by Samim Hossain Mondal.

Javascript

// JavaScript code for the above approach

        // Function to find indices such that
        // elements at those indices equals to the
        // mean of the array except those indices
        function findIndices(N, A) {

            // Vector to store answer (i.e. indices)
            let answer = [];

            // Calculation of sum of all elements
            let sum = 0;
            for (let i = 0; i < N; i++) {
                sum += A[i];
            }

            // For each element checking if its
            // value is equal to the mean of the
            // array except the current element
            for (let i = 0; i < N; i++) {
                let curr_sum = sum - A[i];

                if (curr_sum % (N - 1) == 0
                    && curr_sum / (N - 1) == A[i]) {
                    answer.push(i);
                }
            }

            // returning answer
            return answer;
        }

        // Driver Code
        let N = 5;
        let A = [5, 5, 5, 5, 5];

        let ans = findIndices(N, A);
        for (let i = 0; i < ans.length; i++) {
            document.write(ans[i] + " ")
        }

      // This code is contributed by Potta Lokesh

Output

0 1 2 3 4 

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