Skip to content
Related Articles

Related Articles

Count elements such that there are exactly X elements with values greater than or equal to X

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 07 Sep, 2022
View Discussion
Improve Article
Save Article

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

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 <bits/stdc++.h>
using namespace std;
#define ll long long
 
ll int getCount(vector<ll int> 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<ll int> 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

Javascript




<script>
 
// JavaScript implementation of the approach
 
    function getCount(v,n)
    {
        // Sorting the vector
        v.sort(function(a,b){return a-b;});
        let cnt = 0;
        for (let i = 0; i < n; i++)
        {
   
            // Count of numbers which
            // are greater than v[i]
            let tmp = n - 1 - upperBound(v, n, v[i] - 1);
            if (tmp == v[i])
                cnt++;
        }
        return cnt;
    }
     
    // Function to implement upper_bound()
    function upperBound(array,length,value)
    {
        let low = 0;
        let high = length;
        while (low < high)
        {
            let mid = Math.floor((low + high) / 2);
            if (value >= array[mid])
            {
                low = mid + 1;
            }
            else
            {
                high = mid;
            }
        }
        return low;
    }
     
    // Driver Code
    let n = 4;
    let v=[1, 2, 3, 4];
    document.write(getCount(v, n));
 
 
// This code is contributed by unknown2108
 
</script>

Output

1

Complexity Analysis:

  • Time Complexity: O(N*logN)
  • Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!