Pitfall 1: Misreading the Problem as "Commas in a Single Number"

The most common mistake is confusing two completely different questions:

1. Sum of commas across the whole range [1, n] (what this problem actually asks).
2. Commas in the single formatted number n (what the method name countCommas misleadingly suggests).

Because the constraint guarantees n <= 10^5, every number in the range has at most one comma. This makes the per-number contribution either 0 (for 1–999) or 1 (for 1000–n). People who mentally map "count commas" to a single number often write:

# WRONG for this problem: counts commas in ONE number, not the whole range
return (len(str(n)) - 1) // 3

For n = 1000 this returns 1, but the correct answer is 1 only by coincidence. For n = 2000 it still returns 1, while the true answer is 1001 (numbers 1000 through 2000 each contribute one comma). Always confirm whether you are summing across a range or evaluating a single value.

Pitfall 2: Off-by-One When Counting [1000, n]

When deriving n - 999, it is tempting to write n - 1000 instead, reasoning "subtract the first number that has a comma." That undercounts by one because the range [1000, n] is inclusive on both ends:

# WRONG: drops the number 1000 itself
return max(0, n - 1000)

The correct count of integers in [1000, n] is n - 1000 + 1 = n - 999. A quick sanity check with the smallest commafied value catches this: for n = 1000, exactly one number has a comma, so the answer must be 1, and 1000 - 999 = 1 ✓, whereas 1000 - 1000 = 0 ✗.

Pitfall 3: Forgetting to Clamp the Lower Bound

Returning the raw expression without max(0, ...) produces negative results for small inputs:

# WRONG: returns negative values for n <= 999
return n - 999   # e.g., n = 5 -> -994

Any input from 1 to 999 should yield 0. Wrapping the expression in max(0, ...) (or an explicit if n < 1000: return 0) merges the two cases cleanly and guards against negatives.

Pitfall 4: Assuming the Pattern Holds Beyond the Constraints

The one-line formula max(0, n - 999) relies on the guarantee that n <= 10^5, so no number ever needs a second comma. If the constraints were relaxed (e.g., n up to 10^9), numbers ≥ 1,000,000 would each contribute two commas, and ≥ 1,000,000,000 would contribute three. The shortcut would then silently undercount.

Robust solution that works for any range by summing per-number comma counts in digit-group bands:

class Solution:
    def countCommas(self, n: int) -> int:
        if n < 1000:
            return 0
        total = 0
        # Each band [10^(3k), 10^(3(k+1)) - 1] contributes k commas per number.
        # Walk thresholds: 1000, 1_000_000, 1_000_000_000, ...
        threshold = 1000
        commas_per_number = 1
        while threshold <= n:
            upper = min(n, threshold * 1000 - 1)
            total += (upper - threshold + 1) * commas_per_number
            threshold *= 1000
            commas_per_number += 1
        return total

For n <= 10^5 this reduces to the same value as max(0, n - 999), but it remains correct if the limits ever grow. Match the chosen solution to the actual constraints, and prefer the general version when input bounds are uncertain.