# Number of leading zeros in binary representation of a given number

Given an integer n, output the no. of leading zeros in it’s binary form.

A leading zero is any 0 digit that comes before the first nonzero digit in a number’s binary form.
Examples:

```Input : 16
Output :27
As Binary(16) = (00000000000000000000000000010000)

Input :33
Output :26
As Binary(16)=(00000000000000000000000000100001)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Solution 1: A naive approach is to convert the no. into it’s binary form and then count the no. of leading zeros. It uses expensive divide operations.

## C++

 `// C++ program of number of leading zeros in  ` `// binary representation of a given number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the no. of leading zeros ` `int` `countZeros(unsigned ``int` `x) ` `{ ` `    ``// Keep shifting x by one until leftmost bit ` `    ``// does not become 1. ` `    ``int` `total_bits = ``sizeof``(x) * 8; ` `    ``int` `res = 0; ` `    ``while` `( !(x & (1 << (total_bits - 1))) ) ` `    ``{ ` `        ``x = (x << 1); ` `        ``res++; ` `    ``} ` ` `  `    ``return` `res; ` `} ` ` `  `// Main function ` `int` `main() ` `{ ` `    ``int` `x = 101; ` `    ``cout << countZeros(x); ` `    ``return` `0; ` `} `

## Java

 `// Java program of number of leading zeros in  ` `// binary representation of a given number ` `class` `GFG  ` `{ ` `static` `byte` `sizeofInt = ``8``; ` ` `  `// Function to count the no. of leading zeros ` `static` `int` `countZeros(``int` `x) ` `{ ` `    ``// Keep shifting x by one until leftmost bit ` `    ``// does not become 1. ` `    ``int` `total_bits = sizeofInt * ``8``; ` `    ``int` `res = ``0``; ` `    ``while` `((x & (``1` `<< (total_bits - ``1``))) == ``0``) ` `    ``{ ` `        ``x = (x << ``1``); ` `        ``res++; ` `    ``} ` ` `  `    ``return` `res; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `x = ``101``; ` `    ``System.out.println(countZeros(x)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 program of number of  ` `# leading zeros in binary  ` `# representation of a given number ` ` `  `# Function to count the  ` `# no. of leading zeros ` `def` `countZeros(x): ` `     `  `    ``# Keep shifting x by one until  ` `    ``# leftmost bit does not become 1. ` `    ``total_bits ``=` `32` `    ``res ``=` `0` `    ``while` `((x & (``1` `<< (total_bits ``-` `1``))) ``=``=` `0``): ` `        ``x ``=` `(x << ``1``) ` `        ``res ``+``=` `1` ` `  `    ``return` `res ` ` `  `# Driver Code ` `x ``=` `101` `print``(countZeros(x)) ` ` `  `# This code is contributed  ` `# by Mohit Kumar `

## C#

 `// C# program of number of leading zeros in  ` `// binary representation of a given number ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `static` `byte` `sizeofInt = 8; ` ` `  `// Function to count the  ` `// no. of leading zeros ` `static` `int` `countZeros(``int` `x) ` `{ ` `    ``// Keep shifting x by one until  ` `    ``// leftmost bit does not become 1. ` `    ``int` `total_bits = sizeofInt * 8; ` `    ``int` `res = 0; ` `    ``while` `((x & (1 << (total_bits - 1))) == 0) ` `    ``{ ` `        ``x = (x << 1); ` `        ``res++; ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `x = 101; ` `    ``Console.WriteLine(countZeros(x)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```25
```

Solution 2: An efficient approach is to use Bitwise right shift operation to achieve the same. The steps in the algorithm are:
Let x be our no. then

```    unsigned y;
int n = 32;
y = x >>16; if (y != 0) {n = n -16; x = y;}
y = x >> 8; if (y != 0) {n = n - 8; x = y;}
y = x >> 4; if (y != 0) {n = n - 4; x = y;}
y = x >> 2; if (y != 0) {n = n - 2; x = y;}
y = x >> 1; if (y != 0) return n - 2;
return n - x;```

The above approach executes in only 12 to 20 instructions.

## C++

 `// C++ program of number of leading zeros in  ` `// binary representation of a given number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the no. of leading zeros ` `int` `countZeros(``int` `x) ` `{ ` `    ``unsigned y; ` `    ``int` `n = 32; ` `    ``y = x >> 16; ` `    ``if` `(y != 0) { ` `        ``n = n - 16; ` `        ``x = y; ` `    ``} ` `    ``y = x >> 8; ` `    ``if` `(y != 0) { ` `        ``n = n - 8; ` `        ``x = y; ` `    ``} ` `    ``y = x >> 4; ` `    ``if` `(y != 0) { ` `        ``n = n - 4; ` `        ``x = y; ` `    ``} ` `    ``y = x >> 2; ` `    ``if` `(y != 0) { ` `        ``n = n - 2; ` `        ``x = y; ` `    ``} ` `    ``y = x >> 1; ` `    ``if` `(y != 0) ` `        ``return` `n - 2; ` `    ``return` `n - x; ` `} ` ` `  `// Main function ` `int` `main() ` `{ ` `    ``int` `x = 101; ` `    ``cout << countZeros(x); ` `    ``return` `0; ` `} `

## Java

 `// Java program of number of leading zeros in  ` `// binary representation of a given number ` `import` `java.io.*; ` ` `  `class` `GFG { ` `    ``// Function to count the no. of leading zeros  ` `static` `int` `countZeros(``int` `x)  ` `{  ` `    ``int` `y;  ` `    ``int` `n = ``32``;  ` `    ``y = x >> ``16``;  ` `    ``if` `(y != ``0``) {  ` `        ``n = n - ``16``;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> ``8``;  ` `    ``if` `(y != ``0``) {  ` `        ``n = n - ``8``;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> ``4``;  ` `    ``if` `(y != ``0``) {  ` `        ``n = n - ``4``;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> ``2``;  ` `    ``if` `(y != ``0``) {  ` `        ``n = n - ``2``;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> ``1``;  ` `    ``if` `(y != ``0``)  ` `        ``return` `n - ``2``;  ` `    ``return` `n - x;  ` `}  ` ` `  `// Main function  ` `    ``public` `static` `void` `main (String[] args) { ` `    ``int` `x = ``101``;  ` `    ``System.out.println (countZeros(x));  ` `    ``} ` `//This code is contributed by @Tushil.     ` `} `

## Python3

 `# Python3 program of number of leading zeros in ` `# binary representation of a given number ` ` `  ` `  `# Function to count the no. of leading zeros ` `def` `countZeros(x): ` `    ``n ``=` `32``; ` `    ``y ``=` `x >> ``16``; ` `    ``if` `(y !``=` `0``): ` `        ``n ``=` `n ``-` `16``; ` `        ``x ``=` `y; ` ` `  `    ``y ``=` `x >> ``8``; ` `    ``if` `(y !``=` `0``): ` `        ``n ``=` `n ``-` `8``; ` `        ``x ``=` `y; ` ` `  `    ``y ``=` `x >> ``4``; ` `    ``if` `(y !``=` `0``): ` `        ``n ``=` `n ``-` `4``; ` `        ``x ``=` `y; ` ` `  `    ``y ``=` `x >> ``2``; ` `    ``if` `(y !``=` `0``): ` `        ``n ``=` `n ``-` `2``; ` `        ``x ``=` `y; ` ` `  `    ``y ``=` `x >> ``1``; ` `    ``if` `(y !``=` `0``): ` `        ``return` `n ``-` `2``; ` `    ``return` `n ``-` `x; ` ` `  ` `  `# Main function ` `def` `main(): ` `    ``x ``=` `101``; ` `    ``print``(countZeros(x)) ` ` `  ` `  `if` `__name__ ``=``=` `'__main__'``: ` `    ``main() `

## C#

 `// C# program of number of leading zeros in  ` `// binary representation of a given number ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Function to count the no. of  ` `// leading zeros  ` `static` `int` `countZeros(``int` `x)  ` `{  ` `    ``int` `y;  ` `    ``int` `n = 32;  ` `    ``y = x >> 16;  ` `     `  `    ``if` `(y != 0)  ` `    ``{  ` `        ``n = n - 16;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> 8;  ` `     `  `    ``if` `(y != 0) ` `    ``{  ` `        ``n = n - 8;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> 4;  ` `     `  `    ``if` `(y != 0)  ` `    ``{  ` `        ``n = n - 4;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> 2;  ` `     `  `    ``if` `(y != 0) ` `    ``{  ` `        ``n = n - 2;  ` `        ``x = y;  ` `    ``}  ` `    ``y = x >> 1;  ` `     `  `    ``if` `(y != 0)  ` `        ``return` `n - 2;  ` `    ``return` `n - x;  ` `}  ` ` `  `// Driver Code ` `static` `public` `void` `Main () ` `{ ` `    ``int` `x = 101;  ` `    ``Console.WriteLine(countZeros(x));  ` `} ` `} ` ` `  `// This code is contributed by ajit `

## PHP

 `> 16; ` `    ``if` `(``\$y` `!= 0) ` `    ``{ ` `        ``\$n` `= ``\$n` `- 16; ` `        ``\$x` `= ``\$y``; ` `    ``} ` `    ``\$y` `= ``\$x` `>> 8; ` `    ``if` `(``\$y` `!= 0) ` `    ``{ ` `        ``\$n` `= ``\$n` `- 8; ` `        ``\$x` `= ``\$y``; ` `    ``} ` `    ``\$y` `= ``\$x` `>> 4; ` `    ``if` `(``\$y` `!= 0)  ` `    ``{ ` `        ``\$n` `= ``\$n` `- 4; ` `        ``\$x` `= ``\$y``; ` `    ``} ` `    ``\$y` `= ``\$x` `>> 2; ` `    ``if` `(``\$y` `!= 0) { ` `        ``\$n` `= ``\$n` `- 2; ` `        ``\$x` `= ``\$y``; ` `    ``} ` `    ``\$y` `= ``\$x` `>> 1; ` `    ``if` `(``\$y` `!= 0) ` `        ``return` `\$n` `- 2; ` `    ``return` `\$n` `- ``\$x``; ` `} ` ` `  `// Driver Code ` `\$x` `= 101; ` `echo` `countZeros(``\$x``); ` ` `  `// This code is contributed  ` `// by Akanksha Rai `

Output:

```25
```

Time Complexity: The time complexity of this approach is O(1)
Space Complexity: The space complexity of this approach is O(1)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.