Remove Duplicates from Sorted Array Two Pointer in DSA Python - Execution Trace

Concept Flow - Remove Duplicates from Sorted Array Two Pointer

Start with two pointers

↓

Pointer1 at index 0

↓

Compare values at Pointer1 and Pointer2

↓

Repeat until Pointer2 reaches end

↓

Return length = Pointer1 + 1

Use two pointers to scan the array. One pointer tracks unique elements, the other scans ahead to find new unique values to copy forward.

Execution Sample

DSA Python

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

This code removes duplicates in-place from a sorted array and returns the new length of unique elements.

Execution Table

Step	Operation	Pointer Left	Pointer Right	Array State	Action
0	Initialize pointers	0	1	[1,1,2,2,3]	Start with left=0, right=1
1	Compare nums[left] and nums[right]	0	1	[1,1,2,2,3]	1 == 1, duplicate found, move right
2	Move right pointer	0	2	[1,1,2,2,3]	right moves to 2
3	Compare nums[left] and nums[right]	0	2	[1,1,2,2,3]	1 != 2, unique found
4	Move left pointer and copy	1	2	[1,2,2,2,3]	left moves to 1, nums[1] = 2
5	Move right pointer	1	3	[1,2,2,2,3]	right moves to 3
6	Compare nums[left] and nums[right]	1	3	[1,2,2,2,3]	2 == 2, duplicate found, move right
7	Move right pointer	1	4	[1,2,2,2,3]	right moves to 4
8	Compare nums[left] and nums[right]	1	4	[1,2,2,2,3]	2 != 3, unique found
9	Move left pointer and copy	2	4	[1,2,3,2,3]	left moves to 2, nums[2] = 3
10	Right pointer reached end	2	4	[1,2,3,2,3]	End of array reached
11	Return length	2	4	[1,2,3,2,3]	Length = left + 1 = 3

💡 Right pointer reached end of array, all unique elements moved to front

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	After Step 7	After Step 9	Final
left	0	0	1	1	1	2	2
right	1	1	2	3	4	4	4
nums	[1,1,2,2,3]	[1,1,2,2,3]	[1,2,2,2,3]	[1,2,2,2,3]	[1,2,2,2,3]	[1,2,3,2,3]	[1,2,3,2,3]

Key Moments - 3 Insights

Why do we move the left pointer only when we find a new unique element?

Because left pointer marks the position of last unique element. We only advance it to store the next unique value, as shown in steps 4 and 9 in the execution_table.

Why don't we move the left pointer when duplicates are found?

When duplicates are found (steps 1 and 6), we only move the right pointer to skip them. Left pointer stays to overwrite duplicates later with new unique values.

Why is the returned length left + 1?

Because left is zero-based index of last unique element, so length is left + 1 as shown in step 11.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the array state?

A [1,2,3,2,3]

B [1,2,2,2,3]

C [1,1,2,2,3]

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

💡 Hint

Check the 'Array State' column at step 4 in execution_table

At which step does the left pointer move for the second time?

A Step 4

B Step 6

C Step 9

D Step 2

💡 Hint

Look at the 'Pointer Left' column in execution_table and find when it changes the second time

If the input array was [1,1,1,1], what would be the returned length?

A 1

B 4

C 0

D 2

💡 Hint

All elements are duplicates except the first, so left pointer stays at 0, length = left + 1

Concept Snapshot

Remove duplicates from sorted array using two pointers:
- left pointer tracks last unique element
- right pointer scans ahead
- if nums[right] != nums[left], move left and copy nums[right]
- continue until right reaches end
- return left + 1 as new length

Full Transcript

This visualization shows how to remove duplicates from a sorted array using two pointers. We start with left pointer at index 0 and right pointer at index 1. We compare values at these pointers. If they are the same, right pointer moves forward to skip duplicates. If different, left pointer moves forward and copies the unique value from right pointer. This process continues until right pointer reaches the end of the array. The final length of unique elements is left pointer index plus one. The array is modified in place to have unique elements at the front.

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