Remove Duplicates from Sorted Array Two Pointer in DSA Python - 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 are repeated because the sensor recorded the same temperature multiple times in a row. You want to clean this data by removing duplicate temperatures so that each temperature appears only once, keeping the order intact.

🎯 Goal: Build a program that removes duplicates from a sorted list of numbers using the two-pointer technique. The program should modify the list in place and print the cleaned list without duplicates.

📋 What You'll Learn

Create a list called temperatures with the exact values: [30, 30, 32, 32, 32, 35, 36, 36, 38]

Create a variable called write_index and set it to 1

Use a for loop with variable read_index starting from 1 to iterate over temperatures

Inside the loop, compare temperatures[read_index] with temperatures[write_index - 1]

If they are different, assign temperatures[read_index] to temperatures[write_index] and increment write_index by 1

After the loop, slice temperatures to keep only elements up to write_index

Print the final temperatures list

💡 Why This Matters

🌍 Real World

Cleaning sensor data or logs often requires removing repeated values to simplify analysis.

💼 Career

Understanding two-pointer techniques is useful for optimizing array and list operations in software development.

1

Create the sorted list of temperatures

Create a list called temperatures with these exact values: [30, 30, 32, 32, 32, 35, 36, 36, 38]

DSA Python

# Create the list of temperatures
# Your code here

Hint

Use square brackets to create a list and include the numbers exactly as shown.

2

Set up the write pointer

Create a variable called write_index and set it to 1

DSA Python

temperatures = [30, 30, 32, 32, 32, 35, 36, 36, 38]
# Create the write_index variable
# Your code here

Hint

This variable will track where to write the next unique temperature.

3

Use two pointers to remove duplicates

Use a for loop with variable read_index starting from 1 to iterate over temperatures. Inside the loop, compare temperatures[read_index] with temperatures[write_index - 1]. If they are different, assign temperatures[read_index] to temperatures[write_index] and increment write_index by 1. After the loop, slice temperatures to keep only elements up to write_index.

DSA Python

temperatures = [30, 30, 32, 32, 32, 35, 36, 36, 38]
write_index = 1
# Use a for loop to remove duplicates
# Your code here

Hint

Use the two-pointer technique: one pointer reads through the list, the other writes unique values.

4

Print the cleaned list

Print the temperatures list after removing duplicates using print(temperatures)

DSA Python

temperatures = [30, 30, 32, 32, 32, 35, 36, 36, 38]
write_index = 1
for read_index in range(1, len(temperatures)):
    if temperatures[read_index] != temperatures[write_index - 1]:
        temperatures[write_index] = temperatures[read_index]
        write_index += 1

temperatures = temperatures[:write_index]
# Print the final temperatures list
# Your code here

Hint

Use print(temperatures) to show the cleaned list.

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