Skip to content
Related Articles

Related Articles

Improve Article
Count of greater elements for each element in the Array
  • Difficulty Level : Easy
  • Last Updated : 10 Jul, 2020

Given an array arr of integers of size N, the task is to find, for every element, the number of elements that are greater than it.

Examples:

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

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

Approach: Store the frequencies of every array element using a Map. Iterate the Map in reverse and store the sum of the frequency of all previously traversed elements (i.e. elements greater than it) for every element.



Below code is the implementation of the above approach:

C++




// C++ implementation of the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
void countOfGreaterElements(int arr[], int n)
{
    // Store the frequency of the
    // array elements
    map<int, int> mp;
    for (int i = 0; i < n; i++) {
        mp[arr[i]]++;
    }
  
    int x = 0;
    // Store the sum of frequency of elements
    // greater than the current eleement
    for (auto it = mp.rbegin(); it != mp.rend(); it++) {
        int temp = it->second;
        mp[it->first] = x;
        x += temp;
    }
  
    for (int i = 0; i < n; i++)
        cout << mp[arr[i]] << " ";
}
  
// Driver code
int main()
{
  
    int arr[] = { 7, 9, 5, 2, 1, 3, 4, 8, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    countOfGreaterElements(arr, n);
  
    return 0;
}

Java




// Java implementation of the above approach
import java.util.*;
  
class GfG {
    public static void countOfGreaterElements(int arr[])
    {
        int n = arr.length;
  
        TreeMap<Integer, Integer> mp = new TreeMap<Integer, Integer>(Collections.reverseOrder());
  
        // Store the frequency of the
        // array elements
        for (int i = 0; i < n; i++) {
            mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
        }
  
        // Store the sum of frequency of elements
        // greater than the current eleement
        int x = 0;
        for (Map.Entry<Integer, Integer> e : mp.entrySet()) {
            Integer temp = e.getValue();
            mp.put(e.getKey(), x);
            x += temp;
        }
  
        for (int i = 0; i < n; i++)
            System.out.print(mp.get(arr[i]) + " ");
    }
  
    public static void main(String args[])
    {
        int arr[] = { 7, 9, 5, 2, 1, 3, 4, 8, 6 };
        countOfGreaterElements(arr);
    }
}

Python 3




# Python 3 implementation of the above approach
  
def countOfGreaterElements(arr, n):
    # Store the frequency of the
    # array elements
    mp = {i:0 for i in range(1000)}
    for i in range(n):
        mp[arr[i]] += 1
  
    x = 0
    # Store the sum of frequency of elements
    # greater than the current eleement
    p = []
    q = []
    m = []
    for key, value in mp.items():
        m.append([key, value])
    m = m[::-1]
      
    for p in m:
        temp = p[1]
        mp[p[0]] = x
        x += temp
  
    for i in range(n):
        print(mp[arr[i]], end = " ")
  
# Driver code
if __name__ == '__main__':
    arr = [7, 9, 5, 2, 1, 3, 4, 8, 6]
    n = len(arr)
  
    countOfGreaterElements(arr, n)
  
# This code is contributed by Surendra_Gangwar
Output:
2 0 4 7 8 6 5 1 3

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :