Length of the Longest Consecutive 1s in Binary Representation

Try it on GfG Practice

Given a number N, The task is to find the length of the longest consecutive 1s series in its binary representation.
Examples : 

Input: N = 14
Output: 3
Explanation: The binary representation of 14 is 1110.

Input: N = 222
Output: 4
Explanation: The binary representation of 222 is 11011110.

Naive Approach: Below is the idea to solve the problem

Traverse the bits of binary representation of N and keep a track of the number of consecutive set bits, and the maximum length of consecutive 1s found so far.

Time Complexity: O(X), Here X is the length of binary representation of N.
Auxiliary Space: O(1)

Find the length of the longest consecutive 1s series using Bit Magic:

Below is the idea to solve the problem:

The idea is based on the concept that the AND of bit sequence with a left shifted by 1 version of itself effectively removes the trailing 1 from every sequence of consecutive 1s.  

So the operation N = (N & (N << 1)) reduces length of every sequence of 1s by one in binary representation of N. If we keep doing this operation in a loop, we end up with N = 0. The number of iterations required to reach 0 is actually length of the longest consecutive sequence of 1s.

Illustration:

        11101111   (x)

    & 11011110   (x << 1)

    ---------------------------

      11001110   (x & (x << 1)) 

         ^         ^
          |           |

   Trailing 1 removed

Follow the below steps to implement the above approach:

• Create a variable count initialized with value 0.
• Run a while loop till N is not 0.
  • In each iteration perform the operation N = (N & (N << 1))
  • Increment count by one.
• Return count

Below is the Implementation of above approach:

// C++ program to find length of the longest
// consecutive 1s in binary representation of
// a number.
#include<bits/stdc++.h>
using namespace std;

int maxConsecutiveOnes(int x)
{
    // Initialize result
    int count = 0;

    // Count the number of iterations to
    // reach x = 0.
    while (x!=0)
    {
        // This operation reduces length
        // of every sequence of 1s by one.
        x = (x & (x << 1));

        count++;
    }

    return count;
}

// Driver code
int main()
{
    // Function Call
    cout << maxConsecutiveOnes(14) << endl;
    cout << maxConsecutiveOnes(222) << endl;
    return 0;
}

// Java program to find length of the longest
// consecutive 1s in binary representation of
// a number.
class MaxConsecutiveOnes
{
    private static int maxConsecutiveOnes(int x)
    {
        // Initialize result
        int count = 0;

        // Count the number of iterations to
        // reach x = 0.
        while (x!=0)
        {
            // This operation reduces length
            // of every sequence of 1s by one.
            x = (x & (x << 1));

            count++;
        }

        return count;
    }

    // Driver code
    public static void main(String strings[])
    {
        System.out.println(maxConsecutiveOnes(14));
        System.out.println(maxConsecutiveOnes(222));
    }
}

# Python program to find
# length of the longest
# consecutive 1s in
# binary representation of
# a number.

def maxConsecutiveOnes(x):

    # Initialize result
    count = 0
 
    # Count the number of iterations to
    # reach x = 0.
    while (x!=0):
    
        # This operation reduces length
        # of every sequence of 1s by one.
        x = (x & (x << 1))
 
        count=count+1
    
    return count

# Driver code

print(maxConsecutiveOnes(14))
print(maxConsecutiveOnes(222))

# This code is contributed
# by Anant Agarwal.

// C# program to find length of the 
// longest consecutive 1s in binary
// representation of a number.
using System;

class GFG {
    
    // Function to find length of the 
    // longest consecutive 1s in binary
    // representation of a number 
    private static int maxConsecutiveOnes(int x)
    {
        
        // Initialize result
        int count = 0;

        // Count the number of iterations
        // to reach x = 0.
        while (x != 0)
        {
            
            // This operation reduces length
            // of every sequence of 1s by one.
            x = (x & (x << 1));

            count++;
        }

        return count;
    }

    // Driver code
    public static void Main()
    {
        Console.WriteLine(maxConsecutiveOnes(14));
        Console.Write(maxConsecutiveOnes(222));
    }
}

// This code is contributed by Nitin Mittal.

<script>

// Javascript program to find length 
// of the longest consecutive 1s in 
// binary representation of a number.
function maxConsecutiveOnes(x)
{
    
    // Initialize result
    let count = 0;

    // Count the number of iterations to
    // reach x = 0.
    while (x != 0)
    {
        
        // This operation reduces length
        // of every sequence of 1s by one.
        x = (x & (x << 1));

        count++;
    }
    return count;
}

// Driver code
document.write(maxConsecutiveOnes(14) + "<br/>");
document.write(maxConsecutiveOnes(222));

// This code is contributed by code_hunt    

</script>

<?php
// PHP program to find length 
// of the longest consecutive 
// 1s in binary representation of
// a number.

function maxConsecutiveOnes($x)
{
    // Initialize result
    $count = 0;

    // Count the number of 
    // iterations to reach x = 0.
    while ($x != 0)
    {
        // This operation reduces 
        // length of every sequence
        // of 1s by one.
        $x = ($x & ($x << 1));

        $count++;
    }

    return $count;
}

