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

Last Updated : 11 Apr, 2023

Given a positive integer N, the task is to find the number of leading zeros in its binary representation.
A leading zero is any 0 digit that comes before the first nonzero digit in a number’s binary form.

Examples:

Input : N = 16
Output : 27
Explanation: As Binary(16) = (00000000000000000000000000010000)

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

Solution 1: A naive approach is to convert the no. into its 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 = 0;` `    ``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`

## Javascript

 ``

Output

`25`

Time complexity: O(1)
Auxiliary space: O(1)

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`

## Javascript

 ``

Output

`25`

Time complexity: O(1)
Auxiliary space: O(1)

Solution 3: Using predefined functions

In Java, the numberOfLeadingZeros() method of the Integer and Long class is used to count the leading zeros of the integer.

## C

 `#include ` `int` `main()` `{` `    ``int` `n = 19; ``// 00000000 00000000 00000000 010011` `    ``printf``(``"Count of leading zeros before first "` `           ``"occurrence: %d"``,` `           ``__builtin_clz(n));` `    ``return` `0;` `}`

## C++

 `#include ` `using` `namespace` `std;`   `int` `main()` `{` `    ``int` `n = 19; ``// 00000000 00000000 00000000 010011` `    ``cout << ``"Count of leading zeros before first "` `            ``"occurrence: "` `         ``<< __builtin_clz(n) << endl;` `    ``return` `0;` `}`

## Java

 `// Java Program that counts the number of leading zeroes`   `class` `GFG {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``19``; ``// 00000000 00000000 00000000 010011` `        ``System.out.println(` `            ``"Count of leading zeros before first occurrence: "` `            ``+ Integer.numberOfLeadingZeros(n));` `    ``}` `}`

## Python3

 `# Python program to count the number of leading zeroes`   `n ``=` `19`  `# 00000000 00000000 00000000 010011` `print``(``"Count of leading zeros before first occurrence: "``, ``bin``(n)[``2``:].zfill(``32``).index(``'1'``))`     `# This code is contributed by rishabmilhdijo`

## C#

 `// C# program to count the number of leading zeros`   `using` `System;`   `public` `class` `GFG {` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``int` `n = 19; ``// 00000000 00000000 00000000 010011` `        ``string` `binary = Convert.ToString(n, 2).PadLeft(` `            ``32, ``'0'``); ``// PadLeft method adds 0s to the start` `                      ``// of the string until it reaches 32` `                      ``// characters` `        ``Console.WriteLine(` `            ``"Count of leading zeros before first occurrence: "` `            ``+ binary.IndexOf(` `                ``'1'``)); ``// returns the index of the first` `                       ``// occurrence of 1 which is the count` `                       ``// of leading zeros` `    ``}` `}`

## Javascript

 `// JavaScript program to count the number of leading zeros ` `let n = 19; ``// 00000000 00000000 00000000 010011` `let binary = n.toString(2).padStart(32, ``'0'``); ``// padStart method adds 0s to the start of the string until it reaches 32 characters ` `console.log(``"Count of leading zeros before first occurrence: "``,binary.indexOf(``'1'``)); ``// returns the index of the first occurence of 1 which is the count of leading zeros`

Output

`Count of leading zeros before first occurrence: 27`

Time complexity: O(1)
Auxiliary space: O(1)

Previous
Next