Remove Duplicates from Sorted Array Two Pointer in DSA Python

Mental Model

Use two pointers to overwrite duplicates in a sorted array, keeping only unique elements at the front.

Analogy: Imagine sorting your books on a shelf and removing extra copies by sliding unique books forward, ignoring repeats behind.

Array: [1, 1, 2, 2, 3, 4, 4]
Pointers: i ↑ j ↑
Initially both at start, i marks last unique, j scans ahead

Dry Run Walkthrough

Input: array: [1, 1, 2, 2, 3]

Goal: Remove duplicates so array starts with unique elements only

Step 1: Start with i=0 (first unique), j=1 scanning next element

[1 (i), 1 (j), 2, 2, 3]

Why: We compare j to i to find new unique elements

Step 2: j=1 equals i=0 value (1), so skip duplicate, move j forward

[1 (i), 1, 2 (j), 2, 3]

Why: Duplicate found, do not move i, just advance j

Step 3: j=2 value (2) differs from i=0 value (1), increment i and copy j's value to i

[1, 2 (i), 2 (j), 2, 3]

Why: Found new unique, move i forward and update array

Step 4: j=3 value (2) equals i=1 value (2), skip duplicate, move j forward

[1, 2 (i), 2, 2 (j), 3]

Why: Duplicate again, only advance j

Step 5: j=4 value (3) differs from i=1 value (2), increment i and copy j's value

[1, 2, 3 (i), 2, 3 (j)]

Why: New unique found, move i and update array

Result:

Final array start: [1, 2, 3] with length 3

Annotated Code

DSA Python

from typing import List

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0
        i = 0  # last unique element index
        for j in range(1, len(nums)):
            if nums[j] != nums[i]:
                i += 1
                nums[i] = nums[j]  # overwrite duplicate
        return i + 1

# Driver code
nums = [1, 1, 2, 2, 3]
sol = Solution()
length = sol.removeDuplicates(nums)
print("Unique length:", length)
print("Array after removing duplicates:", nums[:length])

if not nums:

handle empty array edge case

i = 0 # last unique element index

initialize pointer i to track last unique element

for j in range(1, len(nums)):

j scans through array from second element

if nums[j] != nums[i]:

check if current element is new unique

i += 1

move i forward to next unique position

nums[i] = nums[j] # overwrite duplicate

overwrite duplicate with new unique element

return i + 1

return count of unique elements

Output

Unique length: 3

Array after removing duplicates: [1, 2, 3]

Complexity Analysis

Time: O(n) because we scan the array once with pointer j

Space: O(1) because we modify the array in place without extra space

vs Alternative: Compared to creating a new array for uniques (O(n) space), this uses constant space by overwriting duplicates

Edge Cases

empty array

returns 0 immediately

DSA Python

if not nums:

array with all duplicates

returns 1 with first element only

DSA Python

if nums[j] != nums[i]:

array with no duplicates

returns original length, array unchanged

DSA Python

if nums[j] != nums[i]:

When to Use This Pattern

When you see a sorted array and need to remove duplicates in place, use two pointers to overwrite duplicates efficiently.

Common Mistakes

Mistake: Starting i pointer at 1 instead of 0 causes index errors or misses first element
Fix: Initialize i to 0 to mark the first unique element

Mistake: Copying nums[j] to nums[i] without incrementing i leads to overwriting same position
Fix: Increment i before copying to ensure unique elements are placed correctly

Summary

Removes duplicates from a sorted array by overwriting duplicates with unique elements using two pointers.

Use when you want to remove duplicates in place without extra space.

The key is to keep one pointer for the last unique element and another to scan ahead for new uniques.

Practice

1. What is the main purpose of using two pointers in the Remove Duplicates from Sorted Array problem?

easy

A. To create a new array with unique elements

B. To sort the array before removing duplicates

C. To count the total number of duplicates in the array

D. To efficiently track unique elements and overwrite duplicates in-place

Solution

1. Step 1: Understand the two pointer roles

   One pointer tracks the position to place the next unique element, the other scans the array.

2. Step 2: Explain in-place overwrite

   When a new unique element is found, it is placed at the first pointer's position, avoiding extra space.

3. Final Answer:

   To efficiently track unique elements and overwrite duplicates in-place -> Option D

