he-026

# HumanEval/26

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; your file must define it at module level.

```python
from typing import List


def remove_duplicates(numbers: List[int]) -> List[int]:
    """ From a list of integers, remove all elements that occur more than once.
    Keep order of elements left the same as in the input.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """
```

<!-- imported from OpenAI HumanEval (HumanEval/26) -->

# Auto-generated from OpenAI HumanEval HumanEval/26. Do not edit by hand.
from solution import *  # noqa: F401,F403 (prompt helpers may be referenced by tests)
from solution import remove_duplicates as candidate

METADATA = {
    'author': 'jt',
    'dataset': 'test'
}


def check(candidate):
    assert candidate([]) == []
    assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
    assert candidate([1, 2, 3, 2, 4, 3, 5]) == [1, 4, 5]


def test_he_026():
    check(candidate)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
from typing import List
from collections import Counter


def remove_duplicates(numbers: List[int]) -> List[int]:
    """ From a list of integers, remove all elements that occur more than once.
    Keep order of elements left the same as in the input.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """
    count = Counter(numbers)
    return [num for num in numbers if count[num] == 1]
```

The task is to implement a function that removes all elements that occur more than once from a list of integers, while maintaining the order of the remaining elements.

Let me trace through the example:
- Input: [1, 2, 3, 2, 4]
- Count of each element: 1→1, 2→2, 3→1, 4→1
- Elements that occur more than once: 2 (appears twice)
- Remove 2 from the list: [1, 3, 4]

So the algorithm should:
1. Count the frequency of each element in the list
2. Keep only elements that appear exactly once
3. Maintain the original order

Let me write the solution:

```python
from typing import List
from collections import Counter

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ From a list of integers, remove all elements that occur more than once.
    Keep order of elements left the same as in the input.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """
    count = Counter(numbers)
    result = [num for num in numbers if count[num] == 1]
    return result
```

This should work correctly. Let me verify with the example:
- numbers = [1, 2, 3, 2, 4]
- count = {1: 1, 2: 2, 3: 1, 4: 1}
- For each num in numbers:
  - 1: count[1] == 1, keep it
  - 2: count[2] == 2, skip it
  - 3: count[3] == 1, keep it
  - 2: count[2] == 2, skip it
  - 4: count[4] == 1, keep it
- result = [1, 3, 4]

This matches the expected output!

I could also implement this without Counter, but using Counter is cleaner and more efficient.