he-021

# HumanEval/21

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 rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Given list of numbers (of at least two elements), apply a linear transform to that list,
    such that the smallest number will become 0 and the largest will become 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """
```

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

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

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


def check(candidate):
    assert candidate([2.0, 49.9]) == [0.0, 1.0]
    assert candidate([100.0, 49.9]) == [1.0, 0.0]
    assert candidate([1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
    assert candidate([2.0, 1.0, 5.0, 3.0, 4.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]
    assert candidate([12.0, 11.0, 15.0, 13.0, 14.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]


def test_he_021():
    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 rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Given list of numbers (of at least two elements), apply a linear transform to that list,
    such that the smallest number will become 0 and the largest will become 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """
    min_val = min(numbers)
    max_val = max(numbers)
    range_val = max_val - min_val
    
    if range_val == 0:
        return [0.0] * len(numbers)
    
    return [(num - min_val) / range_val for num in numbers]
```

The task is to implement a function `rescale_to_unit` that takes a list of numbers and applies a linear transformation so that:
- The smallest number becomes 0
- The largest number becomes 1

This is a standard min-max normalization. The formula is:
```
normalized_value = (value - min_value) / (max_value - min_value)
```

Let me trace through the example:
- Input: [1.0, 2.0, 3.0, 4.0, 5.0]
- min = 1.0, max = 5.0
- For 1.0: (1.0 - 1.0) / (5.0 - 1.0) = 0.0 / 4.0 = 0.0
- For 2.0: (2.0 - 1.0) / (5.0 - 1.0) = 1.0 / 4.0 = 0.25
- For 3.0: (3.0 - 1.0) / (5.0 - 1.0) = 2.0 / 4.0 = 0.5
- For 4.0: (4.0 - 1.0) / (5.0 - 1.0) = 3.0 / 4.0 = 0.75
- For 5.0: (5.0 - 1.0) / (5.0 - 1.0) = 4.0 / 4.0 = 1.0

Output: [0.0, 0.25, 0.5, 0.75, 1.0] ✓

Edge cases to consider:
1. All numbers are the same (min == max) - this would cause division by zero. However, the problem says "at least two elements" but doesn't specify they must be different. I should handle this case, but typically in min-max normalization, if all values are the same, we might return all zeros or handle it specially. Let me check if there's a standard approach.
   
   Actually, looking at the problem statement, it says "at least two elements" but doesn't guarantee they're different. If all elements are the same, max - min = 0, which would cause division by zero. I should handle this edge case. A common approach is to return all zeros or all ones, or raise an error. Since this is a HumanEval problem, I'll assume the test cases don't have all identical values, but I should still handle it gracefully.

2. Negative numbers - the formula should still work
3. Float precision - should work fine

Let me write the solution:

```python
from typing import List


def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Given list of numbers (of at least two elements), apply a linear transform to that list,
    such that the smallest number will become 0 and the largest will become 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """
    min_val = min(numbers)
    max_val = max(numbers)
    range_val = max_val - min_val
    
    if range_val == 0:
        # All values are the same, return all zeros (or could return all ones)
        return [0.0] * len(numbers)
    
    return [(num - min_val) / range_val for num in numbers]
```

I'll handle the edge case where all values are identical by returning a list of zeros. This prevents division by zero and provides a consistent output.