Max Consecutive Ones - Practice Coding Problems

Max Consecutive Ones - Problem

Array Easy

Find the Longest Streak of Consecutive 1's!

You're given a binary array nums containing only 0's and 1's. Your task is to find the maximum number of consecutive 1's in the array.

Goal: Return the length of the longest unbroken sequence of 1's.

Example: In the array [1,1,0,1,1,1], the longest consecutive sequence of 1's has length 3.

This is a classic problem that tests your ability to traverse an array while keeping track of streaks and maximums!

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The longest sequence of consecutive 1's is [1,1,1] at the end, which has length 3.

example_2.py — Single Element

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

› Output: 2

💡 Note: The longest sequence of consecutive 1's is [1,1] in the middle, which has length 2.

example_3.py — All Zeros

$ Input: [0,0,0]

› Output: 0

💡 Note: There are no 1's in the array, so the maximum consecutive 1's is 0.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The array contains only binary values

Visualization

Tap to expand

Day 1 (1): Start streak! current=1, max=12. Day 2 (1): Continue streak! current=2, max=23. Day 3 (0): Rest day 😴 current=0, max=24. Day 4 (1): New streak starts! current=1, max=25. Day 5 (1): Continue new streak! current=2, max=26. Day 6 (1): New record! current=3, max=3 🏆Longest Running Streak: 3 Days

Understanding the Visualization

Track Current Streak

Keep count of consecutive running days (1's)

Reset on Rest Day

When you don't run (0), reset current streak to 0

Remember Best Streak

Always remember your longest streak so far

Continue Until End

Process the entire log to find the absolute maximum

Key Takeaway

🎯 Key Insight: We only need to track two numbers - our current streak and our best streak ever. When we hit a 0, we reset the current streak but keep our record!

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a single pass through the array with O(n) time and O(1) space. We maintain two variables: currentCount for the current streak and maxCount for the maximum seen so far. When we see a 1, we increment the current count; when we see a 0, we reset it to 0.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to find the longest sequence of consecutive 1's
Single Pass Optimal Solution	O(n)	O(1)	Track current streak and maximum in one pass through the array

Brute Force (Check All Subarrays) — Algorithm Steps

For each index i from 0 to n-1, treat it as a potential start of a consecutive sequence
From position i, count consecutive 1's until we hit a 0 or reach the end
Keep track of the maximum count found so far
Return the maximum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin checking from the first position

Count consecutive 1's

Extend as far as possible counting 1's

Move to next position

Try the next starting position

Track maximum

Keep the longest sequence found

Code -

solution.c — C

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

int findMaxConsecutiveOnes(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() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", findMaxConsecutiveOnes(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we might scan up to n elements to count consecutive 1's

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and maximum

✓ Linear Space

42.4K Views

Medium Frequency

~8 min Avg. Time

1.8K 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