Skip to content

Latest commit

 

History

History
361 lines (347 loc) · 9.93 KB

70.md

File metadata and controls

361 lines (347 loc) · 9.93 KB

Results of Code LLama 34B on HumanEval/70

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

Prompt

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

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

Correct solution

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''res, switch = [], True
    while lst:
        res.append(min(lst) if switch else max(lst))
        lst.remove(res[-1])
        switch = not switch
    return res

Unit tests

def check(candidate):

    # Check some simple cases
    assert candidate([1, 2, 3, 4]) == [1, 4, 2, 3]
    assert candidate([5, 6, 7, 8, 9]) == [5, 9, 6, 8, 7]
    assert candidate([1, 2, 3, 4, 5]) == [1, 5, 2, 4, 3]
    assert candidate([5, 6, 7, 8, 9, 1]) == [1, 9, 5, 8, 6, 7]
    assert candidate([5, 5, 5, 5]) == [5, 5, 5, 5]
    assert candidate([]) == []
    assert candidate([1,2,3,4,5,6,7,8]) == [1, 8, 2, 7, 3, 6, 4, 5]
    assert candidate([0,2,2,2,5,5,-5,-5]) == [-5, 5, -5, 5, 0, 2, 2, 2]
    assert candidate([111111]) == [111111]

    # Check some edge cases that are easy to work out by hand.
    assert True

Runs

❌ Run 1

Start time: 2023-09-01 02:47:30
Duration: 10.63s
Result: Fail

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        min_value = min(lst)
        max_value = max(lst)
        result.append(min_value)
        result.append(max_value)
        lst.remove(min_value)
        lst.remove(max_value)
    return result

❌ Run 2

Start time: 2023-09-01 02:50:30
Duration: 11.85s
Result: Fail

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        min_value = min(lst)
        max_value = max(lst)
        result.append(min_value)
        result.append(max_value)
        lst.remove(min_value)
        lst.remove(max_value)
    return result

❌ Run 3

Start time: 2023-09-01 02:53:28
Duration: 10.9s
Result: Fail

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    minimum = min(lst)
    maximum = max(lst)
    result = [minimum]
    while len(result) < len(lst):
        remaining = lst[:]
        remaining.remove(minimum)
        if remaining:
            maximum = max(remaining)
            result.append(maximum)
            remaining.remove(maximum)
            if remaining:
                minimum = min(remaining)
                result.append(minimum)
    return result

✅ Run 4

Start time: 2023-09-01 02:56:24
Duration: 10.24s
Result: Pass

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        minimum = min(lst)
        result.append(minimum)
        lst.remove(minimum)
        if lst:
            maximum = max(lst)
            result.append(maximum)
            lst.remove(maximum)
    return result

❌ Run 5

Start time: 2023-09-01 02:59:20
Duration: 15.22s
Result: Fail

def strange_sort_list(lst):
    """
    Given a list of integers, return the list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    """
    if not lst:
        return []
    min_val = min(lst)
    max_val = max(lst)
    result = [min_val]
    while len(lst) > 1:
        lst.remove(min_val)
        lst.remove(max_val)
        result.append(max_val)
        result.append(min_val)
        min_val = min(lst)
        max_val = max(lst)
    return result

✅ Run 6

Start time: 2023-09-01 03:02:22
Duration: 9.94s
Result: Pass

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        minimum = min(lst)
        result.append(minimum)
        lst.remove(minimum)
        if lst:
            maximum = max(lst)
            result.append(maximum)
            lst.remove(maximum)
    return result

✅ Run 7

Start time: 2023-09-01 03:05:27
Duration: 9.63s
Result: Pass

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        minimum = min(lst)
        result.append(minimum)
        lst.remove(minimum)
        if lst:
            maximum = max(lst)
            result.append(maximum)
            lst.remove(maximum)
    return result

❌ Run 8

Start time: 2023-09-01 03:08:31
Duration: 11.82s
Result: Fail

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    minimum = min(lst)
    maximum = max(lst)
    result = [minimum]
    while len(result) < len(lst):
        remaining = lst[:]
        remaining.remove(minimum)
        if remaining:
            maximum = max(remaining)
            result.append(maximum)
            remaining.remove(maximum)
            if remaining:
                minimum = min(remaining)
                result.append(minimum)
    return result

✅ Run 9

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

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    result = []
    while lst:
        minimum = min(lst)
        result.append(minimum)
        lst.remove(minimum)
        if lst:
            maximum = max(lst)
            result.append(maximum)
            lst.remove(maximum)
    return result

❌ Run 10

Start time: 2023-09-01 03:14:27
Duration: 12.12s
Result: Fail

def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''
    if not lst:
        return []
    minimum = min(lst)
    maximum = max(lst)
    result = [minimum]
    while len(result) < len(lst):
        remaining = lst[:]
        remaining.remove(minimum)
        if remaining:
            maximum = max(remaining)
            result.append(maximum)
            remaining.remove(maximum)
            if remaining:
                minimum = min(remaining)
                result.append(minimum)
    return result