Open In App

# Length of the Longest Consecutive 1s in Binary Representation

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 1sseries 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++

 `// C++ program to find length of the longest``// consecutive 1s in binary representation of``// a number.``#include``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

 `// 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``));``    ``}``}`

## Python3

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

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

## Javascript

 ``

## PHP

 ``

Output

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

 `// C++ program to find the length of the longest``// consecutive 1s in binary representation of``// a number.` `#include ``#include ``#include ``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

 `// 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);``    ``}``}`

## Python3

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

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

 `// 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();`

Output

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

This article is contributed by Pankaj Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.