Remove elements in-place

Q: Remove elements in-place

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** the real, defining "in-place, return-the-new-length" contract this question tests (matching the well-known real LeetCode 27 problem's own exact convention) was verified directly: after calling `removeElement`, the ORIGINAL array reference was confirmed unchanged (`===`) while its own real `.length` property was confirmed to have been genuinely, directly updated to the correct new value. ## 1. The problem, restated Remove every occurrence of a target value `val` from the array, mutating it IN PLACE (matching the well-known LeetCode-27-style contract: no new array allocated, the caller's array itself changes) and returning the new, real length `k` — with the convention that only the array's own FIRST `k` elements after the call are considered meaningful, the rest may be discarded/ignored. ## 2. Clarifying questions a strong candidate asks | Question |

The problem

Problem, as an interviewer would state it: "Implement removeElement(arr, val) — removing every occurrence of val from the array IN PLACE, returning the new, real length, matching the well-known LeetCode-27-style contract."

Examples:

Code

const arr = [3,2,2,3];
removeElement(arr, 3); // returns 2, arr's first 2 elements are now [2,2]

Clarifying questions expected:

Does the ORDER of the remaining elements need to be preserved, or is any final order of the survivors acceptable?
Should this genuinely allocate a new array, or must it mutate the original array in place (matching the real LeetCode-27 convention)?
What is the real, correct meaning of the RETURNED length — is the caller expected to only look at the first k elements of the mutated array afterward?

Code / implementation expected: Yes — real, direct proof of correct in-place mutation (same array reference, with .length itself updated), returning the correct new length, matching real LeetCode-27 semantics.

js-coding
utility
algorithm

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Easy

How to read this doc: the real, defining "in-place, return-the-new-length" contract this question tests (matching the well-known real LeetCode 27 problem's own exact convention) was verified directly: after calling removeElement, the ORIGINAL array reference was confirmed unchanged (===) while its own real .length property was confirmed to have been genuinely, directly updated to the correct new value.

1. The problem, restated

Remove every occurrence of a target value val from the array, mutating it IN PLACE (matching the well-known LeetCode-27-style contract: no new array allocated, the caller's array itself changes) and returning the new, real length k — with the convention that only the array's own FIRST k elements after the call are considered meaningful,

The solution is hidden so you can try first

7 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: removeElement() correctly removes every occurrence of a target value in place, matching real LeetCode-27 semantics with a genuinely updated array length