Remove Duplicates from Sorted Array Two Pointer in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of removing duplicates from sorted array

What is the output array after removing duplicates using the two-pointer method on this sorted array?

DSA Go

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

input := []int{1,1,2,2,3,4,4,5}
output := removeDuplicates(input)
fmt.Println(output)

A [1 2 3 4 5]

B [1 1 2 3 4 5]

C [1 2 2 3 4 5]

D [1 2 3 4 4 5]

💡 Hint

Focus on how the two pointers move and overwrite duplicates.

The two-pointer method moves through the array, copying unique elements forward. The final slice includes only unique elements.

❓ Predict Output

intermediate

Length of array after removing duplicates

What is the length of the array after removing duplicates from this sorted array using the two-pointer method?

DSA Go

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

input := []int{0,0,1,1,1,2,2,3,3,4}
length := removeDuplicates(input)
fmt.Println(length)

A 7

B 6

C 4

D 5

💡 Hint

Count unique elements after removing duplicates.

The unique elements are 0,1,2,3,4 so length is 5.

🔧 Debug

advanced

Identify the error in two-pointer duplicate removal code

Which option contains a bug that causes incorrect removal of duplicates in a sorted array?

DSA Go

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

A The condition should be nums[j] != nums[i], not nums[j] == nums[i]

B The initial value of i should be 1, not 0

C The loop should start from j = 0, not j = 1

D The function should return i, not i + 1

💡 Hint

Check the condition that decides when to move the pointer and copy values.

The condition must check for inequality to detect new unique elements. Using equality causes wrong behavior.

🧠 Conceptual

advanced

Why does the two-pointer method work for removing duplicates in a sorted array?

Choose the best explanation for why the two-pointer technique correctly removes duplicates from a sorted array.

A Because the array is sorted, duplicates are scattered randomly, so two pointers help find them faster.

B Because the array is sorted, the pointers can jump over duplicates without checking each element.

C Because the array is sorted, duplicates are adjacent, so one pointer tracks unique elements while the other scans ahead.

D Because the array is sorted, the two-pointer method swaps duplicates to the end of the array.

💡 Hint

Think about how sorting affects the position of duplicates.

Duplicates appear next to each other in a sorted array, so one pointer can track the last unique element and the other scans forward to find new unique elements.

❓ Predict Output

expert

Output after removing duplicates with multiple duplicates present

What is the output slice after running the two-pointer duplicate removal function on this input?

DSA Go

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

input := []int{2,2,2,3,3,4,4,4,4,5,5,6}
output := removeDuplicates(input)
fmt.Println(output)

A [2 3 3 4 5 6]

B [2 3 4 5 6]

C [2 3 4 4 5 6]

D [2 2 3 4 5 6]

💡 Hint

Check how many unique numbers are in the input and how the function slices the array.

The unique numbers are 2,3,4,5,6 so the output slice contains these five elements.

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