LeetCode 26: Remove Duplicates from Sorted Array Solution in Python Explained

Problem Statement

LeetCode 26, Remove Duplicates from Sorted Array, is an easy-level problem where you’re given a sorted array of integers nums. Your task is to remove duplicates in-place and return the length of the new array containing only unique elements. The array is sorted in ascending order, and you must modify it such that all duplicates are excluded from the first k elements, where k is the number of unique elements. The elements beyond the first k positions don’t matter.

Constraints

0 <= nums.length <= 3 * 10^4: Array length ranges from 0 to 30,000.
-100 <= nums[i] <= 100: Each element is between -100 and 100.
Array is sorted in ascending order.

Example

Input: nums = [1,1,2]
Output: 2, nums = [1,2,_]
Explanation: Unique elements are [1,2], length = 2. "_" can be any value.

Input: nums = [0,0,1,1,1,2,2,3,3,4]
Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]
Explanation: Unique elements are [0,1,2,3,4], length = 5.

Input: nums = []
Output: 0, nums = []
Explanation: Empty array has length 0.

Understanding the Problem

How do you solve LeetCode 26: Remove Duplicates from Sorted Array in Python? Given a sorted array like [1,1,2], you need to modify it in-place to [1,2,_] and return 2, the count of unique elements. Since the array is sorted, duplicates are adjacent, making it easier to identify and skip them. We’ll explore two approaches: a Two-Pointer Iterative Solution (optimal and primary) and an In-Place Modification with Comparison (alternative for understanding). Both operate in-place, leveraging the sorted nature of the array.

Solution 1: Two-Pointer Iterative Approach (Primary)

Explanation

Use two pointers: one to track the position for the next unique element (k) and another to scan the array (i). Since the array is sorted, compare adjacent elements—if they differ, place the new unique element at k and increment k.

Here’s a visual for [0,0,1,1,2]:

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

Handle Edge Case.

If array is empty, return 0.

Initialize Pointers.

k = 1: Position for next unique element (start after first element).
i = 1: Scanner starting from second element.

Scan and Place Unique Elements.

Compare nums[i] with nums[i-1]. If different, copy nums[i] to nums[k] and increment k.

Return Length.

Return k, the count of unique elements.

Step-by-Step Example

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

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

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

Array not empty, proceed.

Step 2: i = 1, compare nums[1] = 0 with nums[0] = 0.

Same, skip, i += 1.

Step 3: i = 2, compare nums[2] = 1 with nums[1] = 0.

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

Step 4: i = 3, compare nums[3] = 1 with nums[2] = 1.

Same, skip, i += 1.

Step 5: i = 4, compare nums[4] = 1 with nums[3] = 1.

Same, skip, i += 1.

Step 6: i = 5, compare nums[5] = 2 with nums[4] = 1.

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

Step 7: i = 6, compare nums[6] = 2 with nums[5] = 2.

Same, skip, i += 1.

Step 8: i = 7, compare nums[7] = 3 with nums[6] = 2.

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

Step 9: i = 8, compare nums[8] = 3 with nums[7] = 3.

Same, skip, i += 1.

Step 10: i = 9, compare nums[9] = 4 with nums[8] = 3.

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

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

How the Code Works (Two-Pointer)

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

def removeDuplicates(nums: list[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 unique element position
    k = 1
    # Line 4: Start scanning from second element
    for i in range(1, len(nums)):
        # Line 5: Compare current with previous
        if nums[i] != nums[i-1]:
            # Line 6: Place unique element at k
            nums[k] = nums[i]
            # Line 7: Increment k
            k += 1

    # Line 8: Return count of unique elements
    return k

Alternative: In-Place Modification with Comparison

Explanation

This approach uses a single pointer but explicitly shifts elements leftward to overwrite duplicates, though it’s less efficient due to unnecessary assignments. It’s included to deepen understanding.

Handle Edge Case.

Return 0 if empty.

Track Unique Position.

Use k to mark where the next unique element goes.

Compare and Shift.

Compare with previous unique element; if different, place it at k.

Return Length.

Step-by-Step Example (Alternative)

For nums = [1,1,2]:

Goal: Length = 2, nums = [1,2,_].
Result for Reference: Length = 2, nums = [1,2,...].
Start: nums = [1,1,2], k = 1, i = 1.
Step 1: i = 1, nums[1] = 1, nums[0] = 1.

Same, skip, i += 1.

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

Different, nums[1] = 2, k = 2, i = 3.
nums = [1,2,2].

Step 3: i = 3, out of bounds, stop.
Finish: Return k = 2.

How the Code Works (Alternative)

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

    # Line 2: Start with first element as unique
    k = 1
    # Line 3: Compare with first unique element initially
    for i in range(1, len(nums)):
        # Line 4: If different from last unique
        if nums[i] != nums[k-1]:
            # Line 5: Place at k
            nums[k] = nums[i]
            # Line 6: Move k forward
            k += 1

    # Line 7: Return unique count
    return k

Complexity

Two-Pointer:

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

Alternative:

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

Efficiency Notes

Both solutions are O(n) time and O(1) space, but the Two-Pointer approach is more intuitive and aligns with LeetCode’s expectations due to its simplicity and minimal writes.

Key Insights

Tips to master LeetCode 26:

Sorted Advantage: Use the sorted property—duplicates are adjacent!
Two Pointers Shine: k for placement, i for scanning—keep it simple.
In-Place Matters: Modify without extra arrays for efficiency.

Additional Example

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

Goal: Length = 3, nums = [1,2,3,_,_].
Two-Pointer: k = 1, i = 1, skip 1s, place 2 at k = 1, 3 at k = 2, return 3.
Result: [1,2,3,2,3], length = 3.

Edge Cases

Empty Array: [] – Return 0.
No Duplicates: [1,2,3] – Return 3.
All Duplicates: [1,1,1] – Return 1, nums = [1,_,_].

Final Thoughts

The Two-Pointer approach is the go-to solution for LeetCode 26 in Python—fast, clean, and beginner-friendly. For a related challenge, explore LeetCode 27: Remove Element next! Try tweaking the code with different inputs to solidify your understanding.