Remove Duplicates from Sorted Array II - Practice Coding Problems

Remove Duplicates from Sorted Array II - Problem

You're given a sorted integer array and need to clean it up by removing excess duplicates, but here's the twist: each unique element can appear at most twice!

🎯 Your Mission:
• Remove duplicates in-place so no element appears more than 2 times
• Maintain the original relative order
• Use O(1) extra space - no additional arrays allowed
• Return the length k of the cleaned array

Example: [1,1,1,2,2,3] becomes [1,1,2,2,3] with length 5

The array is already sorted, which is your biggest advantage! Can you leverage this property to solve it efficiently with a two-pointer approach?

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,1,2,2,3]

› Output: k = 5, nums = [1,1,2,2,3,_]

💡 Note: Remove one occurrence of 1. The first 5 elements become [1,1,2,2,3], each appearing at most twice.

example_2.py — Multiple Duplicates

$ Input: nums = [0,0,1,1,1,1,2,3,3]

› Output: k = 7, nums = [0,0,1,1,2,3,3]

💡 Note: Remove two occurrences of 1. Result has each element appearing at most twice.

example_3.py — No Removal Needed

$ Input: nums = [1,2,3]

› Output: k = 3, nums = [1,2,3]

💡 Note: All elements already appear at most twice, so no removal needed.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
nums is sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Setup Two Bookmarks

Place a 'reader' bookmark to scan all books and a 'writer' bookmark at position 2

Check Rule

For each book, check if it's the same as the book 2 positions behind the writer

Make Decision

If different, it's safe to keep - move book to writer position and advance writer

Continue Scanning

Reader always advances, writer only advances when keeping a book

Key Takeaway

🎯 Key Insight: In a sorted array, comparing with the element 2 positions behind ensures we never place a 3rd duplicate consecutively!

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a two-pointer technique that leverages the sorted array property. A writer pointer tracks where to place the next valid element, while a reader pointer scans through all elements. The key insight: compare each element with nums[writer-2] - if they're different, placing the current element won't create 3 consecutive duplicates! This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use reader and writer pointers to build result array in-place
Brute Force (Count Each Element)	O(n²)	O(1)	For each position, count occurrences from the start to decide if it's valid

Two Pointers (Optimal) — Algorithm Steps

Initialize writer pointer at index 2 (first 2 elements are always valid)
Use reader pointer to scan from index 2 onwards
For each reader position, compare current element with nums[writer-2]
If different, it means we won't have 3 duplicates, so copy to writer position
Increment writer only when copying a valid element
Return writer as the final length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Writer at index 2, reader scans from index 2

Compare

Compare current element with nums[writer-2]

Decision

If different, copy to writer position and advance writer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int removeDuplicates(int* nums, int numsSize) {
    if (numsSize <= 2) return numsSize;
    
    // Writer pointer - where to place next valid element
    int writer = 2;
    
    // Reader pointer - scan through all elements
    for (int reader = 2; reader < numsSize; reader++) {
        // Key insight: compare with element 2 positions behind writer
        // If different, we won't create 3 duplicates
        if (nums[reader] != nums[writer - 2]) {
            nums[writer] = nums[reader];
            writer++;
        }
    }
    
    return writer;
}

int main() {
    int nums[1000];
    int n = 0;
    
    // Simple input parsing
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", removeDuplicates(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, modifying array in-place

✓ Linear Space

52.0K Views

High Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler