• 1 <= nums.length <= 3 × 10⁴
• -100 <= nums[i] <= 100
• nums is sorted in non-decreasing order
• Solve in-place with O(1) extra memory

The array is sorted, and we must keep one copy of each distinct value, packed at the front, in place. We return k, the count of distinct values; the first k slots must hold them in order, and whatever sits after slot k doesn't matter. Because the array is sorted, equal values are forced to sit next to each other — [1, 1, 2, 2, 3] can never scatter its two 1s apart — and that single fact is what makes one forward pass enough.

The tempting move is to delete a value the moment you spot a repeat. But deleting from an array isn't free: to close the hole, every element after it slides one step left. Do that for each duplicate and you're shifting the tail over and over — up to O(N²) work on an array that's mostly repeats. Deletion is the wrong tool.

i = 1
while i < len(nums):
    if nums[i] == nums[i-1]:
        nums.pop(i)      # closing the gap shifts everything after it — slow
    else:
        i += 1

This is the exact read/write shape from Move Zeroes — a reader sweeping the array while a write pointer w trails, marking where the next value we keep belongs. Nothing about the machinery changes. The only thing that changes is the rule for what counts as a "keeper," and here the sorted order hands it to us: keep a value when it differs from the last value we already kept. Since duplicates are guaranteed adjacent, "the last value I kept" is the same as "the value just before this run," so a single comparison decides it — no set of seen values, no extra memory.

The first element is always a keeper (nothing precedes it), so start w at 1 and let the reader begin at index 1. Each time the reader's value differs from nums[w-1] — the most recently kept value — write it at w and advance w. When the sweep ends, w is exactly the count of distinct values, which is what we return.

w = 1                              # first element is always kept
for r in range(1, len(nums)):
    if nums[r] != nums[w - 1]:     # differs from the last value we kept?
        nums[w] = nums[r]          # keep it at the write position
        w += 1
return w                           # count of distinct values

Same skeleton as Move Zeroes, two slots filled differently: the keeper test became "new distinct value" and the thing we return became w. That's the payoff of learning the pattern rather than the problem — a new keeper rule is often the only thing you write. The linked-list twin of this, Remove Duplicates from Sorted List, is the identical idea with next-pointer rewiring instead of array writes.

One sweep, no deletions, no extra structure: O(N) time, O(1) space, versus the delete-and-shift trap's O(N²). And it all rode on reading the precondition: "sorted" quietly promised that duplicates are neighbours, which is what let a single comparison replace a memory of everything seen. Train the reflex: when an input is sorted, ask what that ordering makes adjacent — adjacency is what lets you swap remembering for a cheap local check.