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

Last Updated : 14 Aug, 2021

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

// 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; }

Java

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

Python3

# 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

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

JavaScript

<script>  // Javascript implementation of the approach  // Function to return the maximum count of  // selection possible from the given array  // following the given process function maxSelectionCount(a, n) {          // Initialize result     var res = 0;      // Sorting the array     a.sort();      // Initialize the select variable     var select = 1;      // Loop through array     for(var i = 0; i < n; i++)      {                  // If selection is possible         if (a[i] >= select)         {             // Increment result             res++;                           // Increment selection variable             select++;          }     }     return res; }  // Driver Code var arr = [ 4, 2, 1, 3, 5, 1, 4 ]; var N = arr.length;  document.write(maxSelectionCount(arr, N));  // This code is contributed by rrrtnx  </script>