Add: 27. Remove Element

Author: andresmunozit

27-remove-element/README.md

@@ -0,0 +1,76 @@
+# 27. Remove Element
+
+## Description
+
+Given an integer array `nums` and an integer `val`, remove all occurrences of `val` **in-place**. The order of the elements may be changed. Then return **the number of elements in `nums` which are not equal to `val`**.
+
+Consider the number of elements in `nums` which are not equal to `val` to be `k`, to get accepted, you need to do the following things:
+
+- Change the array `nums` such that the first `k` elements of `nums` contain the elements which are not equal to `val`. The remaining elements of `nums` are not important as well as the size of `nums`.
+- Return `k`.
+
+---
+
+## Custom Judge:
+
+The judge will test your solution with the following code:
+
+```
+int[] nums = [...]; // Input array
+int val = ...; // Value to remove
+int[] expectedNums = [...]; // The expected answer with correct length.
+// It is sorted with no values equaling val.
+
+int k = removeElement(nums, val); // Calls your implementation
+
+assert k == expectedNums.length;
+sort(nums, 0, k); // Sort the first k elements of nums
+for (int i = 0; i < actualLength; i++) {
+    assert nums[i] == expectedNums[i];
+}
+```
+
+If all assertions pass, then your solution will be accepted.
+
+---
+
+## Examples
+
+### Example 1:
+
+**Input:**
+```
+nums = [3,2,2,3], val = 3
+```
+**Output:**
+```
+2, nums = [2,2,_ ,_]
+```
+**Explanation:**
+Your function should return `k = 2`, with the first two elements of `nums` being `2`.  
+It does not matter what you leave beyond the returned `k` (hence they are underscores).
+
+---
+
+### Example 2:
+
+**Input:**
+```
+nums = [0,1,2,2,3,0,4,2], val = 2
+```
+**Output:**
+```
+5, nums = [0,1,4,0,3,_ ,_ ,_]
+```
+**Explanation:**
+Your function should return `k = 5`, with the first five elements of `nums` containing `0, 0, 1, 3, and 4`.  
+Note that the five elements can be returned in **any order**.  
+It does not matter what you leave beyond the returned `k` (hence they are underscores).
+
+---
+
+## Constraints
+
+- `0 <= nums.length <= 100`
+- `0 <= nums[i] <= 50`
+- `0 <= val <= 100`

27-remove-element/index.js

@@ -0,0 +1,39 @@
+const assert = require('assert');
+
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+var removeElement = function (nums, val) {
+  // Two-pointer approach: one pointer (w) writes, the other (r) reads.
+  // The writer pointer (w) tracks the new valid array length.
+  let w = 0;
+  let r = 0;
+
+  // Iterate through the array using the reader pointer (r).
+  while (r < nums.length) {
+    if (nums[r] === val) {
+      // If the current element is the target value, skip it.
+      r++;
+    } else {
+      // Copy the element to the writer's position and move both pointers.
+      // The writer pointer (w) only moves when we write a non-target value.
+      nums[w++] = nums[r++];
+    }
+  }
+
+  // The final value of 'w' is the number of elements that are not 'val'.
+  return w;
+};
+
+// Example usage
+
+/*
+  Time Complexity: O(n)
+  - We traverse the array once with the reader pointer (r), so the time complexity is O(n).
+
+  Space Complexity: O(1)
+  - We modify the input array in-place without using extra space.
+  - Only a few integer variables are used (constant space).
+*/