Remove Duplicates from Sorted Array Two Pointer in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the slow pointer for the two-pointer technique.

DSA Python

def remove_duplicates(nums):
    if not nums:
        return 0
    slow = [1]
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1

Drag options to blanks, or click blank then click option'

A0

B1

C-1

Dlen(nums)

Attempts:

3 left

💡 Hint

Common Mistakes

Starting slow at 1 causes skipping the first element.

Using -1 causes index errors.

The slow pointer starts at index 0 to track the position of the last unique element.

2fill in blank

medium

Complete the code to check if the current fast pointer element is different from the slow pointer element.

DSA Python

def remove_duplicates(nums):
    if not nums:
        return 0
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] [1] nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1

Drag options to blanks, or click blank then click option'

A!=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' causes duplicates to be copied.

Using '<' or '>' is incorrect for equality check.

We want to move the slow pointer only when we find a new unique element, so we check if nums[fast] is not equal to nums[slow].

3fill in blank

hard

Fix the error in the code to correctly update the slow pointer and assign the new unique element.

DSA Python

def remove_duplicates(nums):
    if not nums:
        return 0
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            [1]  # increment slow pointer
            nums[slow] = nums[fast]
    return slow + 1

Drag options to blanks, or click blank then click option'

Afast += 1

Bslow = fast

Cslow += 1

Dslow -= 1

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning slow = fast skips elements.

Incrementing fast inside loop causes errors.

The slow pointer should be incremented by 1 to move to the next position for the unique element.

4fill in blank

hard

Fill both blanks to complete the function that returns the length of the array after removing duplicates.

DSA Python

def remove_duplicates(nums):
    if not nums:
        return 0
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow [1] 1
            nums[slow] = nums[fast]
    return slow [2] 1

Drag options to blanks, or click blank then click option'

A+=

B-=

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-=' decreases slow incorrectly.

Returning slow - 1 gives wrong length.

We increment slow by 1 using '+=' and return slow + 1 because the length is index + 1.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each unique number to its index after removing duplicates.

DSA Python

def map_unique_indices(nums):
    length = remove_duplicates(nums)
    return { [1]: [2] for [3] in range(length) }

Drag options to blanks, or click blank then click option'

Anums[i]

Bi

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'num' causes NameError as 'num' is not defined.

Mixing variable names like using 'i' for key maps index to index.

We map each unique number nums[i] to its index i, iterating i in range(length).

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