LeetCode 27: Remove Element Solution in Python Explained

Problem Statement

LeetCode 27, Remove Element, is an easy-level problem where you’re given an array of integers nums and an integer val. Your task is to remove all occurrences of val from the array in-place and return the length of the new array containing only elements not equal to val. The order of elements can change, and the elements beyond the new length don’t matter. You must modify the array in-place without using extra space.

Constraints

0 <= nums.length <= 100: Array length ranges from 0 to 100.
0 <= nums[i] <= 50: Each element is between 0 and 50.
0 <= val <= 100: The value to remove is between 0 and 100.

Example

Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2,_,_]
Explanation: Remove 3s, length = 2. "_" can be any value.

Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,3,0,4,_,_,_]
Explanation: Remove 2s, length = 5.

Input: nums = [], val = 1
Output: 0, nums = []
Explanation: Empty array returns length 0.

Understanding the Problem

How do you solve LeetCode 27: Remove Element in Python? Given an array like [3,2,2,3] and val = 3, you need to modify it in-place to [2,2,_,_] and return 2, the count of elements not equal to 3. Unlike LeetCode 26, the array isn’t sorted, and we’re targeting a specific value, not duplicates. We’ll explore two approaches: a Two-Pointer Iterative Solution (optimal and primary) and an Alternative with Swap (for variety and intuition). Both work in-place, leveraging pointer techniques.

Solution 1: Two-Pointer Iterative Approach (Primary)

Explanation

Use one pointer (k) to track the position for the next non-val element and another (i) to scan the array. If nums[i] isn’t val, place it at nums[k] and increment k. This keeps all non-val elements at the front.

Here’s a visual for [3,2,2,3], val = 3:

Initial: [3,2,2,3], k = 0, i = 0
Step 1: [3,2,2,3], k = 0, i = 1 (skip 3)
Step 2: [2,2,2,3], k = 1, i = 2 (place 2)
Step 3: [2,2,2,3], k = 2, i = 3 (place 2)
Final: [2,2,2,3], return k = 2

Handle Edge Case.

If array is empty, return 0.

Initialize Pointers.

k = 0: Position for next non-val element.
i = 0: Scanner starting from the beginning.

Scan and Place Non-val Elements.

If nums[i] != val, copy it to nums[k] and increment k.

Return Length.

Return k, the count of elements not equal to val.

Step-by-Step Example

Example 1: nums = [0,1,2,2,3,0,4,2], val = 2

We need length 5, nums = [0,1,3,0,4,,,_].

Goal: Remove all 2s, keep others in any order.
Result for Reference: Length = 5, nums = [0,1,3,0,4,...].
Start: nums = [0,1,2,2,3,0,4,2], k = 0, i = 0.
Step 1: Check edge case.

Array not empty, proceed.

Step 2: i = 0, nums[0] = 0, val = 2.

0 ≠ 2, nums[0] = 0, k = 1, i = 1.

Step 3: i = 1, nums[1] = 1.

1 ≠ 2, nums[1] = 1, k = 2, i = 2.
nums = [0,1,2,2,3,0,4,2].

Step 4: i = 2, nums[2] = 2.

2 = 2, skip, i = 3.

Step 5: i = 3, nums[3] = 2.

2 = 2, skip, i = 4.

Step 6: i = 4, nums[4] = 3.

3 ≠ 2, nums[2] = 3, k = 3, i = 5.
nums = [0,1,3,2,3,0,4,2].

Step 7: i = 5, nums[5] = 0.

0 ≠ 2, nums[3] = 0, k = 4, i = 6.
nums = [0,1,3,0,3,0,4,2].

Step 8: i = 6, nums[6] = 4.

4 ≠ 2, nums[4] = 4, k = 5, i = 7.
nums = [0,1,3,0,4,0,4,2].

Step 9: i = 7, nums[7] = 2.

2 = 2, skip, i = 8.

Step 10: i = 8, out of bounds, stop.
Finish: Return k = 5, nums = [0,1,3,0,4,...].

How the Code Works (Two-Pointer)

Here’s the Python code with line-by-line explanation:

def removeElement(nums: list[int], val: int) -> int:
    # Line 1: Check if array is empty
    if not nums:
        # Line 2: Return 0 for empty array
        return 0

    # Line 3: Initialize k for non-val element position
    k = 0
    # Line 4: Scan through array
    for i in range(len(nums)):
        # Line 5: If current element isn’t val
        if nums[i] != val:
            # Line 6: Place it at k
            nums[k] = nums[i]
            # Line 7: Increment k
            k += 1

    # Line 8: Return count of non-val elements
    return k

Alternative: Two-Pointer with Swap Approach

Explanation

Use two pointers: one from the start (left) and one from the end (right). Swap val elements to the end, shrinking the valid portion. This preserves relative order of non-val elements but requires more operations.

Handle Edge Case.

Return 0 if empty.

Set Pointers.

left = 0: Start of array.
right = len(nums) - 1: End of array.

Swap and Move.

If nums[left] = val, swap with nums[right], decrement right.
If not, increment left.

Return Length.

Return count of non-val elements.

Step-by-Step Example (Alternative)

For nums = [3,2,2,3], val = 3:

Goal: Length = 2, nums = [2,2,_,_].
Result for Reference: Length = 2, nums = [2,2,...].
Start: nums = [3,2,2,3], left = 0, right = 3.
Step 1: left = 0, nums[0] = 3.

3 = 3, swap with nums[3], nums = [3,2,2,3], right = 2.
Still 3, swap with nums[2], nums = [2,2,3,3], right = 1, left = 1.

Step 2: left = 1, nums[1] = 2.

2 ≠ 3, left = 2.

Step 3: left = 2, nums[2] = 3.

3 = 3, swap with nums[1], nums = [2,3,2,3], right = 0.
left > right, stop.

Step 4: Count non-val up to right + 1, return 2.
Finish: nums = [2,2,3,3], return 2.

How the Code Works (Swap)

def removeElementSwap(nums: list[int], val: int) -> int:
    # Line 1: Check empty array
    if not nums:
        return 0

    # Line 2: Set pointers
    left = 0
    right = len(nums) - 1

    # Line 3: Process until pointers meet
    while left <= right:
        # Line 4: If left points to val
        if nums[left] == val:
            # Line 5: Swap with right
            nums[left], nums[right] = nums[right], nums[left]
            # Line 6: Shrink right
            right -= 1
        else:
            # Line 7: Move left forward
            left += 1

    # Line 8: Return new length
    return right + 1

Complexity

Two-Pointer Iterative:

Time: O(n) – Single pass.
Space: O(1) – In-place.

Swap Approach:

Time: O(n) – Single pass with swaps.
Space: O(1) – In-place.

Efficiency Notes

Both are O(n) time and O(1) space, but the iterative approach is simpler and faster due to fewer operations (no swaps). The swap method preserves relative order, which isn’t required but may be useful in specific contexts.

Key Insights

Tips to master LeetCode 27:

Order Doesn’t Matter: Focus on moving non-val elements forward.
Two Pointers Rule: One for placement, one for scanning—efficiency is key.
In-Place is King: No extra arrays—master array manipulation!

Additional Example

For nums = [1,2,3,2,4], val = 2:

Goal: Length = 3, nums = [1,3,4,_,_].
Iterative: k = 0, place 1, 3, 4, return 3.
Result: [1,3,4,2,4], length = 3.

Edge Cases

Empty Array: [] – Return 0.
No Matches: [1,2,3], val = 4 – Return 3.
All Matches: [2,2,2], val = 2 – Return 0.

Final Thoughts

The Two-Pointer Iterative solution is ideal for LeetCode 27 in Python—straightforward and efficient. Next, try LeetCode 26: Remove Duplicates from Sorted Array for a related challenge! Experiment with different val values to build confidence.