4. Quick Check:

   Two pointers help remove duplicates without extra space [OK]

Hint: Two pointers help overwrite duplicates without extra space [OK]

Common Mistakes:

• Thinking two pointers sort the array
• Assuming a new array is created
• Confusing counting duplicates with removing them

2. Which of the following is the correct syntax to initialize two pointers i and j for the two-pointer approach in Python?

easy

A. i = 1; j = 0

B. i = j = 0

C. i, j = 0, 1

D. i = 0; j = 0

Solution

1. Step 1: Identify pointer roles

   Pointer i starts at 0 (position for unique elements), j starts at 1 (scanning pointer).

2. Step 2: Match initialization

   Correct initialization is i, j = 0, 1 to start comparing adjacent elements.

3. Final Answer:

   i, j = 0, 1 -> Option C

4. Quick Check:

   Start pointers at 0 and 1 for two-pointer scan [OK]

Hint: Start pointers at 0 and 1 to compare adjacent elements [OK]

Common Mistakes:

• Initializing both pointers at 0
• Swapping pointer start positions
• Using incorrect syntax for multiple assignments

3. What will be the output of the following code snippet?

nums = [1, 1, 2, 2, 3]
i = 0
for j in range(1, len(nums)):
    if nums[j] != nums[i]:
        i += 1
        nums[i] = nums[j]
print(nums[:i+1])

medium

A. [1, 1, 2, 3]

B. [1, 2, 3]

C. [1, 2, 2, 3]

D. [1, 1, 2, 2, 3]

Solution

1. Step 1: Trace the loop and pointer updates

   Initially, i=0, j scans from 1 to 4. When nums[j] != nums[i], i increments and nums[i] is updated.

2. Step 2: Track array changes

   After processing, nums becomes [1, 2, 3, 2, 3], but only first i+1=3 elements are unique.

3. Final Answer:

   [1, 2, 3] -> Option B

4. Quick Check:

   Unique elements extracted as [1, 2, 3] [OK]

Hint: Print slice up to i+1 for unique elements [OK]

Common Mistakes:

• Printing full array instead of slice
• Not updating i correctly
• Confusing pointer roles

4. Identify the error in the following code snippet for removing duplicates from a sorted array:

nums = [1, 1, 2, 3, 3]
i = 0
for j in range(1, len(nums)):
    if nums[i] == nums[j]:
        i += 1
        nums[i] = nums[j]
print(nums[:i+1])

medium

A. The condition should check if nums[j] != nums[i]

B. The pointer i should start at 1 instead of 0

C. The loop should start from j = 0

D. The print statement should print the entire array

Solution

1. Step 1: Analyze the if condition

   The code increments i and updates nums[i] only when nums[i] == nums[j], which is incorrect for removing duplicates.

2. Step 2: Correct the condition

   It should increment i and update nums[i] when nums[j] != nums[i] to keep unique elements.

3. Final Answer:

   The condition should check if nums[j] != nums[i] -> Option A

4. Quick Check:

   Use != to detect new unique elements [OK]

Hint: Use != to find unique elements, not == [OK]

Common Mistakes:

• Using == instead of !=
• Starting pointers incorrectly
• Printing wrong slice of array

5. Given a sorted array nums = [0,0,1,1,1,2,2,3,3,4], what will be the array state after applying the two-pointer method to remove duplicates in-place?

hard

A. [0, 1, 2, 3, 4]

B. [0, 0, 1, 2, 3, 4]

C. [0, 1, 1, 2, 3, 4]

D. [0, 1, 2, 2, 3, 4]

Solution

1. Step 1: Apply two-pointer logic on nums

   Start with i=0, j scans from 1 to end. Each time nums[j] != nums[i], increment i and set nums[i] = nums[j].

2. Step 2: Track unique elements placement

   Unique elements placed at start: 0,1,2,3,4. The array's first 5 elements become [0,1,2,3,4].

3. Final Answer:

   [0, 1, 2, 3, 4] -> Option A

4. Quick Check:

   Unique sorted elements remain at front [OK]

Hint: Unique elements stay at front after two-pointer overwrite [OK]

Common Mistakes:

• Assuming duplicates remain in front
• Not updating i correctly
• Confusing array slicing after operation