Max Consecutive Ones in Array

Problem Statement❯

You are given a binary array that consists only of 0s and 1s. Your task is to find the maximum number of consecutive 1s that appear in the array.

In simpler terms, you need to count the longest stretch of 1s that are placed next to each other (without any 0s in between).

If the array is empty, the result should be 0.

Examples❯

Input Array	Max Consecutive 1s	Description
[1, 1, 0, 1, 1, 1]	3	The longest sequence of 1s is [1, 1, 1]Visualization
[1, 1, 1, 1]	4	All elements are 1s, so the count is the length of the arrayVisualization
[0, 0, 0]	0	No 1s in the arrayVisualization
[1, 0, 1, 0, 1]	1	All 1s are isolated by 0sVisualization
[0, 1, 1, 0, 1, 1, 1, 0]	3	There are two sequences: [1, 1] and [1, 1, 1]; the longest is length 3Visualization
[1]	1	Single element that is 1Visualization
[0]	0	Single element that is 0Visualization
[]	0	Empty array should return 0Visualization

Solution❯

Understanding the Problem

We are given a binary array — an array consisting only of 1s and 0s. The goal is to find the length of the longest contiguous sequence of 1s.

That means we want to count how many 1s appear in a row without being interrupted by a 0. As soon as we hit a 0, the streak is broken, and we start counting again.

Step-by-Step Approach (with Example)

Let’s take the example array: [1, 1, 0, 1, 1, 1]

Step 1: Initialize two counters

current_count: to keep track of the current streak of 1s.
max_count: to remember the highest streak we've seen so far.

Step 2: Loop through the array

Start from the first element and go to the end.
If the element is 1: increment current_count.
If the element is 0: reset current_count to 0.
At each step, update max_count to be the maximum of itself and current_count.

Step 3: Final Result

After the loop, max_count will hold the longest stretch of 1s.

Detailed Walkthrough for [1, 1, 0, 1, 1, 1]

Start: current_count = 0, max_count = 0
Index 0: 1 → current_count = 1, max_count = 1
Index 1: 1 → current_count = 2, max_count = 2
Index 2: 0 → current_count = 0, max_count = 2
Index 3: 1 → current_count = 1, max_count = 2
Index 4: 1 → current_count = 2, max_count = 2
Index 5: 1 → current_count = 3, max_count = 3

Final answer: 3

Incorporating Edge Cases

1. All 1s: `[1, 1, 1, 1]`

The entire array is one continuous sequence of 1s → Output: 4

2. All 0s: `[0, 0, 0]`

No 1s present at all → Output: 0

3. Isolated 1s: `[1, 0, 1, 0, 1]`

Each 1 is surrounded by 0s → Maximum streak = 1

4. Empty Array: `[]`

No elements means no 1s → Output: 0

Efficiency

This approach uses only one pass through the array (O(n) time complexity) and does not use any extra space. It’s optimal and beginner-friendly.

Algorithm Steps❯

Given an array arr that contains only 0 and 1.
Initialize two counters: max_count = 0 and current_count = 0.
Iterate through the array:
→ If the current element is 1, increment current_count.
→ If the current element is 0, reset current_count to 0.
After each step, update max_count if current_count is greater.
After the loop, return max_count.

Code

C++

Python

Java

Rust

Kotlin

Swift

#include <stdio.h>

int maxConsecutiveOnes(int arr[], int n) {
    int maxCount = 0, currentCount = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] == 1) {
            currentCount++;
            if (currentCount > maxCount)
                maxCount = currentCount;
        } else {
            currentCount = 0;
        }
    }
    return maxCount;
}

