Remove Element Solution - Leetcode

Understand Remove Element (27 Leetcode) with Solution

12 October 2025

This document presents the solution to the problem 27 - Remove Element - Leetcode.

		
				
You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.

Merge nums1 and nums2 into a single array sorted in non-decreasing order.

The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.

 

Example 1:

Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.

Example 2:

Input: nums1 = [1], m = 1, nums2 = [], n = 0
Output: [1]
Explanation: The arrays we are merging are [1] and [].
The result of the merge is [1].

Example 3:

Input: nums1 = [0], m = 0, nums2 = [1], n = 1
Output: [1]
Explanation: The arrays we are merging are [] and [1].
The result of the merge is [1].
Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.

The provided value, val, needs to be removed from the array. We can’t remove the elements matching val because it requires filling up the spaces created after removal.

Instead, we can swap the val with another element with value not equal to val. This will put all the val values to the right of the array and the left side of the array will contains all the non val values.

Approach:

Create two pointers, i and j
i point to the 0th element of the array.
j points to the last element of the array.
Using i, we keep on traversing to right.
If arr[i] matches val then swap arr[i] with arr[j].
- If arr[j] already contains val then keep on moving j to left until arr[j] does not contain val.
- Swap arr[i] with arr[j].

Iterations: nums: [3, 2, 2, 3] and val: 3

1st Iteration:

We find i pointing to 3.
j is updated to point to new index that does not contain 3.
nums[i] and nums[j] are swapped.
i increments to next index.

2nd Iteration:

No changes are made as nums[i] is 2, not equal to 3
i increments.

3rd Iteration:

i and j point to the same index.
j is updated to point to new index that does not contain 3.
j now points to index 1 and satisfies i >= j.
We break out of the loop returning i.
At this point i equals the count of elements != 3.

Exit Conditions

When i is less than j. This means array is partitioned, i.e., all the elements from i until the end only contain val.

Edge Cases

If all the elmement in the array contain val.
- [3, 3, 3, 3].
- In this case, j cannot point to any element, exit with 0.
All elements except the first one are val.
- [2, 3, 3, 3]
- This represent the exit condition too. i equals j. Return.

Please do provide some comments if you find the explanation a bit lacking.

func removeElement(nums []int, val int) int {
	i := 0
	j := len(nums) - 1
	for {
		if i > len(nums)-1 {
			return i
		}
		if nums[i] != val {
			i++
			continue
		}

		// make sure `j` point to a value not equal to `val`
		for {
			if i >= j {
				break
			}
			if nums[j] == val {
				j--
			} else {
				break
			}
			if j < 0 {
				break
			}
		}

		if i >= j {
			return i
		}

		if j < 0 {
			return i
		}

		temp := nums[i]
		nums[i] = nums[j]
		nums[j] = temp

		i++
	}
}

Loading Comments... Disqus Loader