LeetCode 485: Max Consecutive Ones Solution in Python – A Step-by-Step Guide

What Is LeetCode 485: Max Consecutive Ones?

In LeetCode 485: Max Consecutive Ones, you’re given a binary array nums containing only 0s and 1s, and your task is to find the maximum number of consecutive 1s in the array. For example, with nums = [1, 1, 0, 1, 1, 1], the longest streak is 3 (the last three 1s), and with nums = [1, 0, 1, 1, 0, 1], it’s 2. It’s like counting the longest unbroken chain of treasures in a binary landscape, where 0s interrupt the flow.

Problem Statement

• Input: nums (List[int])—binary array of 0s and 1s.
• Output: int—maximum number of consecutive 1s.
• Rules:
• Count only consecutive 1s (0s break the streak).
• Return the longest such streak.
• Array contains only 0s and 1s.

Constraints

• \( 1 \leq nums.length \leq 10^5 \).
• \( nums[i] \) is either 0 or 1.

Examples to Get Us Started

• Input: nums = [1,1,0,1,1,1]
• Output: 3 (Longest streak: last three 1s).
• Input: nums = [1,0,1,1,0,1]
• Output: 2 (Longest streak: "11" at indices 2-3).
• Input: nums = [0]
• Output: 0 (No 1s).

Understanding the Problem: Finding the Streak

To solve LeetCode 485: Max Consecutive Ones in Python, we need to traverse the binary array nums and find the longest sequence of consecutive 1s, where a 0 resets the count. A naive approach—checking every possible subsequence—could be O(n²), overkill for a simple task. The key? Use a single pass to track the current streak and update the maximum as we go, making it O(n). We’ll explore:

• Best Solution (Single-Pass Counting): O(n) time, O(1) space—fast and optimal.
• Alternative Solution (Sliding Window Approach): O(n) time, O(1) space—intuitive but slightly more structured.

Let’s dive into the single-pass solution—it’s the treasure hunter’s quick scan we need.

Best Solution: Single-Pass Counting

Why This Is the Best Solution

The single-pass counting approach is the top pick because it’s O(n) time (n = array length) and O(1) space, efficiently finding the maximum consecutive 1s by scanning the array once, keeping a running count of 1s and updating the maximum when a 0 breaks the streak. It’s simple, requiring no extra data structures, making it both fast and memory-light. It’s like walking the treasure map with a counter, marking the longest gold streak as you go—straightforward and brilliant!

How It Works

Here’s the strategy:

• Step 1: Initialize two variables:
• curr_count = current streak of 1s.
• max_count = maximum streak found.
• Step 2: Iterate through nums:
• If 1, increment curr_count.
• If 0, update max_count with max(max_count, curr_count), reset curr_count to 0.
• Step 3: After loop, update max_count one last time (for trailing 1s).
• Step 4: Return max_count.
• Why It Works:
• Single pass tracks streaks in real-time.
• Final check ensures no streak is missed at the end.

Step-by-Step Example

Example: nums = [1,1,0,1,1,1]

• Init: curr_count = 0, max_count = 0.
• i=0: 1, curr_count = 1.
• i=1: 1, curr_count = 2.
• i=2: 0, max_count = max(0, 2) = 2, curr_count = 0.
• i=3: 1, curr_count = 1.
• i=4: 1, curr_count = 2.
• i=5: 1, curr_count = 3.
• End: max_count = max(2, 3) = 3.
• Result: 3.

Example: nums = [1,0,1,1,0]

• Init: curr_count = 0, max_count = 0.
• i=0: 1, curr_count = 1.
• i=1: 0, max_count = 1, curr_count = 0.
• i=2: 1, curr_count = 1.
• i=3: 1, curr_count = 2.
• i=4: 0, max_count = 2, curr_count = 0.
• End: max_count = 2.
• Result: 2.

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down clearly:

Copy codeclass Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        # Step 1: Initialize counters
        curr_count = 0
        max_count = 0

        # Step 2: Iterate through array
        for num in nums:
            if num == 1:
                # Increment current streak
                curr_count += 1
            else:
                # Update max and reset current
                max_count = max(max_count, curr_count)
                curr_count = 0

        # Step 3: Final update for trailing 1s
        max_count = max(max_count, curr_count)

        # Step 4: Return result
        return max_count

• Line 4-5: Init curr_count (current streak) and max_count (max streak).
• Line 8-14: Single pass:
• If 1, increment curr_count.
• If 0, update max_count, reset curr_count.
• Line 17: Final max check for end streak.
• Line 20: Return max_count.
• Time Complexity: O(n)—single pass through array.
• Space Complexity: O(1)—two variables.

It’s like a gold-streak counter!

Alternative Solution: Sliding Window Approach

Why an Alternative Approach?

The sliding window approach—O(n) time, O(1) space—uses two pointers to define windows of consecutive 1s, sliding and resizing as it encounters 0s, tracking the max window size. It’s slightly more structured but equally efficient, like panning across the map with a fixed spotlight. Good for learning window techniques or variety!

How It Works

• Step 1: Initialize left pointer and max length.
• Step 2: Iterate with right pointer:
• Expand window while 1s continue.
• Update max length.
• Reset left to right + 1 when 0 hit.
• Step 3: Return max length.

Step-by-Step Example

Example: nums = [1,1,0,1,1,1]

• Init: left = 0, max_len = 0.
• right=0: 1, window = [1], len = 1.
• right=1: 1, window = [1,1], len = 2.
• right=2: 0, max_len = 2, left = 3.
• right=3: 1, window = [1], len = 1.
• right=4: 1, window = [1,1], len = 2.
• right=5: 1, window = [1,1,1], len = 3, max_len = 3.
• Result: 3.

Code for Sliding Window

Copy codeclass Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        # Step 1: Initialize pointers and max
        left = 0
        max_len = 0

        # Step 2: Slide window
        for right in range(len(nums)):
            if nums[right] == 0:
                # Update max and reset window
                max_len = max(max_len, right - left)
                left = right + 1

        # Final check for trailing 1s
        max_len = max(max_len, len(nums) - left)

        # Step 3: Return result
        return max_len

• Line 4-5: Init left pointer and max length.
• Line 8-12: Slide right:
• If 0, update max_len, move left past 0.
• Line 15: Final max check for end streak.
• Line 18: Return max_len.
• Time Complexity: O(n)—single pass.
• Space Complexity: O(1)—two variables.

It’s a window-panning seeker!

Comparing the Two Solutions

• Single-Pass Counting (Best):
• Pros: O(n), simplest, no pointers.
• Cons: None significant.
• Sliding Window (Alternative):
• Pros: O(n), teaches window concept.
• Cons: Slightly more complex.

Single-pass wins for simplicity.

Edge Cases and Examples

• Input: [0] → 0.
• Input: [1] → 1.
• Input: [0,0,0] → 0.

Single-pass handles all perfectly.

Complexity Recap

• Single-Pass: Time O(n), Space O(1).
• Sliding Window: Time O(n), Space O(1).

Single-pass is the champ for clarity.

Key Takeaways

• Single-Pass: Count on the fly.
• Sliding Window: Slide and measure.
• Python Tip: Simplicity wins—see [Python Basics](/python/basics).

Final Thoughts: Unearth That Streak

LeetCode 485: Max Consecutive Ones in Python is a treasure-hunting array quest. Single-pass counting is your quick scan, while sliding window is a steady pan. Want more array adventures? Try LeetCode 487: Max Consecutive Ones II or LeetCode 53: Maximum Subarray. Ready to count some ones? Head to Solve LeetCode 485 on LeetCode and dig it today—your coding skills are gold-ready!