Max Consecutive Ones

Max Consecutive Ones - Problem

Array Easy

Given a binary array nums, return the maximum number of consecutive 1's in the array.

The array contains only 0s and 1s.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,1,0,1,1,1]

› Output: 3

💡 Note: The first two 1s have length 2, the last three 1s have length 3. Maximum is 3.

Example 2 — All Zeros

$ Input: nums = [0,0,0,0]

› Output: 0

💡 Note: No consecutive 1s exist, so the maximum is 0.

Example 3 — All Ones

$ Input: nums = [1,1,1,1]

› Output: 4

💡 Note: The entire array is consecutive 1s, so the maximum is 4.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 f Facebook 8

The key insight is to track the current consecutive count and maximum count in a single pass. The optimal approach uses O(n) time and O(1) space by resetting the current count on encountering 0 and updating the maximum whenever we see a longer streak.

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n²) Space: O(1)

Check every possible starting position and count how many consecutive 1s we can find from there. Keep track of the maximum count seen so far.

Single Pass - Optimal Solution

⏱️ Time: O(n) Space: O(1)

Iterate through the array once, keeping track of the current consecutive count of 1s and the maximum count seen so far. Reset current count when encountering a 0.

Brute Force - Check All Subarrays — Algorithm Steps

For each index i, start counting consecutive 1s
Continue counting until we hit a 0 or reach end
Update maximum count if current streak is longer

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from each index

Try every position as potential start

Count consecutive 1s

Count how many 1s we can find in a row

Track maximum

Keep the longest streak found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize) {
    int maxCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 1) {
            int currentCount = 0;
            int j = i;
            while (j < numsSize && nums[j] == 1) {
                currentCount++;
                j++;
            }
            if (currentCount > maxCount) {
                maxCount = currentCount;
            }
        }
    }
    
    return maxCount;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - outer loop iterates n times, inner loop can iterate up to n times

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

56.7K Views

Medium Frequency

~15 min Avg. Time

2.1K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler