he-009

# HumanEval/9

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, Tuple


def rolling_max(numbers: List[int]) -> List[int]:
    """ From a given list of integers, generate a list of rolling maximum element found until given moment
    in the sequence.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """
```

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

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

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


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


def test_he_009():
    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, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```

The user wants me to implement a function `rolling_max` that takes a list of integers and returns a list of rolling maximums.
For example, given `[1, 2, 3, 2, 3, 4, 2]`, the output should be `[1, 2, 3, 3, 3, 4, 4]`.
This means for each index `i`, the output at `i` is `max(numbers[0]...numbers[i])`.

Let's implement it simply:
```python
def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```

Wait, what if `numbers` is empty? The problem doesn't specify, but returning `[]` is safe.
Let's check the type hints: `from typing import List, Tuple` is given.
The function signature is:
```python
def rolling_max(numbers: List[int]) -> List[int]:
```

I'll write the complete `solution.py` file.

One minor point: `current_max` should be initialized properly. If `numbers` is empty, handle it.
Actually, the loop approach works fine.

Let's test mentally:
`numbers = [1, 2, 3, 2, 3, 4, 2]`
i=0: num=1, current_max=1, res=[1]
i=1: num=2, current_max=2, res=[1, 2]
i=2: num=3, current_max=3, res=[1, 2, 3]
i=3: num=2, current_max=3, res=[1, 2, 3, 3]
i=4: num=3, current_max=3, res=[1, 2, 3, 3, 3]
i=5: num=4, current_max=4, res=[1, 2, 3, 3, 3, 4]
i=6: num=2, current_max=4, res=[1, 2, 3, 3, 3, 4, 4]
Matches example.

Edge cases: negative numbers? `current_max` initialized to `numbers[0]` handles it.
Empty list? Returns `[]`.

Code structure:
```python
from typing import List

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```

Wait, the prompt says `from typing import List, Tuple` is already in the stub, but I'll include it or just assume it's there. I'll provide the full file content.

One thing: `current_max` could be initialized to `-float('inf')` to avoid checking `if not numbers`, but checking is fine.
Actually, a simpler way:
```python
def rolling_max(numbers: List[int]) -> List[int]:
    res = []
    cur = -float('inf')
    for n in numbers:
        if n > cur:
            cur = n
        res.append(cur)
    return res
```
This handles empty lists correctly (returns `[]`), and works for any integers. But `-float('inf')` might be slightly slower or less pythonic than just handling the first element. I'll stick to the first approach or just use `max` accumulation.

Actually, the simplest and most Pythonic:
```python
def rolling_max(numbers: List[int]) -> List[int]:
    result = []
    current_max = float('-inf')
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```
Wait, `float('-inf')` works, but if `numbers` contains only integers, it's fine.
Alternatively:
```python
def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = [numbers[0]]
    for i in range(1, len(numbers)):
        result.append(max(result[-1], numbers[i]))
    return result
```
This is clean.

Let's stick to the straightforward loop.

I will write the complete `solution.py`.

```python
from typing import List

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```

Wait, the prompt includes `from typing import List, Tuple` in the stub. I'll include it to be safe, or just assume it's there. The prompt says "Keep the given name and signature; your file must define it at module level."

I'll output exactly the code.

One minor point: `max` function in Python is fine, but manual comparison is faster. Either is acceptable.

Let's verify with the example:
`rolling_max([1, 2, 3, 2, 3, 4, 2])` -> `[1, 2, 3, 3, 3, 4, 4]`
Correct.

I will produce the final answer.
No extra fluff.
Code:
```python
from typing import List

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```
Actually, I can make it slightly more concise:
```python
from typing import List

def rolling_max(numbers: List[int]) -> List[int]:
    res = []
    cur = float('-inf')
    for n in numbers:
        if n > cur:
            cur = n
        res.append(cur)
    return res
```
But `float('-inf')` might be considered less strict than integers. I'll stick to the first one. It's robust.

Wait, `current_max = numbers[0]` assumes `numbers` is not empty. The `if not numbers: return []` handles it.
All good.

I will format it properly.
One thing: The prompt says `from typing import List, Tuple` is in the stub. I'll include it.
Final code:
```python
from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```
This matches the requirement.
I'll output it. 
Wait, should I use `max`? It doesn't matter. The manual check is fine.
I'll produce the solution. 
All steps verified.
Output matches request.
Proceeds. 
Self-Correction/Refinement during thought: 
Actually, `current_max` can be initialized to `-float('inf')` to avoid the `if not numbers` check, but it's fine either way. I'll keep the `if not numbers` check for clarity. 
The problem is from HumanEval, so standard solutions are expected. 
I will output the code block. 
Done. 
Let's generate. 
```python
from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    if not numbers:
        return []
    result = []
    current_max = numbers[0]
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result
```
Looks good.
One minor point: `Tuple` is imported but unused. That's fine, it was in the prompt stub. I'll keep it or remove it. The prompt says "Keep the given name and signature". I'll just include the import as given.
Ready. 
Output matches. 
Proceeds. 
[Final Check]
Input: `[1, 2, 3, 2, 3, 4, 2]`
Output: `[1, 2, 3, 3, 3, 4, 4]`
Matches docstring.
Complexity: O(N) time, O(N) space. Optimal.
Code is clean.
Done. 
Output generation. 
(Self-Correction/Note during generation prep)
I'll make sure the indentation and formatting are exact.
The prompt asks for `solution.py`.
I will wrap it in ```python ... ```.
All good. 
Proceeds. 
[Output Generation] -> *Proceeds*