9.md

Results of Code LLama 34B on HumanEval/9

Date: 01 September, 2023
Model: codellama-34b-instruct
Temperature: 0.2
Passing runs: 10
Total runs: 10
Success rate: 100%

Prompt

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]
    """

The above is an incomplete Python code fragment. Return the complete and correct code with no additional text.

Correct solution

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]
    """running_max = None
    result = []

    for n in numbers:
        if running_max is None:
            running_max = n
        else:
            running_max = max(running_max, n)

        result.append(running_max)

    return result

Unit tests

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]

Runs

✅ Run 1

Start time: 2023-09-01 02:48:30
Duration: 10.82s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 2

Start time: 2023-09-01 02:51:29
Duration: 13.03s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 3

Start time: 2023-09-01 02:54:25
Duration: 11.56s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 4

Start time: 2023-09-01 02:57:23
Duration: 11.13s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 5

Start time: 2023-09-01 03:00:23
Duration: 12.2s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 6

Start time: 2023-09-01 03:03:25
Duration: 13.31s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 7

Start time: 2023-09-01 03:06:27
Duration: 10.15s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 8

Start time: 2023-09-01 03:09:31
Duration: 8.12s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 9

Start time: 2023-09-01 03:12:24
Duration: 9.64s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result

✅ Run 10

Start time: 2023-09-01 03:15:31
Duration: 12.48s
Result: Pass

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]
    """
    result = []
    current_max = 0
    for num in numbers:
        if num > current_max:
            current_max = num
        result.append(current_max)
    return result