Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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#



// 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>
Output: 
5
 
Time Complexity: O(N * log(N))
Auxiliary Space: O(1) 
 

My Personal Notes
arrow_drop_up
Previous
Minimize the sum after choosing elements from the given three arrays
Next

Length of the largest substring which have character with frequency greater than or equal to half of the substring
Recommended Articles
Page :
Maximize sum of K elements selected from a Matrix such that each selected element must be preceded by selected row elements
02, Dec 20
Check if X and Y elements can be selected from two arrays respectively such that the maximum in X is less than the minimum in Y
20, Jan 21
Maximize count of elements that can be selected having minimum difference between their sum and K
18, Jan 21
Find K such that array A can be converted into array B by adding K to a selected range [L, R]
04, Feb 20
Check if N numbers with Even Sum can be selected from a given Array
19, Aug 20
Maximum sum such that exactly half of the elements are selected and no two adjacent
27, Apr 20
Maximum sum of K elements selected from a Matrix
10, Aug 21
Maximum count of Strings to be selected such that there is a majority character
10, Aug 21
Maximum number of unique Triplets such that each element is selected only once
07, Aug 20
Check if two items can be selected from two different categories without exceeding price
22, May 20
Check if a triplet of buildings can be selected such that the third building is taller than the first building and smaller than the second building
25, May 21
Minimum number of array indices required to be selected to make the sum of a set greater than another
30, Jul 21
Longest increasing subsequence consisting of elements from indices divisible by previously selected indices
04, Dec 20
Maximize the sum of elements arr[i] selected by jumping index by value i
11, Nov 21
Minimum number of pairs required to be selected to cover a given range
28, Jun 21
Minimum points to be selected such that removal of line segments passing through them empties given array
05, Nov 20
Maximize sum of selected numbers from Array to empty it | Set 2
29, Sep 21
Count array elements that can be represented as sum of at least two consecutive array elements
08, Sep 20
Maximize score of same-indexed subarrays selected from two given arrays
15, Jun 21
Smallest number that can replace all -1s in an array such that maximum absolute difference between any pair of adjacent elements is minimum
28, Jun 21
Maximum number of elements that can be removed such that MEX of the given array remains unchanged
25, Oct 20
Maximum number of times Array can be reduced in half when its all elements are even
10, Aug 21
Maximum array elements that can be removed along with its adjacent values to empty given array
05, Nov 20
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rupesh_rao
@rupesh_rao
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!