Skip to content

Latest commit

 

History

History
176 lines (174 loc) · 5.18 KB

149.md

File metadata and controls

176 lines (174 loc) · 5.18 KB

Results of GPT-3.5 on HumanEval/149

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

Prompt

Tokens: 213

def sorted_list_sum(lst):
    """Write a function that accepts a list of strings as a parameter,
    deletes the strings that have odd lengths from it,
    and returns the resulted list with a sorted order,
    The list is always a list of strings and never an array of numbers,
    and it may contain duplicates.
    The order of the list should be ascending by length of each word, and you
    should return the list sorted by that rule.
    If two words have the same length, sort the list alphabetically.
    The function should return a list of strings in sorted order.
    You may assume that all words will have the same length.
    For example:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

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

Correct solution

def sorted_list_sum(lst):
    """Write a function that accepts a list of strings as a parameter,
    deletes the strings that have odd lengths from it,
    and returns the resulted list with a sorted order,
    The list is always a list of strings and never an array of numbers,
    and it may contain duplicates.
    The order of the list should be ascending by length of each word, and you
    should return the list sorted by that rule.
    If two words have the same length, sort the list alphabetically.
    The function should return a list of strings in sorted order.
    You may assume that all words will have the same length.
    For example:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """lst.sort()
    new_lst = []
    for i in lst:
        if len(i)%2 == 0:
            new_lst.append(i)
    return sorted(new_lst, key=len)

Unit tests

def check(candidate):

    # Check some simple cases
    assert candidate(["aa", "a", "aaa"]) == ["aa"]
    assert candidate(["school", "AI", "asdf", "b"]) == ["AI", "asdf", "school"]
    assert candidate(["d", "b", "c", "a"]) == []
    assert candidate(["d", "dcba", "abcd", "a"]) == ["abcd", "dcba"]

    # Check some edge cases that are easy to work out by hand.
    assert candidate(["AI", "ai", "au"]) == ["AI", "ai", "au"]
    assert candidate(["a", "b", "b", "c", "c", "a"]) == []
    assert candidate(['aaaa', 'bbbb', 'dd', 'cc']) == ["cc", "dd", "aaaa", "bbbb"]

Runs

✅ Run 1

Start time: 2023-07-18 17:02:58
Duration: 2.27s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 2

Start time: 2023-07-18 17:02:55
Duration: 2.66s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 3

Start time: 2023-07-18 17:02:53
Duration: 2.27s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 4

Start time: 2023-07-18 17:02:51
Duration: 2.0s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 5

Start time: 2023-07-18 17:02:49
Duration: 1.92s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 6

Start time: 2023-07-18 17:02:47
Duration: 2.04s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 7

Start time: 2023-07-18 17:02:45
Duration: 1.98s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 8

Start time: 2023-07-18 17:02:43
Duration: 2.11s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 9

Start time: 2023-07-18 17:02:41
Duration: 2.02s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst

✅ Run 10

Start time: 2023-07-18 17:02:38
Duration: 2.26s
Completion tokens: 42
Result: Pass

def sorted_list_sum(lst):
    lst = [word for word in lst if len(word) % 2 == 0]
    lst.sort(key=lambda x: (len(x), x))
    return lst