# Minimize operations of removing 2i -1 array elements to empty given array

Last Updated : 21 Apr, 2021

Given an array arr[] of size N, the task is to empty given array by removing 2i – 1 array elements in each operation (i is any positive integer). Find the minimum number of operations required.

Examples:

Input: arr[] = { 2, 3, 4 }
Output:
Explanation:
Removing (22 – 1) elements i.e { arr[0], arr[1], arr[2] } modifies arr[] to { }
Since no elements left in the array therefore, the required output is 1.

Input: arr[] = { 1, 2, 3, 4 }
Output:
Explanation:
Removing (21 – 1) element i.e, { arr[0] } modifies arr[] to { 2, 3, 4 }
Removing (22 – 1) elements i.e, { arr[0], arr[1], arr[2] } modifies arr[] to { }
Since no elements left in the array therefore, the required output is 2.

Approach: The problem can be solved using Greedy technique. The idea is to always remove the maximum possible count(2i – 1) of elements from the array. Follow the steps below to solve the problem:

• Initialize a variable, say cntSteps, to store the minimum count of operations required to empty given array.
• Removing N array elements modifies arr[] to 0 length array. Therefore, increment the value of N by 1.
• Traverse each bit of N using variable i and for every ith bit, check if the bit is set or not. If found to be true, then update cntSteps += 1
• Finally, print the value of cntSteps.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find minimum count of steps` `// required to remove all the array elements` `int` `minimumStepReqArr(``int` `arr[], ``int` `N)` `{`   `    ``// Stores minimum count of steps required` `    ``// to remove all the array elements` `    ``int` `cntStep = 0;`   `    ``// Update N` `    ``N += 1;`   `    ``// Traverse each bit of N` `    ``for` `(``int` `i = 31; i >= 0; i--) {`   `        ``// If current bit is set` `        ``if` `(N & (1 << i)) {`   `            ``// Update cntStep` `            ``cntStep += 1;` `        ``}` `    ``}`   `    ``return` `cntStep;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3 };`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << minimumStepReqArr(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.util.*;` `class` `GFG` `{`   `  ``// Function to find minimum count of steps ` `  ``// required to remove all the array elements ` `  ``static` `int` `minimumStepReqArr(``int``[] arr, ``int` `N) ` `  ``{ `   `    ``// Stores minimum count of steps required ` `    ``// to remove all the array elements ` `    ``int` `cntStep = ``0``; `   `    ``// Update N ` `    ``N += ``1``; `   `    ``// Traverse each bit of N ` `    ``for` `(``int` `i = ``31``; i >= ``0``; i--) ` `    ``{ `   `      ``// If current bit is set ` `      ``if` `((N & (``1` `<< i)) != ``0``) ` `      ``{ `   `        ``// Update cntStep ` `        ``cntStep += ``1``; ` `      ``} ` `    ``}       ` `    ``return` `cntStep; ` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int``[] arr = { ``1``, ``2``, ``3` `}; `   `    ``int` `N = arr.length;` `    ``System.out.println(minimumStepReqArr(arr, N));` `  ``}` `}`   `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find minimum count of steps` `# required to remove all the array elements` `def` `minimumStepReqArr(arr, N):` `    `  `    ``# Stores minimum count of steps required` `    ``# to remove all the array elements` `    ``cntStep ``=` `0`   `    ``# Update N` `    ``N ``+``=` `1`   `    ``i ``=` `31`   `    ``while``(i >``=` `0``):` `        `  `        ``# If current bit is set` `        ``if` `(N & (``1` `<< i)):`   `            ``# Update cntStep` `            ``cntStep ``+``=` `1` `            `  `        ``i ``-``=` `1`   `    ``return` `cntStep`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``1``, ``2``, ``3` `]` `    ``N ``=` `len``(arr)` `    `  `    ``print``(minimumStepReqArr(arr, N))`   `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program to implement ` `// the above approach ` `using` `System;` `class` `GFG ` `{`   `  ``// Function to find minimum count of steps ` `  ``// required to remove all the array elements ` `  ``static` `int` `minimumStepReqArr(``int``[] arr, ``int` `N) ` `  ``{ `   `    ``// Stores minimum count of steps required ` `    ``// to remove all the array elements ` `    ``int` `cntStep = 0; `   `    ``// Update N ` `    ``N += 1; `   `    ``// Traverse each bit of N ` `    ``for` `(``int` `i = 31; i >= 0; i--) ` `    ``{ `   `      ``// If current bit is set ` `      ``if` `((N & (1 << i)) != 0) ` `      ``{ `   `        ``// Update cntStep ` `        ``cntStep += 1; ` `      ``} ` `    ``}       ` `    ``return` `cntStep; ` `  ``} `   `  ``// Driver code` `  ``static` `void` `Main() ` `  ``{` `    ``int``[] arr = { 1, 2, 3 }; `   `    ``int` `N = arr.Length;` `    ``Console.WriteLine(minimumStepReqArr(arr, N));` `  ``}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output:

`1`

Time Complexity: O(31)
Auxiliary Space: O(1)

Previous
Next