Skip to content

Latest commit

 

History

History
367 lines (320 loc) · 10.7 KB

10.md

File metadata and controls

367 lines (320 loc) · 10.7 KB

Results of GPT-4 on HumanEval/10

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

Prompt

Tokens: 168

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

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

Correct solution

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """if not string:
        return ''

    beginning_of_suffix = 0

    while not is_palindrome(string[beginning_of_suffix:]):
        beginning_of_suffix += 1

    return string + string[:beginning_of_suffix][::-1]

Unit tests

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


def check(candidate):
    assert candidate('') == ''
    assert candidate('x') == 'x'
    assert candidate('xyz') == 'xyzyx'
    assert candidate('xyx') == 'xyx'
    assert candidate('jerry') == 'jerryrrej'

Runs

✅ Run 1

Start time: 2023-07-18 18:54:56
Duration: 12.21s
Completion tokens: 174
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


if __name__ == "__main__":
    import doctest
    doctest.testmod()

✅ Run 2

Start time: 2023-07-18 18:54:42
Duration: 14.43s
Completion tokens: 174
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


if __name__ == "__main__":
    import doctest
    doctest.testmod()

✅ Run 3

Start time: 2023-07-18 18:54:28
Duration: 13.63s
Completion tokens: 174
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


if __name__ == "__main__":
    import doctest
    doctest.testmod()

✅ Run 4

Start time: 2023-07-18 18:54:09
Duration: 18.44s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 5

Start time: 2023-07-18 18:53:53
Duration: 15.95s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 6

Start time: 2023-07-18 18:53:36
Duration: 17.76s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 7

Start time: 2023-07-18 18:53:12
Duration: 23.89s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]

# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 8

Start time: 2023-07-18 18:52:51
Duration: 20.13s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 9

Start time: 2023-07-18 18:52:37
Duration: 13.84s
Completion tokens: 197
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


# Test cases
print(make_palindrome(''))  # ''
print(make_palindrome('cat'))  # 'catac'
print(make_palindrome('cata'))  # 'catac'

✅ Run 10

Start time: 2023-07-18 18:52:23
Duration: 14.59s
Completion tokens: 174
Result: Pass

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """ Find the shortest palindrome that begins with a supplied string.
    Algorithm idea is simple:
    - Find the longest postfix of supplied string that is a palindrome.
    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    """
    if is_palindrome(string):
        return string
    else:
        for i in range(len(string) - 1, -1, -1):
            if is_palindrome(string[i:]):
                return string + string[:i][::-1]


if __name__ == "__main__":
    import doctest
    doctest.testmod()