Problem Narrative

You’re on the fraud engineering team at a large fintech processing tens of millions of card transactions per day. A streaming job emits “suspicious transaction IDs” from multiple detectors, and downstream systems must deduplicate these IDs quickly to avoid double-counting fraud alerts (which impacts analyst workload and regulatory reporting).

A teammate shipped the following Python function, but production metrics show both incorrect results and high CPU usage:

def unique_suspicious_ids(ids):
    unique = []
    for x in ids:
        if ids.count(x) == 1:   # keep IDs that appear once
            unique.append(x)
    return unique

Task

Refactor the function into:

def unique_suspicious_ids(ids: list[int]) -> list[int]:
    ...

Requirements

1. Bug fix (correctness): Return all IDs that appear exactly once in the input.
2. Performance: Your solution must run in O(n) time for n = len(ids).
3. Output order: Preserve the original order of IDs that are unique.
4. No mutation: Do not modify the input list ids.

Examples

Example 1

• Input: ids = [42, 17, 42, 9]
• Output: [17, 9]
• Explanation: 42 appears twice, so it’s excluded. 17 and 9 appear once and remain in original order.

Example 2

• Input: ids = [5, 5, 5]
• Output: []
• Explanation: No ID appears exactly once.

Constraints

• 0 <= len(ids) <= 2 * 10^5
• -10^9 <= ids[i] <= 10^9

Notes

• The provided snippet is slow because it repeatedly scans the entire list.
• Be explicit about what the bug is and why your refactor fixes it while improving performance.