Maximum consecutive one’s (or zeros) in a binary array
Last Updated :
25 Jun, 2025
Improve
Try it on GfG Practice 
Given a binary array arr[] consisting of only 0s and 1s, find the length of the longest contiguous sequence of either 1s or 0s in the array.
Examples :
Input: arr[] = [0, 1, 0, 1, 1, 1, 1]
Output: 4
Explanation: The maximum number of consecutive 1’s in the array is 4 from index 3-6.Input: arr[] = [0, 0, 1, 0, 1, 0]
Output: 2
Explanation: The maximum number of consecutive 0’s in the array is 2 from index 0-1.Input: arr[] = [0, 0, 0, 0]
Output: 4
Explanation: The maximum number of consecutive 0’s in the array is 4.
Table of Content
[Approach - 1] Using Simple Traversal - O(n) Time and O(1) Space
The idea is to traverse the array once and count how many times the same value repeats consecutively. The thought process is to use a counter that increases when the current element matches the previous one. If a change is detected, we update the maximum streak and reset the count.
Steps-By-Step Approach:
- Initialize two variables: maxCount = 0 to store result and count = 1 for current streak length.
- Iterate through the array starting from index 1 to compare each element with the previous one.
- If arr[i] equals arr[i - 1], it means the streak continues, so increment count by 1.
- If they differ, update maxCount with the current count and reset count = 1 for a new streak.
- Continue this comparison until the loop finishes checking all elements in the array.
- After the loop, take the maximum of maxCount and count to cover the last streak.
- Return maxCount which holds the maximum number of consecutive 1s or 0s in the array.
#include <iostream>
#include <vector>
using namespace std;
int maxConsecBits(vector<int> &arr) {
int maxCount = 0, count = 1;
// Loop through the array starting from the second element
for(int i = 1; i < arr.size(); i++) {
// If the current element is the same as the previous one
// increment the count
if(arr[i] == arr[i - 1]) {
count++;
}
else {
// If not equal, update maxCount if needed and reset count
maxCount = max(maxCount, count);
// Reset for a new sequence
count = 1;
}
}
return max(maxCount, count);
}
int main() {
vector<int> arr = {0, 1, 0, 1, 1, 1, 1};
cout << maxConsecBits(arr) << endl;
return 0;
}
import java.util.List;
class GfG {
static int maxConsecBits(int[] arr){
if (arr.length == 0)
return 0;
int maxCount = 0, count = 1;
// Loop through the array starting from the second element
for (int i = 1; i < arr.length; i++) {
// If the current element is the same as the previous one
// increment the count
if (arr[i] == arr[i - 1]) {
count++;
}
// If not equal, update maxCount if needed and reset count
else {
maxCount = Math.max(maxCount, count);
count = 1;
}
}
return Math.max(maxCount, count);
}
public static void main(String[] args){
int[] arr = { 0, 1, 0, 1, 1, 1, 1 };
System.out.println(maxConsecBits(arr));
}
}
def maxConsecBits(arr):
maxCount, count = 0, 1
# Loop through the array starting from the second element
for i in range(1, len(arr)):
# If the current element is the same as the previous one
# increment the count
if arr[i] == arr[i - 1]:
count += 1
# If not equal, update maxCount if needed and reset count
else:
maxCount = max(maxCount, count)
count = 1
return max(maxCount, count)
if __name__ == "__main__":
arr = [0, 1, 0, 1, 1, 1, 1]
print(maxConsecBits(arr))
using System;
class GfG {
static int maxConsecBits(int[] arr) {
if (arr.Length == 0) {
return 0;
}
int maxCount = 0;
int count = 1;
// Loop through the array starting from the second element
for (int i = 1; i < arr.Length; i++) {
// If the current element is the same as the previous one
// increment the count
if (arr[i] == arr[i - 1]) {
count++;
}
// If not equal, update maxCount if needed and reset count
else {
maxCount = Math.Max(maxCount, count);
count = 1;
}
}
return Math.Max(maxCount, count);
}
public static void Main(string[] args) {
int[] arr = {0, 1, 0, 1, 1, 1, 1};
Console.WriteLine(maxConsecBits(arr));
}
}
function maxConsecBits(arr) {
let maxCount = 0, count = 1;
// Loop through the array starting from the second element
for (let i = 1; i < arr.length; i++) {
// If the current element is the same as the previous one
// increment the count
if (arr[i] === arr[i - 1]) {
count++;
}
// If not equal, update maxCount if needed and reset count
else {
maxCount = Math.max(maxCount, count);
count = 1;
}
}
return Math.max(maxCount, count);
}
// Driver Code
let arr = [0, 1, 0, 1, 1, 1, 1];
console.log(maxConsecBits(arr));
Output
4
[Approach - 2] Using Bit Manipulation - O(n) Time and O(1) Space
The idea is to use XOR (^) to check if consecutive elements are the same. As XOR of two numbers is 0 if both numbers are same. So, If prev ^ num == 0, the sequence continues; else we update the maximum streak and reset the count.
Steps to implement the above idea:
- Initialize three variables: maxCount = 0, count = 0, and prev = -1 to track current and previous bits.
- Traverse the array, use XOR to compare current num with prev, if equal, increment count for the current streak.
- If prev and num differ, update maxCount with the current count, then reset count to 1.
- Update prev to current num in every iteration to track the previous element for the next comparison.
- After loop ends, compare and return the maximum of maxCount and count to cover last streak.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int maxConsecBits(vector<int> &arr) {
int maxCount = 0, count = 0, prev = -1;
for (int num : arr) {
// If the current number is the
// same as the previous number
if ((prev ^ num) == 0) {
count++;
} else {
// Update maxCount and reset count
maxCount = max(maxCount, count);
count = 1;
}
prev = num;
}
return max(maxCount, count);
}
int main() {
vector<int> arr = {0, 1, 0, 1, 1, 1, 1};
cout << maxConsecBits(arr) << endl;
return 0;
}
import java.util.List;
class GfG {
static int maxConsecBits(int[] arr) {
if (arr.length == 0) return 0;
int maxCount = 0, count = 0, prev = -1;
for (int num : arr) {
// If the current number is the
// same as the previous number
if ((prev ^ num) == 0) {
count++;
} else {
// Update maxCount and reset count
maxCount = Math.max(maxCount, count);
count = 1;
}
prev = num;
}
return Math.max(maxCount, count);
}
public static void main(String[] args) {
int[] arr = {0, 1, 0, 1, 1, 1, 1};
System.out.println(maxConsecBits(arr));
}
}
def maxConsecBits(arr):
maxCount, count, prev = 0, 0, -1
for num in arr:
# If the current number is the same
# as the previous number
if (prev ^ num) == 0:
count += 1
else:
# Update max_count and reset count
maxCount = max(maxCount, count)
count = 1
prev = num
return max(maxCount, count)
if __name__ == "__main__":
arr = [0, 1, 0, 1, 1, 1, 1]
print(maxConsecBits(arr))
using System;
class GfG {
static int maxConsecBits(int[] arr) {
if (arr.Length == 0) {
return 0;
}
int maxCount = 0;
int count = 0;
int prev = -1;
foreach (int num in arr) {
// If the current number is the
// same as the previous number
if ((prev ^ num) == 0) {
count++;
} else {
// Update maxCount and reset count
maxCount = Math.Max(maxCount, count);
count = 1;
}
prev = num;
}
return Math.Max(maxCount, count);
}
public static void Main(string[] args) {
int[] arr = {0, 1, 0, 1, 1, 1, 1};
Console.WriteLine(maxConsecBits(arr));
}
}
function maxConsecBits(arr) {
let maxCount = 0, count = 0, prev = -1;
for (let num of arr) {
// If the current number is the
// same as the previous number
if ((prev ^ num) === 0) {
count++;
} else {
// Update maxCount and reset count
maxCount = Math.max(maxCount, count);
count = 1;
}
prev = num;
}
return Math.max(maxCount, count);
}
// Driver Code
let arr = [0, 1, 0, 1, 1, 1, 1];
console.log(maxConsecBits(arr));
Output
4
