Longest Subarray of 1's After Deleting One Element

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.

Example 1:

Input: nums = [1,1,0,1]
Output: 3
Explanation: After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.

Example 2:

Input: nums = [0,1,1,1,0,1,1,0,1]
Output: 5
Explanation: After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].

Example 3:

Input: nums = [1,1,1]
Output: 2
Explanation: You must delete one element.

Example 4:

Input: nums = [1,1,0,0,1,1,1,0,1]
Output: 4

Example 5:

Input: nums = [0,0,0]
Output: 0

Constraints:

• 1 <= nums.length <= 10^5

• nums[i] is either 0 or 1.

class Solution {
    public int longestSubarray(int[] nums) {
        boolean allOnes = true;
        for (int x : nums)
            if (x == 0) {
                allOnes = false;
                break;
            }
        if (allOnes)
            return nums.length - 1;
        int max = 0;
        int start = 0, end = 0;
        boolean deleted = false;
        while (end < nums.length) {
            if (nums[end] == 0) {
                if (deleted) {
                    while (nums[start] != 0)
                        start++;
                    start++;
                } else
                    deleted = true;
            }
            if (deleted)
                max = Math.max(max, end - start);
            else
                max = Math.max(max, end - start + 1);
            end++;
        }
        return max;
    }
}