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 <bits/stdc++.h>
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 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 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# 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
<script>
// JavaScript program of number of leading zeros in
// binary representation of a given number
let sizeofInt = 8;
// Function to count the no. of leading zeros
function countZeros(x)
{
// Keep shifting x by one until leftmost bit
// does not become 1.
let total_bits = sizeofInt * 8;
let res = 0;
while ((x & (1 << (total_bits - 1))) == 0)
{
x = (x << 1);
res++;
}
return res;
}
// Driver Code
let x = 101;
document.write(countZeros(x));
// This code is contributed by unknown2108
</script>
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 <bits/stdc++.h>
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 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 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# 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
// PHP program of number of leading zeros in
// binary representation of a given number
// Function to count the no. of leading zeros
function countZeros($x)
{
$y;
$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
$x = 101;
echo countZeros($x);
// This code is contributed
// by Akanksha Rai
<script>
// JavaScript program of number of leading zeros in
// binary representation of a given number
// Function to count the no. of leading zeros
function countZeros(x)
{
let y;
let 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
let x = 101;
document.write(countZeros(x));
// This code is contributed by patel2127
</script>
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 <stdio.h>
int main()
{
int n = 19; // 00000000 00000000 00000000 010011
printf("Count of leading zeros before first "
"occurrence: %d",
__builtin_clz(n));
return 0;
}
#include <iostream>
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 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));
}
}
# 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# 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 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
OutputCount of leading zeros before first occurrence: 27
Time complexity: O(1)
Auxiliary space: O(1)
Similar Reads
Length of longest consecutive zeroes in the binary representation of a number.
We have a number N. Determine the length of the longest consecutive 0's in its binary representation. Examples: Input : N = 14 Output : 1 Binary representation of 14 is 1110. There is only one 0 in the binary representation. Input : N = 9 Output : 2 A simple approach is to traverse through all bits
4 min read
Comparing leading zeros in binary representations of two numbers
Given two integer numbers x and y. Compare and print which one of them has more leading zeros using Bitwise operation. If both the no. have the same no. of leading zeros, print "Equal".Note:- A leading zero is any 0 digit that comes before the first nonzero digit in the binary notation of the number
8 min read
Count number of trailing zeros in Binary representation of a number using Bitset
Given a number. The task is to count the number of Trailing Zero in Binary representation of a number using bitset.Examples: Input : N = 16Output : 4Binary representation of N is 10000. Therefore,number of zeroes at the end is 4.Input : N = 8Output : 3Approach: We simply set the number in the bitset
5 min read
Binary representation of a given number
Given an integer n, the task is to print the binary representation of the number. Note: The given number will be maximum of 32 bits, so append 0's to the left if the result string is smaller than 30 length.Examples: Input: n = 2Output: 00000000000000000000000000000010Input: n = 0Output: 000000000000
6 min read
Count number of 0s in base K representation of a number
Given a number N, the task is to find the number of zero's in base K representation of the given number, where K > 1. Examples: Input: N = 10, K = 3Output: 1Explanation: Base 3 representation of 10 is 101. Hence the number of 0's in 101 is 1. Input: N = 8, K = 2Output: 3Explanation: Base 2 repres
5 min read
Find consecutive 1s of length >= n in binary representation of a number
Given two integers x and n, the task is to search for the first consecutive stream of 1s (in the x's 32-bit binary representation) which is greater than or equal to n in length and return its position. If no such string exists then return -1.Examples: Input: x = 35, n = 2 Output: 31 Binary represent
10 min read
Minimum number of Binary strings to represent a Number
Given a number N. The task is to find the minimum number of binary strings required to represent the given number as the sum of the binary strings.Examples: Input : 131 Output : Minimum Number of binary strings needed: 3 111 10 10 Input : 564 Output :Minimum Number of binary strings needed: 6 111 11
7 min read
Binary representation of next greater number with same number of 1's and 0's
Given a binary input that represents binary representation of positive number n, find binary representation of smallest number greater than n with same number of 1's and 0's as in binary representation of n. If no such number can be formed, print "no greater number".The binary input may be and may n
12 min read
Number of trailing zeroes in base 16 representation of N!
Given an integer N, the task is to find the number of trailing zeroes in the base 16 representation of the factorial of N. Examples: Input: N = 6 Output: 1 6! = 720 (base 10) = 2D0 (base 16) Input: N = 100 Output: 24 Approach: Number of trailing zeroes would be the highest power of 16 in the factori
4 min read
XOR of two numbers after making length of their binary representations equal
Given two numbers say a and b. Print their XOR after making the lengths of their binary representation equal by adding trailing zeros to the binary representation of smaller one. Examples : Input : a = 13, b = 5 Output : 7 Explanation : Binary representation of 13 is 1101 and of 5 is 101. As the len
7 min read