Length of longest consecutive zeroes in the binary representation of a number.

Last Updated : 23 Nov, 2022

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 and keep track of the maximum number of consecutive 0s.

C++

// C++ code to determine Length of 
// longest consecutive zeroes in the
// binary representation of a number. 
#include <bits/stdc++.h>
using namespace std;

int maxZeros(int N)
{
    // variable to store the length of
    // longest consecutive 0's
    int maxm = -1;

    // to temporary store the consecutive 0's
    int cnt = 0;

    while (N) {
        if (!(N & 1)) {
            cnt++;
            N >>= 1;
            maxm = max(maxm, cnt);
        }
        else {

            maxm = max(maxm, cnt);
            cnt = 0;
            N >>= 1;
        }
    }
    return maxm;
}

// Driver code
int main()
{
    int N = 14;
    cout << maxZeros(N) << endl;
    return 0;
}

Java

// Java code to determine Length of  
// longest consecutive zeroes in the 
// binary representation of a number. 

public class GFG {
    
    static int maxZeros(int N) 
    { 
        // variable to store the length of 
        // longest consecutive 0's 
        int maxm = -1; 
      
        // to temporary store the consecutive 0's 
        int cnt = 0; 
      
        while (N != 0) { 
            if ((N & 1) == 0 ) { 
                cnt++; 
                N >>= 1; 
                maxm = Math.max(maxm, cnt); 
            } 
            else { 
      
                maxm = Math.max(maxm, cnt); 
                cnt = 0; 
                N >>= 1; 
            } 
        } 
        return maxm; 
    } 
      
    // Driver code
    public static void main(String args[])
    {
         int N = 14; 
         System.out.println(maxZeros(N)); 
    
    }
    // This Code is contributed by ANKITRAI1
}

Python3

# Python3 code to determine Length of 
# longest consecutive zeroes in the
# binary representation of a number. 
def maxZeros(N):

    # variable to store the length 
    # of longest consecutive 0's
    maxm = -1

    # to temporary store the 
    # consecutive 0's
    cnt = 0
    while(N):
        if(not(N & 1)):
            cnt += 1
            N >>= 1
            maxm = max(maxm,cnt)
        else:
            maxm = max(maxm,cnt)
            cnt = 0
            N >>= 1

    return maxm

# Driver Code
N = 14
print(maxZeros(N))

# This code is written by Shrikant13

// C# code to determine Length of 
// longest consecutive zeroes in the 
// binary representation of a number. 
using System;

class GFG 
{
static int maxZeros(int N) 
{ 
    // variable to store the length 
    // of longest consecutive 0's 
    int maxm = -1; 

    // to temporary store the 
    // consecutive 0's 
    int cnt = 0; 

    while (N != 0) 
    { 
        if ((N & 1) == 0 ) 
        { 
            cnt++; 
            N >>= 1; 
            maxm = Math.Max(maxm, cnt); 
        } 
        else 
        { 
            maxm = Math.Max(maxm, cnt); 
            cnt = 0; 
            N >>= 1; 
        } 
    } 
    return maxm; 
} 

// Driver code
public static void Main()
{
    int N = 14; 
    Console.WriteLine(maxZeros(N)); 
}
}

// This code is contributed
// by anuj_67

PHP

<?php
// PHP code to determine Length of 
// longest consecutive zeroes in the
// binary representation of a number. 
function maxZeros($N)
{
    // variable to store the length 
    // of longest consecutive 0's
    $maxm = -1;

    // to temporary store the 
    // of consecutive 0's
    $cnt = 0;

    while ($N) 
    {
        if (!($N & 1)) 
        {
            $cnt++;
            $N >>= 1;
            $maxm = max($maxm, $cnt);
        }
        else 
        {
            $maxm = max($maxm, $cnt);
            $cnt = 0;
            $N >>= 1;
        }
    }
    return $maxm;
}

// Driver code
$N = 14;
echo (maxZeros($N));

// This code is contributed 
// by Shivi_Aggarwal
?>

JavaScript

<script>
    // Javascript code to determine Length of 
    // longest consecutive zeroes in the 
    // binary representation of a number. 
    
    function maxZeros(N) 
    { 
        // variable to store the length 
        // of longest consecutive 0's 
        let maxm = -1; 

        // to temporary store the 
        // consecutive 0's 
        let cnt = 0; 

        while (N != 0) 
        { 
            if ((N & 1) == 0 ) 
            { 
                cnt++; 
                N >>= 1; 
                maxm = Math.max(maxm, cnt); 
            } 
            else 
            { 
                maxm = Math.max(maxm, cnt); 
                cnt = 0; 
                N >>= 1; 
            } 
        } 
        return maxm; 
    } 
    
    let N = 14; 
    document.write(maxZeros(N)); 
    
</script>