Max Consecutive Ones
Last Updated: March 31, 2026
Understanding the Problem
We have an array that only contains 0's and 1's, and we need to find the longest streak of consecutive 1's. Think of it like counting the longest winning streak in a series of games where 1 means a win and 0 means a loss.
The key observation is simple: as we scan through the array, we maintain a running count of consecutive 1's. Every time we hit a 0, the streak breaks and we reset the count. At each step, we keep track of the maximum streak we've seen so far. That's really all there is to it. The challenge isn't finding a clever algorithm, it's implementing the straightforward one cleanly without off-by-one errors.
Key Constraints:
1 <= nums.length <= 10^5→ With n up to 100,000, we need O(n) or O(n log n). An O(n^2) approach (checking every subarray) would be 10 billion operations, which is too slow.nums[i]is either0or1→ This is a binary array. We don't need to worry about negative numbers, large values, or any other edge cases related to element values. The only two states are "part of a streak" or "streak breaker."
Approach 1: Brute Force (Check All Subarrays)
Intuition
The most straightforward approach: for every position in the array, check how long the streak of consecutive 1's starting at that position is. Then take the maximum across all starting positions.
This is what you'd do if you were scanning through the array by hand and being extra careful. Pick a starting index, count how many 1's follow in a row, write that down, move to the next starting index, and repeat.
Algorithm
- Initialize
maxCount = 0to track the best streak found. - For each index
ifrom0ton - 1: - If
nums[i]is1, start counting consecutive 1's from indexi. - Use an inner loop starting at
i, incrementing a counter while elements are1. - Update
maxCountwith the streak length if it's larger. - Return
maxCount.
Example Walkthrough
Code
- Time Complexity: O(n^2). For each starting index, we potentially scan the rest of the array. In the worst case (all 1's), the inner loop runs n, n-1, n-2, ... times, which sums to O(n^2).
- Space Complexity: O(1). Only a few integer variables are used. No extra data structures.
This brute force recounts the same 1's from every starting position in a streak. What if we just kept a running count that grows with each 1 and resets at each 0?
Approach 2: Single Pass (Running Counter)
Intuition
Here's the key insight: we don't need to restart counting from each position. We can just walk through the array once, keeping a running counter. When we see a 1, we increment the counter. When we see a 0, the streak is broken, so we reset the counter to 0. At every step, we check if the current streak is the longest we've seen.
The running counter maintains a simple invariant: count always holds the length of the current streak of 1's ending at the current position. If we're on a 1, the streak extends by one. If we're on a 0, no streak ends here, so the count goes to 0. By checking maxCount after every element, we guarantee we capture the longest streak even if it occurs in the middle of the array and gets broken by a later 0.
This is essentially a simplified version of Kadane's algorithm. Kadane's tracks the "best subarray sum ending here" for the maximum subarray problem. Here, we track the "longest run of 1's ending here." The pattern is the same: maintain a local running value, reset when appropriate, and track the global best.
Algorithm
- Initialize
maxCount = 0andcount = 0. - Iterate through each element in
nums. - If the element is
1, incrementcount. - If the element is
0, resetcountto0. - After each element, update
maxCount = max(maxCount, count). - Return
maxCount.
Example Walkthrough
Code
- Time Complexity: O(n). We visit each element exactly once. The work per element is O(1): one comparison, one increment or reset, and one max update.
- Space Complexity: O(1). Only two integer variables (
countandmaxCount). No extra data structures regardless of input size.