Longest Subarray of 1's After Deleting One Element

Longest Subarray of 1's After Deleting One Element - Problem

Given a binary array nums containing only 0s and 1s, you must delete exactly one element from it.

Your task is to return the maximum length of the longest contiguous subarray containing only 1s after deleting one element. If no such subarray exists, return 0.

Key Points:

You must delete exactly one element (cannot skip deletion)
The resulting subarray must contain only 1s
Return the length of the longest such subarray

Example: In array [1,1,0,1], if we delete the 0 at index 2, we get [1,1,1] with length 3.

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: After deleting the 0 at index 2, we get [1,1,1] which has length 3.

example_2.py — Multiple zeros

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

› Output: 5

💡 Note: We can delete one of the zeros to connect sequences. Deleting the 0 at index 4 gives us a subarray [1,1,1,1,1] of length 5.

example_3.py — All ones

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

› Output: 3

💡 Note: Since we must delete exactly one element, we delete any 1 and get length 3.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
You must delete exactly one element

Visualization

Tap to expand

Understanding the Visualization

Start measurement

Place the measuring tape at the beginning of the necklace

Expand the tape

Stretch the tape to include more pearls, counting any black beads

Adjust when needed

If the tape spans more than one black bead, shrink it from the left

Record maximum

Track the longest stretch that spans at most one black bead

Key Takeaway

🎯 Key Insight: By maintaining a sliding window with at most one zero, we efficiently find the longest possible subarray of 1s after mandatory deletion - the window size minus one gives us our answer!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a sliding window approach to maintain a window containing at most one zero. The key insight is that any such window represents a potential result where we can delete the single zero (or any element if no zeros) to create the longest possible subarray of 1s. This achieves O(n) time complexity with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Deletions)	O(n²)	O(1)	Try deleting each element and find the longest subarray of 1s
Sliding Window (Two Pointers)	O(n)	O(1)	Use sliding window technique allowing at most one zero in the window

Brute Force (Try All Deletions) — Algorithm Steps

Iterate through each index i from 0 to n-1
For each i, simulate deleting element at index i
In the resulting array, find the longest contiguous subarray of 1s
Keep track of the maximum length found
Return the maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Try deleting index 0

Skip first element, scan remaining array for longest 1s sequence

Try deleting index 1

Skip second element, scan remaining array for longest 1s sequence

Continue for all indices

Repeat process for each possible deletion position

Return maximum

Return the maximum length found across all deletions

Code -

solution.c — C

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

int findLengthOfShortestSubarray(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Try deleting each element
    for (int skip = 0; skip < numsSize; skip++) {
        int currentLength = 0;
        int longestInThisDeletion = 0;
        
        // Count longest sequence of 1s after skipping element at 'skip'
        for (int i = 0; i < numsSize; i++) {
            if (i == skip) continue;
            
            if (nums[i] == 1) {
                currentLength++;
                if (longestInThisDeletion < currentLength) {
                    longestInThisDeletion = currentLength;
                }
            } else {
                currentLength = 0;
            }
        }
        
        if (maxLength < longestInThisDeletion) {
            maxLength = longestInThisDeletion;
        }
    }
    
    return maxLength;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    // Parse input
    scanf("%c", &c); // skip '['
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c); // comma or ']'
        if (c == ']') break;
    }
    
    printf("%d\n", findLengthOfShortestSubarray(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan the remaining n-1 elements to find longest sequence

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking maximum length and current sequence length

✓ Linear Space

52.3K Views

Medium-High Frequency

~15 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 (Try All Deletions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler