Remove Duplicates from Sorted Array Two Pointer in DSA Go - Build from Scratch

Remove Duplicates from Sorted Array Using Two Pointers

📖 Scenario: You have a sorted list of numbers representing daily temperatures recorded over several days. Some temperatures repeat more than twice because of sensor errors. You want to clean this data by allowing each temperature to appear at most twice.

🎯 Goal: Build a program that removes extra duplicates from the sorted list so that each number appears at most twice. Use the two-pointer technique to do this efficiently.

📋 What You'll Learn

Create a slice called temps with the exact values: []int{10, 10, 10, 12, 12, 15, 15, 15, 15, 20}

Create an integer variable called maxAllowed and set it to 2

Use two pointers named i and j to iterate and modify temps so that no number appears more than maxAllowed times

Print the cleaned temps slice after removing extra duplicates

💡 Why This Matters

🌍 Real World

Cleaning sensor or user data where repeated values beyond a limit cause errors or misinterpretations.

💼 Career

Data cleaning and preprocessing skills are essential for software engineers, data analysts, and data scientists.

1

Create the initial sorted slice of temperatures

Create a slice called temps with these exact values: []int{10, 10, 10, 12, 12, 15, 15, 15, 15, 20}

DSA Go

# Create the slice temps with the given values
# Your code here

Hint

Use temps := []int{...} to create the slice with the exact numbers.

2

Set the maximum allowed duplicates

Create an integer variable called maxAllowed and set it to 2 inside the main function after the temps slice

DSA Go

package main

func main() {
    temps := []int{10, 10, 10, 12, 12, 15, 15, 15, 15, 20}
    // Create maxAllowed variable and set it to 2
    // Your code here
}

Hint

Use maxAllowed := 2 to set the limit for duplicates.

3

Use two pointers to remove extra duplicates

Use two integer pointers i and j to iterate over temps. Start i at maxAllowed and j at maxAllowed. For each j, check if temps[j] is different from temps[i - maxAllowed]. If yes, assign temps[j] to temps[i] and increment i. After the loop, resize temps to length i.

DSA Go

package main

func main() {
    temps := []int{10, 10, 10, 12, 12, 15, 15, 15, 15, 20}
    maxAllowed := 2

    // Use two pointers i and j to remove extra duplicates
    // Your code here
}

Hint

Use a for loop starting from j := maxAllowed and compare temps[j] with temps[i - maxAllowed]. Update temps[i] and increment i when different.

4

Print the cleaned temperatures slice

Print the temps slice after removing extra duplicates using fmt.Println(temps) inside the main function.

DSA Go

package main

import "fmt"

func main() {
    temps := []int{10, 10, 10, 12, 12, 15, 15, 15, 15, 20}
    maxAllowed := 2

    i := maxAllowed
    for j := maxAllowed; j < len(temps); j++ {
        if temps[j] != temps[i-maxAllowed] {
            temps[i] = temps[j]
            i++
        }
    }
    temps = temps[:i]

    // Print the cleaned temps slice
    // Your code here
}

Hint

Use fmt.Println(temps) to display the final cleaned slice.

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