he-000

# HumanEval/0

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 has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Check if in given list of numbers, are any two numbers closer to each other than
    given threshold.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """
```

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

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

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


def check(candidate):
    assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True
    assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False
    assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True
    assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.8) == False
    assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1) == True
    assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 1.0) == True
    assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 0.5) == False


def test_he_000():
    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


def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Check if in given list of numbers, are any two numbers closer to each other than
    given threshold.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """
    sorted_numbers = sorted(numbers)
    for i in range(len(sorted_numbers) - 1):
        if sorted_numbers[i + 1] - sorted_numbers[i] < threshold:
            return True
    return False
```

The user wants me to implement the function `has_close_elements` that checks if any two numbers in a list are closer to each other than a given threshold.

Let me think about the approach:

1. A naive approach would be to check all pairs, which is O(n²).
2. A more efficient approach is to sort the list first, then check adjacent elements. If any two adjacent elements (after sorting) are closer than the threshold, then we return True. This is O(n log n).

The logic:
- Sort the numbers
- Iterate through adjacent pairs
- If the difference between any adjacent pair is less than the threshold, return True
- If we finish without finding such a pair, return False

Let me verify with the examples:
- `[1.0, 2.0, 3.0]`, threshold `0.5`: Sorted is `[1.0, 2.0, 3.0]`. Differences: 1.0, 1.0. None < 0.5. Returns False. ✓
- `[1.0, 2.8, 3.0, 4.0, 5.0, 2.0]`, threshold `0.3`: Sorted is `[1.0, 2.0, 2.8, 3.0, 4.0, 5.0]`. Differences: 1.0, 0.8, 0.2, 1.0, 1.0. 0.2 < 0.3. Returns True. ✓

This approach is correct because if any two numbers are closer than the threshold, then after sorting, there must be at least one pair of adjacent elements that are closer than the threshold.

Let me write the solution:

```python
from typing import List


def has_close_elements(numbers: List[float], threshold: float) -> bool:
    sorted_numbers = sorted(numbers)
    for i in range(len(sorted_numbers) - 1):
        if sorted_numbers[i + 1] - sorted_numbers[i] < threshold:
            return True
    return False
```

This is clean and efficient.