二进制表示形式中两个紧邻的1之间最大为0

给定数字n，任务是在给定n的二进制表示形式中找到两个紧邻的1之间的最大值0。如果二进制表示形式包含少于两个1，则返回-1。

例子 ：

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.

解决此问题的想法是使用移位运算符。我们只需要找到n的二进制表示形式中两个立即数1的位置，并最大化这些位置的差即可。

• 如果number为0或2的幂，则返回-1。在这些情况下，二进制表示形式少于两个1。
• 用最右边的1初始化变量prev ，它基本上存储先前看到的1的位置。
• 现在使用另一个变量cur ，它存储prev之后立即数1的位置。
• 现在取cur – prev – 1的差，它是到立即数1之间的0的数量，并将其与先前的0的最大值进行比较，并更新prev即； prev = cur用于下一次迭代。
• 使用辅助变量setBit ，它扫描n的所有位并帮助检测当前位是0还是1。
• 最初检查N是否为0或2的幂。

下面是上述想法的实现：

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 cuurent 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 cuurent 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 cuurent 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 cuurent 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

 
// JavaScript 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
function maxZeros(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
    let b = 4;
     
    // Loop to find position of right most 1
    // here sizeof int is 4 that means total 32 bits
    let 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
    let max0 = Number.MIN_VALUE, cur = prev;
    for(let j = i + 1; j <= b * 8; j++)
    {
        cur++;
 
        // If cuurent 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
let n = 549;
 
// Initially check that number must not
// be 0 and power of 2
document.write(maxZeros(n));
 
// This code is contributed by code_hunt
 

输出：

3