Related Articles

# Maximum 0’s between two immediate 1’s in binary representation

• Difficulty Level : Hard
• Last Updated : 16 Jul, 2021

Given a number n, the task is to find the maximum 0’s between two immediate 1’s in binary representation of given n. Return -1 if binary representation contains less than two 1’s.

Examples :

```Input : n = 47
Output: 1
// binary of n = 47 is 101111

Input : n = 549
Output: 3
// binary of n = 549 is 1000100101

Input : n = 1030
Output: 7
// binary of n = 1030 is 10000000110

Input : n = 8
Output: -1
// There is only one 1 in binary representation
// of 8.```

The idea to solve this problem is to use shift operator. We just need to find the position of two immediate 1’s in binary representation of n and maximize the difference of these position.

• Return -1 if number is 0 or is a power of 2. In these cases there are less than two 1’s in binary representation.
• Initialize variable prev with position of first right most 1, it basically stores the position of previously seen 1.
• Now take another variable cur which stores the position of immediate 1 just after prev.
• Now take difference of cur – prev – 1, it will be the number of 0’s between to immediate 1’s and compare it with previous max value of 0’s and update prev i.e; prev=cur for next iteration.
• Use auxiliary variable setBit, which scans all bits of n and helps to detect if current bits is 0 or 1.
• Initially check if N is 0 or power of 2.

Below is the implementation of the above idea :

## C++

 `// C++ program to find maximum number of 0's``// in binary representation of a number``#include ``using` `namespace` `std;` `// Returns maximum 0's between two immediate``// 1's in binary representation of number``int` `maxZeros(``int` `n)``{``    ``// If there are no 1's or there is only``    ``// 1, then return -1``    ``if` `(n == 0 || (n & (n - 1)) == 0)``        ``return` `-1;` `    ``// loop to find position of right most 1``    ``// here sizeof int is 4 that means total 32 bits``    ``int` `setBit = 1, prev = 0, i;``    ``for` `(i = 1; i <= ``sizeof``(``int``) * 8; i++) {``        ``prev++;` `        ``// we have found right most 1``        ``if` `((n & setBit) == setBit) {``            ``setBit = setBit << 1;``            ``break``;``        ``}` `        ``// left shift setBit by 1 to check next bit``        ``setBit = setBit << 1;``    ``}` `    ``// now loop through for remaining bits and find``    ``// position of immediate 1 after prev``    ``int` `max0 = INT_MIN, cur = prev;``    ``for` `(``int` `j = i + 1; j <= ``sizeof``(``int``) * 8; j++) {``        ``cur++;` `        ``// if current bit is set, then compare``        ``// difference of cur - prev -1 with``        ``// previous maximum number of zeros``        ``if` `((n & setBit) == setBit) {``            ``if` `(max0 < (cur - prev - 1))``                ``max0 = cur - prev - 1;` `            ``// update prev``            ``prev = cur;``        ``}``        ``setBit = setBit << 1;``    ``}``    ``return` `max0;``}` `// Driver program to run the case``int` `main()``{``    ``int` `n = 549;` `    ``// Initially check that number must not``    ``// be 0 and power of 2``    ``cout << maxZeros(n);``    ``return` `0;``}`

