Related Articles
Count elements such that there are exactly X elements with values greater than or equal to X
• Difficulty Level : Medium
• Last Updated : 26 Nov, 2019

Given an array arr of N integers, the task is to find the number of elements that satisfy the following condition:
If the element is X then there has to be exactly X number of elements in the array (excluding the number X) which are greater than or equal to X

Examples:

```Input: arr[] = {1, 2, 3, 4}
Output: 1
Only element 2 satisfies the condition as
there are exactly 2 elements which are greater
than or equal to 2 (3, 4) except 2 itself.

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The problem involves efficient searching for each arr[i] element the number of arr[j]’s (i != j) which are greater than or equal to arr[i].

• Sort the array in ascending order.
• For every element arr[i], using binary search get the count of all the elements that are greater than or equal to arr[i] except arr[i] itself.
• If the count is equal to arr[i] then increment the result.
• Print the value of the result in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long`` ` `ll ``int` `getCount(vector v, ``int` `n)``{``    ``// Sorting the vector``    ``sort((v).begin(), (v).end());``    ``ll ``int` `cnt = 0;``    ``for` `(ll ``int` `i = 0; i < n; i++) {`` ` `        ``// Count of numbers which``        ``// are greater than v[i]``        ``ll ``int` `tmp = v.end() - 1``                     ``- upper_bound((v).begin(), (v).end(), v[i] - 1);`` ` `        ``if` `(tmp == v[i])``            ``cnt++;``    ``}``    ``return` `cnt;``}`` ` `// Driver code``int` `main()``{``    ``ll ``int` `n;``    ``n = 4;``    ``vector v;``    ``v.push_back(1);``    ``v.push_back(2);``    ``v.push_back(3);``    ``v.push_back(4);`` ` `    ``cout << getCount(v, n);``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;`` ` `class` `GFG ``{``    ``static` `int` `getCount(``int``[] v, ``int` `n)``    ``{`` ` `        ``// Sorting the vector``        ``Arrays.sort(v);``        ``int` `cnt = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++) ``        ``{`` ` `            ``// Count of numbers which``            ``// are greater than v[i]``            ``int` `tmp = n - ``1` `- upperBound(v, n, v[i] - ``1``);``            ``if` `(tmp == v[i])``                ``cnt++;``        ``}``        ``return` `cnt;``    ``}`` ` `    ``// Function to implement upper_bound()``    ``static` `int` `upperBound(``int``[] array,  ``                          ``int` `length, ``int` `value) ``    ``{``        ``int` `low = ``0``;``        ``int` `high = length;``        ``while` `(low < high) ``        ``{``            ``final` `int` `mid = (low + high) / ``2``;``            ``if` `(value >= array[mid]) ``            ``{``                ``low = mid + ``1``;``            ``} ``            ``else``            ``{``                ``high = mid;``            ``}``        ``}``        ``return` `low;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``int` `n = ``4``;``        ``int``[] v = { ``1``, ``2``, ``3``, ``4` `};``        ``System.out.println(getCount(v, n));``    ``}``}`` ` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python3 implementation of the approach``from` `bisect ``import` `bisect as upper_bound`` ` `def` `getCount(v, n):``     ` `    ``# Sorting the vector``    ``v ``=` `sorted``(v)``    ``cnt ``=` `0``    ``for` `i ``in` `range``(n):`` ` `        ``# Count of numbers which``        ``# are greater than v[i]``        ``tmp ``=` `n ``-` `1` `-` `upper_bound(v, v[i] ``-` `1``)`` ` `        ``if` `(tmp ``=``=` `v[i]):``            ``cnt ``+``=` `1``    ``return` `cnt`` ` `# Driver codemain()``n ``=` `4``v ``=` `[]``v.append(``1``)``v.append(``2``)``v.append(``3``)``v.append(``4``)`` ` `print``(getCount(v, n))`` ` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;`` ` `class` `GFG ``{``    ``static` `int` `getCount(``int``[] v, ``int` `n)``    ``{`` ` `        ``// Sorting the vector``        ``Array.Sort(v);``        ``int` `cnt = 0;``        ``for` `(``int` `i = 0; i < n; i++) ``        ``{`` ` `            ``// Count of numbers which``            ``// are greater than v[i]``            ``int` `tmp = n - 1 - upperBound(v, n, v[i] - 1);``            ``if` `(tmp == v[i])``                ``cnt++;``        ``}``        ``return` `cnt;``    ``}`` ` `    ``// Function to implement upper_bound()``    ``static` `int` `upperBound(``int``[] array, ``                          ``int` `length, ``int` `value) ``    ``{``        ``int` `low = 0;``        ``int` `high = length;``        ``while` `(low < high) ``        ``{``            ``int` `mid = (low + high) / 2;``            ``if` `(value >= array[mid]) ``            ``{``                ``low = mid + 1;``            ``} ``            ``else``            ``{``                ``high = mid;``            ``}``        ``}``        ``return` `low;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args) ``    ``{``        ``int` `n = 4;``        ``int``[] v = { 1, 2, 3, 4 };``        ``Console.WriteLine(getCount(v, n));``    ``}``}`` ` `// This code is contributed by PrinciRaj1992`
Output:
```1
```

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.

My Personal Notes arrow_drop_up