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

Given a binary array nums, you should delete one element from it.

Return the size of the longest non-empty subarray containing only 1's in the resulting array. Return 0 if there is no such subarray.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: After deleting the element at index 2, we get [1,1,1] which has the longest subarray of 1's with length 3.

Example 2 — All Ones

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

› Output: 5

💡 Note: After deleting the element at index 4, we get [0,1,1,1,1,1,0,1] and the longest subarray of 1's is [1,1,1,1,1] with length 5.

Example 3 — All Zeros

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

› Output: 2

💡 Note: We must delete one element, so after deleting any element we get [1,1] with length 2.

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 45 a Amazon 38 G Google 32 M Microsoft 28

The key insight is to find the longest subarray with at most one 0, then subtract 1 for the required deletion. The optimal sliding window approach maintains a window with at most one zero and tracks the maximum size. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

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

For each position, simulate removing that element and find the longest contiguous subarray of 1's in the remaining array. This requires checking all possible deletions.

Sliding Window

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

Maintain a sliding window that contains at most one 0. When we encounter a second 0, shrink the window from the left. The answer is the maximum window size minus 1 (for the required deletion).

Two Pass DP

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

First pass calculates how many consecutive 1's end at each position. Second pass calculates how many consecutive 1's start at each position. For each deletion point, combine left and right lengths.

Brute Force — Algorithm Steps

Iterate through each index to delete
For each deletion, find longest subarray of 1's
Keep track of maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Delete Index 0

Remove first element, scan remaining

Try Delete Index 1

Remove second element, scan remaining

Find Maximum

Return best result found

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Try deleting each element
    for (int skip = 0; skip < numsSize; skip++) {
        int currentLength = 0;
        int bestLength = 0;
        
        // Check array without element at index 'skip'
        for (int i = 0; i < numsSize; i++) {
            if (i == skip) continue;
            
            if (nums[i] == 1) {
                currentLength++;
                bestLength = max(bestLength, currentLength);
            } else {
                currentLength = 0;
            }
        }
        
        maxLength = max(maxLength, bestLength);
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n positions, we scan the array twice (O(n²)) to find longest subarray

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

78.0K Views

High Frequency

~15 min Avg. Time

2.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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler