Highest power of two that divides a given number

Given a number n, find the highest power of 2 that divides n.
Examples:
 

Input : n = 48 
Output : 16 
Highest power of 2 that divides 48 is 16.
Input : n = 5 
Output : 1 
Highest power of 2 that divides 5 is 1.

A simple solution is to try all powers of 2 one by one starting from 1, then 2, then 4 and so on.
An efficient solution is based on bit magic. If we take a closer look, we can notice that, we basically need to find the number that has rightmost bit set at same position as n and all other bits as 0. For example, for n = 5 (101), our output is 001. For n = 48 (110000), our output is 010000 
How do we find a number that has same rightmost set bit and all other bits as 0? 
We follow below steps.
Let n = 48 (00110000) 
Subtract one from n, i.e., we do n-1. We get 47(00101111) 
Do negation of (n-1), i.e., we do ~(n-1). We get (11010000). 
Do n & (~(n-1)), we get 00010000 which has value 16.
Below is the implementation of above approach: 
 

// CPP program to find highest power
// of 2 that divides n.
#include<iostream>
using namespace std;

int highestPowerOf2(int n)
{
    return (n & (~(n - 1)));
}

int main()
{ 
    int n = 48;
    cout << highestPowerOf2(n);
    return 0;
}

// Java program to find highest power
// of 2 that divides n.
 
class GFG
{
     
static int highestPowerOf2(int n)
{
    return (n & (~(n - 1)));
}
 
public static void main(String []args)
{ 
    int n = 48;
    System.out.println(highestPowerOf2(n));
}
}
 

# Python3 program to find highest power 
# of 2 that divides n. 

def highestPowerOf2(n): 

    return (n & (~(n - 1))) 


#Driver code
if __name__=='__main__':
    n = 48
    print(highestPowerOf2(n)) 

# this code is contributed 
# by ash264

// C# program to find highest power
// of 2 that divides n.
using System;

class GFG
{
    
static int highestPowerOf2(int n)
{
    return (n & (~(n - 1)));
}

public static void Main()
{ 
    int n = 48;
    Console.Write(highestPowerOf2(n));
}
}

// This code is contributed
// by Akanksha Rai(Abby_akku)

<script>

// javascript program to find highest power
// of 2 that divides n.
 

     
function highestPowerOf2(n)
{
    return (n & (~(n - 1)));
}

var n = 48;
document.write(highestPowerOf2(n));


// This code is contributed by 29AjayKumar 

</script>

<?php
// PHP program to find highest power 
// of 2 that divides n. 

function highestPowerOf2($n) 
{ 
    return ($n & (~($n - 1))); 
} 

// Driver Code
$n = 48; 
echo highestPowerOf2($n); 

// This code is contributed 
// by Sach_Code..
?>

16

Time Complexity: O(log₂n)
Space Complexity:- O(1).

Approach - 2: This is also an efficient approach, where you can find the largest divisor of power two for a number 'n' using a predefined function in C for handling bits.  Which is  _builtin_ctz(n), this function helps you to find the trailing zeros of the number, and then you can see the bits-magic.

Input : n = 48  ~= (110000)₂     // num of  trailing zeros are = 4, so number of trailing zeros = 4

Output :  1<<4  =16         // pow(2,4) = 16  Highest power of 2 that divides 48 is 16.

Input : n = 21 ~= (10101)₂        // no trailing zeros are present, so number of trailing zeros = 0

Output : 1<<0  =2     //  pow(2,0)=1

Note: To know in the detail about such bits masking functions you can go through this article.

#include <iostream>
using namespace std;

int main()
{
    int n = 21;
    int m = 48;
    cout << "for " << n << " is " << (1 << __builtin_ctz(n))
         << endl;
    cout << "for " << m << " is " << (1 << __builtin_ctz(m))
         << endl;
    return 0;
}

// This code is contributed by Prajwal Kandekar

#include <stdio.h>
int main()
{
    int n = 21;
    int m = 48;
    printf("for %d is %d ", n, (1 << __builtin_ctz(n)));
    printf("\nfor %d is %d ", m, (1 << __builtin_ctz(m)));
    return 0;
}

public class Main {
    public static void main(String[] args)
    {
        int n = 21;
        int m = 48;
        System.out.println(
            "for " + n + " is "
            + (1 << Integer.numberOfTrailingZeros(n)));
        System.out.println(
            "for " + m + " is "
            + (1 << Integer.numberOfTrailingZeros(m)));
    }
}

n = 21
m = 48

print(f"for {n} is {1 << (n & -n).bit_length() - 1}")
print(f"for {m} is {1 << (m & -m).bit_length() - 1}")

using System;

class Program {
    // Function to find the position of the least
    // significant set bit
    static int FindLeastSignificantBitPosition(int num)
    {
        int position = 0;

        while ((num & 1) == 0) {
            num >>= 1;
            position++;
        }

        return position;
    }

    static void Main()
    {
        int n = 21;
        int m = 48;

        int positionN = FindLeastSignificantBitPosition(n);
        int positionM = FindLeastSignificantBitPosition(m);

        Console.WriteLine("for " + n + " is "
                          + (1 << positionN));
        Console.WriteLine("for " + m + " is "
                          + (1 << positionM));
    }
}

// JavaScript code for above approach

// Taken n
let n = 21;

// Taken m 
let m = 48;

// Printing answer
console.log(`for ${n} is ${1 << (n & -n).toString(2).length - 1}`);
console.log(`for ${m} is ${1 << (m & -m).toString(2).length - 1}`);

for 21 is 1 
for 48 is 16 

Time Complexity: O(log₂n)
Space Complexity: O(1)