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

Practice - 5 Tasks

1fill in blank

easy

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

DSA Go

func removeDuplicates(nums []int) int {
    if len(nums) == 0 {
        return 0
    }
    slow := [1]
    for fast := 1; fast < len(nums); fast++ {
        if nums[fast] != nums[slow] {
            slow++
            nums[slow] = nums[fast]
        }
    }
    return slow + 1
}

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

A-1

B1

C0

Dlen(nums)

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing slow to 1 causes skipping the first element.

Initializing slow to -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 compare elements at fast and slow pointers.

DSA Go

for fast := 1; fast < len(nums); fast++ {
    if nums[fast] [1] nums[slow] {
        slow++
        nums[slow] = nums[fast]
    }
}

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 incorrectly.

Using '<' or '>' does not correctly detect duplicates.

We move the slow pointer only when the fast pointer finds a different element (not equal).

3fill in blank

hard

Fix the error in the return statement to return the correct length of unique elements.

DSA Go

return [1] + 1

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

Afast

B0

Clen(nums)

Dslow

Attempts:

3 left

💡 Hint

Common Mistakes

Returning fast causes incorrect length.

Returning len(nums) ignores duplicates.

The slow pointer ends at the last unique element's index, so length is slow + 1.

4fill in blank

hard

Fill both blanks to complete the loop that moves the fast pointer and updates the slow pointer.

DSA Go

for [1] := 1; [2] < len(nums); [1]++ {
    if nums[[1]] != nums[slow] {
        slow++
        nums[slow] = nums[[1]]
    }
}

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

Afast

Bslow

Ci

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in the loop causes errors.

Using slow as loop variable breaks the logic.

The fast pointer variable is named 'fast' and used consistently in the loop.

5fill in blank

hard

Fill all three blanks to complete the function that removes duplicates from a sorted array.

DSA Go

func removeDuplicates(nums []int) int {
    if len(nums) == 0 {
        return 0
    }
    [1] := 0
    for [2] := 1; [2] < len(nums); [2]++ {
        if nums[[2]] != nums[[1]] {
            [1]++
            nums[[1]] = nums[[2]]
        }
    }
    return [1] + 1
}

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

Aslow

Bfast

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing variable names causes logic errors.

Returning wrong pointer value causes incorrect length.

The slow pointer tracks the last unique element, and fast pointer scans the array.

Practice

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

easy

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

B. To sort the array before removing duplicates

C. To create a new array with unique elements

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

Solution

1. Step 1: Understand the two-pointer approach

   One pointer tracks the position to place the next unique element, the other scans the array. This method avoids extra space by overwriting duplicates directly in the original array.

2. Final Answer:

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

3. Quick Check:

   Two pointers help remove duplicates in-place [OK]

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

Common Mistakes:

• Thinking two pointers create a new array
• Assuming sorting is needed inside the method
• Confusing counting duplicates with removing them

2. Which of the following Go code snippets correctly initializes the two pointers for removing duplicates from a sorted array named nums?

easy

A. i, j := 0, 1

B. i, j := 1, 0

C. i, j := 0, 0

D. i, j := 1, 1

Solution

1. Step 1: Identify pointer roles and correct initialization

   Pointer i tracks last unique index starting at 0 (first element), pointer j scans from the next element at 1 to compare adjacent elements.

2. Final Answer:

   i, j := 0, 1 -> Option A

3. Quick Check:

   i=0, j=1 starts correct two-pointer scan [OK]

Hint: Start i at 0 and j at 1 to compare neighbors [OK]

Common Mistakes:

• Swapping i and j initialization
• Starting both pointers at 0
• Starting both pointers at 1

3. What will be the content of the array nums and the returned length after running the two-pointer duplicate removal on nums := []int{1, 1, 2, 3, 3, 4}?

medium

A. nums = [1, 2, 3, 3, 4, 4], length = 3

B. nums = [1, 1, 2, 3, 4, 4], length = 5

C. nums = [1, 2, 3, 4, 4, 4], length = 4

D. nums = [1, 2, 3, 4, 3, 4], length = 4

Solution

1. Step 1: Trace two-pointer process

   Start i=0, j=1; compare nums[j] with nums[i]. When different, increment i and set nums[i]=nums[j]. Unique elements placed at start: 1, 2, 3, 4; length = 4; leftover elements remain unchanged. Final array: [1, 2, 3, 4, 3, 4].

2. Final Answer:

   nums = [1, 2, 3, 4, 3, 4], length = 4 -> Option D

3. Quick Check:

   Unique elements count = 4, array start updated [OK]

Hint: Overwrite duplicates, keep unique at front, count unique [OK]

Common Mistakes:

• Assuming leftover elements are removed
• Counting duplicates as unique
• Misplacing unique elements

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

func removeDuplicates(nums []int) int {
    i := 0
    for j := 1; j < len(nums); j++ {
        if nums[j] != nums[i] {
            i = j
            nums[i] = nums[j]
        }
    }
    return i + 1
}

medium

A. Loop should start from j = 0 instead of 1

B. Pointer i is incorrectly updated to j instead of incrementing

C. Return statement should be i instead of i + 1

D. Comparison should be nums[j] == nums[i] instead of !=

Solution

1. Step 1: Analyze pointer update logic

   Pointer i should move forward by one (i++) to place unique element, not jump to j (i = j). Correct code uses i++ then nums[i] = nums[j] to overwrite duplicates properly.

2. Final Answer:

   Pointer i is incorrectly updated to j instead of incrementing -> Option B

3. Quick Check:

   i must increment, not jump to j [OK]

Hint: Increment i to place unique, don't assign i = j [OK]

Common Mistakes:

• Setting i = j causes skipping elements
• Starting loop at wrong index
• Wrong return value calculation

5. Given a sorted array nums := []int{0,0,1,1,1,2,2,3,3,4}, what will be the final array state and length after applying the two-pointer duplicate removal method?

hard

A. nums = [0,1,1,2,3,4,4,3,3,4], length = 5

B. nums = [0,0,1,2,3,4,3,3,4,4], length = 6

C. nums = [0,1,2,3,4,2,2,3,3,4], length = 5

D. nums = [0,1,2,3,4,0,1,1,2,2], length = 4

Solution

1. Step 1: Apply two-pointer logic step-by-step

   Start with i=0, j=1; move j forward, when nums[j] != nums[i], increment i and set nums[i]=nums[j]. Unique elements are 0,1,2,3,4 placed at start; length = 5; rest of array remains unchanged: [0,1,2,3,4,2,2,3,3,4].

2. Final Answer:

   nums = [0,1,2,3,4,2,2,3,3,4], length = 5 -> Option C

3. Quick Check:

   Unique count 5, array start updated correctly [OK]

Hint: Place unique elements at front, count unique length [OK]

Common Mistakes:

• Assuming leftover elements are removed
• Miscounting unique elements
• Overwriting wrong indices