Find longest sequence of 1's in binary representation with one flip - GeeksforGeeks

21 May, 2021
Give an integer n. We can flip exactly one bit. Write code to find the length of the longest sequence of 1 s you could create. 
Examples: 
Input : 1775         
Output : 8 
Binary representation of 1775 is 11011101111.
After flipping the highlighted bit, we get 
consecutive 8 bits. 11011111111.

Input : 12         
Output : 3 

Input : 15
Output : 5

Input : 71
Output: 4

Binary representation of 71 is 1000111.
After flipping the highlighted bit, we get 
consecutive 4 bits. 1001111. 
A simple solution is to store the binary representation of a given number in a binary array. Once we have elements in a binary array, we can apply the methods discussed here.
An efficient solution is to walk through the bits in the binary representation of the given number. We keep track of the current 1’s sequence length and the previous 1’s sequence length. When we see a zero, update the previous Length:  
If the next bit is a 1, the previous Length should be set to the current Length.If the next bit is a 0, then we can’t merge these sequences together. So, set the previous Length to 0.
If the next bit is a 1, the previous Length should be set to the current Length.
If the next bit is a 0, then we can’t merge these sequences together. So, set the previous Length to 0.
We update max length by comparing the following two:  
The current value of max-lengthCurrent-Length + Previous-Length .
The current value of max-length
Current-Length + Previous-Length .
Result = return max-length+1 (// add 1 for flip bit count )
Below is the implementation of the above idea : 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to find maximum consecutive// 1's in binary representation of a number// after flipping one bit.#include<bits/stdc++.h>using namespace std; int flipBit(unsigned a){    /* If all bits are l, binary representation       of 'a' has all 1s */    if (~a == 0)        return 8*sizeof(int);     int currLen = 0, prevLen = 0, maxLen = 0;    while (a!= 0)    {        // If Current bit is a 1 then increment currLen++        if ((a & 1) == 1)            currLen++;         // If Current bit is a 0 then check next bit of a        else if ((a & 1) == 0)        {            /* Update prevLen to 0 (if next bit is 0)            or currLen (if next bit is 1). */            prevLen = (a & 2) == 0? 0 : currLen;             // If two consecutively bits are 0            // then currLen also will be 0.            currLen = 0;        }         // Update maxLen if required        maxLen = max(prevLen + currLen, maxLen);         // Remove last bit (Right shift)        a >>= 1;    }     // We can always have a sequence of    // at least one 1, this is flipped bit    return maxLen+1;} // Driver codeint main(){    // input 1    cout << flipBit(13);    cout << endl;     // input 2    cout << flipBit(1775);    cout << endl;     // input 3    cout << flipBit(15);    return 0;}
// Java program to find maximum consecutive// 1's in binary representation of a number// after flipping one bit. class GFG{     static int flipBit(int a)    {        /* If all bits are l, binary representation        of 'a' has all 1s */        if (~a == 0)        {            return 8 * sizeof();        }         int currLen = 0, prevLen = 0, maxLen = 0;        while (a != 0)        {            // If Current bit is a 1            // then increment currLen++            if ((a & 1) == 1)            {                currLen++;            }                         // If Current bit is a 0 then            // check next bit of a            else if ((a & 1) == 0)            {                /* Update prevLen to 0 (if next bit is 0)                or currLen (if next bit is 1). */                prevLen = (a & 2) == 0 ? 0 : currLen;                 // If two consecutively bits are 0                // then currLen also will be 0.                currLen = 0;            }             // Update maxLen if required            maxLen = Math.max(prevLen + currLen, maxLen);             // Remove last bit (Right shift)            a >>= 1;        }         // We can always have a sequence of        // at least one 1, this is flipped bit        return maxLen + 1;    }     static byte sizeof()    {        byte sizeOfInteger = 8;        return sizeOfInteger;    }         // Driver code    public static void main(String[] args)    {        // input 1        System.out.println(flipBit(13));         // input 2        System.out.println(flipBit(1775));         // input 3        System.out.println(flipBit(15));    }} // This code is contributed by PrinciRaj1992
# Python3 program to find maximum# consecutive 1's in binary# representation of a number# after flipping one bit.def flipBit(a):         # If all bits are l,    # binary representation    # of 'a' has all 1s    if (~a == 0):        return 8 * sizeof();     currLen = 0;    prevLen = 0;    maxLen = 0;    while (a > 0):                 # If Current bit is a 1        # then increment currLen++        if ((a & 1) == 1):            currLen += 1;         # If Current bit is a 0        # then check next bit of a        elif ((a & 1) == 0):                         # Update prevLen to 0            # (if next bit is 0)            # or currLen (if next            # bit is 1). */            prevLen = 0 if((a & 2) == 0) else currLen;             # If two consecutively bits            # are 0 then currLen also            # will be 0.            currLen = 0;         # Update maxLen if required        maxLen = max(prevLen + currLen, maxLen);         # Remove last bit (Right shift)        a >>= 1;     # We can always have a sequence    # of at least one 1, this is    # flipped bit    return maxLen + 1; # Driver code# input 1print(flipBit(13)); # input 2print(flipBit(1775)); # input 3print(flipBit(15));     # This code is contributed by mits
// C# program to find maximum consecutive// 1's in binary representation of a number// after flipping one bit.using System; class GFG{      static int flipBit(int a)    {        /* If all bits are l, binary representation        of 'a' has all 1s */        if (~a == 0)        {            return 8 * sizeof(int);        }          int currLen = 0, prevLen = 0, maxLen = 0;        while (a != 0)        {            // If Current bit is a 1            // then increment currLen++            if ((a & 1) == 1)            {                currLen++;            }                          // If Current bit is a 0 then            // check next bit of a            else if ((a & 1) == 0)            {                /* Update prevLen to 0 (if next bit is 0)                or currLen (if next bit is 1). */                prevLen = (a & 2) == 0 ? 0 : currLen;                  // If two consecutively bits are 0                // then currLen also will be 0.                currLen = 0;            }              // Update maxLen if required            maxLen = Math.Max(prevLen + currLen, maxLen);              // Remove last bit (Right shift)            a >>= 1;        }          // We can always have a sequence of        // at least one 1, this is flipped bit        return maxLen + 1;    }      // Driver code    public static void Main(String[] args)    {        // input 1        Console.WriteLine(flipBit(13));          // input 2        Console.WriteLine(flipBit(1775));          // input 3        Console.WriteLine(flipBit(15));    }}  // This code contributed by Rajput-Ji
<?php// PHP program to find maximum consecutive// 1's in binary representation of a number// after flipping one bit. function flipBit($a){    /* If all bits are l,       binary representation       of 'a' has all 1s */    if (~$a == 0)        return 8 * sizeof();     $currLen = 0;    $prevLen = 0;    $maxLen = 0;    while ($a!= 0)    {                 // If Current bit is a 1        // then increment currLen++        if (($a & 1) == 1)            $currLen++;         // If Current bit is a 0        // then check next bit of a        else if (($a & 1) == 0)        {                         /* Update prevLen to 0               (if next bit is 0)               or currLen (if next               bit is 1). */            $prevLen = ($a & 2) == 0? 0 : $currLen;             // If two consecutively bits are 0            // then currLen also will be 0.            $currLen = 0;        }         // Update maxLen if required        $maxLen = max($prevLen + $currLen, $maxLen);         // Remove last bit (Right shift)        $a >>= 1;    }     // We can always have a sequence of    // at least one 1, this is flipped bit    return $maxLen+1;}     // Driver code    // input 1    echo flipBit(13);    echo "\n";     // input 2    echo flipBit(1775);    echo "\n";     // input 3    echo flipBit(15);     // This code is contributed by aj_36?>
<script>     // Javascript program to    // find maximum consecutive    // 1's in binary representation    // of a number    // after flipping one bit.         function flipBit(a)    {        /* If all bits are l,        binary representation        of 'a' has all 1s */        if (~a == 0)        {            return 8 * sizeof(int);        }            let currLen = 0, prevLen = 0, maxLen = 0;        while (a != 0)        {            // If Current bit is a 1            // then increment currLen++            if ((a & 1) == 1)            {                currLen++;            }                            // If Current bit is a 0 then            // check next bit of a            else if ((a & 1) == 0)            {                /* Update prevLen to 0                (if next bit is 0)                or currLen (if next bit is 1). */                prevLen = (a & 2) == 0 ? 0 : currLen;                    // If two consecutively bits are 0                // then currLen also will be 0.                currLen = 0;            }                // Update maxLen if required            maxLen = Math.max(prevLen + currLen, maxLen);                // Remove last bit (Right shift)            a >>= 1;        }            // We can always have a sequence of        // at least one 1, this is flipped bit        return maxLen + 1;    }         // input 1    document.write(flipBit(13) + "</br>");     // input 2    document.write(flipBit(1775) + "</br>");     // input 3    document.write(flipBit(15));                                 </script>
Output : 
4
8
5
This article is contributed by Mr. Somesh Awasthi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
jit_t
Mithun Kumar
princiraj1992
Rajput-Ji
shubham_singh
divyeshrabadiya07
surinderdawra388
binary-representation
Bit Magic
Bit Magic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Bits manipulation (Important tactics)
Add two numbers without using arithmetic operators
Bit Fields in C
Find the element that appears once
Set, Clear and Toggle a given bit of a number in C
C++ bitset and its application
1's and 2's complement of a Binary Number
Divide two integers without using multiplication, division and mod operator
Find the Number Occurring Odd Number of Times
Check whether K-th bit is set or not