Count the maximum number of elements that can be selected from the array

Given an array arr[], the task is to count the maximum number of elements that can be selected from the given array following the below selection process:

  • At 1st selection, select an element which is greater than or equal to 1.
  • At 2nd selection, select an element which is greater than or equal to 2.
  • At 3rd selection, select an element which is greater than or equal to 3 and so on.

An element can be selected only once. The operation stops when it is not possible to select any element. So, the task is to maximize the count of selection from the array.

Examples:

Input : arr[] = { 4, 1, 3, 1 }
Output : 3
1st Selection: 1 is selected as 1 >= 1.
2nd Selection: 3 is selected as 3 >= 2.
3rd Selection: 4 is selected as 4 >= 3.
No more selections are possible. Therefore, the answers is 3.

Input : arr[] = { 2, 1, 1, 2, 1 }
Output : 2

Approach: In order to maximize the count of selection it is necessary to select the smallest possible numbers first and then the bigger numbers if the selection is not possible. This can be done easily by sorting the array. Now, loop through the array and increment the result by 1 when the element is greater than or equal to the number to select for the current operation.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the maximum count of 
// selection possible from the given array 
// following the given process
int maxSelectionCount(int a[], int n)
{
    // Initialize result
    int res = 0;
  
    // Sorting the array
    sort(a, a + n);
  
    // Initialize the select variable
    int select = 1;
  
    // Loop through array
    for (int i = 0; i < n; i++) {
        // If selection is possible
        if (a[i] >= select) {
            res++; // Increment result
            select++; // Increment selection variable
        }
    }
  
    return res;
}
  
// Driver Code
int main()
{
    int arr[] = { 4, 2, 1, 3, 5, 1, 4 };
  
    int N = sizeof(arr) / sizeof(arr[0]);
  
    cout << maxSelectionCount(arr, N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
  
class GFG 
{
  
    // Function to return the maximum count of 
    // selection possible from the given array 
    // following the given process
    static int maxSelectionCount(int a[], int n) 
    {
        // Initialize result
        int res = 0;
  
        // Sorting the array
        Arrays.sort(a);
  
        // Initialize the select variable
        int select = 1;
  
        // Loop through array
        for (int i = 0; i < n; i++)
        {
            // If selection is possible
            if (a[i] >= select) 
            {
                res++; // Increment result
                select++; // Increment selection variable
            }
        }
  
        return res;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = {4, 2, 1, 3, 5, 1, 4};
  
        int N = arr.length;
  
        System.out.println(maxSelectionCount(arr, N));
    }
}
  
// This code contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of the approach
  
# Function to return the maximum count of 
# selection possible from the given array 
# following the given process
def maxSelectionCount(a, n):
    # Initialize result
    res = 0;
  
    # Sorting the array
    a.sort();
  
    # Initialize the select variable
    select = 1;
  
    # Loop through array
    for i in range(n):
        # If selection is possible
        if (a[i] >= select):
            res += 1; # Increment result
            select += 1; # Increment selection variable
  
    return res;
  
  
# Driver Code
arr = [ 4, 2, 1, 3, 5, 1, 4 ];
N = len(arr);
print(maxSelectionCount(arr, N));
  
# This code contributed by PrinciRaj1992

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG 
    // Function to return the maximum count of 
    // selection possible from the given array 
    // following the given process 
    static int maxSelectionCount(int []a, int n) 
    
        // Initialize result 
        int res = 0; 
  
        // Sorting the array 
        Array.Sort(a); 
  
        // Initialize the select variable 
        int select = 1; 
  
        // Loop through array 
        for (int i = 0; i < n; i++) 
        
            // If selection is possible 
            if (a[i] >= select
            
                res++; // Increment result 
                select++; // Increment selection variable 
            
        
  
        return res; 
    
  
    // Driver Code 
    public static void Main() 
    
        int []arr = {4, 2, 1, 3, 5, 1, 4}; 
  
        int N = arr.Length; 
  
        Console.WriteLine(maxSelectionCount(arr, N)); 
    
  
// This code contributed by AnkitRai01

chevron_right


Output:

5


My Personal Notes arrow_drop_up

Coder Machine Learner Social Activist Vocalist

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.