// Driver code
echo maxConsecutiveOnes(14), "\n";
echo maxConsecutiveOnes(222), "\n";

// This code is contributed by Ajit
?>

3
4

Time Complexity: O(log X), Here X is the length of binary representation of N 
Auxiliary Space: O(1)

Approach 2: Using String Conversion

Here's a brief explanation of the algorithm:

We start by initializing max_len and cur_len to 0. Then, we iterate through the bits of the given integer n. If we encounter a 1 bit, we increment cur_len. If we encounter a 0 bit, we update max_len if cur_len is greater than max_len, and reset cur_len to 0. This is because a 0 bit breaks the current run of consecutive 1s. Finally, we return max_len.

• Initialize a variable max_len to 0 to store the length of the longest consecutive 1s found so far.
• Initialize a variable cur_len to 0 to store the length of the current consecutive 1s.
• While the integer n is not equal to 0, perform the following steps:
  •  If the least significant bit (LSB) of n is 1, increment cur_len.
  •  If the LSB of n is 0, update max_len if cur_len is greater than max_len, and reset cur_len to.
  • Right shift n by 1 bit.
  • If cur_len is greater than max_len, update max_len.
• Return max_len.

// C++ program to find the length of the longest
// consecutive 1s in binary representation of
// a number.

#include <iostream>
#include <bitset>
#include <string>
using namespace std;

int main() {
    int num = 222;

    // Convert the integer to its binary representation as a string
    string binary = bitset<32>(num).to_string();
    int count = 0;
    int maxCount = 0;

    // Loop through the binary string to find the longest consecutive 1s
    for (int i = 0; i < binary.size(); i++) {
        if (binary[i] == '1') {
            count++;
            if (count > maxCount) {
                maxCount = count;
            }
        } else {
            count = 0;
        }
    }

    // Print the result
    cout << "The length of the longest consecutive 1s in the binary representation is: " << maxCount << endl;

    return 0;
}

// Java program to find the length of the longest
// consecutive 1s in binary representation of
// a number.

import java.util.Arrays;

public class LongestConsecutiveOnes {
    public static void main(String[] args) {
        int num = 222;

        // Convert the integer to its binary representation as a string
        String binary = String.format("%32s", Integer.toBinaryString(num)).replace(' ', '0');
        int count = 0;
        int maxCount = 0;

        // Loop through the binary string to find the longest consecutive 1s
        for (int i = 0; i < binary.length(); i++) {
            if (binary.charAt(i) == '1') {
                count++;
                if (count > maxCount) {
                    maxCount = count;
                }
            } else {
                count = 0;
            }
        }

        // Print the result
        System.out.println("The length of the longest consecutive 1s in the binary representation is: " + maxCount);
    }
}

# Python program to find the length of the longest
# consecutive 1s in binary representation of
# a number.

def main():
    num = 222

    # Convert the integer to its binary representation as a string
    binary = format(num, '032b')
    count = 0
    max_count = 0

    # Loop through the binary string to find the longest consecutive 1s
    for i in range(len(binary)):
        if binary[i] == '1':
            count += 1
            if count > max_count:
                max_count = count
        else:
            count = 0

    # Print the result
    print("The length of the longest consecutive 1s in the binary representation is:", max_count)

if __name__ == "__main__":
    main()

// C# program to find the length of the longest
// consecutive 1s in binary representation of
// a number.

using System;

public class LongestConsecutiveOnes
{
    public static void Main(string[] args)
    {
        int num = 222;

        // Convert the integer to its binary representation as a string
        string binary = Convert.ToString(num, 2).PadLeft(32, '0');
        int count = 0;
        int maxCount = 0;

        // Loop through the binary string to find the longest consecutive 1s
        for (int i = 0; i < binary.Length; i++)
        {
            if (binary[i] == '1')
            {
                count++;
                if (count > maxCount)
                {
                    maxCount = count;
                }
            }
            else
            {
                count = 0;
            }
        }

        // Print the result
        Console.WriteLine("The length of the longest consecutive 1s in the binary representation is: " + maxCount);
    }
}

// JavaScript program to find the length of the longest
// consecutive 1s in binary representation of
// a number.

function main() {
    const num = 222;

    // Convert the integer to its binary representation as a string
    let binary = num.toString(2).padStart(32, '0');
    let count = 0;
    let maxCount = 0;

    // Loop through the binary string to find the longest consecutive 1s
    for (let i = 0; i < binary.length; i++) {
        if (binary[i] === '1') {
            count++;
            if (count > maxCount) {
                maxCount = count;
            }
        } else {
            count = 0;
        }
    }

    // Print the result
    console.log("The length of the longest consecutive 1s in the binary representation is:", maxCount);
}

main();

The length of the longest consecutive 1s in the binary representation is: 4

The time complexity of this algorithm is O(log n), where n is the given integer, since we iterate through the bits of the integer. The space complexity is O(1), since we only use constant extra space to store the variables max_len and cur_len.