int main() {
    int arr[] = {1, 1, 0, 1, 1, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Max Consecutive Ones: %d\n", maxConsecutiveOnes(arr, n));
    return 0;
}

Time Complexity❯

Case	Time Complexity	Explanation
Best Case	O(n)	Even if the array starts with a long streak of 1s, we still need to check all elements to ensure it's the longest sequence.
Average Case	O(n)	The algorithm goes through each element of the array once in a single pass, updating counters as needed.
Worst Case	O(n)	In the worst case, such as alternating 1s and 0s, every element must still be processed to determine the maximum streak.

Space Complexity❯

O(1)

Explanation: The algorithm uses only two variables to keep track of the current and maximum count. No additional space is required.

Problem Statement❯

You are given a binary array that consists only of 0s and 1s. Your task is to find the maximum number of consecutive 1s that appear in the array.

In simpler terms, you need to count the longest stretch of 1s that are placed next to each other (without any 0s in between).

If the array is empty, the result should be 0.

Examples❯

Input Array	Max Consecutive 1s	Description
[1, 1, 0, 1, 1, 1]	3	The longest sequence of 1s is [1, 1, 1]Visualization
[1, 1, 1, 1]	4	All elements are 1s, so the count is the length of the arrayVisualization
[0, 0, 0]	0	No 1s in the arrayVisualization
[1, 0, 1, 0, 1]	1	All 1s are isolated by 0sVisualization
[0, 1, 1, 0, 1, 1, 1, 0]	3	There are two sequences: [1, 1] and [1, 1, 1]; the longest is length 3Visualization
[1]	1	Single element that is 1Visualization
[0]	0	Single element that is 0Visualization
[]	0	Empty array should return 0Visualization

Solution❯

Understanding the Problem

We are given a binary array — an array consisting only of 1s and 0s. The goal is to find the length of the longest contiguous sequence of 1s.

That means we want to count how many 1s appear in a row without being interrupted by a 0. As soon as we hit a 0, the streak is broken, and we start counting again.

Step-by-Step Approach (with Example)

Let’s take the example array: [1, 1, 0, 1, 1, 1]

Step 1: Initialize two counters

current_count: to keep track of the current streak of 1s.
max_count: to remember the highest streak we've seen so far.

Step 2: Loop through the array

Start from the first element and go to the end.
If the element is 1: increment current_count.
If the element is 0: reset current_count to 0.
At each step, update max_count to be the maximum of itself and current_count.

Step 3: Final Result

After the loop, max_count will hold the longest stretch of 1s.

Detailed Walkthrough for [1, 1, 0, 1, 1, 1]

Start: current_count = 0, max_count = 0
Index 0: 1 → current_count = 1, max_count = 1
Index 1: 1 → current_count = 2, max_count = 2
Index 2: 0 → current_count = 0, max_count = 2
Index 3: 1 → current_count = 1, max_count = 2
Index 4: 1 → current_count = 2, max_count = 2
Index 5: 1 → current_count = 3, max_count = 3

Final answer: 3

Incorporating Edge Cases

1. All 1s: `[1, 1, 1, 1]`

The entire array is one continuous sequence of 1s → Output: 4

2. All 0s: `[0, 0, 0]`

No 1s present at all → Output: 0

3. Isolated 1s: `[1, 0, 1, 0, 1]`

Each 1 is surrounded by 0s → Maximum streak = 1

4. Empty Array: `[]`

No elements means no 1s → Output: 0

Efficiency

This approach uses only one pass through the array (O(n) time complexity) and does not use any extra space. It’s optimal and beginner-friendly.

Algorithm Steps❯

Given an array arr that contains only 0 and 1.
Initialize two counters: max_count = 0 and current_count = 0.
Iterate through the array:
→ If the current element is 1, increment current_count.
→ If the current element is 0, reset current_count to 0.
After each step, update max_count if current_count is greater.
After the loop, return max_count.

Code

C++

Python

Java

Rust

Kotlin

Swift

#include <stdio.h>

int maxConsecutiveOnes(int arr[], int n) {
    int maxCount = 0, currentCount = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] == 1) {
            currentCount++;
            if (currentCount > maxCount)
                maxCount = currentCount;
        } else {
            currentCount = 0;
        }
    }
    return maxCount;
}

int main() {
    int arr[] = {1, 1, 0, 1, 1, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Max Consecutive Ones: %d\n", maxConsecutiveOnes(arr, n));
    return 0;
}

Time Complexity❯

Case	Time Complexity	Explanation
Best Case	O(n)	Even if the array starts with a long streak of 1s, we still need to check all elements to ensure it's the longest sequence.
Average Case	O(n)	The algorithm goes through each element of the array once in a single pass, updating counters as needed.
Worst Case	O(n)	In the worst case, such as alternating 1s and 0s, every element must still be processed to determine the maximum streak.

Space Complexity❯

O(1)

Explanation: The algorithm uses only two variables to keep track of the current and maximum count. No additional space is required.

⬅ Previous TopicFind Missing Number in Array

Next Topic ⮕Find Kth Smallest Element

Comments

Loading comments...

Find Maximum Consecutive Ones in Array using Loop - Optimal Algorithm

Contents

Visualization Player

Problem Statement❯

Examples❯

Solution❯

Understanding the Problem

Step-by-Step Approach (with Example)

Step 1: Initialize two counters

Step 2: Loop through the array

Step 3: Final Result

Detailed Walkthrough for [1, 1, 0, 1, 1, 1]

Incorporating Edge Cases

1. All 1s: [1, 1, 1, 1]

2. All 0s: [0, 0, 0]

3. Isolated 1s: [1, 0, 1, 0, 1]

4. Empty Array: []

Efficiency

Algorithm Steps❯

Code

Time Complexity❯

Space Complexity❯

Problem Statement❯

Examples❯

Solution❯

Understanding the Problem

Step-by-Step Approach (with Example)

Step 1: Initialize two counters

Step 2: Loop through the array

Step 3: Final Result

Detailed Walkthrough for [1, 1, 0, 1, 1, 1]

Incorporating Edge Cases

1. All 1s: [1, 1, 1, 1]

2. All 0s: [0, 0, 0]

3. Isolated 1s: [1, 0, 1, 0, 1]

4. Empty Array: []

Efficiency

Algorithm Steps❯

Code

Time Complexity❯

Space Complexity❯

Comments

Welcome to ProgramGuru

Player Settings

1. All 1s: `[1, 1, 1, 1]`

2. All 0s: `[0, 0, 0]`

3. Isolated 1s: `[1, 0, 1, 0, 1]`

4. Empty Array: `[]`

1. All 1s: `[1, 1, 1, 1]`

2. All 0s: `[0, 0, 0]`

3. Isolated 1s: `[1, 0, 1, 0, 1]`

4. Empty Array: `[]`