# Maximum number of times Array can be reduced in half when its all elements are even

• Last Updated : 23 Aug, 2021

Given an array arr, the task is to perform operations on the array when all elements in the array are even. In one operation, replace each integer X in the array by X/2. Find maximum possible number of operations that you can perform.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {8, 12, 40}
Output: 2
Explanation: Initially, {8, 12, 40} are present in array. Since all those integers are even,
you can perform the operation. After the operation is performed once, array becomes
{4, 6, 20}. Since all those integers are again even, we can perform the operation again.
After the operation is performed twice, array becomes {2, 3, 10}. Now, there is an odd
number “3” in the array, so no operation can be performed anymore.
Thus, you can perform the operation at most twice.

Input: arr[] = {5, 6, 8, 10}
Output: 0
Explanation: Since there is an odd number 5 in the initial array, we cant perform the
operation even once.

Approach: Given problem can be solved by making some simple observations:

• If all integers in the array at present are even, then we divide all the numbers by 2.
• Thus, the problem reduces to finding the number of times an element arr[i] can be divided by 2. Let it be times[i] . The answer is the minimum value of times[i] for all i.
• Instead of using an additional array times[], we can update the answer at each stage by simply keeping a variable, this reduces the space complexity to O(1) as we are not using any additional space.

Below is the implementation of the above idea.

## C++

 `// C++ code implementation for the above approach` `#include ``using` `namespace` `std;` `// Function to return the number``// of operations possible``int` `arrayDivisionByTwo(``int` `arr[], ``int` `n)``{``    ``// counter to store the number of times the``    ``// current element is divisible by 2``    ``int` `cnt = 0;` `    ``// variable to store the final answer``    ``int` `ans = INT_MAX;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Initialize the counter to zero``        ``// for each element``        ``cnt = 0;``        ``while` `(arr[i] % 2 == 0) {` `            ``// update the counter till the``            ``// number is divisible by 2``            ``arr[i] = arr[i] / 2;``            ``cnt++;``        ``}` `        ``// update the answer as``        ``// the minimum of all the counts``        ``ans = min(ans, cnt);``    ``}``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 8, 12, 40 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << arrayDivisionByTwo(arr, n);``    ``return` `0;``}`

## Java

 `// Java code implementation for the above approach``import` `java.util.*;` `class` `GFG``{` `// Function to return the number``// of operations possible``static` `int` `arrayDivisionByTwo(``int` `arr[], ``int` `n)``{``  ` `    ``// counter to store the number of times the``    ``// current element is divisible by 2``    ``int` `cnt = ``0``;` `    ``// variable to store the final answer``    ``int` `ans = Integer.MAX_VALUE;``    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``// Initialize the counter to zero``        ``// for each element``        ``cnt = ``0``;``        ``while` `(arr[i] % ``2` `== ``0``) {` `            ``// update the counter till the``            ``// number is divisible by 2``            ``arr[i] = arr[i] / ``2``;``            ``cnt++;``        ``}` `        ``// update the answer as``        ``// the minimum of all the counts``        ``ans = Math.min(ans, cnt);``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``8``, ``12``, ``40` `};``    ``int` `n = arr.length;` `    ``System.out.print(arrayDivisionByTwo(arr, n));``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python 3 code implementation for the above approach``import` `sys` `# Function to return the number``# of operations possible``def` `arrayDivisionByTwo(arr, n):``  ` `    ``# counter to store the number of times the``    ``# current element is divisible by 2``    ``cnt ``=` `0` `    ``# variable to store the final answer``    ``ans ``=` `sys.maxsize``    ``for` `i ``in` `range``(n):``      ` `        ``# Initialize the counter to zero``        ``# for each element``        ``cnt ``=` `0``        ``while``(arr[i] ``%` `2` `=``=` `0``):``          ` `            ``# update the counter till the``            ``# number is divisible by 2``            ``arr[i] ``=` `arr[i] ``/``/` `2``            ``cnt ``+``=` `1` `        ``# update the answer as``        ``# the minimum of all the counts``        ``ans ``=` `min``(ans, cnt)``    ``return` `ans` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``8``, ``12``, ``40``]``    ``n ``=`  `len``(arr)` `    ``print``(arrayDivisionByTwo(arr, n))``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# code implementation for the above approach``using` `System;` `class` `GFG{``// Function to return the number``// of operations possible``static` `int` `arrayDivisionByTwo(``int` `[]arr, ``int` `n)``{``  ` `    ``// counter to store the number of times the``    ``// current element is divisible by 2``    ``int` `cnt = 0;` `    ``// variable to store the final answer``    ``int` `ans = Int32.MaxValue;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Initialize the counter to zero``        ``// for each element``        ``cnt = 0;``        ``while` `(arr[i] % 2 == 0) {` `            ``// update the counter till the``            ``// number is divisible by 2``            ``arr[i] = arr[i] / 2;``            ``cnt++;``        ``}` `        ``// update the answer as``        ``// the minimum of all the counts``        ``ans = Math.Min(ans, cnt);``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 8, 12, 40 };``    ``int` `n = arr.Length;` `    ``Console.Write(arrayDivisionByTwo(arr, n));``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``
Output
`2`

Time Complexity: O(32 * n)
Space Complexity: O(1)

My Personal Notes arrow_drop_up