Pitfall 1: Failing to count the digit 0 in numbers that are exactly 0

The most subtle bug in this solution comes from the loop condition while num:. When num is 0, the loop body never executes because 0 is falsy in Python. This means that if digit is 0 and the array contains the value 0, that occurrence will be missed entirely.

Example of the bug:

• Suppose nums = [0, 10, 5] and digit = 0.
• For 0: the while num: loop is skipped, so 0 contributes 0 (incorrectly — it should contribute 1).
• For 10: the digit 0 is counted once.
• For 5: no 0 found.
• The code returns 1, but the correct answer is 2.

Why it happens:

The while x: idiom is a convenient way to peel off digits, but it implicitly assumes that the number has at least one "real" digit to process. The number 0 is special: it is a single digit 0, yet its truthiness check immediately terminates the loop.

Solution:

Use a do-while style loop that guarantees the body runs at least once, so the single 0 digit gets processed:

class Solution:
    def countDigitOccurrences(self, nums: list[int], digit: int) -> int:
        count = 0
        for num in nums:
            # Guarantee the loop runs at least once to handle num == 0
            while True:
                current_digit = num % 10
                if current_digit == digit:
                    count += 1
                num //= 10
                if num == 0:
                    break
        return count

Alternatively, convert each number to a string, which naturally handles 0 as the single character "0":

class Solution:
    def countDigitOccurrences(self, nums: list[int], digit: int) -> int:
        target = str(digit)
        return sum(str(num).count(target) for num in nums)

Pitfall 2: Not handling negative numbers

If the problem allows negative values in nums, the arithmetic approach can behave unexpectedly. In Python, -123 % 10 returns 7 (not 3) and -123 // 10 returns -13 (floor division rounds toward negative infinity), so the digit extraction breaks down completely.

Example of the bug:

• For num = -123 and digit = 3, you would expect to count the 3, but -123 % 10 == 7, so the count is wrong, and the loop may not even terminate cleanly the way you'd expect.

Solution:

Take the absolute value before processing, since the sign does not affect which digits appear:

class Solution:
    def countDigitOccurrences(self, nums: list[int], digit: int) -> int:
        count = 0
        for num in nums:
            num = abs(num)   # Strip the sign before extracting digits
            while True:
                if num % 10 == digit:
                    count += 1
                num //= 10
                if num == 0:
                    break
        return count

Pitfall 3: Misinterpreting digit as a multi-digit value

The logic current_digit = num % 10 only ever produces a single digit (0–9). If a caller mistakenly passes digit = 12, the comparison current_digit == digit will never be true, silently returning 0 instead of signaling an error.

Solution:

Validate the input range up front so the contract is explicit:

if not (0 <= digit <= 9):
    raise ValueError("digit must be a single decimal digit (0-9)")

This makes incorrect usage fail loudly rather than producing a misleadingly "valid" answer of 0.