Related Articles
Maximize count of 1s in an array by repeated division of array elements by 2 at most K times
• Difficulty Level : Hard
• Last Updated : 19 Feb, 2021

Given an array arr[] of size N and an integer K, the task to find the maximum number of array elements that can be reduced to 1 by repeatedly dividing any element by 2 at most K times.
Note: For odd array elements, take its ceil value of division.

Examples:

Input: arr[] = {5, 8, 4, 7}, K = 5
Output: 2
Explanation:
5 needs 3 operations(5→3→2→1).
8 needs 3 operations(8→4→2→1).
4 needs 2 operations(4→2→1).
7 needs 3 operations(7→4→2→1)
Therefore, in 5 operations, the maximum number of array elements that can be reduced to 1 are 2, either (4, 5), (4, 8) or (4, 7).

Input: arr[] = {5, 8, 5, 7}, K = 5
Output: 1

Approach: To maximize the number of elements, the idea is to sort the array in ascending order and start reducing the elements from the first index and decrement K by the number of operations required to reduce the ith element. Follow the steps below to solve the problem:

• Initialize a variable, say cnt, to store the required number of elements.
• Sort the array arr[] in increasing order.
• Traverse the array, arr[] using the variable i, and perform the following steps:
• Store the number of operations required to reduce arr[i] to 1 is opr = ceil(log2(arr[i])).
• Decrement K by opr.
• If the value of K becomes less than 0, break out of the loop. Otherwise, increment cnt by 1.
• After completing the above steps, print the value of cnt as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the maximum number of``// array elements that can be reduced to 1``// by repeatedly dividing array elements by 2``void` `findMaxNumbers(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Sort the array in ascending order``    ``sort(arr, arr + n);` `    ``// Store the count of array elements``    ``int` `cnt = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Store the number of operations``        ``// required to reduce arr[i] to 1``        ``int` `opr = ``ceil``(log2(arr[i]));` `        ``// Decrement k by opr``        ``k -= opr;` `        ``// If k becomes less than 0,``        ``// then break out of the loop``        ``if` `(k < 0) {``            ``break``;``        ``}` `        ``// Increment cnt by 1``        ``cnt++;``    ``}` `    ``// Print the answer``    ``cout << cnt;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 8, 4, 7 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 5;` `    ``findMaxNumbers(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `GFG``{` `// Function to count the maximum number of``// array elements that can be reduced to 1``// by repeatedly dividing array elements by 2``static` `void` `findMaxNumbers(``int` `arr[], ``int` `n, ``int` `k)``{``  ` `    ``// Sort the array in ascending order``    ``Arrays.sort(arr);` `    ``// Store the count of array elements``    ``int` `cnt = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Store the number of operations``        ``// required to reduce arr[i] to 1``        ``int` `opr = (``int``)Math.ceil((Math.log(arr[i]) / Math.log(``2``)));` `        ``// Decrement k by opr``        ``k -= opr;` `        ``// If k becomes less than 0,``        ``// then break out of the loop``        ``if` `(k < ``0``) {``            ``break``;``        ``}` `        ``// Increment cnt by 1``        ``cnt++;``    ``}` `    ``// Print the answer``    ``System.out.println(cnt);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `arr[] = { ``5``, ``8``, ``4``, ``7` `};``    ``int` `N = arr.length;``    ``int` `K = ``5``;``    ``findMaxNumbers(arr, N, K);``}``}` `// This code is contributed by jana_sayantan.`

## Python3

 `# Python3 program to implement``# the above approach``import` `math` `# Function to count the maximum number of``# array elements that can be reduced to 1``# by repeatedly dividing array elements by 2``def` `findMaxNumbers(arr, n, k) :``    ` `    ``# Sort the array in ascending order``    ``arr.sort()` `    ``# Store the count of array elements``    ``cnt ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``# Store the number of operations``        ``# required to reduce arr[i] to 1``        ``opr ``=` `math.ceil(math.log2(arr[i]))` `        ``# Decrement k by opr``        ``k ``-``=` `opr` `        ``# If k becomes less than 0,``        ``# then break out of the loop``        ``if` `(k < ``0``) :``            ``break``        ` `        ``# Increment cnt by 1``        ``cnt ``+``=` `1``    ` `    ``# Prthe answer``    ``print``(cnt)` `# Driver Code``arr ``=` `[ ``5``, ``8``, ``4``, ``7` `]``N ``=` `len``(arr)``K ``=` `5` `findMaxNumbers(arr, N, K)` `# This code is contributed by splevel62.`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{``  ` `// Function to count the maximum number of``// array elements that can be reduced to 1``// by repeatedly dividing array elements by 2``static` `void` `findMaxNumbers(``int``[] arr, ``int` `n, ``int` `k)``{``  ` `    ``// Sort the array in ascending order``    ``Array.Sort(arr);` `    ``// Store the count of array elements``    ``int` `cnt = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// Store the number of operations``        ``// required to reduce arr[i] to 1``        ``int` `opr = (``int``)Math.Ceiling((Math.Log(arr[i]) / Math.Log(2)));` `        ``// Decrement k by opr``        ``k -= opr;` `        ``// If k becomes less than 0,``        ``// then break out of the loop``        ``if` `(k < 0) {``            ``break``;``        ``}` `        ``// Increment cnt by 1``        ``cnt++;``    ``}` `    ``// Print the answer``    ``Console.Write(cnt);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int``[] arr = { 5, 8, 4, 7 };``    ``int` `N = arr.Length;``    ``int` `K = 5;``    ``findMaxNumbers(arr, N, K);``}``}` `// This code is contributed by susmitakundugoaldanga.`

Output:
`2`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up