# 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 = 48Output : 16Highest power of 2 that divides 48 is 16.Input : n = 5Output : 1Highest 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 (10**1**), our output is 00**1**. For n = 48 (1**1**0000), our output is 0**1**0000 *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:

## C++

`// 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

`// 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

`# 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#

`// 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)` |

## PHP

`<?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..` `?>` |

## Javascript

`<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>` |

**Output**

16

**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)_{2}// 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)_{2}// 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.**

## C

`#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;` `}` |

**Output**

for 21 is 1 for 48 is 16