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-кодов только заглавных символов.
"""
|
HumanEval/67 | В этом задании вам дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами. Эта корзина содержит яблоки, апельсины и плоды манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, возвращает количество плодов манго в корзине.
например:
fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19 | def fruit_distribution(s,n):
"""
В этом задании вам дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами. Эта корзина содержит яблоки, апельсины и плоды манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, возвращает количество плодов манго в корзине.
например:
fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
"""
| lis = list()
for i in s.split(' '):
if i.isdigit():
lis.append(int(i))
return n - sum(lis)
| def check(candidate):
# Check some simple cases
assert candidate("5 apples and 6 oranges",19) == 8
assert candidate("5 apples and 6 oranges",21) == 10
assert candidate("0 apples and 1 oranges",3) == 2
assert candidate("1 apples and 0 oranges",3) == 2
assert candidate("2 apples and 3 oranges",100) == 95
assert candidate("2 apples and 3 oranges",5) == 0
assert candidate("1 apples and 100 oranges",120) == 19
| fruit_distribution | fruit_distribution(s,n) | def fruit_distribution(s,n): | Напишите функцию fruit_distribution(s,n) для решения следующей задачи: В этом задании вам дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами. Эта корзина содержит яблоки, апельсины и плоды манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, возвращает количество плодов манго в корзине.
например:
fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19 | Напишите функцию fruit_distribution(s,n) для решения следующей задачи: В этом задании вам дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами. Эта корзина содержит яблоки, апельсины и плоды манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, возвращает количество плодов манго в корзине.
например: | def fruit_distribution(s,n):
"""
В этом задании вам дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами. Эта корзина содержит яблоки, апельсины и плоды манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, возвращает количество плодов манго в корзине.
например:
"""
|
HumanEval/68 | Дан массив, представляющий ветвь дерева с неотрицательными целыми узлами, ваша задача состоит в том, чтобы выделить один из узлов и вернуть его.
Выделенный узел должен быть узлом с наименьшим четным значением.
Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка, [ наименьшее значение, его индекс ],
Если четных значений нет или данный массив пуст, верните [].
Примеры:
1:
Input: [4,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
2:
Input: [1,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
3:
Input: []
Output: []
4:
Input: [5, 0, 3, 0, 4, 2]
Output: [0, 1]
Explanation: 0 is the smallest value, but there are two zeros,
so we will choose the first zero, which has the smallest index.
Constraints:
* 1 <= nodes.length <= 10000
* 0 <= node.value | def pluck(arr):
"""
Дан массив, представляющий ветвь дерева с неотрицательными целыми узлами, ваша задача состоит в том, чтобы выделить один из узлов и вернуть его.
Выделенный узел должен быть узлом с наименьшим четным значением.
Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка, [ наименьшее значение, его индекс ],
Если четных значений нет или данный массив пуст, верните [].
Примеры:
1:
Input: [4,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
2:
Input: [1,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
3:
Input: []
Output: []
4:
Input: [5, 0, 3, 0, 4, 2]
Output: [0, 1]
Explanation: 0 is the smallest value, but there are two zeros,
so we will choose the first zero, which has the smallest index.
Constraints:
* 1 <= nodes.length <= 10000
* 0 <= node.value
"""
| if(len(arr) == 0): return []
evens = list(filter(lambda x: x%2 == 0, arr))
if(evens == []): return []
return [min(evens), arr.index(min(evens))]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([4,2,3]) == [2, 1], "Error"
assert candidate([1,2,3]) == [2, 1], "Error"
assert candidate([]) == [], "Error"
assert candidate([5, 0, 3, 0, 4, 2]) == [0, 1], "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([1, 2, 3, 0, 5, 3]) == [0, 3], "Error"
assert candidate([5, 4, 8, 4 ,8]) == [4, 1], "Error"
assert candidate([7, 6, 7, 1]) == [6, 1], "Error"
assert candidate([7, 9, 7, 1]) == [], "Error"
| pluck | pluck(arr) | def pluck(arr): | Напишите функцию pluck(arr) для решения следующей задачи: Дан массив, представляющий ветвь дерева с неотрицательными целыми узлами, ваша задача состоит в том, чтобы выделить один из узлов и вернуть его.
Выделенный узел должен быть узлом с наименьшим четным значением.
Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка, [ наименьшее значение, его индекс ],
Если четных значений нет или данный массив пуст, верните [].
Примеры:
1:
Input: [4,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
2:
Input: [1,2,3]
Output: [2, 1]
Explanation: 2 has the smallest even value, and 2 has the smallest index.
3:
Input: []
Output: []
4:
Input: [5, 0, 3, 0, 4, 2]
Output: [0, 1]
Explanation: 0 is the smallest value, but there are two zeros,
so we will choose the first zero, which has the smallest index.
Constraints:
* 1 <= nodes.length <= 10000
* 0 <= node.value | Напишите функцию pluck(arr) для решения следующей задачи: Дан массив, представляющий ветвь дерева с неотрицательными целыми узлами, ваша задача состоит в том, чтобы выделить один из узлов и вернуть его.
Выделенный узел должен быть узлом с наименьшим четным значением.
Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка, [ наименьшее значение, его индекс ],
Если четных значений нет или данный массив пуст, верните [].
| def pluck(arr):
"""
Дан массив, представляющий ветвь дерева с неотрицательными целыми узлами, ваша задача состоит в том, чтобы выделить один из узлов и вернуть его.
Выделенный узел должен быть узлом с наименьшим четным значением.
Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка, [ наименьшее значение, его индекс ],
Если четных значений нет или данный массив пуст, верните [].
"""
|
HumanEval/69 | Вам дан непустой список целых положительных чисел. Возвращает наибольшее целое число, которое больше нуля и имеет частоту, большую или равную самого числа.
Частота целого числа - это количество раз, когда оно появляется в списке.
Если такого значения не существует, верните -1.
Примеры:
search([4, 1, 2, 2, 3, 1]) == 2
search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
search([5, 5, 4, 4, 4]) == -1 | def search(lst):
"""
Вам дан непустой список целых положительных чисел. Возвращает наибольшее целое число, которое больше нуля и имеет частоту, большую или равную самого числа.
Частота целого числа - это количество раз, когда оно появляется в списке.
Если такого значения не существует, верните -1.
Примеры:
search([4, 1, 2, 2, 3, 1]) == 2
search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
search([5, 5, 4, 4, 4]) == -1
"""
| frq = [0] * (max(lst) + 1)
for i in lst:
frq[i] += 1;
ans = -1
for i in range(1, len(frq)):
if frq[i] >= i:
ans = i
return ans
| def check(candidate):
# manually generated tests
assert candidate([5, 5, 5, 5, 1]) == 1
assert candidate([4, 1, 4, 1, 4, 4]) == 4
assert candidate([3, 3]) == -1
assert candidate([8, 8, 8, 8, 8, 8, 8, 8]) == 8
assert candidate([2, 3, 3, 2, 2]) == 2
# automatically generated tests
assert candidate([2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1]) == 1
assert candidate([3, 2, 8, 2]) == 2
assert candidate([6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10]) == 1
assert candidate([8, 8, 3, 6, 5, 6, 4]) == -1
assert candidate([6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9]) == 1
assert candidate([1, 9, 10, 1, 3]) == 1
assert candidate([6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10]) == 5
assert candidate([1]) == 1
assert candidate([8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5]) == 4
assert candidate([2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10]) == 2
assert candidate([1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3]) == 1
assert candidate([9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4]) == 4
assert candidate([2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7]) == 4
assert candidate([9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1]) == 2
assert candidate([5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8]) == -1
assert candidate([10]) == -1
assert candidate([9, 7, 7, 2, 4, 7, 2, 10, 9, 7, 5, 7, 2]) == 2
assert candidate([5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8]) == 1
assert candidate([7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6]) == 1
assert candidate([3, 10, 10, 9, 2]) == -1
| search | search(lst) | def search(lst): | Напишите функцию search(lst) для решения следующей задачи: Вам дан непустой список целых положительных чисел. Возвращает наибольшее целое число, которое больше нуля и имеет частоту, большую или равную самого числа.
Частота целого числа - это количество раз, когда оно появляется в списке.
Если такого значения не существует, верните -1.
Примеры:
search([4, 1, 2, 2, 3, 1]) == 2
search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
search([5, 5, 4, 4, 4]) == -1 | Напишите функцию search(lst) для решения следующей задачи: Вам дан непустой список целых положительных чисел. Возвращает наибольшее целое число, которое больше нуля и имеет частоту, большую или равную самого числа.
Частота целого числа - это количество раз, когда оно появляется в списке.
Если такого значения не существует, верните -1.
| def search(lst):
"""
Вам дан непустой список целых положительных чисел. Возвращает наибольшее целое число, которое больше нуля и имеет частоту, большую или равную самого числа.
Частота целого числа - это количество раз, когда оно появляется в списке.
Если такого значения не существует, верните -1.
"""
|
HumanEval/70 | Задан список целых чисел, верните список в странном порядке.
Странный порядок - это когда вы начинаете с минимального значения,
затем максимального из оставшихся целых чисел, затем минимального и так далее.
Примеры:
s:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
strange_sort_list([]) == [] | def strange_sort_list(lst):
"""
Задан список целых чисел, верните список в странном порядке.
Странный порядок - это когда вы начинаете с минимального значения,
затем максимального из оставшихся целых чисел, затем минимального и так далее.
Примеры:
s:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
strange_sort_list([]) == []
"""
| res, switch = [], True
while lst:
res.append(min(lst) if switch else max(lst))
lst.remove(res[-1])
switch = not switch
return res
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4]) == [1, 4, 2, 3]
assert candidate([5, 6, 7, 8, 9]) == [5, 9, 6, 8, 7]
assert candidate([1, 2, 3, 4, 5]) == [1, 5, 2, 4, 3]
assert candidate([5, 6, 7, 8, 9, 1]) == [1, 9, 5, 8, 6, 7]
assert candidate([5, 5, 5, 5]) == [5, 5, 5, 5]
assert candidate([]) == []
assert candidate([1,2,3,4,5,6,7,8]) == [1, 8, 2, 7, 3, 6, 4, 5]
assert candidate([0,2,2,2,5,5,-5,-5]) == [-5, 5, -5, 5, 0, 2, 2, 2]
assert candidate([111111]) == [111111]
# Check some edge cases that are easy to work out by hand.
assert True
| strange_sort_list | strange_sort_list(lst) | def strange_sort_list(lst): | Напишите функцию strange_sort_list(lst) для решения следующей задачи: Задан список целых чисел, верните список в странном порядке.
Странный порядок - это когда вы начинаете с минимального значения,
затем максимального из оставшихся целых чисел, затем минимального и так далее.
Примеры:
s:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
strange_sort_list([]) == [] | Напишите функцию strange_sort_list(lst) для решения следующей задачи: Задан список целых чисел, верните список в странном порядке.
Странный порядок - это когда вы начинаете с минимального значения,
затем максимального из оставшихся целых чисел, затем минимального и так далее.
| def strange_sort_list(lst):
"""
Задан список целых чисел, верните список в странном порядке.
Странный порядок - это когда вы начинаете с минимального значения,
затем максимального из оставшихся целых чисел, затем минимального и так далее.
"""
|
HumanEval/71 | Даны длины трех сторон треугольника. Верните площадь треугольника, округленную до 2 знаков после запятой, если три стороны образуют треугольник.
В противном случае верните -1
Три стороны образуют треугольник, когда сумма любых двух сторон больше третьей стороны.
Примеры:
:
triangle_area(3, 4, 5) == 6.00
triangle_area(1, 2, 10) == -1 | def triangle_area(a, b, c):
"""
Даны длины трех сторон треугольника. Верните площадь треугольника, округленную до 2 знаков после запятой, если три стороны образуют треугольник.
В противном случае верните -1
Три стороны образуют треугольник, когда сумма любых двух сторон больше третьей стороны.
Примеры:
:
triangle_area(3, 4, 5) == 6.00
triangle_area(1, 2, 10) == -1
"""
| if a + b <= c or a + c <= b or b + c <= a:
return -1
s = (a + b + c)/2
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
area = round(area, 2)
return area
| def check(candidate):
# Check some simple cases
assert candidate(3, 4, 5) == 6.00, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1, 2, 10) == -1
assert candidate(4, 8, 5) == 8.18
assert candidate(2, 2, 2) == 1.73
assert candidate(1, 2, 3) == -1
assert candidate(10, 5, 7) == 16.25
assert candidate(2, 6, 3) == -1
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1, 1) == 0.43, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(2, 2, 10) == -1
| triangle_area | triangle_area(a, b, c) | def triangle_area(a, b, c): | Напишите функцию triangle_area(a, b, c) для решения следующей задачи: Даны длины трех сторон треугольника. Верните площадь треугольника, округленную до 2 знаков после запятой, если три стороны образуют треугольник.
В противном случае верните -1
Три стороны образуют треугольник, когда сумма любых двух сторон больше третьей стороны.
Примеры:
:
triangle_area(3, 4, 5) == 6.00
triangle_area(1, 2, 10) == -1 | Напишите функцию triangle_area(a, b, c) для решения следующей задачи: Даны длины трех сторон треугольника. Верните площадь треугольника, округленную до 2 знаков после запятой, если три стороны образуют треугольник.
В противном случае верните -1
Три стороны образуют треугольник, когда сумма любых двух сторон больше третьей стороны.
| def triangle_area(a, b, c):
"""
Даны длины трех сторон треугольника. Верните площадь треугольника, округленную до 2 знаков после запятой, если три стороны образуют треугольник.
В противном случае верните -1
Три стороны образуют треугольник, когда сумма любых двух сторон больше третьей стороны.
"""
|
HumanEval/72 | Напишите функцию, которая возвращает True, если объект q может полететь, и False в противном случае.
Объект q полетит, если он сбалансирован (это палиндромный список) и сумма его элементов меньше или равна максимально возможному весу w.
Примеры:
will_it_fly([1, 2], 5) ➞ False # 1+2 is less than the maximum possible weight, but it's unbalanced.
will_it_fly([3, 2, 3], 1) ➞ False # it's balanced, but 3+2+3 is more than the maximum possible weight.
will_it_fly([3, 2, 3], 9) ➞ True # 3+2+3 is less than the maximum possible weight, and it's balanced.
will_it_fly([3], 5) ➞ True # 3 is less than the maximum possible weight, and it's balanced. | def will_it_fly(q,w):
"""
Напишите функцию, которая возвращает True, если объект q может полететь, и False в противном случае.
Объект q полетит, если он сбалансирован (это палиндромный список) и сумма его элементов меньше или равна максимально возможному весу w.
Примеры:
will_it_fly([1, 2], 5) ➞ False # 1+2 is less than the maximum possible weight, but it's unbalanced.
will_it_fly([3, 2, 3], 1) ➞ False # it's balanced, but 3+2+3 is more than the maximum possible weight.
will_it_fly([3, 2, 3], 9) ➞ True # 3+2+3 is less than the maximum possible weight, and it's balanced.
will_it_fly([3], 5) ➞ True # 3 is less than the maximum possible weight, and it's balanced.
"""
| if sum(q) > w:
return False
i, j = 0, len(q)-1
while i<j:
if q[i] != q[j]:
return False
i+=1
j-=1
return True
| def check(candidate):
# Check some simple cases
assert candidate([3, 2, 3], 9) is True
assert candidate([1, 2], 5) is False
assert candidate([3], 5) is True
assert candidate([3, 2, 3], 1) is False
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3], 6) is False
assert candidate([5], 5) is True
| will_it_fly | will_it_fly(q,w) | def will_it_fly(q,w): | Напишите функцию will_it_fly(q,w) для решения следующей задачи: Напишите функцию, которая возвращает True, если объект q может полететь, и False в противном случае.
Объект q полетит, если он сбалансирован (это палиндромный список) и сумма его элементов меньше или равна максимально возможному весу w.
Примеры:
will_it_fly([1, 2], 5) ➞ False # 1+2 is less than the maximum possible weight, but it's unbalanced.
will_it_fly([3, 2, 3], 1) ➞ False # it's balanced, but 3+2+3 is more than the maximum possible weight.
will_it_fly([3, 2, 3], 9) ➞ True # 3+2+3 is less than the maximum possible weight, and it's balanced.
will_it_fly([3], 5) ➞ True # 3 is less than the maximum possible weight, and it's balanced. | Напишите функцию will_it_fly(q,w) для решения следующей задачи: Напишите функцию, которая возвращает True, если объект q может полететь, и False в противном случае.
Объект q полетит, если он сбалансирован (это палиндромный список) и сумма его элементов меньше или равна максимально возможному весу w.
| def will_it_fly(q,w):
"""
Напишите функцию, которая возвращает True, если объект q может полететь, и False в противном случае.
Объект q полетит, если он сбалансирован (это палиндромный список) и сумма его элементов меньше или равна максимально возможному весу w.
"""
|
HumanEval/73 | Дан массив arr целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы сделать массив палиндромным. Палиндромный массив - это массив, который считывается одинаково спереди и сзади. За одно изменение вы можете заменить один элемент на любой другой.
Примеры:
:
smallest_change([1,2,3,5,4,7,9,6]) == 4
smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
smallest_change([1, 2, 3, 2, 1]) == 0 | def smallest_change(arr):
"""
Дан массив arr целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы сделать массив палиндромным. Палиндромный массив - это массив, который считывается одинаково спереди и сзади. За одно изменение вы можете заменить один элемент на любой другой.
Примеры:
:
smallest_change([1,2,3,5,4,7,9,6]) == 4
smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
smallest_change([1, 2, 3, 2, 1]) == 0
"""
| ans = 0
for i in range(len(arr) // 2):
if arr[i] != arr[len(arr) - i - 1]:
ans += 1
return ans
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3,5,4,7,9,6]) == 4
assert candidate([1, 2, 3, 4, 3, 2, 2]) == 1
assert candidate([1, 4, 2]) == 1
assert candidate([1, 4, 4, 2]) == 1
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3, 2, 1]) == 0
assert candidate([3, 1, 1, 3]) == 0
assert candidate([1]) == 0
assert candidate([0, 1]) == 1
| smallest_change | smallest_change(arr) | def smallest_change(arr): | Напишите функцию smallest_change(arr) для решения следующей задачи: Дан массив arr целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы сделать массив палиндромным. Палиндромный массив - это массив, который считывается одинаково спереди и сзади. За одно изменение вы можете заменить один элемент на любой другой.
Примеры:
:
smallest_change([1,2,3,5,4,7,9,6]) == 4
smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
smallest_change([1, 2, 3, 2, 1]) == 0 | Напишите функцию smallest_change(arr) для решения следующей задачи: Дан массив arr целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы сделать массив палиндромным. Палиндромный массив - это массив, который считывается одинаково спереди и сзади. За одно изменение вы можете заменить один элемент на любой другой.
| def smallest_change(arr):
"""
Дан массив arr целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы сделать массив палиндромным. Палиндромный массив - это массив, который считывается одинаково спереди и сзади. За одно изменение вы можете заменить один элемент на любой другой.
"""
|
HumanEval/74 | Напишите функцию, которая принимает два списка строк и возвращает список, в котором общее количество символов во всех строках списка меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
Примеры:
s
total_match([], []) ➞ []
total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4'] | def total_match(lst1, lst2):
"""
Напишите функцию, которая принимает два списка строк и возвращает список, в котором общее количество символов во всех строках списка меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
Примеры:
s
total_match([], []) ➞ []
total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
"""
| l1 = 0
for st in lst1:
l1 += len(st)
l2 = 0
for st in lst2:
l2 += len(st)
if l1 <= l2:
return lst1
else:
return lst2
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([], []) == []
assert candidate(['hi', 'admin'], ['hi', 'hi']) == ['hi', 'hi']
assert candidate(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) == ['hi', 'admin']
assert candidate(['4'], ['1', '2', '3', '4', '5']) == ['4']
assert candidate(['hi', 'admin'], ['hI', 'Hi']) == ['hI', 'Hi']
assert candidate(['hi', 'admin'], ['hI', 'hi', 'hi']) == ['hI', 'hi', 'hi']
assert candidate(['hi', 'admin'], ['hI', 'hi', 'hii']) == ['hi', 'admin']
# 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([], ['this']) == []
assert candidate(['this'], []) == []
| total_match | total_match(lst1, lst2) | def total_match(lst1, lst2): | Напишите функцию total_match(lst1, lst2) для решения следующей задачи: Напишите функцию, которая принимает два списка строк и возвращает список, в котором общее количество символов во всех строках списка меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
Примеры:
s
total_match([], []) ➞ []
total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4'] | Напишите функцию total_match(lst1, lst2) для решения следующей задачи: Напишите функцию, которая принимает два списка строк и возвращает список, в котором общее количество символов во всех строках списка меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
| def total_match(lst1, lst2):
"""
Напишите функцию, которая принимает два списка строк и возвращает список, в котором общее количество символов во всех строках списка меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
"""
|
HumanEval/75 | Напишите функцию, которая возвращает true, если заданное число является результатом умножения 3 простых чисел, и false в противном случае.
(a) меньше 100.
Примеры:
:
is_multiply_prime(30) == True 30 = 2 * 3 * 5 | def is_multiply_prime(a):
"""
Напишите функцию, которая возвращает true, если заданное число является результатом умножения 3 простых чисел, и false в противном случае.
(a) меньше 100.
Примеры:
:
is_multiply_prime(30) == True 30 = 2 * 3 * 5
"""
| def is_prime(n):
for j in range(2,n):
if n%j == 0:
return False
return True
for i in range(2,101):
if not is_prime(i): continue
for j in range(2,101):
if not is_prime(j): continue
for k in range(2,101):
if not is_prime(k): continue
if i*j*k == a: return True
return False
| def check(candidate):
assert candidate(5) == False
assert candidate(30) == True
assert candidate(8) == True
assert candidate(10) == False
assert candidate(125) == True
assert candidate(3 * 5 * 7) == True
assert candidate(3 * 6 * 7) == False
assert candidate(9 * 9 * 9) == False
assert candidate(11 * 9 * 9) == False
assert candidate(11 * 13 * 7) == True
| is_multiply_prime | is_multiply_prime(a) | def is_multiply_prime(a): | Напишите функцию is_multiply_prime(a) для решения следующей задачи: Напишите функцию, которая возвращает true, если заданное число является результатом умножения 3 простых чисел, и false в противном случае.
(a) меньше 100.
Примеры:
:
is_multiply_prime(30) == True 30 = 2 * 3 * 5 | Напишите функцию is_multiply_prime(a) для решения следующей задачи: Напишите функцию, которая возвращает true, если заданное число является результатом умножения 3 простых чисел, и false в противном случае.
(a) меньше 100.
| def is_multiply_prime(a):
"""
Напишите функцию, которая возвращает true, если заданное число является результатом умножения 3 простых чисел, и false в противном случае.
(a) меньше 100.
"""
|
HumanEval/76 | Ваша задача состоит в том, чтобы написать функцию, которая возвращает true, если число x является простой степенью n, и false в других случаях.
x - это простая степень n, если n**int=x
Примеры:
:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_simple_power(3, 2) => false
is_simple_power(3, 1) => false
is_simple_power(5, 3) => false | def is_simple_power(x, n):
"""
Ваша задача состоит в том, чтобы написать функцию, которая возвращает true, если число x является простой степенью n, и false в других случаях.
x - это простая степень n, если n**int=x
Примеры:
:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_simple_power(3, 2) => false
is_simple_power(3, 1) => false
is_simple_power(5, 3) => false
"""
| if (n == 1):
return (x == 1)
power = 1
while (power < x):
power = power * n
return (power == x)
| def check(candidate):
# Check some simple cases
assert candidate(16, 2)== True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(143214, 16)== False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(4, 2)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(9, 3)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(16, 4)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(24, 2)==False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(128, 4)==False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(12, 6)==False, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1)==True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(1, 12)==True, "This prints if this assert fails 2 (also good for debugging!)"
| is_simple_power | is_simple_power(x, n) | def is_simple_power(x, n): | Напишите функцию is_simple_power(x, n) для решения следующей задачи: Ваша задача состоит в том, чтобы написать функцию, которая возвращает true, если число x является простой степенью n, и false в других случаях.
x - это простая степень n, если n**int=x
Примеры:
:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_simple_power(3, 2) => false
is_simple_power(3, 1) => false
is_simple_power(5, 3) => false | Напишите функцию is_simple_power(x, n) для решения следующей задачи: Ваша задача состоит в том, чтобы написать функцию, которая возвращает true, если число x является простой степенью n, и false в других случаях.
x - это простая степень n, если n**int=x | def is_simple_power(x, n):
"""
Ваша задача состоит в том, чтобы написать функцию, которая возвращает true, если число x является простой степенью n, и false в других случаях.
x - это простая степень n, если n**int=x
"""
|
HumanEval/77 | Напишите функцию, которая принимает целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда корректен.
Примеры:
s:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
iscube(180) ==> False | def iscube(a):
"""
Напишите функцию, которая принимает целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда корректен.
Примеры:
s:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
iscube(180) ==> False
"""
| a = abs(a)
return int(round(a ** (1. / 3))) ** 3 == a
| def check(candidate):
# Check some simple cases
assert candidate(1) == True, "First test error: " + str(candidate(1))
assert candidate(2) == False, "Second test error: " + str(candidate(2))
assert candidate(-1) == True, "Third test error: " + str(candidate(-1))
assert candidate(64) == True, "Fourth test error: " + str(candidate(64))
assert candidate(180) == False, "Fifth test error: " + str(candidate(180))
assert candidate(1000) == True, "Sixth test error: " + str(candidate(1000))
# Check some edge cases that are easy to work out by hand.
assert candidate(0) == True, "1st edge test error: " + str(candidate(0))
assert candidate(1729) == False, "2nd edge test error: " + str(candidate(1728))
| iscube | iscube(a) | def iscube(a): | Напишите функцию iscube(a) для решения следующей задачи: Напишите функцию, которая принимает целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда корректен.
Примеры:
s:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
iscube(180) ==> False | Напишите функцию iscube(a) для решения следующей задачи: Напишите функцию, которая принимает целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда корректен. | def iscube(a):
"""
Напишите функцию, которая принимает целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда корректен.
"""
|
HumanEval/78 | Вам было поручено написать функцию, которая принимает шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр, которые являются простыми числами (простое число - это натуральное число, большее 1, которое не является произведением двух меньших натуральных чисел).
Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Простые числа - это 2, 3, 5, 7, 11, 13, 17,...
Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
B (=десятичное число 11), D (= десятичное число 13).
Примечание: вы можете предположить, что вводимые данные всегда являются правильной или пустой строкой,
а символы A, B, C, D, E,F всегда прописные.
Примеры:
s:
For num = "AB" the output should be 1.
For num = "1077E" the output should be 2.
For num = "ABED1A33" the output should be 4.
For num = "123456789ABCDEF0" the output should be 6.
For num = "2020" the output should be 2. | def hex_key(num):
"""
Вам было поручено написать функцию, которая принимает шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр, которые являются простыми числами (простое число - это натуральное число, большее 1, которое не является произведением двух меньших натуральных чисел).
Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Простые числа - это 2, 3, 5, 7, 11, 13, 17,...
Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
B (=десятичное число 11), D (= десятичное число 13).
Примечание: вы можете предположить, что вводимые данные всегда являются правильной или пустой строкой,
а символы A, B, C, D, E,F всегда прописные.
Примеры:
s:
For num = "AB" the output should be 1.
For num = "1077E" the output should be 2.
For num = "ABED1A33" the output should be 4.
For num = "123456789ABCDEF0" the output should be 6.
For num = "2020" the output should be 2.
"""
| primes = ('2', '3', '5', '7', 'B', 'D')
total = 0
for i in range(0, len(num)):
if num[i] in primes:
total += 1
return total
| def check(candidate):
# Check some simple cases
assert candidate("AB") == 1, "First test error: " + str(candidate("AB"))
assert candidate("1077E") == 2, "Second test error: " + str(candidate("1077E"))
assert candidate("ABED1A33") == 4, "Third test error: " + str(candidate("ABED1A33"))
assert candidate("2020") == 2, "Fourth test error: " + str(candidate("2020"))
assert candidate("123456789ABCDEF0") == 6, "Fifth test error: " + str(candidate("123456789ABCDEF0"))
assert candidate("112233445566778899AABBCCDDEEFF00") == 12, "Sixth test error: " + str(candidate("112233445566778899AABBCCDDEEFF00"))
# Check some edge cases that are easy to work out by hand.
assert candidate([]) == 0
| hex_key | hex_key(num) | def hex_key(num): | Напишите функцию hex_key(num) для решения следующей задачи: Вам было поручено написать функцию, которая принимает шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр, которые являются простыми числами (простое число - это натуральное число, большее 1, которое не является произведением двух меньших натуральных чисел).
Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Простые числа - это 2, 3, 5, 7, 11, 13, 17,...
Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
B (=десятичное число 11), D (= десятичное число 13).
Примечание: вы можете предположить, что вводимые данные всегда являются правильной или пустой строкой,
а символы A, B, C, D, E,F всегда прописные.
Примеры:
s:
For num = "AB" the output should be 1.
For num = "1077E" the output should be 2.
For num = "ABED1A33" the output should be 4.
For num = "123456789ABCDEF0" the output should be 6.
For num = "2020" the output should be 2. | Напишите функцию hex_key(num) для решения следующей задачи: Вам было поручено написать функцию, которая принимает шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр, которые являются простыми числами (простое число - это натуральное число, большее 1, которое не является произведением двух меньших натуральных чисел).
Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Простые числа - это 2, 3, 5, 7, 11, 13, 17,...
Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
B (=десятичное число 11), D (= десятичное число 13).
Примечание: вы можете предположить, что вводимые данные всегда являются правильной или пустой строкой,
а символы A, B, C, D, E,F всегда прописные.
| def hex_key(num):
"""
Вам было поручено написать функцию, которая принимает шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр, которые являются простыми числами (простое число - это натуральное число, большее 1, которое не является произведением двух меньших натуральных чисел).
Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Простые числа - это 2, 3, 5, 7, 11, 13, 17,...
Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
B (=десятичное число 11), D (= десятичное число 13).
Примечание: вы можете предположить, что вводимые данные всегда являются правильной или пустой строкой,
а символы A, B, C, D, E,F всегда прописные.
"""
|
HumanEval/79 | Вам дано число в десятичной форме, и ваша задача - преобразовать его в двоичный формат. Функция должна возвращать строку, где каждый символ представляет собой двоичное число. Каждый символ в строке будет равен '0' или '1'.
В начале и в конце строки будет добавлена пара дополнительных символов "db".
Дополнительные символы предназначены для того, чтобы помочь с форматированием.
Примеры:
decimal_to_binary(15) # returns "db1111db"
decimal_to_binary(32) # returns "db100000db" | def decimal_to_binary(decimal):
"""
Вам дано число в десятичной форме, и ваша задача - преобразовать его в двоичный формат. Функция должна возвращать строку, где каждый символ представляет собой двоичное число. Каждый символ в строке будет равен '0' или '1'.
В начале и в конце строки будет добавлена пара дополнительных символов "db".
Дополнительные символы предназначены для того, чтобы помочь с форматированием.
Примеры:
decimal_to_binary(15) # returns "db1111db"
decimal_to_binary(32) # returns "db100000db"
"""
| return "db" + bin(decimal)[2:] + "db"
| def check(candidate):
# Check some simple cases
assert candidate(0) == "db0db"
assert candidate(32) == "db100000db"
assert candidate(103) == "db1100111db"
assert candidate(15) == "db1111db", "This prints if this assert fails 1 (good for debugging!)"
# 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!)"
| decimal_to_binary | decimal_to_binary(decimal) | def decimal_to_binary(decimal): | Напишите функцию decimal_to_binary(decimal) для решения следующей задачи: Вам дано число в десятичной форме, и ваша задача - преобразовать его в двоичный формат. Функция должна возвращать строку, где каждый символ представляет собой двоичное число. Каждый символ в строке будет равен '0' или '1'.
В начале и в конце строки будет добавлена пара дополнительных символов "db".
Дополнительные символы предназначены для того, чтобы помочь с форматированием.
Примеры:
decimal_to_binary(15) # returns "db1111db"
decimal_to_binary(32) # returns "db100000db" | Напишите функцию decimal_to_binary(decimal) для решения следующей задачи: Вам дано число в десятичной форме, и ваша задача - преобразовать его в двоичный формат. Функция должна возвращать строку, где каждый символ представляет собой двоичное число. Каждый символ в строке будет равен '0' или '1'.
В начале и в конце строки будет добавлена пара дополнительных символов "db".
Дополнительные символы предназначены для того, чтобы помочь с форматированием. | def decimal_to_binary(decimal):
"""
Вам дано число в десятичной форме, и ваша задача - преобразовать его в двоичный формат. Функция должна возвращать строку, где каждый символ представляет собой двоичное число. Каждый символ в строке будет равен '0' или '1'.
В начале и в конце строки будет добавлена пара дополнительных символов "db".
Дополнительные символы предназначены для того, чтобы помочь с форматированием.
"""
|
HumanEval/80 | Вам дана строка s.
Ваша задача - проверить, является ли строка счастливой или нет.
Строка считается счастливой, если ее длина составляет не менее 3 и каждые 3 последовательные буквы различны
Примеры:
:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => False
is_happy(adb) => True
is_happy(xyy) => False | def is_happy(s):
"""
Вам дана строка s.
Ваша задача - проверить, является ли строка счастливой или нет.
Строка считается счастливой, если ее длина составляет не менее 3 и каждые 3 последовательные буквы различны
Примеры:
:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => False
is_happy(adb) => True
is_happy(xyy) => False
"""
| if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i+1] or s[i+1] == s[i+2] or s[i] == s[i+2]:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate("a") == False , "a"
assert candidate("aa") == False , "aa"
assert candidate("abcd") == True , "abcd"
assert candidate("aabb") == False , "aabb"
assert candidate("adb") == True , "adb"
assert candidate("xyy") == False , "xyy"
assert candidate("iopaxpoi") == True , "iopaxpoi"
assert candidate("iopaxioi") == False , "iopaxioi"
| is_happy | is_happy(s) | def is_happy(s): | Напишите функцию is_happy(s) для решения следующей задачи: Вам дана строка s.
Ваша задача - проверить, является ли строка счастливой или нет.
Строка считается счастливой, если ее длина составляет не менее 3 и каждые 3 последовательные буквы различны
Примеры:
:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => False
is_happy(adb) => True
is_happy(xyy) => False | Напишите функцию is_happy(s) для решения следующей задачи: Вам дана строка s.
Ваша задача - проверить, является ли строка счастливой или нет.
Строка считается счастливой, если ее длина составляет не менее 3 и каждые 3 последовательные буквы различны | def is_happy(s):
"""
Вам дана строка s.
Ваша задача - проверить, является ли строка счастливой или нет.
Строка считается счастливой, если ее длина составляет не менее 3 и каждые 3 последовательные буквы различны
"""
|
HumanEval/81 | Это последняя неделя семестра, и учитель должен выставить оценки студентам. Учительница разработала свой собственный алгоритм выставления оценок.
Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
Она дала вам список средних оценок для некоторых учащихся, и вы должны написать функцию, которая может выводить список буквенных оценок, используя следующую таблицу:
Средний балл | Буквенная оценка
4,0 А+
> 3,7 А
> 3,3 А-
> 3,0 В+
> 2,7 B
> 2,3 B-
> 2,0 ° C+
> 1,7 C
> 1,3 C-
> 1,0 D+
> 0,7 D
> 0,0 D-
0,0 E
Примеры:
grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-'] | def numerical_letter_grade(grades):
"""
Это последняя неделя семестра, и учитель должен выставить оценки студентам. Учительница разработала свой собственный алгоритм выставления оценок.
Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
Она дала вам список средних оценок для некоторых учащихся, и вы должны написать функцию, которая может выводить список буквенных оценок, используя следующую таблицу:
Средний балл | Буквенная оценка
4,0 А+
> 3,7 А
> 3,3 А-
> 3,0 В+
> 2,7 B
> 2,3 B-
> 2,0 ° C+
> 1,7 C
> 1,3 C-
> 1,0 D+
> 0,7 D
> 0,0 D-
0,0 E
Примеры:
grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
"""
|
letter_grade = []
for gpa in grades:
if gpa == 4.0:
letter_grade.append("A+")
elif gpa > 3.7:
letter_grade.append("A")
elif gpa > 3.3:
letter_grade.append("A-")
elif gpa > 3.0:
letter_grade.append("B+")
elif gpa > 2.7:
letter_grade.append("B")
elif gpa > 2.3:
letter_grade.append("B-")
elif gpa > 2.0:
letter_grade.append("C+")
elif gpa > 1.7:
letter_grade.append("C")
elif gpa > 1.3:
letter_grade.append("C-")
elif gpa > 1.0:
letter_grade.append("D+")
elif gpa > 0.7:
letter_grade.append("D")
elif gpa > 0.0:
letter_grade.append("D-")
else:
letter_grade.append("E")
return letter_grade
| def check(candidate):
# Check some simple cases
assert candidate([4.0, 3, 1.7, 2, 3.5]) == ['A+', 'B', 'C-', 'C', 'A-']
assert candidate([1.2]) == ['D+']
assert candidate([0.5]) == ['D-']
assert candidate([0.0]) == ['E']
assert candidate([1, 0.3, 1.5, 2.8, 3.3]) == ['D', 'D-', 'C-', 'B', 'B+']
assert candidate([0, 0.7]) == ['E', 'D-']
# Check some edge cases that are easy to work out by hand.
assert True
| numerical_letter_grade | numerical_letter_grade(grades) | def numerical_letter_grade(grades): | Напишите функцию numerical_letter_grade(grades) для решения следующей задачи: Это последняя неделя семестра, и учитель должен выставить оценки студентам. Учительница разработала свой собственный алгоритм выставления оценок.
Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
Она дала вам список средних оценок для некоторых учащихся, и вы должны написать функцию, которая может выводить список буквенных оценок, используя следующую таблицу:
Средний балл | Буквенная оценка
4,0 А+
> 3,7 А
> 3,3 А-
> 3,0 В+
> 2,7 B
> 2,3 B-
> 2,0 ° C+
> 1,7 C
> 1,3 C-
> 1,0 D+
> 0,7 D
> 0,0 D-
0,0 E
Примеры:
grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-'] | Напишите функцию numerical_letter_grade(grades) для решения следующей задачи: Это последняя неделя семестра, и учитель должен выставить оценки студентам. Учительница разработала свой собственный алгоритм выставления оценок.
Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
Она дала вам список средних оценок для некоторых учащихся, и вы должны написать функцию, которая может выводить список буквенных оценок, используя следующую таблицу:
Средний балл | Буквенная оценка
4,0 А+
> 3,7 А
> 3,3 А-
> 3,0 В+
> 2,7 B
> 2,3 B-
> 2,0 ° C+
> 1,7 C
> 1,3 C-
> 1,0 D+
> 0,7 D
> 0,0 D-
0,0 E
| def numerical_letter_grade(grades):
"""
Это последняя неделя семестра, и учитель должен выставить оценки студентам. Учительница разработала свой собственный алгоритм выставления оценок.
Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
Она дала вам список средних оценок для некоторых учащихся, и вы должны написать функцию, которая может выводить список буквенных оценок, используя следующую таблицу:
Средний балл | Буквенная оценка
4,0 А+
> 3,7 А
> 3,3 А-
> 3,0 В+
> 2,7 B
> 2,3 B-
> 2,0 ° C+
> 1,7 C
> 1,3 C-
> 1,0 D+
> 0,7 D
> 0,0 D-
0,0 E
"""
|
HumanEval/82 | Напишите функцию, которая принимает строку и возвращает True, если длина строки равна простому числу, или False в противном случае
Примеры:
s
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False | def prime_length(string):
"""
Напишите функцию, которая принимает строку и возвращает True, если длина строки равна простому числу, или False в противном случае
Примеры:
s
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
| l = len(string)
if l == 0 or l == 1:
return False
for i in range(2, l):
if l % i == 0:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate('Hello') == True
assert candidate('abcdcba') == True
assert candidate('kittens') == True
assert candidate('orange') == False
assert candidate('wow') == True
assert candidate('world') == True
assert candidate('MadaM') == True
assert candidate('Wow') == True
assert candidate('') == False
assert candidate('HI') == True
assert candidate('go') == True
assert candidate('gogo') == False
assert candidate('aaaaaaaaaaaaaaa') == False
# Check some edge cases that are easy to work out by hand.
assert candidate('Madam') == True
assert candidate('M') == False
assert candidate('0') == False
| prime_length | prime_length(string) | def prime_length(string): | Напишите функцию prime_length(string) для решения следующей задачи: Напишите функцию, которая принимает строку и возвращает True, если длина строки равна простому числу, или False в противном случае
Примеры:
s
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False | Напишите функцию prime_length(string) для решения следующей задачи: Напишите функцию, которая принимает строку и возвращает True, если длина строки равна простому числу, или False в противном случае
| def prime_length(string):
"""
Напишите функцию, которая принимает строку и возвращает True, если длина строки равна простому числу, или False в противном случае
"""
|
HumanEval/83 | Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1. | def starts_one_ends(n):
"""
Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1.
"""
| if n == 1: return 1
return 18 * (10 ** (n - 2))
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1) == 1
assert candidate(2) == 18
assert candidate(3) == 180
assert candidate(4) == 1800
assert candidate(5) == 18000
# 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!)"
| starts_one_ends | starts_one_ends(n) | def starts_one_ends(n): | Напишите функцию starts_one_ends(n) для решения следующей задачи: Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1. | Напишите функцию starts_one_ends(n) для решения следующей задачи: Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1. | def starts_one_ends(n):
"""
Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1.
"""
|
HumanEval/84 | Дано положительное целое число N, верните сумму его цифр в двоичном формате.
Примеры:
For N = 1000, the sum of digits will be 1 the output should be "1".
For N = 150, the sum of digits will be 6 the output should be "110".
For N = 147, the sum of digits will be 12 the output should be "1100".
Variables:
@N integer Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number | def solve(N):
"""
Дано положительное целое число N, верните сумму его цифр в двоичном формате.
Примеры:
For N = 1000, the sum of digits will be 1 the output should be "1".
For N = 150, the sum of digits will be 6 the output should be "110".
For N = 147, the sum of digits will be 12 the output should be "1100".
Variables:
@N integer Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
"""
| return bin(sum(int(i) for i in str(N)))[2:]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1000) == "1", "Error"
assert candidate(150) == "110", "Error"
assert candidate(147) == "1100", "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(333) == "1001", "Error"
assert candidate(963) == "10010", "Error"
| solve | solve(N) | def solve(N): | Напишите функцию solve(N) для решения следующей задачи: Дано положительное целое число N, верните сумму его цифр в двоичном формате.
Примеры:
For N = 1000, the sum of digits will be 1 the output should be "1".
For N = 150, the sum of digits will be 6 the output should be "110".
For N = 147, the sum of digits will be 12 the output should be "1100".
Variables:
@N integer Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number | Напишите функцию solve(N) для решения следующей задачи: Дано положительное целое число N, верните сумму его цифр в двоичном формате.
| def solve(N):
"""
Дано положительное целое число N, верните сумму его цифр в двоичном формате.
"""
|
HumanEval/85 | Дан непустой список целых чисел lst. сложите четные элементы, имеющие нечетные индексы..
Примеры:
s:
add([4, 2, 6, 7]) ==> 2 | def add(lst):
"""
Дан непустой список целых чисел lst. сложите четные элементы, имеющие нечетные индексы..
Примеры:
s:
add([4, 2, 6, 7]) ==> 2
"""
| return sum([lst[i] for i in range(1, len(lst), 2) if lst[i]%2 == 0])
| def check(candidate):
# Check some simple cases
assert candidate([4, 88]) == 88
assert candidate([4, 5, 6, 7, 2, 122]) == 122
assert candidate([4, 0, 6, 7]) == 0
assert candidate([4, 4, 6, 8]) == 12
# Check some edge cases that are easy to work out by hand.
| add | add(lst) | def add(lst): | Напишите функцию add(lst) для решения следующей задачи: Дан непустой список целых чисел lst. сложите четные элементы, имеющие нечетные индексы..
Примеры:
s:
add([4, 2, 6, 7]) ==> 2 | Напишите функцию add(lst) для решения следующей задачи: Дан непустой список целых чисел lst. сложите четные элементы, имеющие нечетные индексы.. | def add(lst):
"""
Дан непустой список целых чисел lst. сложите четные элементы, имеющие нечетные индексы..
"""
|
HumanEval/86 | Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия string - это строка, в которой все слова (разделенные пробелом)
заменяются новым словом, в котором все символы расположены в порядке возрастания на основе значения кода ascii.
Примечание: Вы должны соблюдать порядок слов и пробелов в предложении.
Примеры:
anti_shuffle('Hi') returns 'Hi'
anti_shuffle('hello') returns 'ehllo'
anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor' | def anti_shuffle(s):
"""
Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия string - это строка, в которой все слова (разделенные пробелом)
заменяются новым словом, в котором все символы расположены в порядке возрастания на основе значения кода ascii.
Примечание: Вы должны соблюдать порядок слов и пробелов в предложении.
Примеры:
anti_shuffle('Hi') returns 'Hi'
anti_shuffle('hello') returns 'ehllo'
anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
"""
| return ' '.join([''.join(sorted(list(i))) for i in s.split(' ')])
| def check(candidate):
# Check some simple cases
assert candidate('Hi') == 'Hi'
assert candidate('hello') == 'ehllo'
assert candidate('number') == 'bemnru'
assert candidate('abcd') == 'abcd'
assert candidate('Hello World!!!') == 'Hello !!!Wdlor'
assert candidate('') == ''
assert candidate('Hi. My name is Mister Robot. How are you?') == '.Hi My aemn is Meirst .Rboot How aer ?ouy'
# Check some edge cases that are easy to work out by hand.
assert True
| anti_shuffle | anti_shuffle(s) | def anti_shuffle(s): | Напишите функцию anti_shuffle(s) для решения следующей задачи: Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия string - это строка, в которой все слова (разделенные пробелом)
заменяются новым словом, в котором все символы расположены в порядке возрастания на основе значения кода ascii.
Примечание: Вы должны соблюдать порядок слов и пробелов в предложении.
Примеры:
anti_shuffle('Hi') returns 'Hi'
anti_shuffle('hello') returns 'ehllo'
anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor' | Напишите функцию anti_shuffle(s) для решения следующей задачи: Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия string - это строка, в которой все слова (разделенные пробелом)
заменяются новым словом, в котором все символы расположены в порядке возрастания на основе значения кода ascii.
Примечание: Вы должны соблюдать порядок слов и пробелов в предложении. | def anti_shuffle(s):
"""
Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия string - это строка, в которой все слова (разделенные пробелом)
заменяются новым словом, в котором все символы расположены в порядке возрастания на основе значения кода ascii.
Примечание: Вы должны соблюдать порядок слов и пробелов в предложении.
"""
|
HumanEval/87 | Вам даны двумерные данные в виде вложенных списков,
которые похожи на матрицу, однако, в отличие от матриц,
каждая строка может содержать разное количество столбцов.
Даны lst и целое число x, найдите целые числа x в списке
и верните список кортежей [(x1, y1), (x2, y2) ...] таким образом, чтобы каждый кортеж представлял собой координату - (строка, столбцы), начинающуюся с 0.
Вначале отсортируйте координаты по строкам в порядке возрастания.
Затем отсортируйте координаты строки по столбцам в порядке убывания.
Примеры:
get_row([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
get_row([], 1) == []
get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)] | def get_row(lst, x):
"""
Вам даны двумерные данные в виде вложенных списков,
которые похожи на матрицу, однако, в отличие от матриц,
каждая строка может содержать разное количество столбцов.
Даны lst и целое число x, найдите целые числа x в списке
и верните список кортежей [(x1, y1), (x2, y2) ...] таким образом, чтобы каждый кортеж представлял собой координату - (строка, столбцы), начинающуюся с 0.
Вначале отсортируйте координаты по строкам в порядке возрастания.
Затем отсортируйте координаты строки по столбцам в порядке убывания.
Примеры:
get_row([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
get_row([], 1) == []
get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
"""
| coords = [(i, j) for i in range(len(lst)) for j in range(len(lst[i])) if lst[i][j] == x]
return sorted(sorted(coords, key=lambda x: x[1], reverse=True), key=lambda x: x[0])
| def check(candidate):
# Check some simple cases
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6]
], 2) == [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1)]
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,1,3,4,5,6],
[1,2,1,4,5,6],
[1,2,3,1,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 0), (2, 1), (2, 0), (3, 2), (3, 0), (4, 3), (4, 0), (5, 4), (5, 0), (6, 5), (6, 0)]
assert candidate([], 1) == []
assert candidate([[1]], 2) == []
assert candidate([[], [1], [1, 2, 3]], 3) == [(2, 2)]
# Check some edge cases that are easy to work out by hand.
assert True
| get_row | get_row(lst, x) | def get_row(lst, x): | Напишите функцию get_row(lst, x) для решения следующей задачи: Вам даны двумерные данные в виде вложенных списков,
которые похожи на матрицу, однако, в отличие от матриц,
каждая строка может содержать разное количество столбцов.
Даны lst и целое число x, найдите целые числа x в списке
и верните список кортежей [(x1, y1), (x2, y2) ...] таким образом, чтобы каждый кортеж представлял собой координату - (строка, столбцы), начинающуюся с 0.
Вначале отсортируйте координаты по строкам в порядке возрастания.
Затем отсортируйте координаты строки по столбцам в порядке убывания.
Примеры:
get_row([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
get_row([], 1) == []
get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)] | Напишите функцию get_row(lst, x) для решения следующей задачи: Вам даны двумерные данные в виде вложенных списков,
которые похожи на матрицу, однако, в отличие от матриц,
каждая строка может содержать разное количество столбцов.
Даны lst и целое число x, найдите целые числа x в списке
и верните список кортежей [(x1, y1), (x2, y2) ...] таким образом, чтобы каждый кортеж представлял собой координату - (строка, столбцы), начинающуюся с 0.
Вначале отсортируйте координаты по строкам в порядке возрастания.
Затем отсортируйте координаты строки по столбцам в порядке убывания. | def get_row(lst, x):
"""
Вам даны двумерные данные в виде вложенных списков,
которые похожи на матрицу, однако, в отличие от матриц,
каждая строка может содержать разное количество столбцов.
Даны lst и целое число x, найдите целые числа x в списке
и верните список кортежей [(x1, y1), (x2, y2) ...] таким образом, чтобы каждый кортеж представлял собой координату - (строка, столбцы), начинающуюся с 0.
Вначале отсортируйте координаты по строкам в порядке возрастания.
Затем отсортируйте координаты строки по столбцам в порядке убывания.
"""
|
HumanEval/88 | Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки,
Отсортируйте данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная,
или отсортируйте его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) является четным.
Примечание:
* не меняйте входной массив.
Примеры:
s:
* sort_array([]) => []
* sort_array([5]) => [5]
* sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
* sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0] | def sort_array(array):
"""
Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки,
Отсортируйте данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная,
или отсортируйте его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) является четным.
Примечание:
* не меняйте входной массив.
Примеры:
s:
* sort_array([]) => []
* sort_array([5]) => [5]
* sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
* sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
"""
| return [] if len(array) == 0 else sorted(array, reverse= (array[0]+array[-1]) % 2 == 0)
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([]) == [], "Error"
assert candidate([5]) == [5], "Error"
assert candidate([2, 4, 3, 0, 1, 5]) == [0, 1, 2, 3, 4, 5], "Error"
assert candidate([2, 4, 3, 0, 1, 5, 6]) == [6, 5, 4, 3, 2, 1, 0], "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([2, 1]) == [1, 2], "Error"
assert candidate([15, 42, 87, 32 ,11, 0]) == [0, 11, 15, 32, 42, 87], "Error"
assert candidate([21, 14, 23, 11]) == [23, 21, 14, 11], "Error"
| sort_array | sort_array(array) | def sort_array(array): | Напишите функцию sort_array(array) для решения следующей задачи: Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки,
Отсортируйте данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная,
или отсортируйте его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) является четным.
Примечание:
* не меняйте входной массив.
Примеры:
s:
* sort_array([]) => []
* sort_array([5]) => [5]
* sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
* sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0] | Напишите функцию sort_array(array) для решения следующей задачи: Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки,
Отсортируйте данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная,
или отсортируйте его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) является четным.
Примечание:
* не меняйте входной массив.
| def sort_array(array):
"""
Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки,
Отсортируйте данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная,
или отсортируйте его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) является четным.
Примечание:
* не меняйте входной массив.
"""
|
HumanEval/89 | Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с поворотом алфавита.
Алфавит должен быть повернут таким образом, чтобы буквы смещались вниз на две, умноженные на два.
Примеры:
:
encrypt('hi') returns 'lm'
encrypt('asdfghjkl') returns 'ewhjklnop'
encrypt('gf') returns 'kj'
encrypt('et') returns 'ix' | def encrypt(s):
"""
Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с поворотом алфавита.
Алфавит должен быть повернут таким образом, чтобы буквы смещались вниз на две, умноженные на два.
Примеры:
:
encrypt('hi') returns 'lm'
encrypt('asdfghjkl') returns 'ewhjklnop'
encrypt('gf') returns 'kj'
encrypt('et') returns 'ix'
"""
| d = 'abcdefghijklmnopqrstuvwxyz'
out = ''
for c in s:
if c in d:
out += d[(d.index(c)+2*2) % 26]
else:
out += c
return out
| def check(candidate):
# Check some simple cases
assert candidate('hi') == 'lm', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('asdfghjkl') == 'ewhjklnop', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('gf') == 'kj', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('et') == 'ix', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('faewfawefaewg')=='jeiajeaijeiak', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('hellomyfriend')=='lippsqcjvmirh', "This prints if this assert fails 2 (good for debugging!)"
assert candidate('dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh')=='hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl', "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('a')=='e', "This prints if this assert fails 2 (also good for debugging!)"
| encrypt | encrypt(s) | def encrypt(s): | Напишите функцию encrypt(s) для решения следующей задачи: Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с поворотом алфавита.
Алфавит должен быть повернут таким образом, чтобы буквы смещались вниз на две, умноженные на два.
Примеры:
:
encrypt('hi') returns 'lm'
encrypt('asdfghjkl') returns 'ewhjklnop'
encrypt('gf') returns 'kj'
encrypt('et') returns 'ix' | Напишите функцию encrypt(s) для решения следующей задачи: Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с поворотом алфавита.
Алфавит должен быть повернут таким образом, чтобы буквы смещались вниз на две, умноженные на два.
| def encrypt(s):
"""
Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с поворотом алфавита.
Алфавит должен быть повернут таким образом, чтобы буквы смещались вниз на две, умноженные на два.
"""
|
HumanEval/90 | Вам выдается список целых чисел.
Напишите функцию next_smallest(), которая возвращает 2-й наименьший элемент списка.
Возвращает None, если такого элемента нет.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest([1, 1]) == None | def next_smallest(lst):
"""
Вам выдается список целых чисел.
Напишите функцию next_smallest(), которая возвращает 2-й наименьший элемент списка.
Возвращает None, если такого элемента нет.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest([1, 1]) == None
"""
| lst = sorted(set(lst))
return None if len(lst) < 2 else lst[1]
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4, 5]) == 2
assert candidate([5, 1, 4, 3, 2]) == 2
assert candidate([]) == None
assert candidate([1, 1]) == None
assert candidate([1,1,1,1,0]) == 1
assert candidate([1, 0**0]) == None
assert candidate([-35, 34, 12, -45]) == -35
# Check some edge cases that are easy to work out by hand.
assert True
| next_smallest | next_smallest(lst) | def next_smallest(lst): | Напишите функцию next_smallest(lst) для решения следующей задачи: Вам выдается список целых чисел.
Напишите функцию next_smallest(), которая возвращает 2-й наименьший элемент списка.
Возвращает None, если такого элемента нет.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest([1, 1]) == None | Напишите функцию next_smallest(lst) для решения следующей задачи: Вам выдается список целых чисел.
Напишите функцию next_smallest(), которая возвращает 2-й наименьший элемент списка.
Возвращает None, если такого элемента нет. | def next_smallest(lst):
"""
Вам выдается список целых чисел.
Напишите функцию next_smallest(), которая возвращает 2-й наименьший элемент списка.
Возвращает None, если такого элемента нет.
"""
|
HumanEval/91 | Вам будет дана цепочка слов, и ваша задача - подсчитать количество скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
Предложения разделяются символами ".", "?" или "!".
Например:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1 | def is_bored(S):
"""
Вам будет дана цепочка слов, и ваша задача - подсчитать количество скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
Предложения разделяются символами ".", "?" или "!".
Например:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1
"""
| import re
sentences = re.split(r'[.?!]\s*', S)
return sum(sentence[0:2] == 'I ' for sentence in sentences)
| def check(candidate):
# Check some simple cases
assert candidate("Hello world") == 0, "Test 1"
assert candidate("Is the sky blue?") == 0, "Test 2"
assert candidate("I love It !") == 1, "Test 3"
assert candidate("bIt") == 0, "Test 4"
assert candidate("I feel good today. I will be productive. will kill It") == 2, "Test 5"
assert candidate("You and I are going for a walk") == 0, "Test 6"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| is_bored | is_bored(S) | def is_bored(S): | Напишите функцию is_bored(S) для решения следующей задачи: Вам будет дана цепочка слов, и ваша задача - подсчитать количество скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
Предложения разделяются символами ".", "?" или "!".
Например:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1 | Напишите функцию is_bored(S) для решения следующей задачи: Вам будет дана цепочка слов, и ваша задача - подсчитать количество скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
Предложения разделяются символами ".", "?" или "!".
Например: | def is_bored(S):
"""
Вам будет дана цепочка слов, и ваша задача - подсчитать количество скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
Предложения разделяются символами ".", "?" или "!".
Например:
"""
|
HumanEval/92 | Создайте функцию, которая принимает 3 числа.
Возвращает значение true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
Возвращает значение false в любых других случаях.
Примеры:
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, 1) ➞ True
any_int(3.6, -2.2, 2) ➞ False | def any_int(x, y, z):
"""
Создайте функцию, которая принимает 3 числа.
Возвращает значение true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
Возвращает значение false в любых других случаях.
Примеры:
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, 1) ➞ True
any_int(3.6, -2.2, 2) ➞ False
"""
|
if isinstance(x,int) and isinstance(y,int) and isinstance(z,int):
if (x+y==z) or (x+z==y) or (y+z==x):
return True
return False
return False
| def check(candidate):
# Check some simple cases
assert candidate(2, 3, 1)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(2.5, 2, 3)==False, "This prints if this assert fails 2 (good for debugging!)"
assert candidate(1.5, 5, 3.5)==False, "This prints if this assert fails 3 (good for debugging!)"
assert candidate(2, 6, 2)==False, "This prints if this assert fails 4 (good for debugging!)"
assert candidate(4, 2, 2)==True, "This prints if this assert fails 5 (good for debugging!)"
assert candidate(2.2, 2.2, 2.2)==False, "This prints if this assert fails 6 (good for debugging!)"
assert candidate(-4, 6, 2)==True, "This prints if this assert fails 7 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(2,1,1)==True, "This prints if this assert fails 8 (also good for debugging!)"
assert candidate(3,4,7)==True, "This prints if this assert fails 9 (also good for debugging!)"
assert candidate(3.0,4,7)==False, "This prints if this assert fails 10 (also good for debugging!)"
| any_int | any_int(x, y, z) | def any_int(x, y, z): | Напишите функцию any_int(x, y, z) для решения следующей задачи: Создайте функцию, которая принимает 3 числа.
Возвращает значение true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
Возвращает значение false в любых других случаях.
Примеры:
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, 1) ➞ True
any_int(3.6, -2.2, 2) ➞ False | Напишите функцию any_int(x, y, z) для решения следующей задачи: Создайте функцию, которая принимает 3 числа.
Возвращает значение true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
Возвращает значение false в любых других случаях. | def any_int(x, y, z):
"""
Создайте функцию, которая принимает 3 числа.
Возвращает значение true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
Возвращает значение false в любых других случаях.
"""
|
HumanEval/93 | Напишите функцию, которая принимает сообщение и кодирует таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая появляется на 2 позиции впереди этой гласной в английском алфавите.
Сообщение состоит из букв.
Примеры:
>>> encode('test')
'TGST'
>>> encode('This is a message')
'tHKS KS C MGSSCGG' | def encode(message):
"""
Напишите функцию, которая принимает сообщение и кодирует таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая появляется на 2 позиции впереди этой гласной в английском алфавите.
Сообщение состоит из букв.
Примеры:
>>> encode('test')
'TGST'
>>> encode('This is a message')
'tHKS KS C MGSSCGG'
"""
| vowels = "aeiouAEIOU"
vowels_replace = dict([(i, chr(ord(i) + 2)) for i in vowels])
message = message.swapcase()
return ''.join([vowels_replace[i] if i in vowels else i for i in message])
| def check(candidate):
# Check some simple cases
assert candidate('TEST') == 'tgst', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('Mudasir') == 'mWDCSKR', "This prints if this assert fails 2 (good for debugging!)"
assert candidate('YES') == 'ygs', "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('This is a message') == 'tHKS KS C MGSSCGG', "This prints if this assert fails 2 (also good for debugging!)"
assert candidate("I DoNt KnOw WhAt tO WrItE") == 'k dQnT kNqW wHcT Tq wRkTg', "This prints if this assert fails 2 (also good for debugging!)"
| encode | encode(message) | def encode(message): | Напишите функцию encode(message) для решения следующей задачи: Напишите функцию, которая принимает сообщение и кодирует таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая появляется на 2 позиции впереди этой гласной в английском алфавите.
Сообщение состоит из букв.
Примеры:
>>> encode('test')
'TGST'
>>> encode('This is a message')
'tHKS KS C MGSSCGG' | Напишите функцию encode(message) для решения следующей задачи: Напишите функцию, которая принимает сообщение и кодирует таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая появляется на 2 позиции впереди этой гласной в английском алфавите.
Сообщение состоит из букв.
Примеры: | def encode(message):
"""
Напишите функцию, которая принимает сообщение и кодирует таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая появляется на 2 позиции впереди этой гласной в английском алфавите.
Сообщение состоит из букв.
Примеры:
"""
|
HumanEval/94 | Вам дан список целых чисел.
Вам нужно найти наибольшее простое значение и вернуть сумму его цифр.
Примеры:
For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
For lst = [0,81,12,3,1,21] the output should be 3
For lst = [0,8,1,2,1,7] the output should be 7 | def skjkasdkd(lst):
"""
Вам дан список целых чисел.
Вам нужно найти наибольшее простое значение и вернуть сумму его цифр.
Примеры:
For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
For lst = [0,81,12,3,1,21] the output should be 3
For lst = [0,8,1,2,1,7] the output should be 7
"""
| def isPrime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
maxx = 0
i = 0
while i < len(lst):
if(lst[i] > maxx and isPrime(lst[i])):
maxx = lst[i]
i+=1
result = sum(int(digit) for digit in str(maxx))
return result
| def check(candidate):
# Check some simple cases
assert candidate([0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]) == 10, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]) == 25, "This prints if this assert fails 2 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]) == 13, "This prints if this assert fails 3 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,724,32,71,99,32,6,0,5,91,83,0,5,6]) == 11, "This prints if this assert fails 4 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,81,12,3,1,21]) == 3, "This prints if this assert fails 5 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,8,1,2,1,7]) == 7, "This prints if this assert fails 6 (also good for debugging!)"
assert candidate([8191]) == 19, "This prints if this assert fails 7 (also good for debugging!)"
assert candidate([8191, 123456, 127, 7]) == 19, "This prints if this assert fails 8 (also good for debugging!)"
assert candidate([127, 97, 8192]) == 10, "This prints if this assert fails 9 (also good for debugging!)"
| skjkasdkd | skjkasdkd(lst) | def skjkasdkd(lst): | Напишите функцию skjkasdkd(lst) для решения следующей задачи: Вам дан список целых чисел.
Вам нужно найти наибольшее простое значение и вернуть сумму его цифр.
Примеры:
For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
For lst = [0,81,12,3,1,21] the output should be 3
For lst = [0,8,1,2,1,7] the output should be 7 | Напишите функцию skjkasdkd(lst) для решения следующей задачи: Вам дан список целых чисел.
Вам нужно найти наибольшее простое значение и вернуть сумму его цифр. | def skjkasdkd(lst):
"""
Вам дан список целых чисел.
Вам нужно найти наибольшее простое значение и вернуть сумму его цифр.
"""
|
HumanEval/95 | Дан словарь, верните True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать значение False, если данный словарь пуст.
Примеры:
check_dict_case({"a":"apple", "b":"banana"}) should return True.
check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True. | def check_dict_case(dict):
"""
Дан словарь, верните True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать значение False, если данный словарь пуст.
Примеры:
check_dict_case({"a":"apple", "b":"banana"}) should return True.
check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
"""
| if len(dict.keys()) == 0:
return False
else:
state = "start"
for key in dict.keys():
if isinstance(key, str) == False:
state = "mixed"
break
if state == "start":
if key.isupper():
state = "upper"
elif key.islower():
state = "lower"
else:
break
elif (state == "upper" and not key.isupper()) or (state == "lower" and not key.islower()):
state = "mixed"
break
else:
break
return state == "upper" or state == "lower"
| def check(candidate):
# Check some simple cases
assert candidate({"p":"pineapple", "b":"banana"}) == True, "First test error: " + str(candidate({"p":"pineapple", "b":"banana"}))
assert candidate({"p":"pineapple", "A":"banana", "B":"banana"}) == False, "Second test error: " + str(candidate({"p":"pineapple", "A":"banana", "B":"banana"}))
assert candidate({"p":"pineapple", 5:"banana", "a":"apple"}) == False, "Third test error: " + str(candidate({"p":"pineapple", 5:"banana", "a":"apple"}))
assert candidate({"Name":"John", "Age":"36", "City":"Houston"}) == False, "Fourth test error: " + str(candidate({"Name":"John", "Age":"36", "City":"Houston"}))
assert candidate({"STATE":"NC", "ZIP":"12345" }) == True, "Fifth test error: " + str(candidate({"STATE":"NC", "ZIP":"12345" }))
assert candidate({"fruit":"Orange", "taste":"Sweet" }) == True, "Fourth test error: " + str(candidate({"fruit":"Orange", "taste":"Sweet" }))
# Check some edge cases that are easy to work out by hand.
assert candidate({}) == False, "1st edge test error: " + str(candidate({}))
| check_dict_case | check_dict_case(dict) | def check_dict_case(dict): | Напишите функцию check_dict_case(dict) для решения следующей задачи: Дан словарь, верните True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать значение False, если данный словарь пуст.
Примеры:
check_dict_case({"a":"apple", "b":"banana"}) should return True.
check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True. | Напишите функцию check_dict_case(dict) для решения следующей задачи: Дан словарь, верните True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать значение False, если данный словарь пуст. | def check_dict_case(dict):
"""
Дан словарь, верните True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать значение False, если данный словарь пуст.
"""
|
HumanEval/96 | Реализуйте функцию, которая принимает неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n.
Примеры:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1) => []
count_up_to(18) => [2,3,5,7,11,13,17] | def count_up_to(n):
"""
Реализуйте функцию, которая принимает неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n.
Примеры:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1) => []
count_up_to(18) => [2,3,5,7,11,13,17]
"""
| primes = []
for i in range(2, n):
is_prime = True
for j in range(2, i):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
| def check(candidate):
assert candidate(5) == [2,3]
assert candidate(6) == [2,3,5]
assert candidate(7) == [2,3,5]
assert candidate(10) == [2,3,5,7]
assert candidate(0) == []
assert candidate(22) == [2,3,5,7,11,13,17,19]
assert candidate(1) == []
assert candidate(18) == [2,3,5,7,11,13,17]
assert candidate(47) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
assert candidate(101) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
| count_up_to | count_up_to(n) | def count_up_to(n): | Напишите функцию count_up_to(n) для решения следующей задачи: Реализуйте функцию, которая принимает неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n.
Примеры:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1) => []
count_up_to(18) => [2,3,5,7,11,13,17] | Напишите функцию count_up_to(n) для решения следующей задачи: Реализуйте функцию, которая принимает неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n. | def count_up_to(n):
"""
Реализуйте функцию, которая принимает неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n.
"""
|
HumanEval/97 | Напишите функцию, которая принимает два целых числа и возвращает произведение их младших разрядов.
входные данные всегда корректны.
Примеры:
multiply(148, 412) should return 16.
multiply(19, 28) should return 72.
multiply(2020, 1851) should return 0.
multiply(14,-15) should return 20. | def multiply(a, b):
"""
Напишите функцию, которая принимает два целых числа и возвращает произведение их младших разрядов.
входные данные всегда корректны.
Примеры:
multiply(148, 412) should return 16.
multiply(19, 28) should return 72.
multiply(2020, 1851) should return 0.
multiply(14,-15) should return 20.
"""
| return abs(a % 10) * abs(b % 10)
| def check(candidate):
# Check some simple cases
assert candidate(148, 412) == 16, "First test error: " + str(candidate(148, 412))
assert candidate(19, 28) == 72, "Second test error: " + str(candidate(19, 28))
assert candidate(2020, 1851) == 0, "Third test error: " + str(candidate(2020, 1851))
assert candidate(14,-15) == 20, "Fourth test error: " + str(candidate(14,-15))
assert candidate(76, 67) == 42, "Fifth test error: " + str(candidate(76, 67))
assert candidate(17, 27) == 49, "Sixth test error: " + str(candidate(17, 27))
# Check some edge cases that are easy to work out by hand.
assert candidate(0, 1) == 0, "1st edge test error: " + str(candidate(0, 1))
assert candidate(0, 0) == 0, "2nd edge test error: " + str(candidate(0, 0))
| multiply | multiply(a, b) | def multiply(a, b): | Напишите функцию multiply(a, b) для решения следующей задачи: Напишите функцию, которая принимает два целых числа и возвращает произведение их младших разрядов.
входные данные всегда корректны.
Примеры:
multiply(148, 412) should return 16.
multiply(19, 28) should return 72.
multiply(2020, 1851) should return 0.
multiply(14,-15) should return 20. | Напишите функцию multiply(a, b) для решения следующей задачи: Напишите функцию, которая принимает два целых числа и возвращает произведение их младших разрядов.
входные данные всегда корректны. | def multiply(a, b):
"""
Напишите функцию, которая принимает два целых числа и возвращает произведение их младших разрядов.
входные данные всегда корректны.
"""
|
HumanEval/98 | Дана строка s, подсчитайте количество гласных в верхнем регистре в четных индексах.
Примеры:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0 | def count_upper(s):
"""
Дана строка s, подсчитайте количество гласных в верхнем регистре в четных индексах.
Примеры:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
| count = 0
for i in range(0,len(s),2):
if s[i] in "AEIOU":
count += 1
return count
| def check(candidate):
# Check some simple cases
assert candidate('aBCdEf') == 1
assert candidate('abcdefg') == 0
assert candidate('dBBE') == 0
assert candidate('B') == 0
assert candidate('U') == 1
assert candidate('') == 0
assert candidate('EEEE') == 2
# Check some edge cases that are easy to work out by hand.
assert True
| count_upper | count_upper(s) | def count_upper(s): | Напишите функцию count_upper(s) для решения следующей задачи: Дана строка s, подсчитайте количество гласных в верхнем регистре в четных индексах.
Примеры:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0 | Напишите функцию count_upper(s) для решения следующей задачи: Дана строка s, подсчитайте количество гласных в верхнем регистре в четных индексах. | def count_upper(s):
"""
Дана строка s, подсчитайте количество гласных в верхнем регистре в четных индексах.
"""
|
HumanEval/99 | Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите его от нуля.
Примеры
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15 | def closest_integer(value):
"""
Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите его от нуля.
Примеры
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15
"""
| from math import floor, ceil
if value.count('.') == 1:
# remove trailing zeros
while (value[-1] == '0'):
value = value[:-1]
num = float(value)
if value[-2:] == '.5':
if num > 0:
res = ceil(num)
else:
res = floor(num)
elif len(value) > 0:
res = int(round(num))
else:
res = 0
return res
| def check(candidate):
# Check some simple cases
assert candidate("10") == 10, "Test 1"
assert candidate("14.5") == 15, "Test 2"
assert candidate("-15.5") == -16, "Test 3"
assert candidate("15.3") == 15, "Test 3"
# Check some edge cases that are easy to work out by hand.
assert candidate("0") == 0, "Test 0"
| closest_integer | closest_integer(value) | def closest_integer(value): | Напишите функцию closest_integer(value) для решения следующей задачи: Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите его от нуля.
Примеры
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15 | Напишите функцию closest_integer(value) для решения следующей задачи: Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите его от нуля.
Примеры | def closest_integer(value):
"""
Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите его от нуля.
Примеры
"""
|