or4cl3ai/SoundSlayerAI
Text-to-Speech
•
Updated
•
22
•
16
task_id
stringlengths 11
13
| docstring
stringlengths 56
1.28k
| prompt
stringlengths 118
1.38k
| canonical_solution
stringlengths 16
864
| test
stringlengths 117
1.8k
| entry_point
stringlengths 1
30
| signature
stringlengths 4
68
| context
stringlengths 9
459
| instruction
stringlengths 123
1.34k
| instruction_noexamples
stringlengths 90
1.2k
| prompt_noexamples
stringlengths 69
1.22k
|
|---|---|---|---|---|---|---|---|---|---|---|
HumanEval/0 | Проверьте, есть ли в заданном списке чисел какие-либо два числа ближе друг к другу, чем заданный порог.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""
Проверьте, есть ли в заданном списке чисел какие-либо два числа ближе друг к другу, чем заданный порог.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
"""
| for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.8) == False
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1) == True
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 1.0) == True
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 0.5) == False
| has_close_elements | has_close_elements(numbers: List[float], threshold: float) -> bool | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool: | Напишите функцию has_close_elements(numbers: List[float], threshold: float) -> bool для решения следующей задачи: Проверьте, есть ли в заданном списке чисел какие-либо два числа ближе друг к другу, чем заданный порог.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True | Напишите функцию has_close_elements(numbers: List[float], threshold: float) -> bool для решения следующей задачи: Проверьте, есть ли в заданном списке чисел какие-либо два числа ближе друг к другу, чем заданный порог. | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""
Проверьте, есть ли в заданном списке чисел какие-либо два числа ближе друг к другу, чем заданный порог.
"""
|
HumanEval/1 | Входными данными для этой функции является строка, содержащая несколько групп вложенных круглых скобок. Задача состоит в том, чтобы разделить эти группы на отдельные строки и вернуть их список.
Отдельные группы сбалансированы (каждая открытая фигурная скобка правильно закрыта) и не вложены друг в друга, игнорируя любые пробелы во входной строке.
>>> separate_paren_groups('( ) (( )) (( )( ))')
['()', '(())', '(()())'] | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""
Входными данными для этой функции является строка, содержащая несколько групп вложенных круглых скобок. Задача состоит в том, чтобы разделить эти группы на отдельные строки и вернуть их список.
Отдельные группы сбалансированы (каждая открытая фигурная скобка правильно закрыта) и не вложены друг в друга, игнорируя любые пробелы во входной строке.
>>> separate_paren_groups('( ) (( )) (( )( ))')
['()', '(())', '(()())']
"""
| result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [
'(()())', '((()))', '()', '((())()())'
]
assert candidate('() (()) ((())) (((())))') == [
'()', '(())', '((()))', '(((())))'
]
assert candidate('(()(())((())))') == [
'(()(())((())))'
]
assert candidate('( ) (( )) (( )( ))') == ['()', '(())', '(()())']
| separate_paren_groups | separate_paren_groups(paren_string: str) -> List[str] | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]: | Напишите функцию separate_paren_groups(paren_string: str) -> List[str] для решения следующей задачи: Входными данными для этой функции является строка, содержащая несколько групп вложенных круглых скобок. Задача состоит в том, чтобы разделить эти группы на отдельные строки и вернуть их список.
Отдельные группы сбалансированы (каждая открытая фигурная скобка правильно закрыта) и не вложены друг в друга, игнорируя любые пробелы во входной строке.
>>> separate_paren_groups('( ) (( )) (( )( ))')
['()', '(())', '(()())'] | Напишите функцию separate_paren_groups(paren_string: str) -> List[str] для решения следующей задачи: Входными данными для этой функции является строка, содержащая несколько групп вложенных круглых скобок. Задача состоит в том, чтобы разделить эти группы на отдельные строки и вернуть их список.
Отдельные группы сбалансированы (каждая открытая фигурная скобка правильно закрыта) и не вложены друг в друга, игнорируя любые пробелы во входной строке. | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""
Входными данными для этой функции является строка, содержащая несколько групп вложенных круглых скобок. Задача состоит в том, чтобы разделить эти группы на отдельные строки и вернуть их список.
Отдельные группы сбалансированы (каждая открытая фигурная скобка правильно закрыта) и не вложены друг в друга, игнорируя любые пробелы во входной строке.
"""
|
HumanEval/2 | Дано положительное число с плавающей запятой, его можно разложить на целую часть (наибольшее целое число меньше заданного числа) и десятичные дроби (оставшаяся часть всегда меньше 1).
Возвращает десятичную часть числа.
>>> truncate_number(3.5)
0.5 | def truncate_number(number: float) -> float:
"""
Дано положительное число с плавающей запятой, его можно разложить на целую часть (наибольшее целое число меньше заданного числа) и десятичные дроби (оставшаяся часть всегда меньше 1).
Возвращает десятичную часть числа.
>>> truncate_number(3.5)
0.5
"""
| return number % 1.0
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3.5) == 0.5
assert abs(candidate(1.33) - 0.33) < 1e-6
assert abs(candidate(123.456) - 0.456) < 1e-6
| truncate_number | truncate_number(number: float) -> float | def truncate_number(number: float) -> float: | Напишите функцию truncate_number(number: float) -> float для решения следующей задачи: Дано положительное число с плавающей запятой, его можно разложить на целую часть (наибольшее целое число меньше заданного числа) и десятичные дроби (оставшаяся часть всегда меньше 1).
Возвращает десятичную часть числа.
>>> truncate_number(3.5)
0.5 | Напишите функцию truncate_number(number: float) -> float для решения следующей задачи: Дано положительное число с плавающей запятой, его можно разложить на целую часть (наибольшее целое число меньше заданного числа) и десятичные дроби (оставшаяся часть всегда меньше 1).
Возвращает десятичную часть числа. | def truncate_number(number: float) -> float:
"""
Дано положительное число с плавающей запятой, его можно разложить на целую часть (наибольшее целое число меньше заданного числа) и десятичные дроби (оставшаяся часть всегда меньше 1).
Возвращает десятичную часть числа.
"""
|
HumanEval/3 | Вам предоставляется список операций по вводу и выводу средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить, падает ли в какой-либо момент баланс счета ниже нуля, и в этот момент функция должна возвращать значение True. В противном случае он должен возвращать значение False.
>>> below_zero([1, 2, 3])
False
>>> below_zero([1, 2, -4, 5])
True | from typing import List
def below_zero(operations: List[int]) -> bool:
"""
Вам предоставляется список операций по вводу и выводу средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить, падает ли в какой-либо момент баланс счета ниже нуля, и в этот момент функция должна возвращать значение True. В противном случае он должен возвращать значение False.
>>> below_zero([1, 2, 3])
False
>>> below_zero([1, 2, -4, 5])
True
"""
| balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == False
assert candidate([1, 2, -3, 1, 2, -3]) == False
assert candidate([1, 2, -4, 5, 6]) == True
assert candidate([1, -1, 2, -2, 5, -5, 4, -4]) == False
assert candidate([1, -1, 2, -2, 5, -5, 4, -5]) == True
assert candidate([1, -2, 2, -2, 5, -5, 4, -4]) == True
| below_zero | below_zero(operations: List[int]) -> bool | from typing import List
def below_zero(operations: List[int]) -> bool: | Напишите функцию below_zero(operations: List[int]) -> bool для решения следующей задачи: Вам предоставляется список операций по вводу и выводу средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить, падает ли в какой-либо момент баланс счета ниже нуля, и в этот момент функция должна возвращать значение True. В противном случае он должен возвращать значение False.
>>> below_zero([1, 2, 3])
False
>>> below_zero([1, 2, -4, 5])
True | Напишите функцию below_zero(operations: List[int]) -> bool для решения следующей задачи: Вам предоставляется список операций по вводу и выводу средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить, падает ли в какой-либо момент баланс счета ниже нуля, и в этот момент функция должна возвращать значение True. В противном случае он должен возвращать значение False. | from typing import List
def below_zero(operations: List[int]) -> bool:
"""
Вам предоставляется список операций по вводу и выводу средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить, падает ли в какой-либо момент баланс счета ниже нуля, и в этот момент функция должна возвращать значение True. В противном случае он должен возвращать значение False.
"""
|
HumanEval/4 | Для заданного списка входных чисел вычислите среднее абсолютное отклонение от среднего значения этого набора данных.
Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним значением):
MAD = среднее значение | x - x_mean /
>>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
1.0 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
"""
Для заданного списка входных чисел вычислите среднее абсолютное отклонение от среднего значения этого набора данных.
Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним значением):
MAD = среднее значение | x - x_mean /
>>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
1.0
"""
| mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert abs(candidate([1.0, 2.0, 3.0]) - 2.0/3.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0]) - 1.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0, 5.0]) - 6.0/5.0) < 1e-6
| mean_absolute_deviation | mean_absolute_deviation(numbers: List[float]) -> float | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float: | Напишите функцию mean_absolute_deviation(numbers: List[float]) -> float для решения следующей задачи: Для заданного списка входных чисел вычислите среднее абсолютное отклонение от среднего значения этого набора данных.
Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним значением):
MAD = среднее значение | x - x_mean /
>>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
1.0 | Напишите функцию mean_absolute_deviation(numbers: List[float]) -> float для решения следующей задачи: Для заданного списка входных чисел вычислите среднее абсолютное отклонение от среднего значения этого набора данных.
Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним значением):
MAD = среднее значение | x - x_mean / | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
"""
Для заданного списка входных чисел вычислите среднее абсолютное отклонение от среднего значения этого набора данных.
Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним значением):
MAD = среднее значение | x - x_mean /
"""
|
HumanEval/5 | Вставьте числовой "разделитель" между каждыми двумя последовательными элементами входного списка
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3] | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
"""
Вставьте числовой "разделитель" между каждыми двумя последовательными элементами входного списка
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 7) == []
assert candidate([5, 6, 3, 2], 8) == [5, 8, 6, 8, 3, 8, 2]
assert candidate([2, 2, 2], 2) == [2, 2, 2, 2, 2]
| intersperse | intersperse(numbers: List[int], delimeter: int) -> List[int] | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]: | Напишите функцию intersperse(numbers: List[int], delimeter: int) -> List[int] для решения следующей задачи: Вставьте числовой "разделитель" между каждыми двумя последовательными элементами входного списка
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3] | Напишите функцию intersperse(numbers: List[int], delimeter: int) -> List[int] для решения следующей задачи: Вставьте числовой "разделитель" между каждыми двумя последовательными элементами входного списка | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
"""
Вставьте числовой "разделитель" между каждыми двумя последовательными элементами входного списка
"""
|
HumanEval/6 | Входными данными для этой функции является строка, представленная несколькими группами для вложенных круглых скобок, разделенных пробелами.
Для каждой группы выведите самый глубокий уровень вложенности круглых скобок.
Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три.
>>> parse_nested_parens('(()()) ((())) () ((())()())')
[2, 3, 1, 3] | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
"""
Входными данными для этой функции является строка, представленная несколькими группами для вложенных круглых скобок, разделенных пробелами.
Для каждой группы выведите самый глубокий уровень вложенности круглых скобок.
Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три.
>>> parse_nested_parens('(()()) ((())) () ((())()())')
[2, 3, 1, 3]
"""
| def parse_paren_group(s):
depth = 0
max_depth = 0
for c in s:
if c == '(':
depth += 1
max_depth = max(depth, max_depth)
else:
depth -= 1
return max_depth
return [parse_paren_group(x) for x in paren_string.split(' ') if x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [2, 3, 1, 3]
assert candidate('() (()) ((())) (((())))') == [1, 2, 3, 4]
assert candidate('(()(())((())))') == [4]
| parse_nested_parens | parse_nested_parens(paren_string: str) -> List[int] | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]: | Напишите функцию parse_nested_parens(paren_string: str) -> List[int] для решения следующей задачи: Входными данными для этой функции является строка, представленная несколькими группами для вложенных круглых скобок, разделенных пробелами.
Для каждой группы выведите самый глубокий уровень вложенности круглых скобок.
Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три.
>>> parse_nested_parens('(()()) ((())) () ((())()())')
[2, 3, 1, 3] | Напишите функцию parse_nested_parens(paren_string: str) -> List[int] для решения следующей задачи: Входными данными для этой функции является строка, представленная несколькими группами для вложенных круглых скобок, разделенных пробелами.
Для каждой группы выведите самый глубокий уровень вложенности круглых скобок.
Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три. | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
"""
Входными данными для этой функции является строка, представленная несколькими группами для вложенных круглых скобок, разделенных пробелами.
Для каждой группы выведите самый глубокий уровень вложенности круглых скобок.
Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три.
"""
|
HumanEval/7 | Фильтруйте входной список строк, оставив только те, которые содержат заданную подстроку
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array'] | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
"""
Фильтруйте входной список строк, оставив только те, которые содержат заданную подстроку
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array']
"""
| return [x for x in strings if substring in x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
assert candidate(['xxx', 'asd', 'aaaxxy', 'john doe', 'xxxAAA', 'xxx'], 'xx') == ['xxx', 'aaaxxy', 'xxxAAA', 'xxx']
assert candidate(['grunt', 'trumpet', 'prune', 'gruesome'], 'run') == ['grunt', 'prune']
| filter_by_substring | filter_by_substring(strings: List[str], substring: str) -> List[str] | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]: | Напишите функцию filter_by_substring(strings: List[str], substring: str) -> List[str] для решения следующей задачи: Фильтруйте входной список строк, оставив только те, которые содержат заданную подстроку
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array'] | Напишите функцию filter_by_substring(strings: List[str], substring: str) -> List[str] для решения следующей задачи: Фильтруйте входной список строк, оставив только те, которые содержат заданную подстроку | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
"""
Фильтруйте входной список строк, оставив только те, которые содержат заданную подстроку
"""
|
HumanEval/8 | Для заданного списка целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке.
Сумма пустого списка должна быть равна 0, а произведение пустого списка должно быть равно 1.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24) | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
"""
Для заданного списка целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке.
Сумма пустого списка должна быть равна 0, а произведение пустого списка должно быть равно 1.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24)
"""
| sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == (0, 1)
assert candidate([1, 1, 1]) == (3, 1)
assert candidate([100, 0]) == (100, 0)
assert candidate([3, 5, 7]) == (3 + 5 + 7, 3 * 5 * 7)
assert candidate([10]) == (10, 10)
| sum_product | sum_product(numbers: List[int]) -> Tuple[int, int] | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]: | Напишите функцию sum_product(numbers: List[int]) -> Tuple[int, int] для решения следующей задачи: Для заданного списка целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке.
Сумма пустого списка должна быть равна 0, а произведение пустого списка должно быть равно 1.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24) | Напишите функцию sum_product(numbers: List[int]) -> Tuple[int, int] для решения следующей задачи: Для заданного списка целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке.
Сумма пустого списка должна быть равна 0, а произведение пустого списка должно быть равно 1. | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
"""
Для заданного списка целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке.
Сумма пустого списка должна быть равна 0, а произведение пустого списка должно быть равно 1.
"""
|
HumanEval/9 | Из заданного списка целых чисел сгенерируйте список скользящего максимального элемента, встретившегося в данный момент в последовательности.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4] | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
"""
Из заданного списка целых чисел сгенерируйте список скользящего максимального элемента, встретившегося в данный момент в последовательности.
>>> 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
|
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]
| rolling_max | rolling_max(numbers: List[int]) -> List[int] | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]: | Напишите функцию rolling_max(numbers: List[int]) -> List[int] для решения следующей задачи: Из заданного списка целых чисел сгенерируйте список скользящего максимального элемента, встретившегося в данный момент в последовательности.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4] | Напишите функцию rolling_max(numbers: List[int]) -> List[int] для решения следующей задачи: Из заданного списка целых чисел сгенерируйте список скользящего максимального элемента, встретившегося в данный момент в последовательности. | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
"""
Из заданного списка целых чисел сгенерируйте список скользящего максимального элемента, встретившегося в данный момент в последовательности.
"""
|
HumanEval/10 | Найдите самый короткий палиндром, который начинается с заданной строки.
Идея алгоритма проста:
- Найдите самый длинный постфикс предоставленной строки, который является палиндромом.
- Добавить в конец строки развернутый префикс строки, который стоит перед палиндромным суффиксом.
>>> make_palindrome('')
''
>>> make_palindrome('cat')
'catac'
>>> make_palindrome('cata')
'catac' | def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
"""
Найдите самый короткий палиндром, который начинается с заданной строки.
Идея алгоритма проста:
- Найдите самый длинный постфикс предоставленной строки, который является палиндромом.
- Добавить в конец строки развернутый префикс строки, который стоит перед палиндромным суффиксом.
>>> 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]
|
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'
| make_palindrome | make_palindrome(string: str) -> str | def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str: | Напишите функцию make_palindrome(string: str) -> str для решения следующей задачи: Найдите самый короткий палиндром, который начинается с заданной строки.
Идея алгоритма проста:
- Найдите самый длинный постфикс предоставленной строки, который является палиндромом.
- Добавить в конец строки развернутый префикс строки, который стоит перед палиндромным суффиксом.
>>> make_palindrome('')
''
>>> make_palindrome('cat')
'catac'
>>> make_palindrome('cata')
'catac' | Напишите функцию make_palindrome(string: str) -> str для решения следующей задачи: Найдите самый короткий палиндром, который начинается с заданной строки.
Идея алгоритма проста:
- Найдите самый длинный постфикс предоставленной строки, который является палиндромом.
- Добавить в конец строки развернутый префикс строки, который стоит перед палиндромным суффиксом. | def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
"""
Найдите самый короткий палиндром, который начинается с заданной строки.
Идея алгоритма проста:
- Найдите самый длинный постфикс предоставленной строки, который является палиндромом.
- Добавить в конец строки развернутый префикс строки, который стоит перед палиндромным суффиксом.
"""
|
HumanEval/11 | Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки.
>>> string_xor('010', '110')
'100' | from typing import List
def string_xor(a: str, b: str) -> str:
"""
Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки.
>>> string_xor('010', '110')
'100'
"""
| def xor(i, j):
if i == j:
return '0'
else:
return '1'
return ''.join(xor(x, y) for x, y in zip(a, b))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('111000', '101010') == '010010'
assert candidate('1', '1') == '0'
assert candidate('0101', '0000') == '0101'
| string_xor | string_xor(a: str, b: str) -> str | from typing import List
def string_xor(a: str, b: str) -> str: | Напишите функцию string_xor(a: str, b: str) -> str для решения следующей задачи: Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки.
>>> string_xor('010', '110')
'100' | Напишите функцию string_xor(a: str, b: str) -> str для решения следующей задачи: Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки. | from typing import List
def string_xor(a: str, b: str) -> str:
"""
Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки.
"""
|
HumanEval/12 | Из списка строк верните самую длинную. Возвращает первое значение в случае наличия нескольких строк одинаковой длины. Возвращает None в случае, если список ввода пуст.
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a'
>>> longest(['a', 'bb', 'ccc'])
'ccc' | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
"""
Из списка строк верните самую длинную. Возвращает первое значение в случае наличия нескольких строк одинаковой длины. Возвращает None в случае, если список ввода пуст.
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a'
>>> longest(['a', 'bb', 'ccc'])
'ccc'
"""
| if not strings:
return None
maxlen = max(len(x) for x in strings)
for s in strings:
if len(s) == maxlen:
return s
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == None
assert candidate(['x', 'y', 'z']) == 'x'
assert candidate(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc']) == 'zzzz'
| longest | longest(strings: List[str]) -> Optional[str] | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]: | Напишите функцию longest(strings: List[str]) -> Optional[str] для решения следующей задачи: Из списка строк верните самую длинную. Возвращает первое значение в случае наличия нескольких строк одинаковой длины. Возвращает None в случае, если список ввода пуст.
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a'
>>> longest(['a', 'bb', 'ccc'])
'ccc' | Напишите функцию longest(strings: List[str]) -> Optional[str] для решения следующей задачи: Из списка строк верните самую длинную. Возвращает первое значение в случае наличия нескольких строк одинаковой длины. Возвращает None в случае, если список ввода пуст. | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
"""
Из списка строк верните самую длинную. Возвращает первое значение в случае наличия нескольких строк одинаковой длины. Возвращает None в случае, если список ввода пуст.
"""
|
HumanEval/13 | Возвращает наибольший общий делитель двух целых чисел a и b
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5 | def greatest_common_divisor(a: int, b: int) -> int:
"""
Возвращает наибольший общий делитель двух целых чисел a и b
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
| while b:
a, b = b, a % b
return a
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3, 7) == 1
assert candidate(10, 15) == 5
assert candidate(49, 14) == 7
assert candidate(144, 60) == 12
| greatest_common_divisor | greatest_common_divisor(a: int, b: int) -> int | def greatest_common_divisor(a: int, b: int) -> int: | Напишите функцию greatest_common_divisor(a: int, b: int) -> int для решения следующей задачи: Возвращает наибольший общий делитель двух целых чисел a и b
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5 | Напишите функцию greatest_common_divisor(a: int, b: int) -> int для решения следующей задачи: Возвращает наибольший общий делитель двух целых чисел a и b | def greatest_common_divisor(a: int, b: int) -> int:
"""
Возвращает наибольший общий делитель двух целых чисел a и b
"""
|
HumanEval/14 | Возвращает список всех префиксов входной строки от самого короткого до самого длинного
>>> all_prefixes('abc')
['a', 'ab', 'abc'] | from typing import List
def all_prefixes(string: str) -> List[str]:
"""
Возвращает список всех префиксов входной строки от самого короткого до самого длинного
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| result = []
for i in range(len(string)):
result.append(string[:i+1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('asdfgh') == ['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']
assert candidate('WWW') == ['W', 'WW', 'WWW']
| all_prefixes | all_prefixes(string: str) -> List[str] | from typing import List
def all_prefixes(string: str) -> List[str]: | Напишите функцию all_prefixes(string: str) -> List[str] для решения следующей задачи: Возвращает список всех префиксов входной строки от самого короткого до самого длинного
>>> all_prefixes('abc')
['a', 'ab', 'abc'] | Напишите функцию all_prefixes(string: str) -> List[str] для решения следующей задачи: Возвращает список всех префиксов входной строки от самого короткого до самого длинного | from typing import List
def all_prefixes(string: str) -> List[str]:
"""
Возвращает список всех префиксов входной строки от самого короткого до самого длинного
"""
|
HumanEval/15 | Возвращает строку, содержащую числа, разделенные пробелами, начиная с 0 до n включительно.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5' | def string_sequence(n: int) -> str:
"""
Возвращает строку, содержащую числа, разделенные пробелами, начиная с 0 до n включительно.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
| return ' '.join([str(x) for x in range(n + 1)])
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(0) == '0'
assert candidate(3) == '0 1 2 3'
assert candidate(10) == '0 1 2 3 4 5 6 7 8 9 10'
| string_sequence | string_sequence(n: int) -> str | def string_sequence(n: int) -> str: | Напишите функцию string_sequence(n: int) -> str для решения следующей задачи: Возвращает строку, содержащую числа, разделенные пробелами, начиная с 0 до n включительно.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5' | Напишите функцию string_sequence(n: int) -> str для решения следующей задачи: Возвращает строку, содержащую числа, разделенные пробелами, начиная с 0 до n включительно. | def string_sequence(n: int) -> str:
"""
Возвращает строку, содержащую числа, разделенные пробелами, начиная с 0 до n включительно.
"""
|
HumanEval/16 | По входной строке выясните, из скольких различных символов (независимо от регистра) она состоит
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4 | def count_distinct_characters(string: str) -> int:
"""
По входной строке выясните, из скольких различных символов (независимо от регистра) она состоит
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
| return len(set(string.lower()))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('abcde') == 5
assert candidate('abcde' + 'cade' + 'CADE') == 5
assert candidate('aaaaAAAAaaaa') == 1
assert candidate('Jerry jERRY JeRRRY') == 5
| count_distinct_characters | count_distinct_characters(string: str) -> int | def count_distinct_characters(string: str) -> int: | Напишите функцию count_distinct_characters(string: str) -> int для решения следующей задачи: По входной строке выясните, из скольких различных символов (независимо от регистра) она состоит
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4 | Напишите функцию count_distinct_characters(string: str) -> int для решения следующей задачи: По входной строке выясните, из скольких различных символов (независимо от регистра) она состоит | def count_distinct_characters(string: str) -> int:
"""
По входной строке выясните, из скольких различных символов (независимо от регистра) она состоит
"""
|
HumanEval/17 | Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов не длится каждое из них.
Вот легенда:
"о" - целая нота, длится четыре такта
'o|' - половинная нота, длится два такта
'.|' - четвертная нота, длится один такт
>>> parse_music('o o| .| o| o| .| .| .| .| o o')
[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4] | from typing import List
def parse_music(music_string: str) -> List[int]:
"""
Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов не длится каждое из них.
Вот легенда:
"о" - целая нота, длится четыре такта
'o|' - половинная нота, длится два такта
'.|' - четвертная нота, длится один такт
>>> parse_music('o o| .| o| o| .| .| .| .| o o')
[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
"""
| note_map = {'o': 4, 'o|': 2, '.|': 1}
return [note_map[x] for x in music_string.split(' ') if x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('o o o o') == [4, 4, 4, 4]
assert candidate('.| .| .| .|') == [1, 1, 1, 1]
assert candidate('o| o| .| .| o o o o') == [2, 2, 1, 1, 4, 4, 4, 4]
assert candidate('o| .| o| .| o o| o o|') == [2, 1, 2, 1, 4, 2, 4, 2]
| parse_music | parse_music(music_string: str) -> List[int] | from typing import List
def parse_music(music_string: str) -> List[int]: | Напишите функцию parse_music(music_string: str) -> List[int] для решения следующей задачи: Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов не длится каждое из них.
Вот легенда:
"о" - целая нота, длится четыре такта
'o|' - половинная нота, длится два такта
'.|' - четвертная нота, длится один такт
>>> parse_music('o o| .| o| o| .| .| .| .| o o')
[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4] | Напишите функцию parse_music(music_string: str) -> List[int] для решения следующей задачи: Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов не длится каждое из них.
Вот легенда:
"о" - целая нота, длится четыре такта
'o|' - половинная нота, длится два такта
'.|' - четвертная нота, длится один такт | from typing import List
def parse_music(music_string: str) -> List[int]:
"""
Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов не длится каждое из них.
Вот легенда:
"о" - целая нота, длится четыре такта
'o|' - половинная нота, длится два такта
'.|' - четвертная нота, длится один такт
"""
|
HumanEval/18 | Найдите, сколько раз данная подстрока встречается в исходной строке с учетом перекрытий. >>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3 | def how_many_times(string: str, substring: str) -> int:
"""
Найдите, сколько раз данная подстрока встречается в исходной строке с учетом перекрытий. >>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
| times = 0
for i in range(len(string) - len(substring) + 1):
if string[i:i+len(substring)] == substring:
times += 1
return times
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('', 'x') == 0
assert candidate('xyxyxyx', 'x') == 4
assert candidate('cacacacac', 'cac') == 4
assert candidate('john doe', 'john') == 1
| how_many_times | how_many_times(string: str, substring: str) -> int | def how_many_times(string: str, substring: str) -> int: | Напишите функцию how_many_times(string: str, substring: str) -> int для решения следующей задачи: Найдите, сколько раз данная подстрока встречается в исходной строке с учетом перекрытий. >>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3 | Напишите функцию how_many_times(string: str, substring: str) -> int для решения следующей задачи: Найдите, сколько раз данная подстрока встречается в исходной строке с учетом перекрытий. >>> how_many_times('', 'a')
0 | def how_many_times(string: str, substring: str) -> int:
"""
Найдите, сколько раз данная подстрока встречается в исходной строке с учетом перекрытий. >>> how_many_times('', 'a')
0
"""
|
HumanEval/19 | Входные данные представляют собой разделенную пробелами строку чисел от "zero" до "nine".
Допустимыми вариантами являются "zero", "one", "two", "three", "four", "five", "six", "seven", "eight" и "nine".
Возвращает строку с числами, отсортированными от наименьшего к наибольшему
>>> sort_numbers('three one five')
'one three five' | from typing import List
def sort_numbers(numbers: str) -> str:
"""
Входные данные представляют собой разделенную пробелами строку чисел от "zero" до "nine".
Допустимыми вариантами являются "zero", "one", "two", "three", "four", "five", "six", "seven", "eight" и "nine".
Возвращает строку с числами, отсортированными от наименьшего к наибольшему
>>> sort_numbers('three one five')
'one three five'
"""
| value_map = {
'zero': 0,
'one': 1,
'two': 2,
'three': 3,
'four': 4,
'five': 5,
'six': 6,
'seven': 7,
'eight': 8,
'nine': 9
}
return ' '.join(sorted([x for x in numbers.split(' ') if x], key=lambda x: value_map[x]))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('three') == 'three'
assert candidate('three five nine') == 'three five nine'
assert candidate('five zero four seven nine eight') == 'zero four five seven eight nine'
assert candidate('six five four three two one zero') == 'zero one two three four five six'
| sort_numbers | sort_numbers(numbers: str) -> str | from typing import List
def sort_numbers(numbers: str) -> str: | Напишите функцию sort_numbers(numbers: str) -> str для решения следующей задачи: Входные данные представляют собой разделенную пробелами строку чисел от "zero" до "nine".
Допустимыми вариантами являются "zero", "one", "two", "three", "four", "five", "six", "seven", "eight" и "nine".
Возвращает строку с числами, отсортированными от наименьшего к наибольшему
>>> sort_numbers('three one five')
'one three five' | Напишите функцию sort_numbers(numbers: str) -> str для решения следующей задачи: Входные данные представляют собой разделенную пробелами строку чисел от "zero" до "nine".
Допустимыми вариантами являются "zero", "one", "two", "three", "four", "five", "six", "seven", "eight" и "nine".
Возвращает строку с числами, отсортированными от наименьшего к наибольшему | from typing import List
def sort_numbers(numbers: str) -> str:
"""
Входные данные представляют собой разделенную пробелами строку чисел от "zero" до "nine".
Допустимыми вариантами являются "zero", "one", "two", "three", "four", "five", "six", "seven", "eight" и "nine".
Возвращает строку с числами, отсортированными от наименьшего к наибольшему
"""
|
HumanEval/20 | Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по возрастанию (меньшее число, большее число).
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
(2.0, 2.0) | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
"""
Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по возрастанию (меньшее число, большее число).
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
(2.0, 2.0)
"""
| closest_pair = None
distance = None
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2]) == (3.9, 4.0)
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0]) == (5.0, 5.9)
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1]) == (2.2, 3.1)
| find_closest_elements | find_closest_elements(numbers: List[float]) -> Tuple[float, float] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]: | Напишите функцию find_closest_elements(numbers: List[float]) -> Tuple[float, float] для решения следующей задачи: Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по возрастанию (меньшее число, большее число).
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
(2.0, 2.0) | Напишите функцию find_closest_elements(numbers: List[float]) -> Tuple[float, float] для решения следующей задачи: Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по возрастанию (меньшее число, большее число). | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
"""
Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по возрастанию (меньшее число, большее число).
"""
|
HumanEval/21 | Ко входному списку чисел (по крайней мере, из двух элементов) примените линейное преобразование
таким образом, чтобы наименьшее число стало 0, а наибольшее - 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
"""
Ко входному списку чисел (по крайней мере, из двух элементов) примените линейное преобразование
таким образом, чтобы наименьшее число стало 0, а наибольшее - 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0]
"""
| min_number = min(numbers)
max_number = max(numbers)
return [(x - min_number) / (max_number - min_number) for x in numbers]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([2.0, 49.9]) == [0.0, 1.0]
assert candidate([100.0, 49.9]) == [1.0, 0.0]
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
assert candidate([2.0, 1.0, 5.0, 3.0, 4.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]
assert candidate([12.0, 11.0, 15.0, 13.0, 14.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]
| rescale_to_unit | rescale_to_unit(numbers: List[float]) -> List[float] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]: | Напишите функцию rescale_to_unit(numbers: List[float]) -> List[float] для решения следующей задачи: Ко входному списку чисел (по крайней мере, из двух элементов) примените линейное преобразование
таким образом, чтобы наименьшее число стало 0, а наибольшее - 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0] | Напишите функцию rescale_to_unit(numbers: List[float]) -> List[float] для решения следующей задачи: Ко входному списку чисел (по крайней мере, из двух элементов) примените линейное преобразование
таким образом, чтобы наименьшее число стало 0, а наибольшее - 1 | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
"""
Ко входному списку чисел (по крайней мере, из двух элементов) примените линейное преобразование
таким образом, чтобы наименьшее число стало 0, а наибольшее - 1
"""
|
HumanEval/22 | Фильтровать данный список любых значений python, оставив только целые чисел
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
"""
Фильтровать данный список любых значений python, оставив только целые чисел
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| return [x for x in values if isinstance(x, int)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([4, {}, [], 23.2, 9, 'adasd']) == [4, 9]
assert candidate([3, 'c', 3, 3, 'a', 'b']) == [3, 3, 3]
| filter_integers | filter_integers(values: List[Any]) -> List[int] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]: | Напишите функцию filter_integers(values: List[Any]) -> List[int] для решения следующей задачи: Фильтровать данный список любых значений python, оставив только целые чисел
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3] | Напишите функцию filter_integers(values: List[Any]) -> List[int] для решения следующей задачи: Фильтровать данный список любых значений python, оставив только целые чисел | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
"""
Фильтровать данный список любых значений python, оставив только целые чисел
"""
|
HumanEval/23 | Возвращает длину заданной строки
>>> strlen('')
0
>>> strlen('abc')
3 | def strlen(string: str) -> int:
"""
Возвращает длину заданной строки
>>> strlen('')
0
>>> strlen('abc')
3
"""
| return len(string)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('x') == 1
assert candidate('asdasnakj') == 9
| strlen | strlen(string: str) -> int | def strlen(string: str) -> int: | Напишите функцию strlen(string: str) -> int для решения следующей задачи: Возвращает длину заданной строки
>>> strlen('')
0
>>> strlen('abc')
3 | Напишите функцию strlen(string: str) -> int для решения следующей задачи: Возвращает длину заданной строки | def strlen(string: str) -> int:
"""
Возвращает длину заданной строки
"""
|
HumanEval/24 | Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n
>>> largest_divisor(15)
5 | def largest_divisor(n: int) -> int:
"""
Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n
>>> largest_divisor(15)
5
"""
| for i in reversed(range(n)):
if n % i == 0:
return i
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3) == 1
assert candidate(7) == 1
assert candidate(10) == 5
assert candidate(100) == 50
assert candidate(49) == 7
| largest_divisor | largest_divisor(n: int) -> int | def largest_divisor(n: int) -> int: | Напишите функцию largest_divisor(n: int) -> int для решения следующей задачи: Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n
>>> largest_divisor(15)
5 | Напишите функцию largest_divisor(n: int) -> int для решения следующей задачи: Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n | def largest_divisor(n: int) -> int:
"""
Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n
"""
|
HumanEval/25 | Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему.
Каждый из множителей должен быть указан количество раз, соответствующее тому, сколько раз он появляется при разложении на множители.
Входное число должно быть равно произведению всех множителей
>>> factorize(8)
[2, 2, 2]
>>> factorize(25)
[5, 5]
>>> factorize(70)
[2, 5, 7] | from typing import List
def factorize(n: int) -> List[int]:
"""
Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему.
Каждый из множителей должен быть указан количество раз, соответствующее тому, сколько раз он появляется при разложении на множители.
Входное число должно быть равно произведению всех множителей
>>> factorize(8)
[2, 2, 2]
>>> factorize(25)
[5, 5]
>>> factorize(70)
[2, 5, 7]
"""
| import math
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(2) == [2]
assert candidate(4) == [2, 2]
assert candidate(8) == [2, 2, 2]
assert candidate(3 * 19) == [3, 19]
assert candidate(3 * 19 * 3 * 19) == [3, 3, 19, 19]
assert candidate(3 * 19 * 3 * 19 * 3 * 19) == [3, 3, 3, 19, 19, 19]
assert candidate(3 * 19 * 19 * 19) == [3, 19, 19, 19]
assert candidate(3 * 2 * 3) == [2, 3, 3]
| factorize | factorize(n: int) -> List[int] | from typing import List
def factorize(n: int) -> List[int]: | Напишите функцию factorize(n: int) -> List[int] для решения следующей задачи: Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему.
Каждый из множителей должен быть указан количество раз, соответствующее тому, сколько раз он появляется при разложении на множители.
Входное число должно быть равно произведению всех множителей
>>> factorize(8)
[2, 2, 2]
>>> factorize(25)
[5, 5]
>>> factorize(70)
[2, 5, 7] | Напишите функцию factorize(n: int) -> List[int] для решения следующей задачи: Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему.
Каждый из множителей должен быть указан количество раз, соответствующее тому, сколько раз он появляется при разложении на множители.
Входное число должно быть равно произведению всех множителей | from typing import List
def factorize(n: int) -> List[int]:
"""
Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему.
Каждый из множителей должен быть указан количество раз, соответствующее тому, сколько раз он появляется при разложении на множители.
Входное число должно быть равно произведению всех множителей
"""
|
HumanEval/26 | Из списка целых чисел удалите все элементы, которые встречаются более одного раза.
Сохраняйте порядок расположения элементов таким же, как и во входных данных.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
"""
Из списка целых чисел удалите все элементы, которые встречаются более одного раза.
Сохраняйте порядок расположения элементов таким же, как и во входных данных.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| import collections
c = collections.Counter(numbers)
return [n for n in numbers if c[n] <= 1]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
assert candidate([1, 2, 3, 2, 4, 3, 5]) == [1, 4, 5]
| remove_duplicates | remove_duplicates(numbers: List[int]) -> List[int] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]: | Напишите функцию remove_duplicates(numbers: List[int]) -> List[int] для решения следующей задачи: Из списка целых чисел удалите все элементы, которые встречаются более одного раза.
Сохраняйте порядок расположения элементов таким же, как и во входных данных.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4] | Напишите функцию remove_duplicates(numbers: List[int]) -> List[int] для решения следующей задачи: Из списка целых чисел удалите все элементы, которые встречаются более одного раза.
Сохраняйте порядок расположения элементов таким же, как и во входных данных. | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
"""
Из списка целых чисел удалите все элементы, которые встречаются более одного раза.
Сохраняйте порядок расположения элементов таким же, как и во входных данных.
"""
|
HumanEval/27 | Для данной строки преобразуйте строчные символы в прописные, а прописные - в строчные.
>>> flip_case('Hello')
'hELLO' | def flip_case(string: str) -> str:
"""
Для данной строки преобразуйте строчные символы в прописные, а прописные - в строчные.
>>> flip_case('Hello')
'hELLO'
"""
| return string.swapcase()
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('Hello!') == 'hELLO!'
assert candidate('These violent delights have violent ends') == 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'
| flip_case | flip_case(string: str) -> str | def flip_case(string: str) -> str: | Напишите функцию flip_case(string: str) -> str для решения следующей задачи: Для данной строки преобразуйте строчные символы в прописные, а прописные - в строчные.
>>> flip_case('Hello')
'hELLO' | Напишите функцию flip_case(string: str) -> str для решения следующей задачи: Для данной строки преобразуйте строчные символы в прописные, а прописные - в строчные. | def flip_case(string: str) -> str:
"""
Для данной строки преобразуйте строчные символы в прописные, а прописные - в строчные.
"""
|
HumanEval/28 | Конкатенировать список строк в одну строку
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc' | from typing import List
def concatenate(strings: List[str]) -> str:
"""
Конкатенировать список строк в одну строку
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| return ''.join(strings)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == ''
assert candidate(['x', 'y', 'z']) == 'xyz'
assert candidate(['x', 'y', 'z', 'w', 'k']) == 'xyzwk'
| concatenate | concatenate(strings: List[str]) -> str | from typing import List
def concatenate(strings: List[str]) -> str: | Напишите функцию concatenate(strings: List[str]) -> str для решения следующей задачи: Конкатенировать список строк в одну строку
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc' | Напишите функцию concatenate(strings: List[str]) -> str для решения следующей задачи: Конкатенировать список строк в одну строку | from typing import List
def concatenate(strings: List[str]) -> str:
"""
Конкатенировать список строк в одну строку
"""
|
HumanEval/29 | Отфильтруйте входной список строк только для тех, которые начинаются с заданного префикса.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array'] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
"""
Отфильтруйте входной список строк только для тех, которые начинаются с заданного префикса.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""
| return [x for x in strings if x.startswith(prefix)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
| filter_by_prefix | filter_by_prefix(strings: List[str], prefix: str) -> List[str] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]: | Напишите функцию filter_by_prefix(strings: List[str], prefix: str) -> List[str] для решения следующей задачи: Отфильтруйте входной список строк только для тех, которые начинаются с заданного префикса.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array'] | Напишите функцию filter_by_prefix(strings: List[str], prefix: str) -> List[str] для решения следующей задачи: Отфильтруйте входной список строк только для тех, которые начинаются с заданного префикса. | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
"""
Отфильтруйте входной список строк только для тех, которые начинаются с заданного префикса.
"""
|
HumanEval/30 | Возвращает только положительные числа в списке.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1] | def get_positive(l: list):
"""
Возвращает только положительные числа в списке.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
| return [e for e in l if e > 0]
|
METADATA = {}
def check(candidate):
assert candidate([-1, -2, 4, 5, 6]) == [4, 5, 6]
assert candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]
assert candidate([-1, -2]) == []
assert candidate([]) == []
| get_positive | get_positive(l: list) | def get_positive(l: list): | Напишите функцию get_positive(l: list) для решения следующей задачи: Возвращает только положительные числа в списке.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1] | Напишите функцию get_positive(l: list) для решения следующей задачи: Возвращает только положительные числа в списке. | def get_positive(l: list):
"""
Возвращает только положительные числа в списке.
"""
|
HumanEval/31 | Возвращает true, если заданное число простое, и false в противном случае.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False | def is_prime(n):
"""
Возвращает true, если заданное число простое, и false в противном случае.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
| if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate(6) == False
assert candidate(101) == True
assert candidate(11) == True
assert candidate(13441) == True
assert candidate(61) == True
assert candidate(4) == False
assert candidate(1) == False
assert candidate(5) == True
assert candidate(11) == True
assert candidate(17) == True
assert candidate(5 * 17) == False
assert candidate(11 * 7) == False
assert candidate(13441 * 19) == False
| is_prime | is_prime(n) | def is_prime(n): | Напишите функцию is_prime(n) для решения следующей задачи: Возвращает true, если заданное число простое, и false в противном случае.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False | Напишите функцию is_prime(n) для решения следующей задачи: Возвращает true, если заданное число простое, и false в противном случае. | def is_prime(n):
"""
Возвращает true, если заданное число простое, и false в противном случае.
"""
|
HumanEval/32 | xs - коэффициенты многочлена.
find_zero найдите x таким образом, чтобы poly(x) = 0.
find_zero возвращает только нулевую точку, даже если их много.
Более того, find_zero принимает только список xs с четным числом коэффициентов и наибольшим ненулевым коэффициентом, поскольку это гарантирует решение.
>>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-0.5
>>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
1.0 | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
"""
xs - коэффициенты многочлена.
find_zero найдите x таким образом, чтобы poly(x) = 0.
find_zero возвращает только нулевую точку, даже если их много.
Более того, find_zero принимает только список xs с четным числом коэффициентов и наибольшим ненулевым коэффициентом, поскольку это гарантирует решение.
>>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-0.5
>>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
1.0
"""
| begin, end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
|
METADATA = {}
def check(candidate):
import math
import random
rng = random.Random(42)
import copy
for _ in range(100):
ncoeff = 2 * rng.randint(1, 4)
coeffs = []
for _ in range(ncoeff):
coeff = rng.randint(-10, 10)
if coeff == 0:
coeff = 1
coeffs.append(coeff)
solution = candidate(copy.deepcopy(coeffs))
assert math.fabs(poly(coeffs, solution)) < 1e-4
| find_zero | find_zero(xs: list) | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list): | Напишите функцию find_zero(xs: list) для решения следующей задачи: xs - коэффициенты многочлена.
find_zero найдите x таким образом, чтобы poly(x) = 0.
find_zero возвращает только нулевую точку, даже если их много.
Более того, find_zero принимает только список xs с четным числом коэффициентов и наибольшим ненулевым коэффициентом, поскольку это гарантирует решение.
>>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-0.5
>>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
1.0 | Напишите функцию find_zero(xs: list) для решения следующей задачи: xs - коэффициенты многочлена.
find_zero найдите x таким образом, чтобы poly(x) = 0.
find_zero возвращает только нулевую точку, даже если их много.
Более того, find_zero принимает только список xs с четным числом коэффициентов и наибольшим ненулевым коэффициентом, поскольку это гарантирует решение. | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
"""
xs - коэффициенты многочлена.
find_zero найдите x таким образом, чтобы poly(x) = 0.
find_zero возвращает только нулевую точку, даже если их много.
Более того, find_zero принимает только список xs с четным числом коэффициентов и наибольшим ненулевым коэффициентом, поскольку это гарантирует решение.
"""
|
HumanEval/33 | Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в индексах, которые не делятся на три, в то время как его значения в индексах, которые делятся на три, равны значениям соответствующих индексов l, но отсортированы.
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_third([5, 6, 3, 4, 8, 9, 2])
[2, 6, 3, 4, 8, 9, 5] | def sort_third(l: list):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в индексах, которые не делятся на три, в то время как его значения в индексах, которые делятся на три, равны значениям соответствующих индексов l, но отсортированы.
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_third([5, 6, 3, 4, 8, 9, 2])
[2, 6, 3, 4, 8, 9, 5]
"""
| l = list(l)
l[::3] = sorted(l[::3])
return l
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple(sort_third([1, 2, 3]))
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple(sort_third([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]))
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple(sort_third([5, 8, -12, 4, 23, 2, 3, 11, 12, -10]))
assert tuple(candidate([5, 6, 3, 4, 8, 9, 2])) == tuple([2, 6, 3, 4, 8, 9, 5])
assert tuple(candidate([5, 8, 3, 4, 6, 9, 2])) == tuple([2, 8, 3, 4, 6, 9, 5])
assert tuple(candidate([5, 6, 9, 4, 8, 3, 2])) == tuple([2, 6, 9, 4, 8, 3, 5])
assert tuple(candidate([5, 6, 3, 4, 8, 9, 2, 1])) == tuple([2, 6, 3, 4, 8, 9, 5, 1])
| sort_third | sort_third(l: list) | def sort_third(l: list): | Напишите функцию sort_third(l: list) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в индексах, которые не делятся на три, в то время как его значения в индексах, которые делятся на три, равны значениям соответствующих индексов l, но отсортированы.
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_third([5, 6, 3, 4, 8, 9, 2])
[2, 6, 3, 4, 8, 9, 5] | Напишите функцию sort_third(l: list) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в индексах, которые не делятся на три, в то время как его значения в индексах, которые делятся на три, равны значениям соответствующих индексов l, но отсортированы. | def sort_third(l: list):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в индексах, которые не делятся на три, в то время как его значения в индексах, которые делятся на три, равны значениям соответствующих индексов l, но отсортированы.
"""
|
HumanEval/34 | Возвращает отсортированные уникальные элементы в списке
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123] | def unique(l: list):
"""
Возвращает отсортированные уникальные элементы в списке
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
| return sorted(list(set(l)))
|
METADATA = {}
def check(candidate):
assert candidate([5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
| unique | unique(l: list) | def unique(l: list): | Напишите функцию unique(l: list) для решения следующей задачи: Возвращает отсортированные уникальные элементы в списке
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123] | Напишите функцию unique(l: list) для решения следующей задачи: Возвращает отсортированные уникальные элементы в списке | def unique(l: list):
"""
Возвращает отсортированные уникальные элементы в списке
"""
|
HumanEval/35 | Возвращает максимальный элемент в списке.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123 | def max_element(l: list):
"""
Возвращает максимальный элемент в списке.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
| m = l[0]
for e in l:
if e > m:
m = e
return m
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 3]) == 3
assert candidate([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]) == 124
| max_element | max_element(l: list) | def max_element(l: list): | Напишите функцию max_element(l: list) для решения следующей задачи: Возвращает максимальный элемент в списке.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123 | Напишите функцию max_element(l: list) для решения следующей задачи: Возвращает максимальный элемент в списке. | def max_element(l: list):
"""
Возвращает максимальный элемент в списке.
"""
|
HumanEval/36 | Возвращает количество раз, когда цифра 7 встречается в целых числах меньше n, которые делятся на 11 или 13.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3 | def fizz_buzz(n: int):
"""
Возвращает количество раз, когда цифра 7 встречается в целых числах меньше n, которые делятся на 11 или 13.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
| ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
|
METADATA = {}
def check(candidate):
assert candidate(50) == 0
assert candidate(78) == 2
assert candidate(79) == 3
assert candidate(100) == 3
assert candidate(200) == 6
assert candidate(4000) == 192
assert candidate(10000) == 639
assert candidate(100000) == 8026
| fizz_buzz | fizz_buzz(n: int) | def fizz_buzz(n: int): | Напишите функцию fizz_buzz(n: int) для решения следующей задачи: Возвращает количество раз, когда цифра 7 встречается в целых числах меньше n, которые делятся на 11 или 13.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3 | Напишите функцию fizz_buzz(n: int) для решения следующей задачи: Возвращает количество раз, когда цифра 7 встречается в целых числах меньше n, которые делятся на 11 или 13. | def fizz_buzz(n: int):
"""
Возвращает количество раз, когда цифра 7 встречается в целых числах меньше n, которые делятся на 11 или 13.
"""
|
HumanEval/37 | Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4] | def sort_even(l: list):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4]
"""
| evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple([1, 2, 3])
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple([-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123])
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple([-12, 8, 3, 4, 5, 2, 12, 11, 23, -10])
| sort_even | sort_even(l: list) | def sort_even(l: list): | Напишите функцию sort_even(l: list) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4] | Напишите функцию sort_even(l: list) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы. | def sort_even(l: list):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
"""
|
HumanEval/38 | Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4] | def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
return "".join(groups)
def decode_cyclic(s: str):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4]
"""
| return encode_cyclic(encode_cyclic(s))
|
METADATA = {}
def check(candidate):
from random import randint, choice
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_cyclic(str)
assert candidate(encoded_str) == str
| decode_cyclic | decode_cyclic(s: str) | def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
return "".join(groups)
def decode_cyclic(s: str): | Напишите функцию decode_cyclic(s: str) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4] | Напишите функцию decode_cyclic(s: str) для решения следующей задачи: Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы. | def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
return "".join(groups)
def decode_cyclic(s: str):
"""
Эта функция принимает список l и возвращает список l' таким образом, что l' идентичен l в нечетных индексах, в то время как его значения в четных индексах равны значениям четных индексов l, но отсортированы.
"""
|
HumanEval/39 | prime_fib возвращает n-е число, которое является числом Фибоначчи и также является простым.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89 | def prime_fib(n: int):
"""
prime_fib возвращает n-е число, которое является числом Фибоначчи и также является простым.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
| import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
|
METADATA = {}
def check(candidate):
assert candidate(1) == 2
assert candidate(2) == 3
assert candidate(3) == 5
assert candidate(4) == 13
assert candidate(5) == 89
assert candidate(6) == 233
assert candidate(7) == 1597
assert candidate(8) == 28657
assert candidate(9) == 514229
assert candidate(10) == 433494437
| prime_fib | prime_fib(n: int) | def prime_fib(n: int): | Напишите функцию prime_fib(n: int) для решения следующей задачи: prime_fib возвращает n-е число, которое является числом Фибоначчи и также является простым.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89 | Напишите функцию prime_fib(n: int) для решения следующей задачи: prime_fib возвращает n-е число, которое является числом Фибоначчи и также является простым. | def prime_fib(n: int):
"""
prime_fib возвращает n-е число, которое является числом Фибоначчи и также является простым.
"""
|
HumanEval/40 | triples_sum_to_zero принимает список целых чисел в качестве входных данных.
он возвращает значение True, если в списке есть три различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True
>>> triples_sum_to_zero([1, 2, 3, 7])
False
>>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
True
>>> triples_sum_to_zero([1])
False | def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero принимает список целых чисел в качестве входных данных.
он возвращает значение True, если в списке есть три различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True
>>> triples_sum_to_zero([1, 2, 3, 7])
False
>>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
True
>>> triples_sum_to_zero([1])
False
"""
| for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, 5, -1]) == False
assert candidate([1, 3, -2, 1]) == True
assert candidate([1, 2, 3, 7]) == False
assert candidate([1, 2, 5, 7]) == False
assert candidate([2, 4, -5, 3, 9, 7]) == True
assert candidate([1]) == False
assert candidate([1, 3, 5, -100]) == False
assert candidate([100, 3, 5, -100]) == False
| triples_sum_to_zero | triples_sum_to_zero(l: list) | def triples_sum_to_zero(l: list): | Напишите функцию triples_sum_to_zero(l: list) для решения следующей задачи: triples_sum_to_zero принимает список целых чисел в качестве входных данных.
он возвращает значение True, если в списке есть три различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True
>>> triples_sum_to_zero([1, 2, 3, 7])
False
>>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
True
>>> triples_sum_to_zero([1])
False | Напишите функцию triples_sum_to_zero(l: list) для решения следующей задачи: triples_sum_to_zero принимает список целых чисел в качестве входных данных.
он возвращает значение True, если в списке есть три различных элемента, сумма которых равна нулю, и значение False в противном случае. | def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero принимает список целых чисел в качестве входных данных.
он возвращает значение True, если в списке есть три различных элемента, сумма которых равна нулю, и значение False в противном случае.
"""
|
HumanEval/41 | Представьте себе дорогу, представляющую собой идеально прямую бесконечно длинную линию.
n автомобилей движутся слева направо; одновременно другой набор из n автомобилей движется справа налево. Две группы автомобилей изначально находились очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево.
Однако автомобили бесконечно прочны; в результате они продолжают двигаться по своей траектории, как будто и не сталкивались.
Эта функция выводит количество таких столкновений. | def car_race_collision(n: int):
"""
Представьте себе дорогу, представляющую собой идеально прямую бесконечно длинную линию.
n автомобилей движутся слева направо; одновременно другой набор из n автомобилей движется справа налево. Две группы автомобилей изначально находились очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево.
Однако автомобили бесконечно прочны; в результате они продолжают двигаться по своей траектории, как будто и не сталкивались.
Эта функция выводит количество таких столкновений.
"""
| return n**2
|
METADATA = {}
def check(candidate):
assert candidate(2) == 4
assert candidate(3) == 9
assert candidate(4) == 16
assert candidate(8) == 64
assert candidate(10) == 100
| car_race_collision | car_race_collision(n: int) | def car_race_collision(n: int): | Напишите функцию car_race_collision(n: int) для решения следующей задачи: Представьте себе дорогу, представляющую собой идеально прямую бесконечно длинную линию.
n автомобилей движутся слева направо; одновременно другой набор из n автомобилей движется справа налево. Две группы автомобилей изначально находились очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево.
Однако автомобили бесконечно прочны; в результате они продолжают двигаться по своей траектории, как будто и не сталкивались.
Эта функция выводит количество таких столкновений. | Напишите функцию car_race_collision(n: int) для решения следующей задачи: Представьте себе дорогу, представляющую собой идеально прямую бесконечно длинную линию.
n автомобилей движутся слева направо; одновременно другой набор из n автомобилей движется справа налево. Две группы автомобилей изначально находились очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево.
Однако автомобили бесконечно прочны; в результате они продолжают двигаться по своей траектории, как будто и не сталкивались.
Эта функция выводит количество таких столкновений. | def car_race_collision(n: int):
"""
Представьте себе дорогу, представляющую собой идеально прямую бесконечно длинную линию.
n автомобилей движутся слева направо; одновременно другой набор из n автомобилей движется справа налево. Две группы автомобилей изначально находились очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево.
Однако автомобили бесконечно прочны; в результате они продолжают двигаться по своей траектории, как будто и не сталкивались.
Эта функция выводит количество таких столкновений.
"""
|
HumanEval/42 | Возвращает список с элементами, увеличенными на 1.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124] | def incr_list(l: list):
"""
Возвращает список с элементами, увеличенными на 1.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
| return [(e + 1) for e in l]
|
METADATA = {}
def check(candidate):
assert candidate([]) == []
assert candidate([3, 2, 1]) == [4, 3, 2]
assert candidate([5, 2, 5, 2, 3, 3, 9, 0, 123]) == [6, 3, 6, 3, 4, 4, 10, 1, 124]
| incr_list | incr_list(l: list) | def incr_list(l: list): | Напишите функцию incr_list(l: list) для решения следующей задачи: Возвращает список с элементами, увеличенными на 1.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124] | Напишите функцию incr_list(l: list) для решения следующей задачи: Возвращает список с элементами, увеличенными на 1. | def incr_list(l: list):
"""
Возвращает список с элементами, увеличенными на 1.
"""
|
HumanEval/43 | pairs_sum_to_zero принимает список целых чисел в качестве входных данных.
она возвращает значение True, если в списке есть два различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_to_zero([1, 2, 3, 7])
False
>>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
True
>>> pairs_sum_to_zero([1])
False | def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero принимает список целых чисел в качестве входных данных.
она возвращает значение True, если в списке есть два различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_to_zero([1, 2, 3, 7])
False
>>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
True
>>> pairs_sum_to_zero([1])
False
"""
| for i, l1 in enumerate(l):
for j in range(i + 1, len(l)):
if l1 + l[j] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, -2, 1]) == False
assert candidate([1, 2, 3, 7]) == False
assert candidate([2, 4, -5, 3, 5, 7]) == True
assert candidate([1]) == False
assert candidate([-3, 9, -1, 3, 2, 30]) == True
assert candidate([-3, 9, -1, 3, 2, 31]) == True
assert candidate([-3, 9, -1, 4, 2, 30]) == False
assert candidate([-3, 9, -1, 4, 2, 31]) == False
| pairs_sum_to_zero | pairs_sum_to_zero(l) | def pairs_sum_to_zero(l): | Напишите функцию pairs_sum_to_zero(l) для решения следующей задачи: pairs_sum_to_zero принимает список целых чисел в качестве входных данных.
она возвращает значение True, если в списке есть два различных элемента, сумма которых равна нулю, и значение False в противном случае.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_to_zero([1, 2, 3, 7])
False
>>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
True
>>> pairs_sum_to_zero([1])
False | Напишите функцию pairs_sum_to_zero(l) для решения следующей задачи: pairs_sum_to_zero принимает список целых чисел в качестве входных данных.
она возвращает значение True, если в списке есть два различных элемента, сумма которых равна нулю, и значение False в противном случае. | def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero принимает список целых чисел в качестве входных данных.
она возвращает значение True, если в списке есть два различных элемента, сумма которых равна нулю, и значение False в противном случае.
"""
|
HumanEval/44 | Измените степень исчисления входного числа x на новую.
возвращает строковое представление после преобразования.
новая степень меньше 10.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111' | def change_base(x: int, base: int):
"""
Измените степень исчисления входного числа x на новую.
возвращает строковое представление после преобразования.
новая степень меньше 10.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
| ret = ""
while x > 0:
ret = str(x % base) + ret
x //= base
return ret
|
METADATA = {}
def check(candidate):
assert candidate(8, 3) == "22"
assert candidate(9, 3) == "100"
assert candidate(234, 2) == "11101010"
assert candidate(16, 2) == "10000"
assert candidate(8, 2) == "1000"
assert candidate(7, 2) == "111"
for x in range(2, 8):
assert candidate(x, x + 1) == str(x)
| change_base | change_base(x: int, base: int) | def change_base(x: int, base: int): | Напишите функцию change_base(x: int, base: int) для решения следующей задачи: Измените степень исчисления входного числа x на новую.
возвращает строковое представление после преобразования.
новая степень меньше 10.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111' | Напишите функцию change_base(x: int, base: int) для решения следующей задачи: Измените степень исчисления входного числа x на новую.
возвращает строковое представление после преобразования.
новая степень меньше 10. | def change_base(x: int, base: int):
"""
Измените степень исчисления входного числа x на новую.
возвращает строковое представление после преобразования.
новая степень меньше 10.
"""
|
HumanEval/45 | Задана длина стороны и высота, верните площадь треугольника.
>>> triangle_area(5, 3)
7.5 | def triangle_area(a, h):
"""
Задана длина стороны и высота, верните площадь треугольника.
>>> triangle_area(5, 3)
7.5
"""
| return a * h / 2.0
|
METADATA = {}
def check(candidate):
assert candidate(5, 3) == 7.5
assert candidate(2, 2) == 2.0
assert candidate(10, 8) == 40.0
| triangle_area | triangle_area(a, h) | def triangle_area(a, h): | Напишите функцию triangle_area(a, h) для решения следующей задачи: Задана длина стороны и высота, верните площадь треугольника.
>>> triangle_area(5, 3)
7.5 | Напишите функцию triangle_area(a, h) для решения следующей задачи: Задана длина стороны и высота, верните площадь треугольника. | def triangle_area(a, h):
"""
Задана длина стороны и высота, верните площадь треугольника.
"""
|
HumanEval/46 | Числовая последовательность Fib4 - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию.
>>> fib4(5)
4
>>> fib4(6)
8
>>> fib4(7)
14 | def fib4(n: int):
"""
Числовая последовательность Fib4 - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию.
>>> fib4(5)
4
>>> fib4(6)
8
>>> fib4(7)
14
"""
| results = [0, 0, 2, 0]
if n < 4:
return results[n]
for _ in range(4, n + 1):
results.append(results[-1] + results[-2] + results[-3] + results[-4])
results.pop(0)
return results[-1]
|
METADATA = {}
def check(candidate):
assert candidate(5) == 4
assert candidate(8) == 28
assert candidate(10) == 104
assert candidate(12) == 386
| fib4 | fib4(n: int) | def fib4(n: int): | Напишите функцию fib4(n: int) для решения следующей задачи: Числовая последовательность Fib4 - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию.
>>> fib4(5)
4
>>> fib4(6)
8
>>> fib4(7)
14 | Напишите функцию fib4(n: int) для решения следующей задачи: Числовая последовательность Fib4 - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию. | def fib4(n: int):
"""
Числовая последовательность Fib4 - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию.
"""
|
HumanEval/47 | Возвращает медиану элементов в списке l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0 | def median(l: list):
"""
Возвращает медиану элементов в списке l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
| l = sorted(l)
if len(l) % 2 == 1:
return l[len(l) // 2]
else:
return (l[len(l) // 2 - 1] + l[len(l) // 2]) / 2.0
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == 3
assert candidate([-10, 4, 6, 1000, 10, 20]) == 8.0
assert candidate([5]) == 5
assert candidate([6, 5]) == 5.5
assert candidate([8, 1, 3, 9, 9, 2, 7]) == 7
| median | median(l: list) | def median(l: list): | Напишите функцию median(l: list) для решения следующей задачи: Возвращает медиану элементов в списке l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0 | Напишите функцию median(l: list) для решения следующей задачи: Возвращает медиану элементов в списке l. | def median(l: list):
"""
Возвращает медиану элементов в списке l.
"""
|
HumanEval/48 | Проверяет, является ли данная строка палиндромом
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False | def is_palindrome(text: str):
"""
Проверяет, является ли данная строка палиндромом
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
| for i in range(len(text)):
if text[i] != text[len(text) - 1 - i]:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate('') == True
assert candidate('aba') == True
assert candidate('aaaaa') == True
assert candidate('zbcd') == False
assert candidate('xywyx') == True
assert candidate('xywyz') == False
assert candidate('xywzx') == False
| is_palindrome | is_palindrome(text: str) | def is_palindrome(text: str): | Напишите функцию is_palindrome(text: str) для решения следующей задачи: Проверяет, является ли данная строка палиндромом
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False | Напишите функцию is_palindrome(text: str) для решения следующей задачи: Проверяет, является ли данная строка палиндромом | def is_palindrome(text: str):
"""
Проверяет, является ли данная строка палиндромом
"""
|
HumanEval/49 | Верните 2^n по модулю p.
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1 | def modp(n: int, p: int):
"""
Верните 2^n по модулю p.
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
| ret = 1
for i in range(n):
ret = (2 * ret) % p
return ret
|
METADATA = {}
def check(candidate):
assert candidate(3, 5) == 3
assert candidate(1101, 101) == 2
assert candidate(0, 101) == 1
assert candidate(3, 11) == 8
assert candidate(100, 101) == 1
assert candidate(30, 5) == 4
assert candidate(31, 5) == 3
| modp | modp(n: int, p: int) | def modp(n: int, p: int): | Напишите функцию modp(n: int, p: int) для решения следующей задачи: Верните 2^n по модулю p.
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1 | Напишите функцию modp(n: int, p: int) для решения следующей задачи: Верните 2^n по модулю p. | def modp(n: int, p: int):
"""
Верните 2^n по модулю p.
"""
|
HumanEval/50 | принимает в качестве входных данных строку, закодированную с помощью функции encode_shift. Возвращает декодированную строку. | def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
принимает в качестве входных данных строку, закодированную с помощью функции encode_shift. Возвращает декодированную строку.
"""
| return "".join([chr(((ord(ch) - 5 - ord("a")) % 26) + ord("a")) for ch in s])
|
METADATA = {}
def check(candidate):
from random import randint, choice
import copy
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_shift(str)
assert candidate(copy.deepcopy(encoded_str)) == str
| decode_shift | decode_shift(s: str) | def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str): | Напишите функцию decode_shift(s: str) для решения следующей задачи: принимает в качестве входных данных строку, закодированную с помощью функции encode_shift. Возвращает декодированную строку. | Напишите функцию decode_shift(s: str) для решения следующей задачи: принимает в качестве входных данных строку, закодированную с помощью функции encode_shift. Возвращает декодированную строку. | def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
принимает в качестве входных данных строку, закодированную с помощью функции encode_shift. Возвращает декодированную строку.
"""
|
HumanEval/51 | remove_vowels - это функция, которая принимает строку и возвращает строку без гласных.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\
ghijklm")
'bcdf\
ghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaBAA')
'B'
>>> remove_vowels('zbcd')
'zbcd' | def remove_vowels(text):
"""
remove_vowels - это функция, которая принимает строку и возвращает строку без гласных.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\
ghijklm")
'bcdf\
ghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaBAA')
'B'
>>> remove_vowels('zbcd')
'zbcd'
"""
| return "".join([s for s in text if s.lower() not in ["a", "e", "i", "o", "u"]])
|
METADATA = {}
def check(candidate):
assert candidate('') == ''
assert candidate("abcdef\nghijklm") == 'bcdf\nghjklm'
assert candidate('fedcba') == 'fdcb'
assert candidate('eeeee') == ''
assert candidate('acBAA') == 'cB'
assert candidate('EcBOO') == 'cB'
assert candidate('ybcd') == 'ybcd'
| remove_vowels | remove_vowels(text) | def remove_vowels(text): | Напишите функцию remove_vowels(text) для решения следующей задачи: remove_vowels - это функция, которая принимает строку и возвращает строку без гласных.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\
ghijklm")
'bcdf\
ghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaBAA')
'B'
>>> remove_vowels('zbcd')
'zbcd' | Напишите функцию remove_vowels(text) для решения следующей задачи: remove_vowels - это функция, которая принимает строку и возвращает строку без гласных. | def remove_vowels(text):
"""
remove_vowels - это функция, которая принимает строку и возвращает строку без гласных.
"""
|
HumanEval/52 | Возвращает значение True, если все числа в списке l ниже порогового значения t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False | def below_threshold(l: list, t: int):
"""
Возвращает значение True, если все числа в списке l ниже порогового значения t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
| for e in l:
if e >= t:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10], 100)
assert not candidate([1, 20, 4, 10], 5)
assert candidate([1, 20, 4, 10], 21)
assert candidate([1, 20, 4, 10], 22)
assert candidate([1, 8, 4, 10], 11)
assert not candidate([1, 8, 4, 10], 10)
| below_threshold | below_threshold(l: list, t: int) | def below_threshold(l: list, t: int): | Напишите функцию below_threshold(l: list, t: int) для решения следующей задачи: Возвращает значение True, если все числа в списке l ниже порогового значения t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False | Напишите функцию below_threshold(l: list, t: int) для решения следующей задачи: Возвращает значение True, если все числа в списке l ниже порогового значения t. | def below_threshold(l: list, t: int):
"""
Возвращает значение True, если все числа в списке l ниже порогового значения t.
"""
|
HumanEval/53 | Сложите два числа x и y
>>> add(2, 3)
5
>>> add(5, 7)
12 | def add(x: int, y: int):
"""
Сложите два числа x и y
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
| return x + y
|
METADATA = {}
def check(candidate):
import random
assert candidate(0, 1) == 1
assert candidate(1, 0) == 1
assert candidate(2, 3) == 5
assert candidate(5, 7) == 12
assert candidate(7, 5) == 12
for i in range(100):
x, y = random.randint(0, 1000), random.randint(0, 1000)
assert candidate(x, y) == x + y
| add | add(x: int, y: int) | def add(x: int, y: int): | Напишите функцию add(x: int, y: int) для решения следующей задачи: Сложите два числа x и y
>>> add(2, 3)
5
>>> add(5, 7)
12 | Напишите функцию add(x: int, y: int) для решения следующей задачи: Сложите два числа x и y | def add(x: int, y: int):
"""
Сложите два числа x и y
"""
|
HumanEval/54 | Проверьте, совпадают ли символы в двух словах.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same_chars('abcd', 'dddddddabce')
False
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
False | def same_chars(s0: str, s1: str):
"""
Проверьте, совпадают ли символы в двух словах.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same_chars('abcd', 'dddddddabce')
False
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
False
"""
| return set(s0) == set(s1)
|
METADATA = {}
def check(candidate):
assert candidate('eabcdzzzz', 'dddzzzzzzzddeddabc') == True
assert candidate('abcd', 'dddddddabc') == True
assert candidate('dddddddabc', 'abcd') == True
assert candidate('eabcd', 'dddddddabc') == False
assert candidate('abcd', 'dddddddabcf') == False
assert candidate('eabcdzzzz', 'dddzzzzzzzddddabc') == False
assert candidate('aabb', 'aaccc') == False
| same_chars | same_chars(s0: str, s1: str) | def same_chars(s0: str, s1: str): | Напишите функцию same_chars(s0: str, s1: str) для решения следующей задачи: Проверьте, совпадают ли символы в двух словах.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same_chars('abcd', 'dddddddabce')
False
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
False | Напишите функцию same_chars(s0: str, s1: str) для решения следующей задачи: Проверьте, совпадают ли символы в двух словах. | def same_chars(s0: str, s1: str):
"""
Проверьте, совпадают ли символы в двух словах.
"""
|
HumanEval/55 | Возвращает n-е число Фибоначчи.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21 | def fib(n: int):
"""
Возвращает n-е число Фибоначчи.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
| if n == 0:
return 0
if n == 1:
return 1
return fib(n - 1) + fib(n - 2)
|
METADATA = {}
def check(candidate):
assert candidate(10) == 55
assert candidate(1) == 1
assert candidate(8) == 21
assert candidate(11) == 89
assert candidate(12) == 144
| fib | fib(n: int) | def fib(n: int): | Напишите функцию fib(n: int) для решения следующей задачи: Возвращает n-е число Фибоначчи.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21 | Напишите функцию fib(n: int) для решения следующей задачи: Возвращает n-е число Фибоначчи. | def fib(n: int):
"""
Возвращает n-е число Фибоначчи.
"""
|
HumanEval/56 | скобки - это строка из "<" и ">".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing("><<>")
False | def correct_bracketing(brackets: str):
"""
скобки - это строка из "<" и ">".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing("><<>")
False
"""
| depth = 0
for b in brackets:
if b == "<":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("<>")
assert candidate("<<><>>")
assert candidate("<><><<><>><>")
assert candidate("<><><<<><><>><>><<><><<>>>")
assert not candidate("<<<><>>>>")
assert not candidate("><<>")
assert not candidate("<")
assert not candidate("<<<<")
assert not candidate(">")
assert not candidate("<<>")
assert not candidate("<><><<><>><>><<>")
assert not candidate("<><><<><>><>>><>")
| correct_bracketing | correct_bracketing(brackets: str) | def correct_bracketing(brackets: str): | Напишите функцию correct_bracketing(brackets: str) для решения следующей задачи: скобки - это строка из "<" и ">".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing("><<>")
False | Напишите функцию correct_bracketing(brackets: str) для решения следующей задачи: скобки - это строка из "<" и ">".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку. | def correct_bracketing(brackets: str):
"""
скобки - это строка из "<" и ">".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
"""
|
HumanEval/57 | Возвращает значение True, если элементы списка монотонно возрастают или убывают.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True | def monotonic(l: list):
"""
Возвращает значение True, если элементы списка монотонно возрастают или убывают.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
| if l == sorted(l) or l == sorted(l, reverse=True):
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10]) == True
assert candidate([1, 2, 4, 20]) == True
assert candidate([1, 20, 4, 10]) == False
assert candidate([4, 1, 0, -10]) == True
assert candidate([4, 1, 1, 0]) == True
assert candidate([1, 2, 3, 2, 5, 60]) == False
assert candidate([1, 2, 3, 4, 5, 60]) == True
assert candidate([9, 9, 9, 9]) == True
| monotonic | monotonic(l: list) | def monotonic(l: list): | Напишите функцию monotonic(l: list) для решения следующей задачи: Возвращает значение True, если элементы списка монотонно возрастают или убывают.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True | Напишите функцию monotonic(l: list) для решения следующей задачи: Возвращает значение True, если элементы списка монотонно возрастают или убывают. | def monotonic(l: list):
"""
Возвращает значение True, если элементы списка монотонно возрастают или убывают.
"""
|
HumanEval/58 | Возвращает отсортированные уникальные общие элементы для двух списков.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3] | def common(l1: list, l2: list):
"""
Возвращает отсортированные уникальные общие элементы для двух списков.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
| ret = set()
for e1 in l1:
for e2 in l2:
if e1 == e2:
ret.add(e1)
return sorted(list(ret))
|
METADATA = {}
def check(candidate):
assert candidate([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]) == [1, 5, 653]
assert candidate([5, 3, 2, 8], [3, 2]) == [2, 3]
assert candidate([4, 3, 2, 8], [3, 2, 4]) == [2, 3, 4]
assert candidate([4, 3, 2, 8], []) == []
| common | common(l1: list, l2: list) | def common(l1: list, l2: list): | Напишите функцию common(l1: list, l2: list) для решения следующей задачи: Возвращает отсортированные уникальные общие элементы для двух списков.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3] | Напишите функцию common(l1: list, l2: list) для решения следующей задачи: Возвращает отсортированные уникальные общие элементы для двух списков. | def common(l1: list, l2: list):
"""
Возвращает отсортированные уникальные общие элементы для двух списков.
"""
|
HumanEval/59 | Возвращает наибольший простой множитель n. Предположим, что n > 1 и не является простым числом.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2 | def largest_prime_factor(n: int):
"""
Возвращает наибольший простой множитель n. Предположим, что n > 1 и не является простым числом.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
| def is_prime(k):
if k < 2:
return False
for i in range(2, k - 1):
if k % i == 0:
return False
return True
largest = 1
for j in range(2, n + 1):
if n % j == 0 and is_prime(j):
largest = max(largest, j)
return largest
|
METADATA = {}
def check(candidate):
assert candidate(15) == 5
assert candidate(27) == 3
assert candidate(63) == 7
assert candidate(330) == 11
assert candidate(13195) == 29
| largest_prime_factor | largest_prime_factor(n: int) | def largest_prime_factor(n: int): | Напишите функцию largest_prime_factor(n: int) для решения следующей задачи: Возвращает наибольший простой множитель n. Предположим, что n > 1 и не является простым числом.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2 | Напишите функцию largest_prime_factor(n: int) для решения следующей задачи: Возвращает наибольший простой множитель n. Предположим, что n > 1 и не является простым числом. | def largest_prime_factor(n: int):
"""
Возвращает наибольший простой множитель n. Предположим, что n > 1 и не является простым числом.
"""
|
HumanEval/60 | sum_to_n - это функция, которая суммирует числа от 1 до n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1 | def sum_to_n(n: int):
"""
sum_to_n - это функция, которая суммирует числа от 1 до n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
| return sum(range(n + 1))
|
METADATA = {}
def check(candidate):
assert candidate(1) == 1
assert candidate(6) == 21
assert candidate(11) == 66
assert candidate(30) == 465
assert candidate(100) == 5050
| sum_to_n | sum_to_n(n: int) | def sum_to_n(n: int): | Напишите функцию sum_to_n(n: int) для решения следующей задачи: sum_to_n - это функция, которая суммирует числа от 1 до n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1 | Напишите функцию sum_to_n(n: int) для решения следующей задачи: sum_to_n - это функция, которая суммирует числа от 1 до n. | def sum_to_n(n: int):
"""
sum_to_n - это функция, которая суммирует числа от 1 до n.
"""
|
HumanEval/61 | скобки - это строка из "(" и ")".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(")(()")
False | def correct_bracketing(brackets: str):
"""
скобки - это строка из "(" и ")".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(")(()")
False
"""
| depth = 0
for b in brackets:
if b == "(":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("()")
assert candidate("(()())")
assert candidate("()()(()())()")
assert candidate("()()((()()())())(()()(()))")
assert not candidate("((()())))")
assert not candidate(")(()")
assert not candidate("(")
assert not candidate("((((")
assert not candidate(")")
assert not candidate("(()")
assert not candidate("()()(()())())(()")
assert not candidate("()()(()())()))()")
| correct_bracketing | correct_bracketing(brackets: str) | def correct_bracketing(brackets: str): | Напишите функцию correct_bracketing(brackets: str) для решения следующей задачи: скобки - это строка из "(" и ")".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(")(()")
False | Напишите функцию correct_bracketing(brackets: str) для решения следующей задачи: скобки - это строка из "(" и ")".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку. | def correct_bracketing(brackets: str):
"""
скобки - это строка из "(" и ")".
возвращает значение True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
"""
|
HumanEval/62 | xs представляют собой коэффициенты многочлена.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Верните производную этого многочлена в том же виде.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6] | def derivative(xs: list):
"""
xs представляют собой коэффициенты многочлена.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Верните производную этого многочлена в том же виде.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
| return [(i * x) for i, x in enumerate(xs)][1:]
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == [1, 4, 12, 20]
assert candidate([1, 2, 3]) == [2, 6]
assert candidate([3, 2, 1]) == [2, 2]
assert candidate([3, 2, 1, 0, 4]) == [2, 2, 0, 16]
assert candidate([1]) == []
| derivative | derivative(xs: list) | def derivative(xs: list): | Напишите функцию derivative(xs: list) для решения следующей задачи: xs представляют собой коэффициенты многочлена.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Верните производную этого многочлена в том же виде.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6] | Напишите функцию derivative(xs: list) для решения следующей задачи: xs представляют собой коэффициенты многочлена.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Верните производную этого многочлена в том же виде. | def derivative(xs: list):
"""
xs представляют собой коэффициенты многочлена.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Верните производную этого многочлена в том же виде.
"""
|
HumanEval/63 | Числовая последовательность FibFib - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fibfib.
>>> fibfib(1)
0
>>> fibfib(5)
4
>>> fibfib(8)
24 | def fibfib(n: int):
"""
Числовая последовательность FibFib - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fibfib.
>>> fibfib(1)
0
>>> fibfib(5)
4
>>> fibfib(8)
24
"""
| if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n - 1) + fibfib(n - 2) + fibfib(n - 3)
|
METADATA = {}
def check(candidate):
assert candidate(2) == 1
assert candidate(1) == 0
assert candidate(5) == 4
assert candidate(8) == 24
assert candidate(10) == 81
assert candidate(12) == 274
assert candidate(14) == 927
| fibfib | fibfib(n: int) | def fibfib(n: int): | Напишите функцию fibfib(n: int) для решения следующей задачи: Числовая последовательность FibFib - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fibfib.
>>> fibfib(1)
0
>>> fibfib(5)
4
>>> fibfib(8)
24 | Напишите функцию fibfib(n: int) для решения следующей задачи: Числовая последовательность FibFib - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fibfib. | def fibfib(n: int):
"""
Числовая последовательность FibFib - это последовательность, аналогичная последовательности Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Пожалуйста, напишите функцию для эффективного вычисления n-го элемента числовой последовательности fibfib.
"""
|
HumanEval/64 | Напишите функцию vowels_count, которая принимает строку, представляющую слово, в качестве входных данных и возвращает количество гласных в строке.
Гласными в данном случае являются "a", "e", "i", "o", "u". Здесь "y" также является гласной, но только тогда, когда она находится в конце данного слова.
Пример:
>>> vowels_count("abcde")
2
>>> vowels_count("ACEDY")
3 | FIX = """
Add more test cases.
"""
def vowels_count(s):
"""
Напишите функцию vowels_count, которая принимает строку, представляющую слово, в качестве входных данных и возвращает количество гласных в строке.
Гласными в данном случае являются "a", "e", "i", "o", "u". Здесь "y" также является гласной, но только тогда, когда она находится в конце данного слова.
Пример:
>>> vowels_count("abcde")
2
>>> vowels_count("ACEDY")
3
"""
| vowels = "aeiouAEIOU"
n_vowels = sum(c in vowels for c in s)
if s[-1] == 'y' or s[-1] == 'Y':
n_vowels += 1
return n_vowels
| def check(candidate):
# Check some simple cases
assert candidate("abcde") == 2, "Test 1"
assert candidate("Alone") == 3, "Test 2"
assert candidate("key") == 2, "Test 3"
assert candidate("bye") == 1, "Test 4"
assert candidate("keY") == 2, "Test 5"
assert candidate("bYe") == 1, "Test 6"
assert candidate("ACEDY") == 3, "Test 7"
# 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!)"
| vowels_count | vowels_count(s) | FIX = """
Add more test cases.
"""
def vowels_count(s): | Напишите функцию vowels_count(s) для решения следующей задачи: Напишите функцию vowels_count, которая принимает строку, представляющую слово, в качестве входных данных и возвращает количество гласных в строке.
Гласными в данном случае являются "a", "e", "i", "o", "u". Здесь "y" также является гласной, но только тогда, когда она находится в конце данного слова.
Пример:
>>> vowels_count("abcde")
2
>>> vowels_count("ACEDY")
3 | Напишите функцию vowels_count(s) для решения следующей задачи: Напишите функцию vowels_count, которая принимает строку, представляющую слово, в качестве входных данных и возвращает количество гласных в строке.
Гласными в данном случае являются "a", "e", "i", "o", "u". Здесь "y" также является гласной, но только тогда, когда она находится в конце данного слова.
Пример: | FIX = """
Add more test cases.
"""
def vowels_count(s):
"""
Напишите функцию vowels_count, которая принимает строку, представляющую слово, в качестве входных данных и возвращает количество гласных в строке.
Гласными в данном случае являются "a", "e", "i", "o", "u". Здесь "y" также является гласной, но только тогда, когда она находится в конце данного слова.
Пример:
"""
|
HumanEval/65 | Осуществите круговой сдвиг цифр целого числа x, сдвиг цифр вправо на shift и верните результат в виде строки.
Если shift > количество цифр, верните цифры в обратном порядке.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12" | def circular_shift(x, shift):
"""
Осуществите круговой сдвиг цифр целого числа x, сдвиг цифр вправо на shift и верните результат в виде строки.
Если shift > количество цифр, верните цифры в обратном порядке.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
| s = str(x)
if shift > len(s):
return s[::-1]
else:
return s[len(s) - shift:] + s[:len(s) - shift]
| def check(candidate):
# Check some simple cases
assert candidate(100, 2) == "001"
assert candidate(12, 2) == "12"
assert candidate(97, 8) == "79"
assert candidate(12, 1) == "21", "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(11, 101) == "11", "This prints if this assert fails 2 (also good for debugging!)"
| circular_shift | circular_shift(x, shift) | def circular_shift(x, shift): | Напишите функцию circular_shift(x, shift) для решения следующей задачи: Осуществите круговой сдвиг цифр целого числа x, сдвиг цифр вправо на shift и верните результат в виде строки.
Если shift > количество цифр, верните цифры в обратном порядке.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12" | Напишите функцию circular_shift(x, shift) для решения следующей задачи: Осуществите круговой сдвиг цифр целого числа x, сдвиг цифр вправо на shift и верните результат в виде строки.
Если shift > количество цифр, верните цифры в обратном порядке. | def circular_shift(x, shift):
"""
Осуществите круговой сдвиг цифр целого числа x, сдвиг цифр вправо на shift и верните результат в виде строки.
Если shift > количество цифр, верните цифры в обратном порядке.
"""
|
HumanEval/66 | Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов только заглавных символов.
Примеры:
s:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
digitSum("aAaaaXa") => 153 | def digitSum(s):
"""
Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов только заглавных символов.
Примеры:
s:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
digitSum("aAaaaXa") => 153
"""
| if s == "": return 0
return sum(ord(char) if char.isupper() else 0 for char in s)
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate("") == 0, "Error"
assert candidate("abAB") == 131, "Error"
assert candidate("abcCd") == 67, "Error"
assert candidate("helloE") == 69, "Error"
assert candidate("woArBld") == 131, "Error"
assert candidate("aAaaaXa") == 153, "Error"
# 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!)"
assert candidate(" How are yOu?") == 151, "Error"
assert candidate("You arE Very Smart") == 327, "Error"
| digitSum | digitSum(s) | def digitSum(s): | Напишите функцию digitSum(s) для решения следующей задачи: Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов только заглавных символов.
Примеры:
s:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
digitSum("aAaaaXa") => 153 | Напишите функцию digitSum(s) для решения следующей задачи: Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов только заглавных символов. | def digitSum(s):
"""
Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов только заглавных символов.
"""
|
End of preview. Expand
in Dataset Viewer.
HumanEval_ru Dataset
Dataset Summary
This is a version of Code Geneneration HumanEval dataset translated to Russian.
Supported tasks
The task is to generate body of the function based on the function signature and docstring. The programming problems are written in Python and contain Russian natural text in comments and docstrings.
Task example
from typing import List
def string_xor(a: str, b: str) -> str:
"""
Входными данными являются две строки a и b, состоящие только из 1 и 0.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки.
>>> string_xor('010', '110')
'100'
"""
# Your code here
Dataset structure
Please refer to the structure of the original HumanEval dataset
Translation
Textual descriptions of tasks were translated automatically via Yandex.Translate API and then manually edited. Feel free to report errors in translations.
Usage
Load dataset
from datasets import load_dataset
load_dataset('NLPCoreTeam/humaneval_ru')
DatasetDict({
train: Dataset({
features: ['task_id', 'prompt', 'canonical_solution', 'test', 'entry_point', 'signature', 'docstring', 'context', 'instruction', 'instruction_noexamples'],
num_rows: 164
})
})
How to evaluate your models
To evaluate code generation capabilities of your models on HumanEval_ru please follow these steps (example is for Codellama-7b-Python):
- Clone https://github.com/NLP-Core-Team/bigcode-evaluation-harness
- Run evaluation (WARNING: generated code is executed, it may be unsafe) with the following command
# mkdir -p ./outs/humaneval_ru
# mkdir -p ./results/humaneval_ru
accelerate launch main.py \
--model codellama/CodeLlama-7b-Python-hf \
--max_length_generation 512 \
--tasks humaneval_ru \
--use_auth_token \
--temperature 0.2 \
--n_samples 20 \
--precision fp16 \
--batch_size 1 \
--allow_code_execution \
--save_generations_path ./outs/humaneval_ru/codellama-7b-py.json \
--metric_output_path ./results/humaneval_ru/codellama-7b-py.metrics
- Resulting metrics of Codellama-7b-Python should be
"humaneval_ru": {
"pass@1": 0.35,
"pass@10": 0.5122803695209872
},
Benchmark
Starcoder and Codellama models evaluations on HumanEval_Ru and HumanEval are presented in the table below. For further information on Pass@1 and Pass@10 please refer to original paper.
| model | RU Pass@1 | RU Pass@10 | EN Pass@1 | EN Pass@10 |
|---|---|---|---|---|
| starcoderbase-1b | 0.1420 | 0.1801 | 0.1509 | 0.2045 |
| starcoderbase-3b | 0.1924 | 0.2606 | 0.2137 | 0.3289 |
| starcoderbase-7b | 0.2515 | 0.3359 | 0.2868 | 0.3852 |
| starcoderbase-15b | 0.2676 | 0.3872 | 0.3036 | 0.4611 |
| starcoder-15b-Python | 0.3103 | 0.4132 | 0.3353 | 0.4931 |
| CodeLlama-7b-hf | 0.2673 | 0.3688 | 0.2975 | 0.4351 |
| CodeLlama-7b-Python-hf | 0.3500 | 0.5122 | 0.3960 | 0.5761 |
| CodeLlama-13b-hf | 0.3380 | 0.4884 | 0.3557 | 0.5489 |
| CodeLlama-13b-Python-hf | 0.4380 | 0.5796 | 0.4301 | 0.6226 |
Script to reproduce the results in the table
#!/bin/bash
# use with https://github.com/NLP-Core-Team/bigcode-evaluation-harness
# RU
mkdir -p ./outs/humaneval_ru
mkdir -p ./results/humaneval_ru
MODELS_PATH="bigcode"
echo $MODELS_PATH
declare -A bs=( ["starcoderbase-1b"]=16 ["starcoderbase-3b"]=8 ["starcoderbase-7b"]=4 ["starcoderbase"]=1 ["starcoder"]=1)
for model_name in starcoderbase-1b starcoderbase-3b starcoderbase-7b starcoderbase starcoder
do
echo $MODELS_PATH/$model_name
accelerate launch --mixed_precision="fp16" main.py \
--model $MODELS_PATH/$model_name \
--max_length_generation 512 \
--tasks humaneval_ru \
--use_auth_token \
--temperature 0.2 \
--n_samples 20 \
--precision fp16 \
--batch_size ${bs[$model_name]} \
--allow_code_execution \
--save_generations_path ./outs/humaneval_ru/$model_name.json \
--metric_output_path ./results/humaneval_ru/$model_name.metrics
done
MODELS_PATH="codellama"
echo $MODELS_PATH
declare -A bs=( ["CodeLlama-7b-Python-hf"]=8 ["CodeLlama-7b-hf"]=16 ["CodeLlama-13b-Python-hf"]=4 ["CodeLlama-13b-hf"]=4 )
for model_name in CodeLlama-7b-hf CodeLlama-7b-Python-hf CodeLlama-13b-hf CodeLlama-13b-Python-hf
do
echo $MODELS_PATH/$model_name
accelerate launch --mixed_precision="fp16" main.py \
--model $MODELS_PATH/$model_name \
--max_length_generation 512 \
--tasks humaneval_ru \
--use_auth_token \
--temperature 0.2 \
--n_samples 20 \
--precision fp16 \
--batch_size ${bs[$model_name]} \
--allow_code_execution \
--save_generations_path ./outs/humaneval_ru/$model_name.json \
--metric_output_path ./results/humaneval_ru/$model_name.metrics
done
# EN
mkdir -p ./outs/humaneval
mkdir -p ./results/humaneval
MODELS_PATH="bigcode"
echo $MODELS_PATH
declare -A bs=( ["starcoderbase-1b"]=16 ["starcoderbase-3b"]=8 ["starcoderbase-7b"]=4 ["starcoderbase"]=1 ["starcoder"]=1)
for model_name in starcoderbase-1b starcoderbase-3b starcoderbase-7b starcoderbase starcoder
do
echo $MODELS_PATH/$model_name
accelerate launch --mixed_precision="fp16" main.py \
--model $MODELS_PATH/$model_name \
--max_length_generation 512 \
--tasks humaneval \
--use_auth_token \
--temperature 0.2 \
--n_samples 20 \
--precision fp16 \
--batch_size ${bs[$model_name]} \
--allow_code_execution \
--save_generations_path ./outs/humaneval/$model_name.json \
--metric_output_path ./results/humaneval/$model_name.metrics
done
MODELS_PATH="codellama"
echo $MODELS_PATH
declare -A bs=( ["CodeLlama-7b-Python-hf"]=8 ["CodeLlama-7b-hf"]=16 ["CodeLlama-13b-Python-hf"]=4 ["CodeLlama-13b-hf"]=4 )
for model_name in CodeLlama-7b-hf CodeLlama-7b-Python-hf CodeLlama-13b-hf CodeLlama-13b-Python-hf
do
echo $MODELS_PATH/$model_name
accelerate launch --mixed_precision="fp16" main.py \
--model $MODELS_PATH/$model_name \
--max_length_generation 512 \
--tasks humaneval \
--use_auth_token \
--temperature 0.2 \
--n_samples 20 \
--precision fp16 \
--batch_size ${bs[$model_name]} \
--allow_code_execution \
--save_generations_path ./outs/humaneval/$model_name.json \
--metric_output_path ./results/humaneval/$model_name.metrics
done
- Downloads last month
- 65
Size of downloaded dataset files:
280 kB
Size of the auto-converted Parquet files:
280 kB
Number of rows:
164
