Contar elementos de manera que haya exactamente X elementos con valores mayores o iguales a X

Dada una array de N enteros , la tarea es encontrar el número de elementos que satisfacen la siguiente condición: 
si el elemento es X , entonces tiene que haber exactamente X cantidad de elementos en la array (excluyendo el número X ) que son mayores que o igual a X
Ejemplos: 
 

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

Enfoque: El problema consiste en buscar eficientemente para cada elemento arr[i] el número de arr[j] (i != j) que son mayores o iguales que arr[i]. 
 

• Ordene la array en orden ascendente.
• Para cada elemento arr[i], utilizando la búsqueda binaria obtenga el recuento de todos los elementos que son mayores o iguales que arr[i] excepto arr[i] en sí mismo.
• Si el conteo es igual a arr[i] entonces incremente el resultado.
• Imprime el valor del resultado al final.

A continuación se muestra la implementación del enfoque anterior: 
 

// 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 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 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# 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

<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>

1

Complejidad de tiempo: O(N*logN)

Espacio Auxiliar: O(1)