Find longest sequence of 1’s in binary representation with one flip

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 binary representation of given number in a binary array. Once we have elements in binary array, we can apply methods discussed here.

An efficient solution is to walk through the bits in binary representation of given number. We keep track of current 1’s sequence length and the previous 1’s sequence length. When we see a zero, update previous Length:

  1. If the next bit is a 1, previous Length should be set to current Length.
  2. If the next bit is a 0, then we can’t merge these sequences together. So, set previous Length to 0.

We update max length by comparing following two:

  1. Current value of max-length
  2. Current-Length + Previous-Length .
  • result = return max-length+1 (// add 1 for flip bit count )
  • .

    Below is the implementation of above idea :

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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 fliped bit
        return maxLen+1;
    }
      
    // Driver code
    int main()
    {
        // input 1
        cout << flipBit(13);
        cout << endl;
      
        // input 2
        cout << flipBit(1775);
        cout << endl;
      
        // input 3
        cout << flipBit(15);
        return 0;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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 fliped 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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 
        # fliped bit
        return maxLen + 1;
      
    # Driver code
    # input 1
    print(flipBit(13));
      
    # input 2
    print(flipBit(1775));
      
    # input 3
    print(flipBit(15));
          
    # This code is contributed by mits

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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 fliped 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

    chevron_right

    
    

    PHP

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    <?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 fliped 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
    ?>

    chevron_right

    
    


    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 contribute.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.



    My Personal Notes arrow_drop_up



    Article Tags :
    Practice Tags :


    Be the First to upvote.


    Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.