1004. Max Consecutive Ones III

Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
Output: 6
Explanation: [1,1,1,0,0,1,1,1,1,1,1]
Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.

Input: nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
Output: 10
Explanation: [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var longestOnes = function (nums, k) {
  let maxlen = 0;
  let lptr = 0;
  for (let rptr = 0; rptr < nums.length; rptr++) {
    if (nums[rptr] === 0) {
      k--;
    }
 
    if (k < 0) {
      if (nums[lptr] === 0) {
        k++;
      }
      lptr++;
    }
    maxlen = Math.max(maxlen, rptr - lptr + 1);
  }
  return maxlen;
};

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var longestOnes = function (nums, k) {
  let left = 0;
  let maxLength = 0;
  let zeroCount = 0;
 
  for (let right = 0; right < nums.length; right++) {
    // If we encounter a '0', increase the zero count
    if (nums[right] === 0) {
      zeroCount++;
    }
 
    // If there are more than k zeros, shrink the window from the left
    while (zeroCount > k) {
      if (nums[left] === 0) {
        zeroCount--;
      }
      left++;
    }
 
    // Calculate the maximum length of the window
    maxLength = Math.max(maxLength, right - left + 1);
  }
 
  return maxLength;
};

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var longestOnes = function (nums, k) {
  let left = 0;
  let max = 0;
 
  for (let right = 0; right < nums.length; right++) {
    if (nums[right] === 0) {
      k--;
    }
 
    while (k < 0) {
      if (nums[left] === 0) {
        k++;
      }
      left++;
    }
    max = Math.max(max, right - left + 1);
  }
 
  return max;
};

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var longestOnes = function (nums, k) {
  let end = 0;
  let start = 0;
  let max = 0;
  let zero = 0;
  while (end < nums.length) {
    nums[end] === 0 && zero++;
    while (zero > k) {
      if (nums[start] === 0) zero--;
      start++;
    }
    max = Math.max(end - start + 1, max);
    end++;
  }
  return max;
};

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var longestOnes = function (nums, k) {
  let start = 0;
  let ans = 0,
    count = 0;
 
  for (let i = 0; i < nums.length; i++) {
    if (!nums[i]) count++;
 
    if (count > k) {
      if (!nums[start]) count--;
      start++;
    }
    ans = Math.max(ans, i - start + 1);
  }
  return ans;
};