## Java

 `// Java program to find maximum number of 0's``// in binary representation of a number``class` `GFG {` `    ``// Returns maximum 0's between two immediate``    ``// 1's in binary representation of number``    ``static` `int` `maxZeros(``int` `n) {``        ``// If there are no 1's or there is only``        ``// 1, then return -1``        ``if` `(n == ``0` `|| (n & (n - ``1``)) == ``0``) {``            ``return` `-``1``;``        ``}``        ``//int size in java is 4 byte``        ``byte` `b = ``4``;``        ``// loop to find position of right most 1``        ``// here sizeof int is 4 that means total 32 bits``        ``int` `setBit = ``1``, prev = ``0``, i;``        ``for` `(i = ``1``; i <= b* ``8``; i++) {``            ``prev++;` `            ``// we have found right most 1``            ``if` `((n & setBit) == setBit) {``                ``setBit = setBit << ``1``;``                ``break``;``            ``}` `            ``// left shift setBit by 1 to check next bit``            ``setBit = setBit << ``1``;``        ``}` `        ``// now loop through for remaining bits and find``        ``// position of immediate 1 after prev``        ``int` `max0 = Integer.MIN_VALUE, cur = prev;``        ``for` `(``int` `j = i + ``1``; j <= b * ``8``; j++) {``            ``cur++;` `            ``// if current bit is set, then compare``            ``// difference of cur - prev -1 with``            ``// previous maximum number of zeros``            ``if` `((n & setBit) == setBit) {``                ``if` `(max0 < (cur - prev - ``1``)) {``                    ``max0 = cur - prev - ``1``;``                ``}` `                ``// update prev``                ``prev = cur;``            ``}``            ``setBit = setBit << ``1``;``        ``}``        ``return` `max0;``    ``}` `    ``// Driver program to run the case``    ``static` `public` `void` `main(String[] args) {``        ``int` `n = ``549``;` `        ``// Initially check that number must not``        ``// be 0 and power of 2``        ``System.out.println(maxZeros(n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find maximum number of``# 0's in binary representation of a number` `# Returns maximum 0's between two immediate``# 1's in binary representation of number``def` `maxZeros(n):``    ``# If there are no 1's or there is``    ``# only 1, then return -1``    ``if` `(n ``=``=` `0` `or` `(n & (n ``-` `1``)) ``=``=` `0``):``        ``return` `-``1` `    ``# loop to find position of right most 1``    ``# here sizeof is 4 that means total 32 bits``    ``setBit ``=` `1``    ``prev ``=` `0``    ``i ``=` `1``    ``while``(i < ``33``):``        ``prev ``+``=` `1` `        ``# we have found right most 1``        ``if` `((n & setBit) ``=``=` `setBit):``            ``setBit ``=` `setBit << ``1``            ``break` `        ``# left shift setBit by 1 to check next bit``        ``setBit ``=` `setBit << ``1` `    ``# now loop through for remaining bits and find``    ``# position of immediate 1 after prev``    ``max0 ``=` `-``10``*``*``9``    ``cur ``=` `prev``    ``for` `j ``in` `range``(i ``+` `1``, ``33``):``        ``cur ``+``=` `1` `        ``# if current bit is set, then compare``        ``# difference of cur - prev -1 with``        ``# previous maximum number of zeros``        ``if` `((n & setBit) ``=``=` `setBit):``            ``if` `(max0 < (cur ``-` `prev ``-` `1``)):``                ``max0 ``=` `cur ``-` `prev ``-` `1` `            ``# update prev``            ``prev ``=` `cur``        ``setBit ``=` `setBit << ``1` `    ``return` `max0` `# Driver Code``n ``=` `549` `# Initially check that number must not``# be 0 and power of 2``print``(maxZeros(n))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# program to find maximum number of 0's``// in binary representation of a number``using` `System;` `class` `GFG {` `    ``// Returns maximum 0's between two immediate``    ``// 1's in binary representation of number``    ``static` `int` `maxZeros(``int` `n)``    ``{``        ``// If there are no 1's or there is only``        ``// 1, then return -1``        ``if` `(n == 0 || (n & (n - 1)) == 0)``            ``return` `-1;` `        ``// loop to find position of right most 1``        ``// here sizeof int is 4 that means total 32 bits``        ``int` `setBit = 1, prev = 0, i;``        ``for` `(i = 1; i <= ``sizeof``(``int``) * 8; i++) {``            ``prev++;` `            ``// we have found right most 1``            ``if` `((n & setBit) == setBit) {``                ``setBit = setBit << 1;``                ``break``;``            ``}` `            ``// left shift setBit by 1 to check next bit``            ``setBit = setBit << 1;``        ``}` `        ``// now loop through for remaining bits and find``        ``// position of immediate 1 after prev``        ``int` `max0 = ``int``.MinValue, cur = prev;``        ``for` `(``int` `j = i + 1; j <= ``sizeof``(``int``) * 8; j++) {``            ``cur++;` `            ``// if current bit is set, then compare``            ``// difference of cur - prev -1 with``            ``// previous maximum number of zeros``            ``if` `((n & setBit) == setBit) {``                ``if` `(max0 < (cur - prev - 1))``                    ``max0 = cur - prev - 1;` `                ``// update prev``                ``prev = cur;``            ``}``            ``setBit = setBit << 1;``        ``}``        ``return` `max0;``    ``}` `    ``// Driver program to run the case``    ``static` `public` `void` `Main()``    ``{``        ``int` `n = 549;` `        ``// Initially check that number must not``        ``// be 0 and power of 2``        ``Console.WriteLine(maxZeros(n));``    ``}``}` `// This code is contributed by vt_m.`

## Javascript

 ``

Output:

`3`

This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.