• n == nums.length
• 1 <= n <= 300
• nums[i] is 0, 1, or 2
• Target: one pass, O(1) extra space, no library sort

We have an array made of just three values — 0, 1, and 2 — and we want them grouped in order: every 0, then every 1, then every 2. A general sorting algorithm would work but costs O(N log N) and ignores how little variety there is. With only three possible values we can do much better.

The simplest fast idea is to make two passes. First pass: count how many 0s, 1s, and 2s there are. Second pass: overwrite the array with that many 0s, then that many 1s, then the 2s. This is O(N) time and O(1) space, and honestly it is fine. The only thing left to improve is that it touches the array twice — can we finish it in a single sweep?

counts = [0, 0, 0]
for x in nums:
    counts[x] += 1
i = 0
for color in range(3):
    for _ in range(counts[color]):
        nums[i] = color
        i += 1

In Move Zeroes we used a single write pointer to split an array into two parts — keepers packed in front, the rest behind. Here we have three groups instead of two, so we grow two finished regions inward from the ends and sweep the unknown middle. Three markers do it:
- low — everything before low is a settled 0.
- high — everything after high is a settled 2.
- mid — the scanner, checking one value at a time, starting at the front.

Everything between low and mid is known to be 1, and everything from mid to high is still unexamined. As mid walks, it sorts each value into its region:
- Sees a 0: it belongs at the front, so swap it down to low, then move both low and mid forward.
- Sees a 2: it belongs at the back, so swap it up to high, then move high inward — but leave mid where it is.
- Sees a 1: it is already in the middle where 1s live, so just step mid forward.

low, mid = 0, 0
high = len(nums) - 1
while mid <= high:
    if nums[mid] == 0:
        nums[low], nums[mid] = nums[mid], nums[low]
        low += 1
        mid += 1
    elif nums[mid] == 2:
        nums[mid], nums[high] = nums[high], nums[mid]
        high -= 1                        # note: mid does NOT advance here
    else:                                # nums[mid] == 1
        mid += 1

This three-pointer sweep is called the Dutch National Flag partition, and its real lesson generalizes past colors: when you must rearrange an array in place into a small, fixed number of categories in one pass, grow the finished categories inward from the boundaries and scan the shrinking unknown middle. Move Zeroes was the two-category version (keep vs. not) with one boundary pointer; this is the three-category version with two. The signal to reach for it: the values come from a tiny fixed set (or split cleanly into "less than / equal / greater than a pivot" — which is exactly how quicksort partitions), and you want O(1) space and a single sweep. The invariant that keeps it correct — before low all 0s, before mid all 1s, after high all 2s — is the thing to hold in your head; every move preserves it.