145.md

Results of GPT-3.5 on HumanEval/145

Date: 18 July, 2023
Model: gpt-3.5-turbo
Temperature: 0.2
Passing runs: 0
Total runs: 10
Success rate: 0%

Prompt

Tokens: 141

def order_by_points(nums):
    """
    Write a function which sorts the given list of integers
    in ascending order according to the sum of their digits.
    Note: if there are several items with similar sum of their digits,
    order them based on their index in original list.

    For example:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

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

Correct solution

def order_by_points(nums):
    """
    Write a function which sorts the given list of integers
    in ascending order according to the sum of their digits.
    Note: if there are several items with similar sum of their digits,
    order them based on their index in original list.

    For example:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """def digits_sum(n):
        neg = 1
        if n < 0: n, neg = -1 * n, -1 
        n = [int(i) for i in str(n)]
        n[0] = n[0] * neg
        return sum(n)
    return sorted(nums, key=digits_sum)

Unit tests

def check(candidate):

    # Check some simple cases
    assert candidate([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    assert candidate([1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]) == [0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]
    assert candidate([]) == []
    assert candidate([1, -11, -32, 43, 54, -98, 2, -3]) == [-3, -32, -98, -11, 1, 2, 43, 54]
    assert candidate([1,2,3,4,5,6,7,8,9,10,11]) == [1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]
    assert candidate([0,6,6,-76,-21,23,4]) == [-76, -21, 0, 4, 23, 6, 6]

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"

Runs

❌ Run 1

Start time: 2023-07-18 17:03:44
Duration: 2.02s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 2

Start time: 2023-07-18 17:03:42
Duration: 1.86s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 3

Start time: 2023-07-18 17:03:40
Duration: 1.69s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 4

Start time: 2023-07-18 17:03:38
Duration: 1.72s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 5

Start time: 2023-07-18 17:03:36
Duration: 1.78s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 6

Start time: 2023-07-18 17:03:34
Duration: 2.08s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 7

Start time: 2023-07-18 17:03:32
Duration: 1.93s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 8

Start time: 2023-07-18 17:03:30
Duration: 2.04s
Completion tokens: 32
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(abs(x))), nums.index(x)))

❌ Run 9

Start time: 2023-07-18 17:03:28
Duration: 2.06s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))

❌ Run 10

Start time: 2023-07-18 17:03:26
Duration: 2.05s
Completion tokens: 31
Result: Fail

def order_by_points(nums):
    return sorted(nums, key=lambda x: (sum(int(digit) for digit in str(x)), nums.index(x)))