Remove Duplicates from Sorted Array Two Pointer in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the two-pointer technique in removing duplicates from a sorted array?

Use one pointer to track the position of the last unique element and another pointer to scan through the array. When a new unique element is found, move it next to the last unique element.

beginner

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

Because duplicates are adjacent in a sorted array, we can easily compare current and previous elements to detect duplicates without extra space.

intermediate

In the two-pointer approach, what does the first pointer represent after processing the array?

It represents the index of the last unique element, so the length of the array without duplicates is this index plus one.

beginner

What is the time complexity of removing duplicates from a sorted array using the two-pointer technique?

O(n), where n is the number of elements in the array, because each element is visited once.

intermediate

Show the C# code snippet for removing duplicates from a sorted array using two pointers.

int RemoveDuplicates(int[] nums) { if (nums.Length == 0) return 0; int i = 0; for (int j = 1; j < nums.Length; j++) { if (nums[j] != nums[i]) { i++; nums[i] = nums[j]; } } return i + 1; }

What does the first pointer track in the two-pointer method for removing duplicates?

A The current element being checked

B The total number of duplicates

C The last unique element's index

D The first element of the array

The first pointer tracks the index of the last unique element found.

Why is the two-pointer technique suitable for sorted arrays when removing duplicates?

A It uses extra memory

B Duplicates are grouped together

C It sorts the array again

D It removes elements randomly

Because duplicates are adjacent in sorted arrays, the technique can easily detect and skip them.

What is the time complexity of the two-pointer approach for removing duplicates?

A O(n^2)

B O(n log n)

C O(1)

D O(n)

The array is traversed once, so the time complexity is O(n).

After removing duplicates, how do you find the new length of the array?

A Last unique index + 1

B Total elements - duplicates

C First pointer index

D Array length divided by 2

The new length is the last unique element's index plus one.

In the two-pointer method, what happens when nums[j] != nums[i]?

A Increment i and copy nums[j] to nums[i]

B Skip the element

C Reset pointers

D Do nothing

When a new unique element is found, i is incremented and nums[j] is copied to nums[i].

Explain how the two-pointer technique removes duplicates from a sorted array step-by-step.

Think about how one pointer tracks unique elements and the other scans the array.

Write the C# code to remove duplicates from a sorted array using the two-pointer approach and explain each line.

Focus on how the pointers move and how the array is updated.

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 efficiently track unique elements and overwrite duplicates in-place

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.

2. Step 2: Purpose of pointers in-place

   This method avoids extra space by overwriting duplicates directly in the original array.

3. Final Answer:

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

4. Quick Check:

   Two pointers help remove duplicates in-place [OK]

Hint: Two pointers track and 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 C# syntax to initialize the two pointers i and j for the problem?

easy

A. int i = 1; int j = 1;

B. int i = 1, j = 0;

C. int i = 0; int j = 0;

D. int i = 0, j = 1;

Solution

1. Step 1: Identify pointer roles

   Pointer i starts at index 0 to track unique elements, j starts at 1 to scan ahead.

2. Step 2: Check initialization correctness

   Initializing i = 0 and j = 1 matches the logic of comparing current and next elements.

3. Final Answer:

   int i = 0, j = 1; -> Option D

4. Quick Check:

   Start i at 0 and j at 1 [OK]

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

Common Mistakes:

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

3. What will be the output array and new length after running the two-pointer method on the sorted array [1, 1, 2, 3, 3]?

medium

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

B. [1, 2, 3], length = 3

C. [1, 1, 2, 3, 3], length = 5

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

Solution

1. Step 1: Trace the two-pointer process

   Start with i=0, j=1. Compare elements: skip duplicates, overwrite unique elements at i+1.

2. Step 2: Final array and length

   Unique elements are 1, 2, 3 placed at start. Length is 3.

3. Final Answer:

   [1, 2, 3], length = 3 -> Option B

4. Quick Check:

   Unique elements count = 3 [OK]

Hint: Overwrite duplicates, count unique elements for length [OK]

Common Mistakes:

• Not updating length after removal
• Leaving duplicates in output
• Misplacing unique elements

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

int RemoveDuplicates(int[] nums) {
    int i = 0, j = 1;
    while (j < nums.Length) {
        if (nums[i] != nums[j]) {
            i++;
            nums[i] = nums[j];
        }
        j++;
    }
    return i;
}

medium

A. The function should return i + 1 instead of i

B. Pointers i and j should both start at 1

C. The while loop condition should be j <= nums.Length

D. The array should be sorted inside the function

Solution

1. Step 1: Understand pointer meaning

   Pointer i tracks last unique element index, so length is i + 1.

2. Step 2: Check return value

   Returning i alone misses counting the first element, so return i + 1.

3. Final Answer:

   The function should return i + 1 instead of i -> Option A

4. Quick Check:

   Return length as i + 1 [OK]

Hint: Return i + 1 as length, not just i [OK]

Common Mistakes:

• Returning i instead of i + 1
• Incorrect loop boundary causing out-of-range
• Sorting array inside function unnecessarily

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

hard

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

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

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

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

Solution

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

   Start with i=0, j=1. Move j forward, overwrite duplicates by placing unique elements at i+1.

2. Step 2: Final array and length

   Unique elements are 0,1,2,3,4 placed at start. Length is 5.

3. Final Answer:

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

4. Quick Check:

   Unique count = 5 [OK]

Hint: Overwrite duplicates, count unique elements for final length [OK]

Common Mistakes:

• Leaving duplicates in the array
• Returning wrong length
• Misplacing unique elements during overwrite