README.md

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

Solutions (Ruby)

1. Solution

# @param {Integer[]} nums
# @return {Integer}
def longest_subarray(nums)
  zeros = 0
  l = 0
  ret = 0

  (0...nums.size).each do |r|
    zeros += 1 if nums[r] == 0
    while zeros > 1
      zeros -= 1 if nums[l] == 0
      l += 1
    end
    ret = [ret, r - l - zeros + 1].max
  end

  [ret, nums.size - 1].min
end

Solutions (Rust)

1. Solution

impl Solution {
    pub fn longest_subarray(nums: Vec<i32>) -> i32 {
        let mut zeros = 0;
        let mut l = 0;
        let mut ret = 0;

        for r in 0..nums.len() {
            if nums[r] == 0 {
                zeros += 1;
            }
            while zeros > 1 {
                if nums[l] == 0 {
                    zeros -= 1;
                }
                l += 1;
            }
            ret = ret.max(r - l - zeros + 1)
        }

        ret.min(nums.len() - 1) as i32
    }
}