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

1. If the next bit is a 1, the previous Length should be set to the current Length.
2. 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:  

1. The 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 the above idea : 

C++

// 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 code
int main()
{
    // input 1
    cout << flipBit(13);
    cout << endl;

    // input 2
    cout << flipBit(1775);
    cout << endl;

    // input 3
    cout << flipBit(15);
    return 0;
}

Java

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

# 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 1
print(flipBit(13));

# input 2
print(flipBit(1775));

# input 3
print(flipBit(15));

# This code is contributed by mits

C#

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

Javascript

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

PHP

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

Output

4
8
5

Time Complexity: O(log₂n)
Auxiliary Space: O(1)

Approach 2: Sliding Window

In this approach, we can use a sliding window to count the length of the longest consecutive 1’s. We can use two pointers to define a window and keep track of the number of flips we have made. When we encounter a 0, we can flip it and move the right pointer to the right. If the number of flips we have made is greater than 1, we can move the left pointer to the right until we have made only one flip. We can then update the maximum length obtained so far.

Here’s the code:

C++

// 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 findMaxConsecutiveOnes(int num) {
    int left = 0, right = 0, flips = 0, max_len = 0;
    string binary = bitset<32>(num).to_string(); // convert integer to binary string
    while (right < binary.size()) {
        if (binary[right] == '0') {
            flips++;
        }
        while (flips > 1) {
            if (binary[left] == '0') {
                flips--;
            }
            left++;
        }
        max_len = max(max_len, right - left + 1);
        right++;
    }
    return max_len;
}

// Driver code
int main()
{
    // input 1
    cout << findMaxConsecutiveOnes(13);
    cout << endl;

    // input 2
    cout << findMaxConsecutiveOnes(1775);
    cout << endl;

    // input 3
    cout << findMaxConsecutiveOnes(15);
    return 0;
}

Java

public class Main {

    public static int findMaxConsecutiveOnes(int num) {
        int left = 0, right = 0, flips = 0, max_len = 0;
        String binary = String.format("%32s", Integer.toBinaryString(num)).replace(' ', '0');
        while (right < binary.length()) {
            if (binary.charAt(right) == '0') {
                flips++;
            }
            while (flips > 1) {
                if (binary.charAt(left) == '0') {
                    flips--;
                }
                left++;
            }
            max_len = Math.max(max_len, right - left + 1);
            right++;
        }
        return max_len;
    }

    // Driver code
    public static void main(String[] args) {
        // input 1
        System.out.println(findMaxConsecutiveOnes(13));

        // input 2
        System.out.println(findMaxConsecutiveOnes(1775));

        // input 3
        System.out.println(findMaxConsecutiveOnes(15));
    }
}

Python3

# Python program to find maximum consecutive
# 1's in binary representation of a number
# after flipping one bit.

def findMaxConsecutiveOnes(num):
    left, right, flips, max_len = 0, 0, 0, 0
    binary = format(num, 'b').zfill(32)  # convert integer to binary string
    while right < len(binary):
        if binary[right] == '0':
            flips += 1
        while flips > 1:
            if binary[left] == '0':
                flips -= 1
            left += 1
        max_len = max(max_len, right - left + 1)
        right += 1
    return max_len

# Driver code
if __name__ == "__main__":
    # input 1
    print(findMaxConsecutiveOnes(13))

    # input 2
    print(findMaxConsecutiveOnes(1775))

    # input 3
    print(findMaxConsecutiveOnes(15))

# This code is contributed by Susobhan Akhuli

C#

using System;

class GFG
{
    // This function finds the length of the longest substring of ones
    static int FindMaxConsecutiveOnes(int num)
    {
        int left = 0, right = 0, flips = 0, max_len = 0;
        string binary = Convert.ToString(num, 2).PadLeft(32, '0'); // convert integer to binary string

        // Iterating over the binary string
        while (right < binary.Length)
        {
            if (binary[right] == '0')
                flips++;

            // Updating left index of the sliding window
            while (flips > 1)
            {
                if (binary[left] == '0')
                    flips--;
                left++;
            }

            // Updating maximum length
            max_len = Math.Max(max_len, right - left + 1);
            right++;
        }
        return max_len;
    }

    // Driver code
    static void Main()
    {
        // input 1
        Console.WriteLine(FindMaxConsecutiveOnes(13));

        // input 2
        Console.WriteLine(FindMaxConsecutiveOnes(1775));

        // input 3
        Console.WriteLine(FindMaxConsecutiveOnes(15));
    }
}

// by phasing17

Javascript

function findMaxConsecutiveOnes(num) {
    let left = 0;
    let right = 0;
    let flips = 0;
    let max_len = 0;

    // Convert the integer to a binary string with a length of 32 bits
    let binary = num.toString(2).padStart(32, '0');

    // Iterate over the binary string
    while (right < binary.length) {
        if (binary[right] === '0') {
            flips++;
        }

        // Update the left index of the sliding window
        while (flips > 1) {
            if (binary[left] === '0') {
                flips--;
            }
            left++;
        }

        // Update the maximum length
        max_len = Math.max(max_len, right - left + 1);
        right++;
    }

    return max_len;
}

// Driver code
// Input 1
console.log("Max Consecutive 1's after flipping one bit in binary of 13:", findMaxConsecutiveOnes(13));

// Input 2
console.log("Max Consecutive 1's after flipping one bit in binary of 1775:", findMaxConsecutiveOnes(1775));

// Input 3
console.log("Max Consecutive 1's after flipping one bit in binary of 15:", findMaxConsecutiveOnes(15));

Output

4
8
5

Time Complexity: O(n), where n is the number of bits in the binary representation of the given number.
Space Complexity: O(1)

This article is contributed by Mr. Somesh Awasthi.