Add: Exercise 1004. Longest Subarray of 1's After Deleting One Element

Author: BlackBeast593

1004-max-consecutive-ones-iii/README.md

@@ -0,0 +1,25 @@
+# 1004. Max Consecutive Ones III
+Given a binary array `nums` and an integer `k`, return the maximum number of consecutive 1's in the
+array if you can flip at most `k` 0's.
+
+## Examples
+
+### Example 1:
+
+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.
+
+### Example 2:
+
+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.
+
+## Constraints
+
+- 1 <= `nums.length` <= 10^5
+- `nums[i]` is either 0 or 1.
+- 0 <= `k` <= `nums.length`

1004-max-consecutive-ones-iii/index.js

@@ -0,0 +1,43 @@
+/**
+ * Finds the maximum number of consecutive 1s in the array if you can flip at most k 0s.
+ * @param {number[]} nums - Binary array (only contains 0s and 1s).
+ * @param {number} k - The maximum number of 0s that can be flipped to 1s.
+ * @return {number} - The maximum number of consecutive 1s after flipping at most k 0s.
+ */
+var longestOnes = function (nums, k) {
+  let left = 0; // Left pointer for the sliding window
+  let right = 0; // Right pointer for the sliding window
+  let longest = 0; // Track the length of the longest subarray
+  let zerosCount = 0; // Count the number of zeros in the current window
+
+  // Iterate through the array with the right pointer
+  while (right < nums.length) {
+    // Increment zerosCount if current element is 0
+    if (nums[right] === 0) {
+      zerosCount++;
+    }
+
+    // When zerosCount exceeds k, update longest and shrink window from the left
+    if (zerosCount > k) longest = Math.max(longest, right - left);
+    while (zerosCount > k) {
+      // If the left element is 0, decrement zerosCount
+      if (nums[left] === 0) {
+        zerosCount--;
+      }
+      // Move the left pointer to shrink the window
+      left++;
+    }
+
+    // Move the right pointer to expand the window
+    right++;
+  }
+
+  // Update longest for the case where the loop exits without updating longest
+  longest = Math.max(longest, right - left);
+
+  return longest;
+};
+
+var a = longestOnes([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2) // expected 6
+
+module.exports = longestOnes

1004-max-consecutive-ones-iii/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "1004-max-consecutive-ones-iii",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "debug": "node --inspect-brk index.js",
+    "test": "node test.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

1004-max-consecutive-ones-iii/test.js

@@ -0,0 +1,19 @@
+const assert = require('assert')
+const longestOnes = require('./index')
+
+const tests = [
+    {
+        nums: [1,1,1,0,0,0,1,1,1,1,0],
+        k: 2,
+        expectedOutput: 6,
+    },
+    {
+        nums: [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1],
+        k: 3,
+        expectedOutput: 10,
+    },
+]
+
+for (const t of tests) {
+    assert.strict.deepEqual(longestOnes(t.nums, t.k), t.expectedOutput)
+}