humaneval_ru.csv

prompt,tests,task_id
"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) Ложь >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3) Истина""""""
","['assert has_close_elements([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True', 'assert has_close_elements([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False', 'assert has_close_elements([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True', 'assert has_close_elements([1.0, 2.0, 5.9, 4.0, 5.0], 0.8) == False', 'assert has_close_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1) == True', 'assert has_close_elements([1.1, 2.2, 3.1, 4.1, 5.1], 1.0) == True', 'assert has_close_elements([1.1, 2.2, 3.1, 4.1, 5.1], 0.5) == False']",HumanEval/0
"from typing import List


def separate_paren_groups(paren_string: str) -> List[str]:
    """""" Входные данные для этой функции — строка, содержащая несколько групп вложенных скобок. Ваша цель — разделить эти группы на отдельные строки и вернуть их список. Отдельные группы сбалансированы (каждая открытая скобка правильно закрыта) и не вложены друг в друга. Игнорируйте любые пробелы во входной строке. >>> separate_paren_groups('( ) (( )) (( )( ))') ['()', '(())', '(()())']""""""
","[""assert separate_paren_groups('(()()) ((())) () ((())()())') == [ '(()())', '((()))', '()', '((())()())' ]"", ""assert separate_paren_groups('() (()) ((())) (((())))') == [ '()', '(())', '((()))', '(((())))' ]"", ""assert separate_paren_groups('(()(())((())))') == [ '(()(())((())))' ]"", ""assert separate_paren_groups('( ) (( )) (( )( ))') == ['()', '(())', '(()())']""]",HumanEval/1
"

def truncate_number(number: float) -> float:
    """""" Дано положительное число с плавающей точкой, его можно разложить на целую часть (наибольшее целое число, меньшее заданного числа) и десятичную часть (оставшаяся часть всегда меньше 1). Вернуть десятичную часть числа. >>> truncate_number(3.5) 0.5""""""
","['assert truncate_number(3.5) == 0.5', 'assert abs(truncate_number(1.33) - 0.33) < 1e-6', 'assert abs(truncate_number(123.456) - 0.456) < 1e-6']",HumanEval/2
"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""""""
","['assert below_zero([]) == False', 'assert below_zero([1, 2, -3, 1, 2, -3]) == False', 'assert below_zero([1, 2, -4, 5, 6]) == True', 'assert below_zero([1, -1, 2, -2, 5, -5, 4, -4]) == False', 'assert below_zero([1, -1, 2, -2, 5, -5, 4, -5]) == True', 'assert below_zero([1, -2, 2, -2, 5, -5, 4, -4]) == True']",HumanEval/3
"from typing import List


def mean_absolute_deviation(numbers: List[float]) -> float:
    """""" Для заданного списка входных чисел вычислите среднее абсолютное отклонение вокруг среднего значения этого набора данных. Среднее абсолютное отклонение — это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае средним): MAD = среднее | x - x_mean | >>> среднее_абсолютное_отклонение([1.0, 2.0, 3.0, 4.0]) 1.0""""""
","['assert abs(mean_absolute_deviation([1.0, 2.0, 3.0]) - 2.0/3.0) < 1e-6', 'assert abs(mean_absolute_deviation([1.0, 2.0, 3.0, 4.0]) - 1.0) < 1e-6', 'assert abs(mean_absolute_deviation([1.0, 2.0, 3.0, 4.0, 5.0]) - 6.0/5.0) < 1e-6']",HumanEval/4
"from typing import List


def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """""" Вставить число 'разделитель' между каждыми двумя последовательными элементами входного списка `numbers' >>> intersperse([], 4) [] >>> intersperse([1, 2, 3], 4) [1, 4, 2, 4, 3]""""""
","['assert intersperse([], 7) == []', 'assert intersperse([5, 6, 3, 2], 8) == [5, 8, 6, 8, 3, 8, 2]', 'assert intersperse([2, 2, 2], 2) == [2, 2, 2, 2, 2]']",HumanEval/5
"from typing import List


def parse_nested_parens(paren_string: str) -> List[int]:
    """"""Входные данные для этой функции — строка, представляющая собой несколько групп вложенных скобок, разделенных пробелами. Для каждой группы выведите самый глубокий уровень вложенности скобок. Например, (()()) имеет максимум два уровня вложенности, а ((())) — три. >>> parse_nested_parens('(()()) ((())) () ((())()())') [2, 3, 1, 3]""""""
","[""assert parse_nested_parens('(()()) ((())) () ((())()())') == [2, 3, 1, 3]"", ""assert parse_nested_parens('() (()) ((())) (((())))') == [1, 2, 3, 4]"", ""assert parse_nested_parens('(()(())((())))') == [4]""]",HumanEval/6
"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']""""""
","[""assert filter_by_substring([], 'john') == []"", ""assert filter_by_substring(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']"", ""assert filter_by_substring(['xxx', 'asd', 'aaaxxy', 'john doe', 'xxxAAA', 'xxx'], 'xx') == ['xxx', 'aaaxxy', 'xxxAAA', 'xxx']"", ""assert filter_by_substring(['grunt', 'trumpet', 'prune', 'gruesome'], 'run') == ['grunt', 'prune']""]",HumanEval/7
"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)""""""
","['assert sum_product([]) == (0, 1)', 'assert sum_product([1, 1, 1]) == (3, 1)', 'assert sum_product([100, 0]) == (100, 0)', 'assert sum_product([3, 5, 7]) == (3 + 5 + 7, 3 * 5 * 7)', 'assert sum_product([10]) == (10, 10)']",HumanEval/8
"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]""""""
","['assert rolling_max([]) == []', 'assert rolling_max([1, 2, 3, 4]) == [1, 2, 3, 4]', 'assert rolling_max([4, 3, 2, 1]) == [4, 4, 4, 4]', 'assert rolling_max([3, 2, 3, 100, 3]) == [3, 3, 3, 100, 100]']",HumanEval/9
"

def is_palindrome(string: str) -> bool:
    """""" Проверить, является ли данная строка палиндромом""""""
    return string == string[::-1]


def make_palindrome(string: str) -> str:
    """""" Проверить, является ли данная строка палиндромом""""""
","[""assert make_palindrome('') == ''"", ""assert make_palindrome('x') == 'x'"", ""assert make_palindrome('xyz') == 'xyzyx'"", ""assert make_palindrome('xyx') == 'xyx'"", ""assert make_palindrome('jerry') == 'jerryrrej'""]",HumanEval/10
"from typing import List


def string_xor(a: str, b: str) -> str:
    """""" Входные данные — две строки a и b, состоящие только из 1 и 0. Выполните двоичное XOR на этих входных данных и верните результат также в виде строки. >>> string_xor('010', '110') '100'""""""
","[""assert string_xor('111000', '101010') == '010010'"", ""assert string_xor('1', '1') == '0'"", ""assert string_xor('0101', '0000') == '0101'""]",HumanEval/11
"from typing import List, Optional


def longest(strings: List[str]) -> Optional[str]:
    """""" Из списка строк вернуть самую длинную. Вернуть первую, если несколько строк одинаковой длины. Вернуть None, если входной список пуст. >>> longest([]) >>> longest(['a', 'b', 'c']) 'a' >>> longest(['a', 'bb', 'ccc']) 'ccc'""""""
","['assert longest([]) == None', ""assert longest(['x', 'y', 'z']) == 'x'"", ""assert longest(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc']) == 'zzzz'""]",HumanEval/12
"

def greatest_common_divisor(a: int, b: int) -> int:
    """""" Возвращает наибольший общий делитель двух целых чисел a и b >>> greatest_common_divisor(3, 5) 1 >>> greatest_common_divisor(25, 15) 5""""""
","['assert greatest_common_divisor(3, 7) == 1', 'assert greatest_common_divisor(10, 15) == 5', 'assert greatest_common_divisor(49, 14) == 7', 'assert greatest_common_divisor(144, 60) == 12']",HumanEval/13
"from typing import List


def all_prefixes(string: str) -> List[str]:
    """"""Возвращает список всех префиксов входной строки от самого короткого до самого длинного >>> all_prefixes('abc') ['a', 'ab', 'abc']""""""
","[""assert all_prefixes('') == []"", ""assert all_prefixes('asdfgh') == ['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']"", ""assert all_prefixes('WWW') == ['W', 'WW', 'WWW']""]",HumanEval/14
"

def string_sequence(n: int) -> str:
    """""" Возвращает строку, содержащую разделенные пробелом числа от 0 до n включительно. >>> string_sequence(0) '0' >>> string_sequence(5) '0 1 2 3 4 5'""""""
","[""assert string_sequence(0) == '0'"", ""assert string_sequence(3) == '0 1 2 3'"", ""assert string_sequence(10) == '0 1 2 3 4 5 6 7 8 9 10'""]",HumanEval/15
"

def count_distinct_characters(string: str) -> int:
    """""" Дана строка, найдите, из скольких различных символов (независимо от регистра) она состоит >>> count_distinct_characters('xyzXYZ') 3 >>> count_distinct_characters('Jerry') 4""""""
","[""assert count_distinct_characters('') == 0"", ""assert count_distinct_characters('abcde') == 5"", ""assert count_distinct_characters('abcde' + 'cade' + 'CADE') == 5"", ""assert count_distinct_characters('aaaaAAAAaaaa') == 1"", ""assert count_distinct_characters('Jerry jERRY JeRRRY') == 5""]",HumanEval/16
"from typing import List


def parse_music(music_string: str) -> List[int]:
    """"""Входными данными для этой функции является строка, представляющая музыкальные ноты в специальном формате ASCII. Ваша задача — разобрать эту строку и вернуть список целых чисел, соответствующих количеству долей, которые не длится каждая из них. Вот легенда: 'o' — целая нота, длится четыре доли 'o|' — половинная нота, длится две доли '.|' — четвертная нота, длится одну долю >>> parse_music('oo| .| o| o| .| .| .| .| o o') [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]""""""
","[""assert parse_music('') == []"", ""assert parse_music('o o o o') == [4, 4, 4, 4]"", ""assert parse_music('.| .| .| .|') == [1, 1, 1, 1]"", ""assert parse_music('o| o| .| .| o o o o') == [2, 2, 1, 1, 4, 4, 4, 4]"", ""assert parse_music('o| .| o| .| o o| o o|') == [2, 1, 2, 1, 4, 2, 4, 2]""]",HumanEval/17
"

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""""""
","[""assert how_many_times('', 'x') == 0"", ""assert how_many_times('xyxyxyx', 'x') == 4"", ""assert how_many_times('cacacacac', 'cac') == 4"", ""assert how_many_times('john doe', 'john') == 1""]",HumanEval/18
"from typing import List


def sort_numbers(numbers: str) -> str:
    """"""Входные данные — это разделенная пробелами строка чисел от «нуля» до «девяти». Допустимые варианты: «ноль», «один», «два», «три», «четыре», «пять», «шесть», «семь», «восемь» и «девять». Возвращает строку с числами, отсортированными от наименьшего к наибольшему >>> sort_numbers('три один пять') 'один три пять'""""""
","[""assert sort_numbers('') == ''"", ""assert sort_numbers('three') == 'three'"", ""assert sort_numbers('three five nine') == 'three five nine'"", ""assert sort_numbers('five zero four seven nine eight') == 'zero four five seven eight nine'"", ""assert sort_numbers('six five four three two one zero') == 'zero one two three four five six'""]",HumanEval/19
"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)""""""
","['assert find_closest_elements([1.0, 2.0, 3.9, 4.0, 5.0, 2.2]) == (3.9, 4.0)', 'assert find_closest_elements([1.0, 2.0, 5.9, 4.0, 5.0]) == (5.0, 5.9)', 'assert find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)', 'assert find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)', 'assert find_closest_elements([1.1, 2.2, 3.1, 4.1, 5.1]) == (2.2, 3.1)']",HumanEval/20
"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]""""""
","['assert rescale_to_unit([2.0, 49.9]) == [0.0, 1.0]', 'assert rescale_to_unit([100.0, 49.9]) == [1.0, 0.0]', 'assert rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]', 'assert rescale_to_unit([2.0, 1.0, 5.0, 3.0, 4.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]', 'assert rescale_to_unit([12.0, 11.0, 15.0, 13.0, 14.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]']",HumanEval/21
"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]""""""
","['assert filter_integers([]) == []', ""assert filter_integers([4, {}, [], 23.2, 9, 'adasd']) == [4, 9]"", ""assert filter_integers([3, 'c', 3, 3, 'a', 'b']) == [3, 3, 3]""]",HumanEval/22
"

def strlen(string: str) -> int:
    """""" Возвращает длину заданной строки >>> strlen('') 0 >>> strlen('abc') 3""""""
","[""assert strlen('') == 0"", ""assert strlen('x') == 1"", ""assert strlen('asdasnakj') == 9""]",HumanEval/23
"

def largest_divisor(n: int) -> int:
    """""" Для заданного числа n найдите наибольшее число, которое делит n нацело, меньшее, чем n >>> largest_divisor(15) 5""""""
","['assert largest_divisor(3) == 1', 'assert largest_divisor(7) == 1', 'assert largest_divisor(10) == 5', 'assert largest_divisor(100) == 50', 'assert largest_divisor(49) == 7']",HumanEval/24
"from typing import List


def factorize(n: int) -> List[int]:
    """"""Возвращает список простых множителей заданного целого числа в порядке от наименьшего к наибольшему. Каждый из множителей должен быть указан столько раз, сколько раз он появляется в факторизации. Входное число должно быть равно произведению всех множителей >>> factorize(8) [2, 2, 2] >>> factorize(25) [5, 5] >>> factorize(70) [2, 5, 7]""""""
","['assert factorize(2) == [2]', 'assert factorize(4) == [2, 2]', 'assert factorize(8) == [2, 2, 2]', 'assert factorize(3 * 19) == [3, 19]', 'assert factorize(3 * 19 * 3 * 19) == [3, 3, 19, 19]', 'assert factorize(3 * 19 * 3 * 19 * 3 * 19) == [3, 3, 3, 19, 19, 19]', 'assert factorize(3 * 19 * 19 * 19) == [3, 19, 19, 19]', 'assert factorize(3 * 2 * 3) == [2, 3, 3]']",HumanEval/25
"from typing import List


def remove_duplicates(numbers: List[int]) -> List[int]:
    """""" Из списка целых чисел удалить все элементы, которые встречаются более одного раза. Сохраните порядок элементов таким же, как и во входных данных. >>> remove_duplicates([1, 2, 3, 2, 4]) [1, 3, 4]""""""
","['assert remove_duplicates([]) == []', 'assert remove_duplicates([1, 2, 3, 4]) == [1, 2, 3, 4]', 'assert remove_duplicates([1, 2, 3, 2, 4, 3, 5]) == [1, 4, 5]']",HumanEval/26
"

def flip_case(string: str) -> str:
    """""" Для заданной строки переставить строчные символы в заглавные и заглавные в строчные. >>> flip_case('Hello') 'hELLO'""""""
","[""assert flip_case('') == ''"", ""assert flip_case('Hello!') == 'hELLO!'"", ""assert flip_case('These violent delights have violent ends') == 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'""]",HumanEval/27
"from typing import List


def concatenate(strings: List[str]) -> str:
    """""" Объединить список строк в одну строку >>> concatenate([]) '' >>> concatenate(['a', 'b', 'c']) 'abc'""""""
","[""assert concatenate([]) == ''"", ""assert concatenate(['x', 'y', 'z']) == 'xyz'"", ""assert concatenate(['x', 'y', 'z', 'w', 'k']) == 'xyzwk'""]",HumanEval/28
"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']""""""
","[""assert filter_by_prefix([], 'john') == []"", ""assert filter_by_prefix(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']""]",HumanEval/29
"

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]""""""
","['assert get_positive([-1, -2, 4, 5, 6]) == [4, 5, 6]', 'assert get_positive([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]', 'assert get_positive([-1, -2]) == []', 'assert get_positive([]) == []']",HumanEval/30
"

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""""""
","['assert is_prime(6) == False', 'assert is_prime(101) == True', 'assert is_prime(11) == True', 'assert is_prime(13441) == True', 'assert is_prime(61) == True', 'assert is_prime(4) == False', 'assert is_prime(1) == False', 'assert is_prime(5) == True', 'assert is_prime(11) == True', 'assert is_prime(17) == True', 'assert is_prime(5 * 17) == False', 'assert is_prime(11 * 7) == False', 'assert is_prime(13441 * 19) == False']",HumanEval/31
"import math


def poly(xs: list, x: float):
    """""" Вычисляет полином с коэффициентами xs в точке x. возвращает 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 в точке x. возвращает xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n""""""
","['assert math.fabs(poly(coeffs, solution)) < 1e-4']",HumanEval/32
"

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]""""""
","['assert tuple(sort_third([1, 2, 3])) == tuple(sort_third([1, 2, 3]))', 'assert tuple(sort_third([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(sort_third([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(sort_third([5, 6, 3, 4, 8, 9, 2])) == tuple([2, 6, 3, 4, 8, 9, 5])', 'assert tuple(sort_third([5, 8, 3, 4, 6, 9, 2])) == tuple([2, 8, 3, 4, 6, 9, 5])', 'assert tuple(sort_third([5, 6, 9, 4, 8, 3, 2])) == tuple([2, 6, 9, 4, 8, 3, 5])', 'assert tuple(sort_third([5, 6, 3, 4, 8, 9, 2, 1])) == tuple([2, 6, 3, 4, 8, 9, 5, 1])']",HumanEval/33
"

def unique(l: list):
    """""" Возврат отсортированных уникальных элементов в списке >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123]) [0, 2, 3, 5, 9, 123]""""""
","['assert unique([5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]']",HumanEval/34
"

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""""""
","['assert max_element([1, 2, 3]) == 3', 'assert max_element([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]) == 124']",HumanEval/35
"

def fizz_buzz(n: int):
    """""" Возвращает количество появлений цифры 7 в целых числах, меньших n, которые делятся на 11 или 13. >>> fizz_buzz(50) 0 >>> fizz_buzz(78) 2 >>> fizz_buzz(79) 3""""""
","['assert fizz_buzz(50) == 0', 'assert fizz_buzz(78) == 2', 'assert fizz_buzz(79) == 3', 'assert fizz_buzz(100) == 3', 'assert fizz_buzz(200) == 6', 'assert fizz_buzz(4000) == 192', 'assert fizz_buzz(10000) == 639', 'assert fizz_buzz(100000) == 8026']",HumanEval/36
"

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]""""""
","['assert tuple(sort_even([1, 2, 3])) == tuple([1, 2, 3])', 'assert tuple(sort_even([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(sort_even([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple([-12, 8, 3, 4, 5, 2, 12, 11, 23, -10])']",HumanEval/37
"

def encode_cyclic(s: str):
    """""" возвращает закодированную строку путем циклического перебора групп из трех символов.""""""
    # 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):
    """""" возвращает закодированную строку путем циклического перебора групп из трех символов.""""""
",['assert decode_cyclic(encoded_str) == str'],HumanEval/38
"

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""""""
","['assert prime_fib(1) == 2', 'assert prime_fib(2) == 3', 'assert prime_fib(3) == 5', 'assert prime_fib(4) == 13', 'assert prime_fib(5) == 89', 'assert prime_fib(6) == 233', 'assert prime_fib(7) == 1597', 'assert prime_fib(8) == 28657', 'assert prime_fib(9) == 514229', 'assert prime_fib(10) == 433494437']",HumanEval/39
"

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""""""
","['assert triples_sum_to_zero([1, 3, 5, 0]) == False', 'assert triples_sum_to_zero([1, 3, 5, -1]) == False', 'assert triples_sum_to_zero([1, 3, -2, 1]) == True', 'assert triples_sum_to_zero([1, 2, 3, 7]) == False', 'assert triples_sum_to_zero([1, 2, 5, 7]) == False', 'assert triples_sum_to_zero([2, 4, -5, 3, 9, 7]) == True', 'assert triples_sum_to_zero([1]) == False', 'assert triples_sum_to_zero([1, 3, 5, -100]) == False', 'assert triples_sum_to_zero([100, 3, 5, -100]) == False']",HumanEval/40
"

def car_race_collision(n: int):
    """"""Представьте себе дорогу, которая представляет собой идеально прямую бесконечно длинную линию. n автомобилей едут слева направо; одновременно другой набор из n автомобилей едет справа налево. Два набора автомобилей начинают движение очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Говорят, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, врезается в автомобиль, движущийся справа налево. Однако автомобили бесконечно прочны и сильны; в результате они продолжают движение по своей траектории, как будто они не сталкивались. Эта функция выводит количество таких столкновений.""""""
","['assert car_race_collision(2) == 4', 'assert car_race_collision(3) == 9', 'assert car_race_collision(4) == 16', 'assert car_race_collision(8) == 64', 'assert car_race_collision(10) == 100']",HumanEval/41
"

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]""""""
","['assert incr_list([]) == []', 'assert incr_list([3, 2, 1]) == [4, 3, 2]', 'assert incr_list([5, 2, 5, 2, 3, 3, 9, 0, 123]) == [6, 3, 6, 3, 4, 4, 10, 1, 124]']",HumanEval/42
"

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""""""
","['assert pairs_sum_to_zero([1, 3, 5, 0]) == False', 'assert pairs_sum_to_zero([1, 3, -2, 1]) == False', 'assert pairs_sum_to_zero([1, 2, 3, 7]) == False', 'assert pairs_sum_to_zero([2, 4, -5, 3, 5, 7]) == True', 'assert pairs_sum_to_zero([1]) == False', 'assert pairs_sum_to_zero([-3, 9, -1, 3, 2, 30]) == True', 'assert pairs_sum_to_zero([-3, 9, -1, 3, 2, 31]) == True', 'assert pairs_sum_to_zero([-3, 9, -1, 4, 2, 30]) == False', 'assert pairs_sum_to_zero([-3, 9, -1, 4, 2, 31]) == False']",HumanEval/43
"

def change_base(x: int, base: int):
    """""" Изменить основание системы счисления входного числа x на основание. вернуть строковое представление после преобразования. основания системы счисления меньше 10. >>> change_base(8, 3) '22' >>> change_base(8, 2) '1000' >>> change_base(7, 2) '111'""""""
","['assert change_base(8, 3) == ""22""', 'assert change_base(9, 3) == ""100""', 'assert change_base(234, 2) == ""11101010""', 'assert change_base(16, 2) == ""10000""', 'assert change_base(8, 2) == ""1000""', 'assert change_base(7, 2) == ""111"" for x in range(2, 8):', 'assert change_base(x, x + 1) == str(x)']",HumanEval/44
"

def triangle_area(a, h):
    """""" Дана длина стороны и площадь высокой доходности для треугольника. >>> triangle_area(5, 3) 7.5""""""
","['assert triangle_area(5, 3) == 7.5', 'assert triangle_area(2, 2) == 2.0', 'assert triangle_area(10, 8) == 40.0']",HumanEval/45
"

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""""""
","['assert fib4(5) == 4', 'assert fib4(8) == 28', 'assert fib4(10) == 104', 'assert fib4(12) == 386']",HumanEval/46
"

def median(l: list):
    """""" Возвращает медиану элементов в списке l. >>> median([3, 1, 2, 4, 5]) 3 >>> median([-10, 4, 6, 1000, 10, 20]) 15.0""""""
","['assert median([3, 1, 2, 4, 5]) == 3', 'assert median([-10, 4, 6, 1000, 10, 20]) == 8.0', 'assert median([5]) == 5', 'assert median([6, 5]) == 5.5', 'assert median([8, 1, 3, 9, 9, 2, 7]) == 7']",HumanEval/47
"

def is_palindrome(text: str):
    """""" Проверяет, является ли заданная строка палиндромом >>> is_palindrome('') True >>> is_palindrome('aba') True >>> is_palindrome('aaaaa') True >>> is_palindrome('zbcd') False""""""
","[""assert is_palindrome('') == True"", ""assert is_palindrome('aba') == True"", ""assert is_palindrome('aaaaa') == True"", ""assert is_palindrome('zbcd') == False"", ""assert is_palindrome('xywyx') == True"", ""assert is_palindrome('xywyz') == False"", ""assert is_palindrome('xywzx') == False""]",HumanEval/48
"

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""""""
","['assert modp(3, 5) == 3', 'assert modp(1101, 101) == 2', 'assert modp(0, 101) == 1', 'assert modp(3, 11) == 8', 'assert modp(100, 101) == 1', 'assert modp(30, 5) == 4', 'assert modp(31, 5) == 3']",HumanEval/49
"

def encode_shift(s: str):
    """""" возвращает закодированную строку, сдвигая каждый символ на 5 в алфавите.""""""
    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])


def decode_shift(s: str):
    """""" возвращает закодированную строку, сдвигая каждый символ на 5 в алфавите.""""""
",['assert decode_shift(copy.deepcopy(encoded_str)) == str'],HumanEval/50
"

def remove_vowels(text):
    """""" remove_vowels — это функция, которая принимает строку и возвращает строку без гласных. >>> remove_vowels('') '' >>> remove_vowels(""abcdef
ghijklm"") 'bcdf
ghjklm' >>> remove_vowels('abcdef') 'bcdf ' >>> удалить_гласные('aaaaa') '' >>> удалить_гласные('aaBAA') 'B' >>> удалить_гласные('zbcd') 'zbcd'""""""
","[""assert remove_vowels('') == ''"", 'assert remove_vowels(""abcdef\\nghijklm"") == \'bcdf\\nghjklm\'', ""assert remove_vowels('fedcba') == 'fdcb'"", ""assert remove_vowels('eeeee') == ''"", ""assert remove_vowels('acBAA') == 'cB'"", ""assert remove_vowels('EcBOO') == 'cB'"", ""assert remove_vowels('ybcd') == 'ybcd'""]",HumanEval/51
"

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""""""
","['assert below_threshold([1, 2, 4, 10], 100)', 'assert not below_threshold([1, 20, 4, 10], 5)', 'assert below_threshold([1, 20, 4, 10], 21)', 'assert below_threshold([1, 20, 4, 10], 22)', 'assert below_threshold([1, 8, 4, 10], 11)', 'assert not below_threshold([1, 8, 4, 10], 10)']",HumanEval/52
"

def add(x: int, y: int):
    """"""Сложить два числа x и y >>> add(2, 3) 5 >>> add(5, 7) 12""""""
","['assert add(0, 1) == 1', 'assert add(1, 0) == 1', 'assert add(2, 3) == 5', 'assert add(5, 7) == 12', 'assert add(7, 5) == 12 for i in range(100): x, y = random.randint(0, 1000), random.randint(0, 1000)', 'assert add(x, y) == x + y']",HumanEval/53
"

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', 'dddzzzzzzddddabc') False""""""
","[""assert same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc') == True"", ""assert same_chars('abcd', 'dddddddabc') == True"", ""assert same_chars('dddddddabc', 'abcd') == True"", ""assert same_chars('eabcd', 'dddddddabc') == False"", ""assert same_chars('abcd', 'dddddddabcf') == False"", ""assert same_chars('eabcdzzzz', 'dddzzzzzzzddddabc') == False"", ""assert same_chars('aabb', 'aaccc') == False""]",HumanEval/54
"

def fib(n: int):
    """""" Верните n-ное число Фибоначчи. >>> fib(10) 55 >>> fib(1) 1 >>> fib(8) 21""""""
","['assert fib(10) == 55', 'assert fib(1) == 1', 'assert fib(8) == 21', 'assert fib(11) == 89', 'assert fib(12) == 144']",HumanEval/55
"

def correct_bracketing(brackets: str):
    """"""скобки — это строка из ""<"" и "">"". возвращает True, если каждой открывающей скобке соответствует закрывающая скобка. >>> correct_bracketing(""<"") False >>> correct_bracketing(""<>"") True >>> correct_bracketing(""<<><>>"") True >>> correct_bracketing(""><<>"") False""""""
","['assert correct_bracketing(""<>"")', 'assert correct_bracketing(""<<><>>"")', 'assert correct_bracketing(""<><><<><>><>"")', 'assert correct_bracketing(""<><><<<><><>><>><<><><<>>>"")', 'assert not correct_bracketing(""<<<><>>>>"")', 'assert not correct_bracketing(""><<>"")', 'assert not correct_bracketing(""<"")', 'assert not correct_bracketing(""<<<<"")', 'assert not correct_bracketing("">"")', 'assert not correct_bracketing(""<<>"")', 'assert not correct_bracketing(""<><><<><>><>><<>"")', 'assert not correct_bracketing(""<><><<><>><>>><>"")']",HumanEval/56
"

def monotonic(l: list):
    """""" Возвращает True, если элементы списка монотонно увеличиваются или убывают. >>> monotonic([1, 2, 4, 20]) True >>> monotonic([1, 20, 4, 10]) False >>> monotonic([4, 1, 0, -10]) True""""""
","['assert monotonic([1, 2, 4, 10]) == True', 'assert monotonic([1, 2, 4, 20]) == True', 'assert monotonic([1, 20, 4, 10]) == False', 'assert monotonic([4, 1, 0, -10]) == True', 'assert monotonic([4, 1, 1, 0]) == True', 'assert monotonic([1, 2, 3, 2, 5, 60]) == False', 'assert monotonic([1, 2, 3, 4, 5, 60]) == True', 'assert monotonic([9, 9, 9, 9]) == True']",HumanEval/57
"

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]""""""
","['assert common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]) == [1, 5, 653]', 'assert common([5, 3, 2, 8], [3, 2]) == [2, 3]', 'assert common([4, 3, 2, 8], [3, 2, 4]) == [2, 3, 4]', 'assert common([4, 3, 2, 8], []) == []']",HumanEval/58
"

def largest_prime_factor(n: int):
    """"""Верните наибольший простой множитель числа n. Предположим, что n > 1 и не является простым. >>> largest_prime_factor(13195) 29 >>> largest_prime_factor(2048) 2""""""
","['assert largest_prime_factor(15) == 5', 'assert largest_prime_factor(27) == 3', 'assert largest_prime_factor(63) == 7', 'assert largest_prime_factor(330) == 11', 'assert largest_prime_factor(13195) == 29']",HumanEval/59
"

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""""""
","['assert sum_to_n(1) == 1', 'assert sum_to_n(6) == 21', 'assert sum_to_n(11) == 66', 'assert sum_to_n(30) == 465', 'assert sum_to_n(100) == 5050']",HumanEval/60
"

def correct_bracketing(brackets: str):
    """""" скобки — это строка из ""("" и "")"". возвращает True, если каждой открывающей скобке соответствует закрывающая скобка. >>> correct_bracketing(""("") Ложь >>> correct_bracketing(""()"") Истина >>> correct_bracketing(""(()())"") Истина >>> correct_bracketing("")(()"") Ложь""""""
","['assert correct_bracketing(""()"")', 'assert correct_bracketing(""(()())"")', 'assert correct_bracketing(""()()(()())()"")', 'assert correct_bracketing(""()()((()()())())(()()(()))"")', 'assert not correct_bracketing(""((()())))"")', 'assert not correct_bracketing("")(()"")', 'assert not correct_bracketing(""("")', 'assert not correct_bracketing(""(((("")', 'assert not correct_bracketing("")"")', 'assert not correct_bracketing(""(()"")', 'assert not correct_bracketing(""()()(()())())(()"")', 'assert not correct_bracketing(""()()(()())()))()"")']",HumanEval/61
"

def derivative(xs: list):
    """"""xs представляют коэффициенты полинома. xs[0] + xs[1] * x + xs[2] * x^2 + .... Возвращает производную этого полинома в той же форме. >>> derived([3, 1, 2, 4, 5]) [1, 4, 12, 20] >>> derived([1, 2, 3]) [2, 6]""""""
","['assert derivative([3, 1, 2, 4, 5]) == [1, 4, 12, 20]', 'assert derivative([1, 2, 3]) == [2, 6]', 'assert derivative([3, 2, 1]) == [2, 2]', 'assert derivative([3, 2, 1, 0, 4]) == [2, 2, 0, 16]', 'assert derivative([1]) == []']",HumanEval/62
"

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""""""
","['assert fibfib(2) == 1', 'assert fibfib(1) == 0', 'assert fibfib(5) == 4', 'assert fibfib(8) == 24', 'assert fibfib(10) == 81', 'assert fibfib(12) == 274', 'assert fibfib(14) == 927']",HumanEval/63
"
FIX = """""" Добавьте больше тестовых случаев.""""""

def vowels_count(s):
    """""" Добавьте больше тестовых случаев.""""""
","['assert vowels_count(""abcde"") == 2, ""Test 1""', 'assert vowels_count(""Alone"") == 3, ""Test 2""', 'assert vowels_count(""key"") == 2, ""Test 3""', 'assert vowels_count(""bye"") == 1, ""Test 4""', 'assert vowels_count(""keY"") == 2, ""Test 5""', 'assert vowels_count(""bYe"") == 1, ""Test 6""', 'assert vowels_count(""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!)""']",HumanEval/64
"
def circular_shift(x, shift):
    """""" Циклический сдвиг цифр целого числа x, сдвиг цифр вправо на сдвиг и возврат результата в виде строки. Если сдвиг > количества цифр, возвратить цифры в обратном порядке. >>> circular_shift(12, 1) ""21"" >>> circular_shift(12, 2) ""12""""""""
","['assert circular_shift(100, 2) == ""001""', 'assert circular_shift(12, 2) == ""12""', 'assert circular_shift(97, 8) == ""79""', 'assert circular_shift(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 circular_shift(11, 101) == ""11"", ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/65
"
def digitSum(s):
    """"""Задача Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму кодов ASCII только верхних символов. Примеры: digitSum("""") => 0 digitSum(""abAB"") => 131 digitSum(""abcCd"") => 67 digitSum(""helloE"") => 69 digitSum(""woArBld"") => 131 digitSum(""aAaaaXa"") => 153""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert digitSum("""") == 0, ""Error""', 'assert digitSum(""abAB"") == 131, ""Error""', 'assert digitSum(""abcCd"") == 67, ""Error""', 'assert digitSum(""helloE"") == 69, ""Error""', 'assert digitSum(""woArBld"") == 131, ""Error""', 'assert digitSum(""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 digitSum("" How are yOu?"") == 151, ""Error""', 'assert digitSum(""You arE Very Smart"") == 327, ""Error""']",HumanEval/66
"
def fruit_distribution(s,n):
    """"""В этом задании вам будет дана строка, представляющая количество яблок и апельсинов, которые распределены в корзине с фруктами, эта корзина содержит яблоки, апельсины и манго. Учитывая строку, представляющую общее количество апельсинов и яблок, и целое число, представляющее общее количество фруктов в корзине, верните количество манго в корзине. например: fruit_distribution(""5 яблок и 6 апельсинов"", 19) ->19 - 5 - 6 = 8 fruit_distribution(""0 яблок и 1 апельсин"", 3) -> 3 - 0 - 1 = 2 fruit_distribution(""2 яблока и 3 апельсина"", 100) -> 100 - 2 - 3 = 95 fruit_distribution(""100 яблок и 1 апельсин"", 120) -> 120 - 100 - 1 = 19""""""
","['assert fruit_distribution(""5 apples and 6 oranges"",19) == 8', 'assert fruit_distribution(""5 apples and 6 oranges"",21) == 10', 'assert fruit_distribution(""0 apples and 1 oranges"",3) == 2', 'assert fruit_distribution(""1 apples and 0 oranges"",3) == 2', 'assert fruit_distribution(""2 apples and 3 oranges"",100) == 95', 'assert fruit_distribution(""2 apples and 3 oranges"",5) == 0', 'assert fruit_distribution(""1 apples and 100 oranges"",120) == 19']",HumanEval/67
"
def pluck(arr):
    """"""""Дан массив, представляющий ветвь дерева, которая имеет неотрицательные целые узлы, ваша задача — вырвать один из узлов и вернуть его. Вырванный узел должен быть узлом с наименьшим четным значением. Если найдено несколько узлов с одинаковым наименьшим четным значением, вернуть узел с наименьшим индексом. Вырванный узел должен быть возвращен в списке, [smalest_value, its index], Если четных значений нет или заданный массив пуст, вернуть []. Пример 1: Ввод: [4,2,3] Вывод: [2, 1] Пояснение: 2 имеет наименьшее четное значение, а 2 имеет наименьший индекс. Пример 2: Ввод: [1,2,3] Вывод: [2, 1] Пояснение: 2 имеет наименьшее четное значение, а 2 имеет наименьший индекс. Пример 3: Ввод: [] Вывод: [] Пример 4: Ввод: [5, 0, 3, 0, 4, 2] Вывод: [0, 1] Пояснение: 0 наименьшее значение, но есть два нуля, поэтому мы выберем первый ноль, который имеет наименьший индекс. Ограничения: * 1 <= nodes.length <= 10000 * 0 <= node.value""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert pluck([4,2,3]) == [2, 1], ""Error""', 'assert pluck([1,2,3]) == [2, 1], ""Error""', 'assert pluck([]) == [], ""Error""', 'assert pluck([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 pluck([1, 2, 3, 0, 5, 3]) == [0, 3], ""Error""', 'assert pluck([5, 4, 8, 4 ,8]) == [4, 1], ""Error""', 'assert pluck([7, 6, 7, 1]) == [6, 1], ""Error""', 'assert pluck([7, 9, 7, 1]) == [], ""Error""']",HumanEval/68
"
def search(lst):
    '''
    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
    zero, and has a frequency greater than or equal to the value of the integer itself. 
    The frequency of an integer is the number of times it appears in the list.
    If no such a value exist, return -1.
    Examples:
        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
    '''
","['assert search([5, 5, 5, 5, 1]) == 1', 'assert search([4, 1, 4, 1, 4, 4]) == 4', 'assert search([3, 3]) == -1', 'assert search([8, 8, 8, 8, 8, 8, 8, 8]) == 8', 'assert search([2, 3, 3, 2, 2]) == 2 # automatically generated tests', 'assert search([2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1]) == 1', 'assert search([3, 2, 8, 2]) == 2', 'assert search([6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10]) == 1', 'assert search([8, 8, 3, 6, 5, 6, 4]) == -1', 'assert search([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 search([1, 9, 10, 1, 3]) == 1', 'assert search([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 search([1]) == 1', 'assert search([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 search([2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10]) == 2', 'assert search([1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3]) == 1', 'assert search([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 search([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 search([9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1]) == 2', 'assert search([5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8]) == -1', 'assert search([10]) == -1', 'assert search([9, 7, 7, 2, 4, 7, 2, 10, 9, 7, 5, 7, 2]) == 2', 'assert search([5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8]) == 1', 'assert search([7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6]) == 1', 'assert search([3, 10, 10, 9, 2]) == -1']",HumanEval/69
"
def strange_sort_list(lst):
    '''
    Given list of integers, return list in strange order.
    Strange sorting, is when you start with the minimum value,
    then maximum of the remaining integers, then minimum and so on.

    Examples:
    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([]) == []
    '''
","['assert strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]', 'assert strange_sort_list([5, 6, 7, 8, 9]) == [5, 9, 6, 8, 7]', 'assert strange_sort_list([1, 2, 3, 4, 5]) == [1, 5, 2, 4, 3]', 'assert strange_sort_list([5, 6, 7, 8, 9, 1]) == [1, 9, 5, 8, 6, 7]', 'assert strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]', 'assert strange_sort_list([]) == []', 'assert strange_sort_list([1,2,3,4,5,6,7,8]) == [1, 8, 2, 7, 3, 6, 4, 5]', 'assert strange_sort_list([0,2,2,2,5,5,-5,-5]) == [-5, 5, -5, 5, 0, 2, 2, 2]', 'assert strange_sort_list([111111]) == [111111] # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/70
"
def triangle_area(a, b, c):
    '''
    Given the lengths of the three sides of a triangle. Return the area of
    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
    Otherwise return -1
    Three sides make a valid triangle when the sum of any two sides is greater 
    than the third side.
    Example:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''
","['assert triangle_area(3, 4, 5) == 6.00, ""This prints if this assert fails 1 (good for debugging!)""', 'assert triangle_area(1, 2, 10) == -1', 'assert triangle_area(4, 8, 5) == 8.18', 'assert triangle_area(2, 2, 2) == 1.73', 'assert triangle_area(1, 2, 3) == -1', 'assert triangle_area(10, 5, 7) == 16.25', 'assert triangle_area(2, 6, 3) == -1 # Check some edge cases that are easy to work out by hand.', 'assert triangle_area(1, 1, 1) == 0.43, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert triangle_area(2, 2, 10) == -1']",HumanEval/71
"
def will_it_fly(q,w):
    '''
    Write a function that returns True if the object q will fly, and False otherwise.
    The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.

    Example:
    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.
    '''
","['assert will_it_fly([3, 2, 3], 9) is True', 'assert will_it_fly([1, 2], 5) is False', 'assert will_it_fly([3], 5) is True', 'assert will_it_fly([3, 2, 3], 1) is False # Check some edge cases that are easy to work out by hand.', 'assert will_it_fly([1, 2, 3], 6) is False', 'assert will_it_fly([5], 5) is True']",HumanEval/72
"
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""""""
","['assert smallest_change([1,2,3,5,4,7,9,6]) == 4', 'assert smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1', 'assert smallest_change([1, 4, 2]) == 1', 'assert smallest_change([1, 4, 4, 2]) == 1 # Check some edge cases that are easy to work out by hand.', 'assert smallest_change([1, 2, 3, 2, 1]) == 0', 'assert smallest_change([3, 1, 1, 3]) == 0', 'assert smallest_change([1]) == 0', 'assert smallest_change([0, 1]) == 1']",HumanEval/73
"
def total_match(lst1, lst2):
    '''
    Write a function that accepts two lists of strings and returns the list that has 
    total number of chars in the all strings of the list less than the other list.

    if the two lists have the same number of chars, return the first list.

    Examples
    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']
    '''
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert total_match([], []) == []', ""assert total_match(['hi', 'admin'], ['hi', 'hi']) == ['hi', 'hi']"", ""assert total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) == ['hi', 'admin']"", ""assert total_match(['4'], ['1', '2', '3', '4', '5']) == ['4']"", ""assert total_match(['hi', 'admin'], ['hI', 'Hi']) == ['hI', 'Hi']"", ""assert total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) == ['hI', 'hi', 'hi']"", ""assert total_match(['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 total_match([], ['this']) == []"", ""assert total_match(['this'], []) == []""]",HumanEval/74
"
def is_multiply_prime(a):
    """""" Напишите функцию, которая возвращает true, если заданное число является произведением 3 простых чисел, и false в противном случае. Зная, что (a) меньше 100. Пример: is_multiply_prime(30) == True 30 = 2 * 3 * 5""""""
","['assert is_multiply_prime(5) == False', 'assert is_multiply_prime(30) == True', 'assert is_multiply_prime(8) == True', 'assert is_multiply_prime(10) == False', 'assert is_multiply_prime(125) == True', 'assert is_multiply_prime(3 * 5 * 7) == True', 'assert is_multiply_prime(3 * 6 * 7) == False', 'assert is_multiply_prime(9 * 9 * 9) == False', 'assert is_multiply_prime(11 * 9 * 9) == False', 'assert is_multiply_prime(11 * 13 * 7) == True']",HumanEval/75
"
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""""""
","['assert is_simple_power(16, 2)== True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(143214, 16)== False, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(4, 2)==True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(9, 3)==True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(16, 4)==True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(24, 2)==False, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(128, 4)==False, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_simple_power(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 is_simple_power(1, 1)==True, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert is_simple_power(1, 12)==True, ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/76
"
def iscube(a):
    '''
    Write a function that takes an integer a and returns True 
    if this ingeger is a cube of some integer number.
    Note: you may assume the input is always valid.
    Examples:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''
","['assert iscube(1) == True, ""First test error: "" + str(iscube(1))', 'assert iscube(2) == False, ""Second test error: "" + str(iscube(2))', 'assert iscube(-1) == True, ""Third test error: "" + str(iscube(-1))', 'assert iscube(64) == True, ""Fourth test error: "" + str(iscube(64))', 'assert iscube(180) == False, ""Fifth test error: "" + str(iscube(180))', 'assert iscube(1000) == True, ""Sixth test error: "" + str(iscube(1000)) # Check some edge cases that are easy to work out by hand.', 'assert iscube(0) == True, ""1st edge test error: "" + str(iscube(0))', 'assert iscube(1729) == False, ""2nd edge test error: "" + str(iscube(1728))']",HumanEval/77
"
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 всегда заглавные. Примеры: Для num = ""AB"" вывод должен быть 1. Для num = ""1077E"" вывод должен быть 2. Для num = ""ABED1A33"" вывод должен быть 4. Для num = ""123456789ABCDEF0"" вывод должен быть 6. Для num = ""2020"" вывод должен быть 2.""""""
","['assert hex_key(""AB"") == 1, ""First test error: "" + str(hex_key(""AB""))', 'assert hex_key(""1077E"") == 2, ""Second test error: "" + str(hex_key(""1077E""))', 'assert hex_key(""ABED1A33"") == 4, ""Third test error: "" + str(hex_key(""ABED1A33""))', 'assert hex_key(""2020"") == 2, ""Fourth test error: "" + str(hex_key(""2020""))', 'assert hex_key(""123456789ABCDEF0"") == 6, ""Fifth test error: "" + str(hex_key(""123456789ABCDEF0""))', 'assert hex_key(""112233445566778899AABBCCDDEEFF00"") == 12, ""Sixth test error: "" + str(hex_key(""112233445566778899AABBCCDDEEFF00"")) # Check some edge cases that are easy to work out by hand.', 'assert hex_key([]) == 0']",HumanEval/78
"
def decimal_to_binary(decimal):
    """"""Вам будет дано число в десятичной форме, и ваша задача — преобразовать его в двоичный формат. Функция должна возвращать строку, в которой каждый символ представляет двоичное число. Каждый символ в строке будет '0' или '1'. В начале и в конце строки будет пара дополнительных символов 'db'. Дополнительные символы нужны для помощи с форматом. Примеры: decimal_to_binary(15) # возвращает ""db1111db"" decimal_to_binary(32) # возвращает ""db100000db""""""""
","['assert decimal_to_binary(0) == ""db0db""', 'assert decimal_to_binary(32) == ""db100000db""', 'assert decimal_to_binary(103) == ""db1100111db""', 'assert decimal_to_binary(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!)""']",HumanEval/79
"
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""""""
","['assert is_happy(""a"") == False , ""a""', 'assert is_happy(""aa"") == False , ""aa""', 'assert is_happy(""abcd"") == True , ""abcd""', 'assert is_happy(""aabb"") == False , ""aabb""', 'assert is_happy(""adb"") == True , ""adb""', 'assert is_happy(""xyy"") == False , ""xyy""', 'assert is_happy(""iopaxpoi"") == True , ""iopaxpoi""', 'assert is_happy(""iopaxioi"") == False , ""iopaxioi""']",HumanEval/80
"
def numerical_letter_grade(grades):
    """"""Последняя неделя семестра, и преподаватель должен выставить оценки студентам. Преподаватель создал свой собственный алгоритм для выставления оценок. Единственная проблема в том, что она потеряла код, который использовала для выставления оценок. Она дала вам список средних баллов некоторых студентов, и вам нужно написать функцию, которая может вывести список буквенных оценок, используя следующую таблицу: Средний балл | Буквенная оценка 4.0 A+ > 3.7 A > 3.3 A- > 3.0 B+ > 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-']""""""
","[""assert numerical_letter_grade([4.0, 3, 1.7, 2, 3.5]) == ['A+', 'B', 'C-', 'C', 'A-']"", ""assert numerical_letter_grade([1.2]) == ['D+']"", ""assert numerical_letter_grade([0.5]) == ['D-']"", ""assert numerical_letter_grade([0.0]) == ['E']"", ""assert numerical_letter_grade([1, 0.3, 1.5, 2.8, 3.3]) == ['D', 'D-', 'C-', 'B', 'B+']"", ""assert numerical_letter_grade([0, 0.7]) == ['E', 'D-'] # Check some edge cases that are easy to work out by hand."", 'assert True']",HumanEval/81
"
def prime_length(string):
    """"""Напишите функцию, которая принимает строку и возвращает True, если длина строки является простым числом, или False в противном случае Примеры prime_length('Hello') == True prime_length('abcdcba') == True prime_length('kittens') == True prime_length('orange') == False""""""
","[""assert prime_length('Hello') == True"", ""assert prime_length('abcdcba') == True"", ""assert prime_length('kittens') == True"", ""assert prime_length('orange') == False"", ""assert prime_length('wow') == True"", ""assert prime_length('world') == True"", ""assert prime_length('MadaM') == True"", ""assert prime_length('Wow') == True"", ""assert prime_length('') == False"", ""assert prime_length('HI') == True"", ""assert prime_length('go') == True"", ""assert prime_length('gogo') == False"", ""assert prime_length('aaaaaaaaaaaaaaa') == False # Check some edge cases that are easy to work out by hand."", ""assert prime_length('Madam') == True"", ""assert prime_length('M') == False"", ""assert prime_length('0') == False""]",HumanEval/82
"
def starts_one_ends(n):
    """""" Дано положительное целое число n, вернуть количество положительных целых чисел длиной n цифр, начинающихся или заканчивающихся на 1.""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert starts_one_ends(1) == 1', 'assert starts_one_ends(2) == 18', 'assert starts_one_ends(3) == 180', 'assert starts_one_ends(4) == 1800', 'assert starts_one_ends(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!)""']",HumanEval/83
"
def solve(N):
    """""" Дано положительное целое число N, вернуть общую сумму его цифр в двоичном формате. Пример Для N = 1000 сумма цифр будет равна 1, вывод должен быть ""1"". Для N = 150 сумма цифр будет равна 6, вывод должен быть ""110"". Для N = 147 сумма цифр будет равна 12, вывод должен быть ""1100"". Переменные: @N integer Ограничения: 0 ≤ N ≤ 10000. Вывод: строка двоичного числа""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert solve(1000) == ""1"", ""Error""', 'assert solve(150) == ""110"", ""Error""', 'assert solve(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 solve(333) == ""1001"", ""Error""', 'assert solve(963) == ""10010"", ""Error""']",HumanEval/84
"
def add(lst):
    """"""Дан непустой список целых чисел lst. Добавьте четные элементы, которые находятся в нечетных индексах. Примеры: add([4, 2, 6, 7]) ==> 2""""""
","['assert add([4, 88]) == 88', 'assert add([4, 5, 6, 7, 2, 122]) == 122', 'assert add([4, 0, 6, 7]) == 0', 'assert add([4, 4, 6, 8]) == 12 # Check some edge cases that are easy to work out by hand.']",HumanEval/85
"
def anti_shuffle(s):
    """""" Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию. Упорядоченная версия строки — это строка, в которой все слова (разделенные пробелом) заменены новым словом, в котором все символы расположены в порядке возрастания на основе значения ascii. Примечание: следует сохранять порядок слов и пробелов в предложении. Например: anti_shuffle('Hi') возвращает 'Hi' anti_shuffle('hello') возвращает 'ehllo' anti_shuffle('Hello World!!!') возвращает 'Hello !!!Wdlor'""""""
","[""assert anti_shuffle('Hi') == 'Hi'"", ""assert anti_shuffle('hello') == 'ehllo'"", ""assert anti_shuffle('number') == 'bemnru'"", ""assert anti_shuffle('abcd') == 'abcd'"", ""assert anti_shuffle('Hello World!!!') == 'Hello !!!Wdlor'"", ""assert anti_shuffle('') == ''"", ""assert anti_shuffle('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']",HumanEval/86
"
def get_row(lst, x):
    """"""Вам даны 2-мерные данные в виде вложенных списков, которые похожи на матрицы, однако, в отличие от матриц, каждая строка может содержать разное количество столбцов. Даны 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)]""""""
","['assert 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)]', 'assert get_row([ [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 get_row([ [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 get_row([], 1) == []', 'assert get_row([[1]], 2) == []', 'assert get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)] # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/87
"
def sort_array(array):
    """"""Дан массив неотрицательных целых чисел, вернуть копию данного массива после сортировки, вы отсортируете данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетная, или отсортируете его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) четная. Примечание: * не изменяйте данный массив. Примеры: * 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]""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sort_array([]) == [], ""Error""', 'assert sort_array([5]) == [5], ""Error""', 'assert sort_array([2, 4, 3, 0, 1, 5]) == [0, 1, 2, 3, 4, 5], ""Error""', 'assert sort_array([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 sort_array([2, 1]) == [1, 2], ""Error""', 'assert sort_array([15, 42, 87, 32 ,11, 0]) == [0, 11, 15, 32, 42, 87], ""Error""', 'assert sort_array([21, 14, 23, 11]) == [23, 21, 14, 11], ""Error""']",HumanEval/88
"
def encrypt(s):
    """""" Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную с помощью ротируемого алфавита. Алфавит должен быть ротирован таким образом, чтобы буквы сместились вниз на два, умноженные на две позиции. Например: encrypt('hi') возвращает 'lm' encrypt('asdfghjkl') возвращает 'ewhjklnop' encrypt('gf') возвращает 'kj' encrypt('et') возвращает 'ix'""""""
","['assert encrypt(\'hi\') == \'lm\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encrypt(\'asdfghjkl\') == \'ewhjklnop\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encrypt(\'gf\') == \'kj\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encrypt(\'et\') == \'ix\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encrypt(\'faewfawefaewg\')==\'jeiajeaijeiak\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encrypt(\'hellomyfriend\')==\'lippsqcjvmirh\', ""This prints if this assert fails 2 (good for debugging!)""', 'assert encrypt(\'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 encrypt(\'a\')==\'e\', ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/89
"
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""""""
","['assert next_smallest([1, 2, 3, 4, 5]) == 2', 'assert next_smallest([5, 1, 4, 3, 2]) == 2', 'assert next_smallest([]) == None', 'assert next_smallest([1, 1]) == None', 'assert next_smallest([1,1,1,1,0]) == 1', 'assert next_smallest([1, 0**0]) == None', 'assert next_smallest([-35, 34, 12, -45]) == -35 # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/90
"
def is_bored(S):
    """""" Вам будет дана строка слов, и ваша задача — подсчитать количество скук. Скука — это предложение, которое начинается со слова «I». Предложения разделяются символами «.», «?» или «!». Например: >>> is_bored(""Привет, мир"") 0 >>> is_bored(""Небо голубое. Солнце светит. Мне нравится эта погода"") 1""""""
","['assert is_bored(""Hello world"") == 0, ""Test 1""', 'assert is_bored(""Is the sky blue?"") == 0, ""Test 2""', 'assert is_bored(""I love It !"") == 1, ""Test 3""', 'assert is_bored(""bIt"") == 0, ""Test 4""', 'assert is_bored(""I feel good today. I will be productive. will kill It"") == 2, ""Test 5""', 'assert is_bored(""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!)""']",HumanEval/91
"
def any_int(x, y, z):
    '''
    Create a function that takes 3 numbers.
    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
    Returns false in any other cases.
    
    Examples
    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
  

    
    '''
","['assert any_int(2, 3, 1)==True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert any_int(2.5, 2, 3)==False, ""This prints if this assert fails 2 (good for debugging!)""', 'assert any_int(1.5, 5, 3.5)==False, ""This prints if this assert fails 3 (good for debugging!)""', 'assert any_int(2, 6, 2)==False, ""This prints if this assert fails 4 (good for debugging!)""', 'assert any_int(4, 2, 2)==True, ""This prints if this assert fails 5 (good for debugging!)""', 'assert any_int(2.2, 2.2, 2.2)==False, ""This prints if this assert fails 6 (good for debugging!)""', 'assert any_int(-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 any_int(2,1,1)==True, ""This prints if this assert fails 8 (also good for debugging!)""', 'assert any_int(3,4,7)==True, ""This prints if this assert fails 9 (also good for debugging!)""', 'assert any_int(3.0,4,7)==False, ""This prints if this assert fails 10 (also good for debugging!)""']",HumanEval/92
"
def encode(message):
    """"""Напишите функцию, которая принимает сообщение и кодирует его таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении на букву, которая находится на 2 позиции впереди этой гласной в английском алфавите. Предположим, что есть только буквы. Примеры: >>> encode('test') 'TGST' >>> encode('This is a message') 'tHKS KS C MGSSCGG'""""""
","['assert encode(\'TEST\') == \'tgst\', ""This prints if this assert fails 1 (good for debugging!)""', 'assert encode(\'Mudasir\') == \'mWDCSKR\', ""This prints if this assert fails 2 (good for debugging!)""', 'assert encode(\'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 encode(\'This is a message\') == \'tHKS KS C MGSSCGG\', ""This prints if this assert fails 2 (also good for debugging!)""', 'assert encode(""I DoNt KnOw WhAt tO WrItE"") == \'k dQnT kNqW wHcT Tq wRkTg\', ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/93
"

def skjkasdkd(lst):
    """""" Вам дан список целых чисел. Вам нужно найти наибольшее простое число и вернуть сумму его цифр. Примеры: Для lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] вывод должен быть 10 Для lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] вывод должен быть 25 Для lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] вывод должен быть 13 Для lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] вывод должен быть 11 Для lst = [0,81,12,3,1,21] вывод должен быть 3 Для lst = [0,8,1,2,1,7] вывод должен быть 7""""""
","['assert skjkasdkd([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 skjkasdkd([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 skjkasdkd([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 skjkasdkd([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 skjkasdkd([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 skjkasdkd([0,8,1,2,1,7]) == 7, ""This prints if this assert fails 6 (also good for debugging!)""', 'assert skjkasdkd([8191]) == 19, ""This prints if this assert fails 7 (also good for debugging!)""', 'assert skjkasdkd([8191, 123456, 127, 7]) == 19, ""This prints if this assert fails 8 (also good for debugging!)""', 'assert skjkasdkd([127, 97, 8192]) == 10, ""This prints if this assert fails 9 (also good for debugging!)""']",HumanEval/94
"
def check_dict_case(dict):
    """"""Если задан словарь, вернуть True, если все ключи являются строками в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае вернуть False. Функция должна вернуть False, если заданный словарь пуст. Примеры: check_dict_case({""a"":""apple"", ""b"":""banana""}) должна вернуть True. check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) должна вернуть False. check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) должна вернуть False. check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) должна вернуть False. check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) должна вернуть True.""""""
","['assert check_dict_case({""p"":""pineapple"", ""b"":""banana""}) == True, ""First test error: "" + str(check_dict_case({""p"":""pineapple"", ""b"":""banana""}))', 'assert check_dict_case({""p"":""pineapple"", ""A"":""banana"", ""B"":""banana""}) == False, ""Second test error: "" + str(check_dict_case({""p"":""pineapple"", ""A"":""banana"", ""B"":""banana""}))', 'assert check_dict_case({""p"":""pineapple"", 5:""banana"", ""a"":""apple""}) == False, ""Third test error: "" + str(check_dict_case({""p"":""pineapple"", 5:""banana"", ""a"":""apple""}))', 'assert check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) == False, ""Fourth test error: "" + str(check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}))', 'assert check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) == True, ""Fifth test error: "" + str(check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }))', 'assert check_dict_case({""fruit"":""Orange"", ""taste"":""Sweet"" }) == True, ""Fourth test error: "" + str(check_dict_case({""fruit"":""Orange"", ""taste"":""Sweet"" })) # Check some edge cases that are easy to work out by hand.', 'assert check_dict_case({}) == False, ""1st edge test error: "" + str(check_dict_case({}))']",HumanEval/95
"
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]""""""
","['assert count_up_to(5) == [2,3]', 'assert count_up_to(6) == [2,3,5]', 'assert count_up_to(7) == [2,3,5]', 'assert count_up_to(10) == [2,3,5,7]', 'assert count_up_to(0) == []', 'assert count_up_to(22) == [2,3,5,7,11,13,17,19]', 'assert count_up_to(1) == []', 'assert count_up_to(18) == [2,3,5,7,11,13,17]', 'assert count_up_to(47) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]', 'assert count_up_to(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]']",HumanEval/96
"
def multiply(a, b):
    """""" Завершите функцию, которая принимает два целых числа и возвращает произведение их единичных цифр. Предположим, что входные данные всегда допустимы. Примеры: умножение(148, 412) должно вернуть 16. умножение(19, 28) должно вернуть 72. умножение(2020, 1851) должно вернуть 0. умножение(14,-15) должно вернуть 20.""""""
","['assert multiply(148, 412) == 16, ""First test error: "" + str(multiply(148, 412))', 'assert multiply(19, 28) == 72, ""Second test error: "" + str(multiply(19, 28))', 'assert multiply(2020, 1851) == 0, ""Third test error: "" + str(multiply(2020, 1851))', 'assert multiply(14,-15) == 20, ""Fourth test error: "" + str(multiply(14,-15))', 'assert multiply(76, 67) == 42, ""Fifth test error: "" + str(multiply(76, 67))', 'assert multiply(17, 27) == 49, ""Sixth test error: "" + str(multiply(17, 27)) # Check some edge cases that are easy to work out by hand.', 'assert multiply(0, 1) == 0, ""1st edge test error: "" + str(multiply(0, 1))', 'assert multiply(0, 0) == 0, ""2nd edge test error: "" + str(multiply(0, 0))']",HumanEval/97
"
def count_upper(s):
    """""" Дана строка s, подсчитать количество заглавных гласных в четных индексах. Например: count_upper('aBCdEf') возвращает 1 count_upper('abcdefg') возвращает 0 count_upper('dBBE') возвращает 0""""""
","[""assert count_upper('aBCdEf') == 1"", ""assert count_upper('abcdefg') == 0"", ""assert count_upper('dBBE') == 0"", ""assert count_upper('B') == 0"", ""assert count_upper('U') == 1"", ""assert count_upper('') == 0"", ""assert count_upper('EEEE') == 2 # Check some edge cases that are easy to work out by hand."", 'assert True']",HumanEval/98
"
def closest_integer(value):
    '''
    Create a function that takes a value (string) representing a number
    and returns the closest integer to it. If the number is equidistant
    from two integers, round it away from zero.

    Examples
    >>> closest_integer(""10"")
    10
    >>> closest_integer(""15.3"")
    15

    Note:
    Rounding away from zero means that if the given number is equidistant
    from two integers, the one you should return is the one that is the
    farthest from zero. For example closest_integer(""14.5"") should
    return 15 and closest_integer(""-14.5"") should return -15.
    '''
","['assert closest_integer(""10"") == 10, ""Test 1""', 'assert closest_integer(""14.5"") == 15, ""Test 2""', 'assert closest_integer(""-15.5"") == -16, ""Test 3""', 'assert closest_integer(""15.3"") == 15, ""Test 3"" # Check some edge cases that are easy to work out by hand.', 'assert closest_integer(""0"") == 0, ""Test 0""']",HumanEval/99
"
def make_a_pile(n):
    """"""Дано положительное целое число n, вам нужно сделать кучу из n уровней камней. На первом уровне находится n камней. Количество камней на следующем уровне равно: - следующему нечетному числу, если n нечетное. - следующему четному числу, если n четное. Верните количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1). Примеры: >>> make_a_pile(3) [3, 5, 7]""""""
","['assert make_a_pile(3) == [3, 5, 7], ""Test 3""', 'assert make_a_pile(4) == [4,6,8,10], ""Test 4""', 'assert make_a_pile(5) == [5, 7, 9, 11, 13]', 'assert make_a_pile(6) == [6, 8, 10, 12, 14, 16]', 'assert make_a_pile(8) == [8, 10, 12, 14, 16, 18, 20, 22] # 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!)""']",HumanEval/100
"
def words_string(s):
    """""" Вам будет дана строка слов, разделенных запятыми или пробелами. Ваша задача — разбить строку на слова и вернуть массив слов. Например: words_string(""Привет, меня зовут Джон"") == [""Привет"", ""мой"", ""имя"", ""есть"", ""Джон""] words_string(""Один, два, три, четыре, пять, шесть"") == [""Один"", ""два"", ""три"", ""четыре"", ""пять"", ""шесть""]""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]', 'assert words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]', 'assert words_string(""Hi, my name"") == [""Hi"", ""my"", ""name""]', 'assert words_string(""One,, two, three, four, five, six,"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""] # 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 words_string("""") == []', 'assert words_string(""ahmed , gamal"") == [""ahmed"", ""gamal""]']",HumanEval/101
"
def choose_num(x, y):
    """"""Эта функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, которое находится в диапазоне [x, y] включительно. Если такого числа нет, то функция должна вернуть -1. Например: choose_num(12, 15) = 14 choose_num(13, 12) = -1""""""
","['assert choose_num(12, 15) == 14', 'assert choose_num(13, 12) == -1', 'assert choose_num(33, 12354) == 12354', 'assert choose_num(5234, 5233) == -1', 'assert choose_num(6, 29) == 28', 'assert choose_num(27, 10) == -1 # Check some edge cases that are easy to work out by hand.', 'assert choose_num(7, 7) == -1', 'assert choose_num(546, 546) == 546']",HumanEval/102
"
def rounded_avg(n, m):
    """""" Вам даны два положительных целых числа n и m, и ваша задача — вычислить среднее значение целых чисел от n до m (включая n и m). Округлите ответ до ближайшего целого числа и преобразуйте его в двоичную систему счисления. Если n больше m, верните -1. Пример: rounded_avg(1, 5) => ""0b11"" rounded_avg(7, 5) => -1 rounded_avg(10, 20) => ""0b1111"" rounded_avg(20, 33) => ""0b11010""""""""
","['assert rounded_avg(1, 5) == ""0b11""', 'assert rounded_avg(7, 13) == ""0b1010""', 'assert rounded_avg(964,977) == ""0b1111001010""', 'assert rounded_avg(996,997) == ""0b1111100100""', 'assert rounded_avg(560,851) == ""0b1011000010""', 'assert rounded_avg(185,546) == ""0b101101110""', 'assert rounded_avg(362,496) == ""0b110101101""', 'assert rounded_avg(350,902) == ""0b1001110010""', 'assert rounded_avg(197,233) == ""0b11010111"" # Check some edge cases that are easy to work out by hand.', 'assert rounded_avg(7, 5) == -1', 'assert rounded_avg(5, 1) == -1', 'assert rounded_avg(5, 5) == ""0b101""']",HumanEval/103
"
def unique_digits(x):
    """"""Дан список положительных целых чисел x. вернуть отсортированный список всех элементов, в которых нет ни одной четной цифры. Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания. Например: >>> unique_digits([15, 33, 1422, 1]) [1, 15, 33] >>> unique_digits([152, 323, 1422, 10]) []""""""
","['assert unique_digits([15, 33, 1422, 1]) == [1, 15, 33]', 'assert unique_digits([152, 323, 1422, 10]) == []', 'assert unique_digits([12345, 2033, 111, 151]) == [111, 151]', 'assert unique_digits([135, 103, 31]) == [31, 135] # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/104
"
def by_length(arr):
    """"""Дан массив целых чисел. Отсортируйте целые числа от 1 до 9 включительно, переверните полученный массив, а затем замените каждую цифру соответствующим ей именем из следующих: «Один», «Два», «Три», «Четыре», «Пять», «Шесть», «Семь», «Восемь», «Девять». Например: arr = [2, 1, 1, 4, 5, 8, 2, 3] -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1] return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""] Если массив пуст, вернуть пустой массив: arr = [] return [] Если в массиве есть какие-либо странные числа, проигнорировать их: arr = [1, -1 , 55] -> sort arr -> [-1, 1, 55] -> reverse arr -> [55, 1, -1] return = ['One']""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert by_length([2, 1, 1, 4, 5, 8, 2, 3]) == [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""], ""Error""', 'assert by_length([]) == [], ""Error""', 'assert by_length([1, -1 , 55]) == [\'One\'], ""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 by_length([1, -1, 3, 2]) == [""Three"", ""Two"", ""One""]', 'assert by_length([9, 4, 8]) == [""Nine"", ""Eight"", ""Four""]']",HumanEval/105
"
def f(n):
    """"""Реализуйте функцию f, которая принимает n в качестве параметра и возвращает список размера n, такой, что значение элемента с индексом i является факториалом i, если i четное, или суммой чисел от 1 до i в противном случае. i начинается с 1. Факториал i является произведением чисел от 1 до i (1 * 2 * ... * i). Пример: f(5) == [1, 2, 6, 24, 15]""""""
","['assert f(5) == [1, 2, 6, 24, 15]', 'assert f(7) == [1, 2, 6, 24, 15, 720, 28]', 'assert f(1) == [1]', 'assert f(3) == [1, 2, 6]']",HumanEval/106
"
def even_odd_palindrome(n):
    """""" Дано положительное целое число n, вернуть кортеж, содержащий количество четных и нечетных целочисленных палиндромов, которые попадают в диапазон (1, n) включительно. Пример 1: Ввод: 3 Вывод: (1, 2) Пояснение: Целочисленные палиндромы — это 1, 2, 3. Один из них четный, а два из них нечетные. Пример 2: Ввод: 12 Вывод: (4, 6) Пояснение: Целочисленные палиндромы — это 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Четыре из них четные, а 6 из них нечетные. Примечание: 1. 1 <= n <= 10^3 2. Возвращаемый кортеж содержит количество четных и нечетных целочисленных палиндромов соответственно.""""""
","['assert even_odd_palindrome(123) == (8, 13)', 'assert even_odd_palindrome(12) == (4, 6)', 'assert even_odd_palindrome(3) == (1, 2)', 'assert even_odd_palindrome(63) == (6, 8)', 'assert even_odd_palindrome(25) == (5, 6)', 'assert even_odd_palindrome(19) == (4, 6)', 'assert even_odd_palindrome(9) == (4, 5), ""This prints if this assert fails 1 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert even_odd_palindrome(1) == (0, 1), ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/107
"
def count_nums(arr):
    """"""Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0. Если число отрицательное, то его первая знаковая цифра будет отрицательной: например, -123 имеет знаковые цифры -1, 2 и 3. >>> count_nums([]) == 0 >>> count_nums([-1, 11, -11]) == 1 >>> count_nums([1, 1, 2]) == 3""""""
","['assert count_nums([]) == 0', 'assert count_nums([-1, -2, 0]) == 0', 'assert count_nums([1, 1, 2, -2, 3, 4, 5]) == 6', 'assert count_nums([1, 6, 9, -6, 0, 1, 5]) == 5', 'assert count_nums([1, 100, 98, -7, 1, -1]) == 4', 'assert count_nums([12, 23, 34, -45, -56, 0]) == 5', 'assert count_nums([-0, 1**0]) == 1', 'assert count_nums([1]) == 1 # 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!)""']",HumanEval/108
"
def move_one_ball(arr):
    """"""У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N]. Числа в массиве будут упорядочены случайным образом. Ваша задача — определить, возможно ли получить массив, отсортированный в неубывающем порядке, выполнив следующую операцию над заданным массивом: Вам разрешено выполнять операцию сдвига вправо любое количество раз. Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т. е. на 0-й индекс. Если возможно получить отсортированный массив, выполнив указанную выше операцию, то верните True, иначе верните False. Если заданный массив пуст, то верните True. Примечание: заданный список гарантированно содержит уникальные элементы. Например: move_one_ball([3, 4, 5, 1, 2])==>True Объяснение: Выполнив 2 операции сдвига вправо, можно добиться неубывающегго порядка для заданного массива. move_one_ball([3, 5, 4, 1, 2])==>Ложь Объяснение: невозможно получить неубывающую упорядоченность для заданного массива, выполнив любое количество операций сдвига вправо.""""""
","['assert move_one_ball([3, 4, 5, 1, 2])==True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert move_one_ball([3, 5, 10, 1, 2])==True', 'assert move_one_ball([4, 3, 1, 2])==False # Check some edge cases that are easy to work out by hand.', 'assert move_one_ball([3, 5, 4, 1, 2])==False, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert move_one_ball([])==True']",HumanEval/109
"
def exchange(lst1, lst2):
    """"""В этой задаче вы реализуете функцию, которая берет два списка чисел и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только из четных чисел. Нет ограничений на количество обмениваемых элементов между lst1 и lst2. Если возможно обменять элементы между lst1 и lst2, чтобы сделать все элементы lst1 четными, верните ""ДА"". В противном случае верните ""НЕТ"". Например: exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""ДА"" exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""НЕТ"" Предполагается, что входные списки будут непустыми.""""""
","['assert exchange([1, 2, 3, 4], [1, 2, 3, 4]) == ""YES""', 'assert exchange([1, 2, 3, 4], [1, 5, 3, 4]) == ""NO""', 'assert exchange([1, 2, 3, 4], [2, 1, 4, 3]) == ""YES""', 'assert exchange([5, 7, 3], [2, 6, 4]) == ""YES""', 'assert exchange([5, 7, 3], [2, 6, 3]) == ""NO""', 'assert exchange([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]) == ""NO"" # Check some edge cases that are easy to work out by hand.', 'assert exchange([100, 200], [200, 200]) == ""YES""']",HumanEval/110
"
def histogram(test):
    """"""Дана строка, представляющая собой строчные буквы, разделенные пробелом, вернуть словарь букв с наибольшим повторением и содержащий соответствующее количество. Если несколько букв встречаются одинаково, вернуть все из них. Пример: histogram('ab c') == {'a': 1, 'b': 1, 'c': 1} histogram('abb a') == {'a': 2, 'b': 2} histogram('abca b') == {'a': 2, 'b': 2} histogram('bbbb a') == {'b': 4} histogram('') == {}""""""
","['assert histogram(\'a b b a\') == {\'a\':2,\'b\': 2}, ""This prints if this assert fails 1 (good for debugging!)""', 'assert histogram(\'a b c a b\') == {\'a\': 2, \'b\': 2}, ""This prints if this assert fails 2 (good for debugging!)""', 'assert histogram(\'a b c d g\') == {\'a\': 1, \'b\': 1, \'c\': 1, \'d\': 1, \'g\': 1}, ""This prints if this assert fails 3 (good for debugging!)""', 'assert histogram(\'r t g\') == {\'r\': 1,\'t\': 1,\'g\': 1}, ""This prints if this assert fails 4 (good for debugging!)""', 'assert histogram(\'b b b b a\') == {\'b\': 4}, ""This prints if this assert fails 5 (good for debugging!)""', 'assert histogram(\'r t g\') == {\'r\': 1,\'t\': 1,\'g\': 1}, ""This prints if this assert fails 6 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert histogram(\'\') == {}, ""This prints if this assert fails 7 (also good for debugging!)""', 'assert histogram(\'a\') == {\'a\': 1}, ""This prints if this assert fails 8 (also good for debugging!)""']",HumanEval/111
"
def reverse_delete(s,c):
    """"""Задача Нам даны две строки s и c, вам нужно удалить все символы в s, которые равны любому символу в c, а затем проверить, является ли результирующая строка палиндромом. Строка называется палиндромом, если она читается одинаково как в прямом, так и в обратном порядке. Вы должны вернуть кортеж, содержащий результирующую строку и True/False для проверки. Пример Для s = ""abcde"", c = ""ae"", результат должен быть ('bcd',False) Для s = ""abcdef"", c = ""b"" результат должен быть ('acdef',False) Для s = ""abcdedcba"", c = ""ab"", результат должен быть ('cdedc',True)""""""
","['assert reverse_delete(""abcde"",""ae"") == (\'bcd\',False)', 'assert reverse_delete(""abcdef"", ""b"") == (\'acdef\',False)', 'assert reverse_delete(""abcdedcba"",""ab"") == (\'cdedc\',True)', 'assert reverse_delete(""dwik"",""w"") == (\'dik\',False)', 'assert reverse_delete(""a"",""a"") == (\'\',True)', 'assert reverse_delete(""abcdedcba"","""") == (\'abcdedcba\',True)', 'assert reverse_delete(""abcdedcba"",""v"") == (\'abcdedcba\',True)', 'assert reverse_delete(""vabba"",""v"") == (\'abba\',True)', 'assert reverse_delete(""mamma"", ""mia"") == ("""", True)']",HumanEval/112
"
def odd_count(lst):
    """"""Если задан список строк, где каждая строка состоит только из цифр, вернуть список. Каждый элемент i выходных данных должен быть ""количеством нечетных элементов в строке i входных данных"". где все i должны быть заменены на количество нечетных цифр в i-й строке входных данных. >>> odd_count(['1234567']) [""количество нечетных элементов 4 в строке 4 входных данных.""] >>> odd_count(['3',""11111111""]) [""количество нечетных элементов 1 в строке 1 входных данных."", ""количество нечетных элементов 8 в строке 8 входных данных.""]""""""
","['assert odd_count([\'1234567\']) == [""the number of odd elements 4n the str4ng 4 of the 4nput.""], ""Test 1""', 'assert odd_count([\'3\',""11111111""]) == [""the number of odd elements 1n the str1ng 1 of the 1nput."", ""the number of odd elements 8n the str8ng 8 of the 8nput.""], ""Test 2""', ""assert odd_count(['271', '137', '314']) == [ 'the number of odd elements 2n the str2ng 2 of the 2nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.', 'the number of odd elements 2n the str2ng 2 of the 2nput.' ] # 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!)""']",HumanEval/113
"
def minSubArraySum(nums):
    """""" Дан массив целых чисел nums, найти минимальную сумму любого непустого подмассива nums. Пример minSubArraySum([2, 3, 4, 1, 2, 4]) == 1 minSubArraySum([-1, -2, -3]) == -6""""""
","['assert minSubArraySum([2, 3, 4, 1, 2, 4]) == 1, ""This prints if this assert fails 1 (good for debugging!)""', 'assert minSubArraySum([-1, -2, -3]) == -6', 'assert minSubArraySum([-1, -2, -3, 2, -10]) == -14', 'assert minSubArraySum([-9999999999999999]) == -9999999999999999', 'assert minSubArraySum([0, 10, 20, 1000000]) == 0', 'assert minSubArraySum([-1, -2, -3, 10, -5]) == -6', 'assert minSubArraySum([100, -1, -2, -3, 10, -5]) == -6', 'assert minSubArraySum([10, 11, 13, 8, 3, 4]) == 3', 'assert minSubArraySum([100, -33, 32, -1, 0, -2]) == -33 # Check some edge cases that are easy to work out by hand.', 'assert minSubArraySum([-10]) == -10, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert minSubArraySum([7]) == 7', 'assert minSubArraySum([1, -1]) == -1']",HumanEval/114
"
def max_fill(grid, capacity):
    import math
    """"""Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец, а каждая единица в строке представляет собой единицу воды. Каждому колодцу соответствует ведро, которое можно использовать для извлечения из него воды, и все ведра имеют одинаковую вместимость. Ваша задача — использовать ведра для опорожнения колодцев. Выведите количество раз, которое вам нужно опустить ведра. Пример 1: Ввод: сетка: [[0,0,1,0], [0,1,0,0], [1,1,1,1]] емкость_бака: 1 Вывод: 6 Пример 2: Ввод: сетка: [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]] емкость_бака: 2 Вывод: 5 Пример 3: Ввод: сетка: [[0,0,0], [0,0,0]] емкость_бака: 5 Вывод: 0 Ограничения: * все скважины имеют одинаковую длину * 1 <= длина сетки <= 10^2 * 1 <= сетка[:,1].длина <= 10^2 * сетка[i][j] -> 0 | 1 * 1 <= емкость <= 10""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert max_fill([[0,0,1,0], [0,1,0,0], [1,1,1,1]], 1) == 6, ""Error""', 'assert max_fill([[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]], 2) == 5, ""Error""', 'assert max_fill([[0,0,0], [0,0,0]], 5) == 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 max_fill([[1,1,1,1], [1,1,1,1]], 2) == 4, ""Error""', 'assert max_fill([[1,1,1,1], [1,1,1,1]], 9) == 2, ""Error""']",HumanEval/115
"
def sort_array(arr):
    """"""В этой Kata вам нужно отсортировать массив неотрицательных целых чисел по количеству единиц в их двоичном представлении в порядке возрастания. Для похожего количества единиц сортируйте на основе десятичного значения. Это должно быть реализовано следующим образом: >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5] >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2] >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sort_array([1,5,2,3,4]) == [1, 2, 4, 3, 5]', 'assert sort_array([-2,-3,-4,-5,-6]) == [-4, -2, -6, -5, -3]', 'assert sort_array([1,0,2,3,4]) == [0, 1, 2, 4, 3]', 'assert sort_array([]) == []', 'assert sort_array([2,5,77,4,5,3,5,7,2,3,4]) == [2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]', 'assert sort_array([3,6,44,12,32,5]) == [32, 3, 5, 6, 12, 44]', 'assert sort_array([2,4,8,16,32]) == [2, 4, 8, 16, 32]', 'assert sort_array([2,4,8,16,32]) == [2, 4, 8, 16, 32] # 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!)""']",HumanEval/116
"
def select_words(s, n):
    """"""Дана строка s и натуральное число n. Вам поручено реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке их появления в строке s. Если строка s пуста, то функция должна вернуть пустой список. Примечание: вы можете предположить, что входная строка содержит только буквы и пробелы. Примеры: select_words(""Mary had a little lamb"", 4) ==> [""little""] select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""] select_words(""simple white space"", 2) ==> [] select_words(""Hello world"", 4) ==> [""world""] select_words(""Uncle sam"", 3) ==> [""Uncle""]""""""
","['assert select_words(""Mary had a little lamb"", 4) == [""little""], ""First test error: "" + str(select_words(""Mary had a little lamb"", 4))', 'assert select_words(""Mary had a little lamb"", 3) == [""Mary"", ""lamb""], ""Second test error: "" + str(select_words(""Mary had a little lamb"", 3))', 'assert select_words(""simple white space"", 2) == [], ""Third test error: "" + str(select_words(""simple white space"", 2))', 'assert select_words(""Hello world"", 4) == [""world""], ""Fourth test error: "" + str(select_words(""Hello world"", 4))', 'assert select_words(""Uncle sam"", 3) == [""Uncle""], ""Fifth test error: "" + str(select_words(""Uncle sam"", 3)) # Check some edge cases that are easy to work out by hand.', 'assert select_words("""", 4) == [], ""1st edge test error: "" + str(select_words("""", 4))', 'assert select_words(""a b c d e f"", 1) == [""b"", ""c"", ""d"", ""f""], ""2nd edge test error: "" + str(select_words(""a b c d e f"", 1))']",HumanEval/117
"
def get_closest_vowel(word):
    """"""Вам дано слово. Ваша задача — найти ближайшую гласную, которая находится между двумя согласными с правой стороны слова (с учетом регистра). Гласные в начале и конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию. Вы можете предположить, что данная строка содержит только английские буквы. Пример: get_closest_vowel(""yogurt"") ==> ""u"" get_closest_vowel(""FULL"") ==> ""U"" get_closest_vowel(""quick"") ==> """" get_closest_vowel(""ab"") ==> """"""""""
","['assert get_closest_vowel(""yogurt"") == ""u""', 'assert get_closest_vowel(""full"") == ""u""', 'assert get_closest_vowel(""easy"") == """"', 'assert get_closest_vowel(""eAsy"") == """"', 'assert get_closest_vowel(""ali"") == """"', 'assert get_closest_vowel(""bad"") == ""a""', 'assert get_closest_vowel(""most"") == ""o""', 'assert get_closest_vowel(""ab"") == """"', 'assert get_closest_vowel(""ba"") == """"', 'assert get_closest_vowel(""quick"") == """"', 'assert get_closest_vowel(""anime"") == ""i""', 'assert get_closest_vowel(""Asia"") == """"', 'assert get_closest_vowel(""Above"") == ""o"" # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/118
"
def match_parens(lst):
    '''
    You are given a list of two strings, both strings consist of open
    parentheses '(' or close parentheses ')' only.
    Your job is to check if it is possible to concatenate the two strings in
    some order, that the resulting string will be good.
    A string S is considered to be good if and only if all parentheses in S
    are balanced. For example: the string '(())()' is good, while the string
    '())' is not.
    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.

    Examples:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''
","[""assert match_parens(['()(', ')']) == 'Yes'"", ""assert match_parens([')', ')']) == 'No'"", ""assert match_parens(['(()(())', '())())']) == 'No'"", ""assert match_parens([')())', '(()()(']) == 'Yes'"", ""assert match_parens(['(())))', '(()())((']) == 'Yes'"", ""assert match_parens(['()', '())']) == 'No'"", ""assert match_parens(['(()(', '()))()']) == 'Yes'"", ""assert match_parens(['((((', '((())']) == 'No'"", ""assert match_parens([')(()', '(()(']) == 'No'"", ""assert match_parens([')(', ')(']) == 'No' # Check some edge cases that are easy to work out by hand."", ""assert match_parens(['(', ')']) == 'Yes'"", ""assert match_parens([')', '(']) == 'Yes'""]",HumanEval/119
"
def maximum(arr, k):
    """"""Дан массив arr целых чисел и положительное целое число k, вернуть отсортированный список длины k с максимальным количеством k чисел в arr. Пример 1: Ввод: arr = [-3, -4, 5], k = 3 Вывод: [-4, -3, 5] Пример 2: Ввод: arr = [4, -4, 4], k = 2 Вывод: [4, 4] Пример 3: Ввод: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1 Вывод: [2] Примечание: 1. Длина массива будет находиться в диапазоне [1, 1000]. 2. Элементы массива будут находиться в диапазоне [-1000, 1000]. 3. 0 <= k <= len(arr)""""""
","['assert maximum([-3, -4, 5], 3) == [-4, -3, 5]', 'assert maximum([4, -4, 4], 2) == [4, 4]', 'assert maximum([-3, 2, 1, 2, -1, -2, 1], 1) == [2]', 'assert maximum([123, -123, 20, 0 , 1, 2, -3], 3) == [2, 20, 123]', 'assert maximum([-123, 20, 0 , 1, 2, -3], 4) == [0, 1, 2, 20]', 'assert maximum([5, 15, 0, 3, -13, -8, 0], 7) == [-13, -8, 0, 0, 3, 5, 15]', 'assert maximum([-1, 0, 2, 5, 3, -10], 2) == [3, 5]', 'assert maximum([1, 0, 5, -7], 1) == [5]', 'assert maximum([4, -4], 2) == [-4, 4]', 'assert maximum([-10, 10], 2) == [-10, 10] # Check some edge cases that are easy to work out by hand.', 'assert maximum([1, 2, 3, -23, 243, -400, 0], 0) == []']",HumanEval/120
"
def solution(lst):
    """""" Дан непустой список целых чисел, вернуть сумму всех нечетных элементов, которые находятся на четных позициях. Примеры решение([5, 8, 7, 1]) ==> 12 решение([3, 3, 3, 3, 3]) ==> 9 решение([30, 13, 24, 321]) ==>0""""""
","['assert solution([5, 8, 7, 1]) == 12', 'assert solution([3, 3, 3, 3, 3]) == 9', 'assert solution([30, 13, 24, 321]) == 0', 'assert solution([5, 9]) == 5', 'assert solution([2, 4, 8]) == 0', 'assert solution([30, 13, 23, 32]) == 23', 'assert solution([3, 13, 2, 9]) == 3 # Check some edge cases that are easy to work out by hand.']",HumanEval/121
"
def add_elements(arr, k):
    """"""Дан непустой массив целых чисел arr и целое число k, вернуть сумму элементов с не более чем двумя цифрами из первых k элементов arr. Пример: Вход: arr = [111,21,3,4000,5,6,7,8,9], k = 4 Выход: 24 # сумма 21 + 3 Ограничения: 1. 1 <= len(arr) <= 100 2. 1 <= k <= len(arr)""""""
","['assert add_elements([1,-2,-3,41,57,76,87,88,99], 3) == -4', 'assert add_elements([111,121,3,4000,5,6], 2) == 0', 'assert add_elements([11,21,3,90,5,6,7,8,9], 4) == 125', 'assert add_elements([111,21,3,4000,5,6,7,8,9], 4) == 24, ""This prints if this assert fails 1 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert add_elements([1], 1) == 1, ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/122
"
def get_odd_collatz(n):
    """"""Дано положительное целое число n, вернуть отсортированный список, содержащий нечетные числа в последовательности Коллатца. Гипотеза Коллатца — это гипотеза в математике, которая касается последовательности, определяемой следующим образом: начать с любого положительного целого числа n. Затем каждый член получается из предыдущего следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член равен предыдущему члену в 3 раза больше плюс 1. Гипотеза заключается в том, что независимо от значения n последовательность всегда достигнет 1. Примечание: 1. Collatz(1) — это [1]. 2. возвращенный список, отсортированный по возрастанию. Например: get_odd_collatz(5) возвращает [1, 5] # Последовательность Коллатца для 5 равна [5, 16, 8, 4, 2, 1], поэтому нечетными числами являются только 1 и 5.""""""
","['assert get_odd_collatz(14) == [1, 5, 7, 11, 13, 17]', 'assert get_odd_collatz(5) == [1, 5]', 'assert get_odd_collatz(12) == [1, 3, 5], ""This prints if this assert fails 1 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert get_odd_collatz(1) == [1], ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/123
"
def valid_date(date):
    """"""Вам нужно написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False. Дата действительна, если выполняются все следующие правила: 1. Строка даты не пуста. 2. Количество дней не меньше 1 и не больше 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней не меньше 1 и не больше 30 дней для месяцев 4,6,9,11. И количество дней не должно быть меньше 1 или больше 29 для месяца 2. 3. Месяцы не должны быть меньше 1 или больше 12. 4. Дата должна быть в формате: мм-дд-гггг, например: valid_date('03-11-2000') => True valid_date('15-01-2012') => False valid_date('04-0-2040') => False valid_date('06-04-2020') => True valid_date('06/04/2020') => False""""""
","[""assert valid_date('03-11-2000') == True"", ""assert valid_date('15-01-2012') == False"", ""assert valid_date('04-0-2040') == False"", ""assert valid_date('06-04-2020') == True"", ""assert valid_date('01-01-2007') == True"", ""assert valid_date('03-32-2011') == False"", ""assert valid_date('') == False"", ""assert valid_date('04-31-3000') == False"", ""assert valid_date('06-06-2005') == True"", ""assert valid_date('21-31-2000') == False"", ""assert valid_date('04-12-2003') == True"", ""assert valid_date('04122003') == False"", ""assert valid_date('20030412') == False"", ""assert valid_date('2003-04') == False"", ""assert valid_date('2003-04-12') == False"", ""assert valid_date('04-2003') == False""]",HumanEval/124
"
def split_words(txt):
    '''
    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Examples
    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
    split_words(""abcdef"") == 3 
    '''
","['assert split_words(""Hello world!"") == [""Hello"",""world!""]', 'assert split_words(""Hello,world!"") == [""Hello"",""world!""]', 'assert split_words(""Hello world,!"") == [""Hello"",""world,!""]', 'assert split_words(""Hello,Hello,world !"") == [""Hello,Hello,world"",""!""]', 'assert split_words(""abcdef"") == 3', 'assert split_words(""aaabb"") == 2', 'assert split_words(""aaaBb"") == 1', 'assert split_words("""") == 0']",HumanEval/125
"
def is_sorted(lst):
    '''
    Given a list of numbers, return whether or not they are sorted
    in ascending order. If list has more than 1 duplicate of the same
    number, return False. Assume no negative numbers and only integers.

    Examples
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''
","['assert is_sorted([5]) == True', 'assert is_sorted([1, 2, 3, 4, 5]) == True', 'assert is_sorted([1, 3, 2, 4, 5]) == False', 'assert is_sorted([1, 2, 3, 4, 5, 6]) == True', 'assert is_sorted([1, 2, 3, 4, 5, 6, 7]) == True', 'assert is_sorted([1, 3, 2, 4, 5, 6, 7]) == False, ""This prints if this assert fails 1 (good for debugging!)""', 'assert is_sorted([]) == True, ""This prints if this assert fails 2 (good for debugging!)""', 'assert is_sorted([1]) == True, ""This prints if this assert fails 3 (good for debugging!)""', 'assert is_sorted([3, 2, 1]) == False, ""This prints if this assert fails 4 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert is_sorted([1, 2, 2, 2, 3, 4]) == False, ""This prints if this assert fails 5 (good for debugging!)""', 'assert is_sorted([1, 2, 3, 3, 3, 4]) == False, ""This prints if this assert fails 6 (good for debugging!)""', 'assert is_sorted([1, 2, 2, 3, 3, 4]) == True, ""This prints if this assert fails 7 (good for debugging!)""', 'assert is_sorted([1, 2, 3, 4]) == True, ""This prints if this assert fails 8 (good for debugging!)""']",HumanEval/126
"
def intersection(interval1, interval2):
    """"""Вам даны два интервала, каждый из которых представляет собой пару целых чисел. Например, интервал = (начало, конец) = (1, 2). Данные интервалы являются замкнутыми, что означает, что интервал (начало, конец) включает в себя как начало, так и конец. Для каждого данного интервала предполагается, что его начало меньше или равно его концу. Ваша задача — определить, является ли длина пересечения этих двух интервалов простым числом. Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3), длина которого равна 1, что не является простым числом. Если длина пересечения является простым числом, верните «ДА», в противном случае верните «НЕТ». Если два интервала не пересекаются, верните «НЕТ». [вход/выход] образцы: пересечение((1, 2), (2, 3)) ==> ""НЕТ"" пересечение((-1, 1), (0, 4)) ==> ""НЕТ"" пересечение((-3, -1), (-5, 5)) ==> ""ДА""""""""
","['assert intersection((1, 2), (2, 3)) == ""NO""', 'assert intersection((-1, 1), (0, 4)) == ""NO""', 'assert intersection((-3, -1), (-5, 5)) == ""YES""', 'assert intersection((-2, 2), (-4, 0)) == ""YES"" # Check some edge cases that are easy to work out by hand.', 'assert intersection((-11, 2), (-1, -1)) == ""NO""', 'assert intersection((1, 2), (3, 5)) == ""NO""', 'assert intersection((1, 2), (1, 2)) == ""NO""', 'assert intersection((-2, -2), (-3, -2)) == ""NO""']",HumanEval/127
"
def prod_signs(arr):
    """"""Вам дан массив arr целых чисел, и вам нужно вернуть сумму величин целых чисел, умноженных на произведение всех знаков каждого числа в массиве, представленных как 1, -1 или 0. Примечание: вернуть None для пустого arr. Пример: >>> prod_signs([1, 2, 2, -4]) == -9 >>> prod_signs([0, 1]) == 0 >>> prod_signs([]) == None""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert prod_signs([1, 2, 2, -4]) == -9', 'assert prod_signs([0, 1]) == 0', 'assert prod_signs([1, 1, 1, 2, 3, -1, 1]) == -10', 'assert prod_signs([]) == None', 'assert prod_signs([2, 4,1, 2, -1, -1, 9]) == 20', 'assert prod_signs([-1, 1, -1, 1]) == 4', 'assert prod_signs([-1, 1, 1, 1]) == -4', 'assert prod_signs([-1, 1, 1, 0]) == 0 # 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!)""']",HumanEval/128
"
def minPath(grid, k):
    """"""Дана сетка с N строками и N столбцами (N >= 2) и положительное целое число k, каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N] включительно встречается ровно один раз в ячейках сетки. Вам нужно найти минимальный путь длины k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти в любую из соседних ячеек, другими словами, вы можете перейти в ячейки, которые имеют общее ребро с вашей текущей ячейкой. Обратите внимание, что путь длины k означает посещение ровно k ячеек (не обязательно различных). Вы НЕ МОЖЕТЕ выйти за пределы сетки. Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после создания упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше lst_B, другими словами, существует целый индекс i (1 <= i <= k) такой, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) имеем lst_A[j] = lst_B[j]. Гарантируется, что ответ уникален. Верните упорядоченный список значений в ячейках, через которые проходит минимальный путь. Примеры: Входные данные: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3 Выходные данные: [1, 2, 1] Входные данные: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1 Выходные данные: [1]""""""
","['assert minPath([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3) == [1, 2, 1]', 'assert minPath([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1) == [1]', 'assert minPath([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 4) == [1, 2, 1, 2]', 'assert minPath([[6, 4, 13, 10], [5, 7, 12, 1], [3, 16, 11, 15], [8, 14, 9, 2]], 7) == [1, 10, 1, 10, 1, 10, 1]', 'assert minPath([[8, 14, 9, 2], [6, 4, 13, 15], [5, 7, 1, 12], [3, 10, 11, 16]], 5) == [1, 7, 1, 7, 1]', 'assert minPath([[11, 8, 7, 2], [5, 16, 14, 4], [9, 3, 15, 6], [12, 13, 10, 1]], 9) == [1, 6, 1, 6, 1, 6, 1, 6, 1]', 'assert minPath([[12, 13, 10, 1], [9, 3, 15, 6], [5, 16, 14, 4], [11, 8, 7, 2]], 12) == [1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6]', 'assert minPath([[2, 7, 4], [3, 1, 5], [6, 8, 9]], 8) == [1, 3, 1, 3, 1, 3, 1, 3]', 'assert minPath([[6, 1, 5], [3, 8, 9], [2, 7, 4]], 8) == [1, 5, 1, 5, 1, 5, 1, 5] # Check some edge cases that are easy to work out by hand.', 'assert minPath([[1, 2], [3, 4]], 10) == [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]', 'assert minPath([[1, 3], [3, 2]], 10) == [1, 3, 1, 3, 1, 3, 1, 3, 1, 3]']",HumanEval/129
"
def tri(n):
    """"""Все знают последовательность Фибоначчи, она была глубоко изучена математиками в последние пару столетий. Однако, чего люди не знают, так это последовательности Трибоначчи. Последовательность Трибоначчи определяется рекуррентностью: tri(1) = 3 tri(n) = 1 + n / 2, если n четное. tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетное. Например: tri(2) = 1 + (2 / 2) = 2 tri(4) = 3 tri(3) = tri(2) + tri(1) + tri(4) = 2 + 3 + 3 = 8 Вам дано неотрицательное целое число n, вы должны вернуть список первых n + 1 чисел последовательности Трибоначчи. Примеры: tri(3) = [1, 3, 2, 8]""""""
","['assert tri(3) == [1, 3, 2.0, 8.0]', 'assert tri(4) == [1, 3, 2.0, 8.0, 3.0]', 'assert tri(5) == [1, 3, 2.0, 8.0, 3.0, 15.0]', 'assert tri(6) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0]', 'assert tri(7) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0]', 'assert tri(8) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0]', 'assert tri(9) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0]', 'assert tri(20) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0, 6.0, 48.0, 7.0, 63.0, 8.0, 80.0, 9.0, 99.0, 10.0, 120.0, 11.0] # Check some edge cases that are easy to work out by hand.', 'assert tri(0) == [1]', 'assert tri(1) == [1, 3]']",HumanEval/130
"
def digits(n):
    """""" Дано положительное целое число n, вернуть произведение нечетных цифр. Верните 0, если все цифры четные. Например: digits(1) == 1 digits(4) == 0 digits(235) == 15""""""
","['assert digits(5) == 5', 'assert digits(54) == 5', 'assert digits(120) ==1', 'assert digits(5014) == 5', 'assert digits(98765) == 315', 'assert digits(5576543) == 2625 # Check some edge cases that are easy to work out by hand.', 'assert digits(2468) == 0']",HumanEval/131
"
def is_nested(string):
    '''
    Create a function that takes a string as input which contains only square brackets.
    The function should return True if and only if there is a valid subsequence of brackets 
    where at least one bracket in the subsequence is nested.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''
","['assert is_nested(\'[[]]\') == True, ""This prints if this assert fails 1 (good for debugging!)""', ""assert is_nested('[]]]]]]][[[[[]') == False"", ""assert is_nested('[][]') == False"", ""assert is_nested(('[]')) == False"", ""assert is_nested('[[[[]]]]') == True"", ""assert is_nested('[]]]]]]]]]]') == False"", ""assert is_nested('[][][[]]') == True"", ""assert is_nested('[[]') == False"", ""assert is_nested('[]]') == False"", ""assert is_nested('[[]][[') == True"", ""assert is_nested('[[][]]') == True # Check some edge cases that are easy to work out by hand."", 'assert is_nested(\'\') == False, ""This prints if this assert fails 2 (also good for debugging!)""', ""assert is_nested('[[[[[[[[') == False"", ""assert is_nested(']]]]]]]]') == False""]",HumanEval/132
"

def sum_squares(lst):
    """"""Вам дан список чисел. Вам нужно вернуть сумму квадратов чисел в данном списке, округлив каждый элемент в списке до верхнего int(Ceiling) сначала. Примеры: Для lst = [1,2,3] вывод должен быть 14 Для lst = [1,4,9] вывод должен быть 98 Для lst = [1,3,5,7] вывод должен быть 84 Для lst = [1.4,4.2,0] вывод должен быть 29 Для lst = [-2.4,1,1] вывод должен быть 6""""""
","['assert sum_squares([1,2,3])==14, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([1.0,2,3])==14, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([1,3,5,7])==84, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([1.4,4.2,0])==29, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([-2.4,1,1])==6, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([100,1,15,2])==10230, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([10000,10000])==200000000, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([-1.4,4.6,6.3])==75, ""This prints if this assert fails 1 (good for debugging!)""', 'assert sum_squares([-1.4,17.9,18.9,19.9])==1086, ""This prints if this assert fails 1 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert sum_squares([0])==0, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert sum_squares([-1])==1, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert sum_squares([-1,1,0])==2, ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/133
"
def check_if_last_char_is_a_letter(txt):
    '''
    Create a function that returns True if the last character
    of a given string is an alphabetical character and is not
    a part of a word, and False otherwise.
    Note: ""word"" is a group of characters separated by space.

    Examples:
    check_if_last_char_is_a_letter(""apple pie"") ➞ False
    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
    check_if_last_char_is_a_letter("""") ➞ False 
    '''
","['assert check_if_last_char_is_a_letter(""apple"") == False', 'assert check_if_last_char_is_a_letter(""apple pi e"") == True', 'assert check_if_last_char_is_a_letter(""eeeee"") == False', 'assert check_if_last_char_is_a_letter(""A"") == True', 'assert check_if_last_char_is_a_letter(""Pumpkin pie "") == False', 'assert check_if_last_char_is_a_letter(""Pumpkin pie 1"") == False', 'assert check_if_last_char_is_a_letter("""") == False', 'assert check_if_last_char_is_a_letter(""eeeee e "") == False', 'assert check_if_last_char_is_a_letter(""apple pie"") == False', 'assert check_if_last_char_is_a_letter(""apple pi e "") == False # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/134
"
def can_arrange(arr):
    """""" Создайте функцию, которая возвращает наибольший индекс элемента, который не больше или равен элементу, непосредственно предшествующему ему. Если такого элемента не существует, то верните -1. Данный массив не будет содержать повторяющихся значений. Примеры: can_arrange([1,2,4,3,5]) = 3 can_arrange([1,2,3]) = -1""""""
","['assert can_arrange([1,2,4,3,5])==3', 'assert can_arrange([1,2,4,5])==-1', 'assert can_arrange([1,4,2,5,6,7,8,9,10])==2', 'assert can_arrange([4,8,5,7,3])==4 # Check some edge cases that are easy to work out by hand.', 'assert can_arrange([])==-1']",HumanEval/135
"
def largest_smallest_integers(lst):
    '''
    Create a function that returns a tuple (a, b), where 'a' is
    the largest of negative integers, and 'b' is the smallest
    of positive integers in a list.
    If there is no negative or positive integers, return them as None.

    Examples:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''
","['assert largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)', 'assert largest_smallest_integers([2, 4, 1, 3, 5, 7, 0]) == (None, 1)', 'assert largest_smallest_integers([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)', 'assert largest_smallest_integers([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)', 'assert largest_smallest_integers([7, 3, 8, 4, 9, 2, 5, -9]) == (-9, 2)', 'assert largest_smallest_integers([]) == (None, None)', 'assert largest_smallest_integers([0]) == (None, None)', 'assert largest_smallest_integers([-1, -3, -5, -6]) == (-1, None)', 'assert largest_smallest_integers([-1, -3, -5, -6, 0]) == (-1, None)', 'assert largest_smallest_integers([-6, -4, -4, -3, 1]) == (-3, 1)', 'assert largest_smallest_integers([-6, -4, -4, -3, -100, 1]) == (-3, 1) # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/136
"
def compare_one(a, b):
    """"""Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает большую переменную в заданном типе переменной. Возвращает None, если значения равны. Примечание: если действительное число представлено как строка, плавающая точка может быть . или , compare_one(1, 2.5) ➞ 2.5 compare_one(1, ""2,3"") ➞ ""2,3"" compare_one(""5,1"", ""6"") ➞ ""6"" compare_one(""1"", 1) ➞ None""""""
","['assert compare_one(1, 2) == 2', 'assert compare_one(1, 2.5) == 2.5', 'assert compare_one(2, 3) == 3', 'assert compare_one(5, 6) == 6', 'assert compare_one(1, ""2,3"") == ""2,3""', 'assert compare_one(""5,1"", ""6"") == ""6""', 'assert compare_one(""1"", ""2"") == ""2""', 'assert compare_one(""1"", 1) == None # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/137
"
def is_equal_to_sum_even(n):
    """""" Оцените, можно ли записать заданное число n в виде суммы ровно 4 положительных четных чисел. Пример is_equal_to_sum_even(4) == False is_equal_to_sum_even(6) == False is_equal_to_sum_even(8) == True""""""
","['assert is_equal_to_sum_even(4) == False', 'assert is_equal_to_sum_even(6) == False', 'assert is_equal_to_sum_even(8) == True', 'assert is_equal_to_sum_even(10) == True', 'assert is_equal_to_sum_even(11) == False', 'assert is_equal_to_sum_even(12) == True', 'assert is_equal_to_sum_even(13) == False', 'assert is_equal_to_sum_even(16) == True']",HumanEval/138
"
def special_factorial(n):
    """""" Бразильский факториал определяется как: brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1! где n > 0 Например: >>> special_factorial(4) 288 Функция получит целое число в качестве входных данных и должна вернуть специальный факториал этого целого числа.""""""
","['assert special_factorial(4) == 288, ""Test 4""', 'assert special_factorial(5) == 34560, ""Test 5""', 'assert special_factorial(7) == 125411328000, ""Test 7"" # Check some edge cases that are easy to work out by hand.', 'assert special_factorial(1) == 1, ""Test 1""']",HumanEval/139
"
def fix_spaces(text):
    """"""Дана строка текста, замените все пробелы в ней на подчеркивания, а если в строке более 2 последовательных пробелов, то замените все последовательные пробелы на - fix_spaces(""Example"") == ""Example"" fix_spaces(""Example 1"") == ""Example_1"" fix_spaces("" Example 2"") == ""_Example_2"" fix_spaces("" Example 3"") == ""_Example-3""""""""
","['assert fix_spaces(""Example"") == ""Example"", ""This prints if this assert fails 1 (good for debugging!)""', 'assert fix_spaces(""Mudasir Hanif "") == ""Mudasir_Hanif_"", ""This prints if this assert fails 2 (good for debugging!)""', 'assert fix_spaces(""Yellow Yellow Dirty Fellow"") == ""Yellow_Yellow__Dirty__Fellow"", ""This prints if this assert fails 3 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert fix_spaces(""Exa mple"") == ""Exa-mple"", ""This prints if this assert fails 4 (good for debugging!)""', 'assert fix_spaces("" Exa 1 2 2 mple"") == ""-Exa_1_2_2_mple"", ""This prints if this assert fails 4 (good for debugging!)""']",HumanEval/140
"
def file_name_check(file_name):
    """"""Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает «Да», если имя файла допустимо, и возвращает «Нет» в противном случае. Имя файла считается допустимым, если и только если выполнены все следующие условия: - В имени файла не должно быть более трех цифр ('0'-'9'). - Имя файла содержит ровно одну точку '.' - Подстрока перед точкой не должна быть пустой и начинаться с буквы латинского алфавита ('a'-'z' и 'A'-'Z'). - Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll'] Примеры: file_name_check(""example.txt"") # => 'Да' file_name_check(""1example.dll"") # => 'Нет' (имя должно начинаться с буквы латинского алфавита)""""""
","['assert file_name_check(""example.txt"") == \'Yes\'', 'assert file_name_check(""1example.dll"") == \'No\'', ""assert file_name_check('s1sdf3.asd') == 'No'"", ""assert file_name_check('K.dll') == 'Yes'"", ""assert file_name_check('MY16FILE3.exe') == 'Yes'"", ""assert file_name_check('His12FILE94.exe') == 'No'"", ""assert file_name_check('_Y.txt') == 'No'"", ""assert file_name_check('?aREYA.exe') == 'No'"", ""assert file_name_check('/this_is_valid.dll') == 'No'"", ""assert file_name_check('this_is_valid.wow') == 'No'"", ""assert file_name_check('this_is_valid.txt') == 'Yes'"", ""assert file_name_check('this_is_valid.txtexe') == 'No'"", ""assert file_name_check('#this2_i4s_5valid.ten') == 'No'"", ""assert file_name_check('@this1_is6_valid.exe') == 'No'"", ""assert file_name_check('this_is_12valid.6exe4.txt') == 'No'"", ""assert file_name_check('all.exe.txt') == 'No'"", ""assert file_name_check('I563_No.exe') == 'Yes'"", ""assert file_name_check('Is3youfault.txt') == 'Yes'"", ""assert file_name_check('no_one#knows.dll') == 'Yes'"", ""assert file_name_check('1I563_Yes3.exe') == 'No'"", ""assert file_name_check('I563_Yes3.txtt') == 'No'"", ""assert file_name_check('final..txt') == 'No'"", ""assert file_name_check('final132') == 'No'"", ""assert file_name_check('_f4indsartal132.') == 'No' # Check some edge cases that are easy to work out by hand."", ""assert file_name_check('.txt') == 'No'"", ""assert file_name_check('s.') == 'No'""]",HumanEval/141
"


def sum_squares(lst):
    """"""""Эта функция примет список целых чисел. Для всех записей в списке функция возведет в квадрат запись целого числа, если ее индекс кратен 3, и возведет в куб запись целого числа, если ее индекс кратен 4, но не кратен 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция вернет сумму всех записей. Примеры: Для lst = [1,2,3] вывод должен быть 6 Для lst = [] вывод должен быть 0 Для lst = [-1,-5,2,-1,-5] вывод должен быть -126""""""
","['assert sum_squares([1,2,3]) == 6', 'assert sum_squares([1,4,9]) == 14', 'assert sum_squares([]) == 0', 'assert sum_squares([1,1,1,1,1,1,1,1,1]) == 9', 'assert sum_squares([-1,-1,-1,-1,-1,-1,-1,-1,-1]) == -3', 'assert sum_squares([0]) == 0', 'assert sum_squares([-1,-5,2,-1,-5]) == -126', 'assert sum_squares([-56,-99,1,0,-2]) == 3030', 'assert sum_squares([-1,0,0,0,0,0,0,0,-1]) == 0', 'assert sum_squares([-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37]) == -14196', ""assert sum_squares([-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10]) == -1448 # Don't remove this line:""]",HumanEval/142
"
def words_in_sentence(sentence):
    """"""Вам дана строка, представляющая предложение, предложение содержит несколько слов, разделенных пробелом, и вы должны вернуть строку, содержащую слова из исходного предложения, длины которых являются простыми числами, порядок слов в новой строке должен быть таким же, как и в исходной. Пример 1: Ввод: предложение = ""Это тест"" Вывод: ""есть"" Пример 2: Ввод: предложение = ""пойдем плавать"" Вывод: ""пойдем"" Ограничения: * 1 <= len(предложение) <= 100 * предложение содержит только буквы""""""
","['assert words_in_sentence(""This is a test"") == ""is""', 'assert words_in_sentence(""lets go for swimming"") == ""go for""', 'assert words_in_sentence(""there is no place available here"") == ""there is no place""', 'assert words_in_sentence(""Hi I am Hussein"") == ""Hi am Hussein""', 'assert words_in_sentence(""go for it"") == ""go for it"" # Check some edge cases that are easy to work out by hand.', 'assert words_in_sentence(""here"") == """"', 'assert words_in_sentence(""here is"") == ""is""']",HumanEval/143
"
def simplify(x, n):
    """"""Ваша задача — реализовать функцию, которая упростит выражение x * n. Функция возвращает True, если x * n вычисляется как целое число, и False в противном случае. Оба значения x и n являются строковыми представлениями дроби и имеют следующий формат: <числитель>/<знаменатель>, где и числитель, и знаменатель являются положительными целыми числами. Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя. simplify(""1/5"", ""5/1"") = True simplify(""1/6"", ""2/1"") = False simplify(""7/10"", ""10/2"") = False""""""
","['assert simplify(""1/5"", ""5/1"") == True, \'test1\'', 'assert simplify(""1/6"", ""2/1"") == False, \'test2\'', 'assert simplify(""5/1"", ""3/1"") == True, \'test3\'', 'assert simplify(""7/10"", ""10/2"") == False, \'test4\'', 'assert simplify(""2/10"", ""50/10"") == True, \'test5\'', 'assert simplify(""7/2"", ""4/2"") == True, \'test6\'', 'assert simplify(""11/6"", ""6/1"") == True, \'test7\'', 'assert simplify(""2/3"", ""5/2"") == False, \'test8\'', 'assert simplify(""5/2"", ""3/5"") == False, \'test9\'', 'assert simplify(""2/4"", ""8/4"") == True, \'test10\' # Check some edge cases that are easy to work out by hand.', 'assert simplify(""2/4"", ""4/2"") == True, \'test11\'', 'assert simplify(""1/5"", ""5/1"") == True, \'test12\'', 'assert simplify(""1/5"", ""1/5"") == False, \'test13\'']",HumanEval/144
"
def order_by_points(nums):
    """""" Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания в соответствии с суммой их цифр. Примечание: если есть несколько элементов с одинаковой суммой их цифр, упорядочите их на основе их индекса в исходном списке. Например: >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11] >>> order_by_points([]) == []""""""
","['assert order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]', 'assert order_by_points([1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]) == [0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]', 'assert order_by_points([]) == []', 'assert order_by_points([1, -11, -32, 43, 54, -98, 2, -3]) == [-3, -32, -98, -11, 1, 2, 43, 54]', 'assert order_by_points([1,2,3,4,5,6,7,8,9,10,11]) == [1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]', 'assert order_by_points([0,6,6,-76,-21,23,4]) == [-76, -21, 0, 4, 23, 6, 6] # Check some edge cases that are easy to work out by hand.', 'assert True, ""This prints if this assert fails 2 (also good for debugging!)""']",HumanEval/145
"
def specialFilter(nums):
    """"""Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, которые больше 10, и обе первые и последние цифры числа нечетные (1, 3, 5, 7, 9). Например: specialFilter([15, -73, 14, -15]) => 1 specialFilter([33, -2, -3, 45, 21, 109]) => 2""""""
","['assert specialFilter([5, -2, 1, -5]) == 0', 'assert specialFilter([15, -73, 14, -15]) == 1', 'assert specialFilter([33, -2, -3, 45, 21, 109]) == 2', 'assert specialFilter([43, -12, 93, 125, 121, 109]) == 4', 'assert specialFilter([71, -2, -33, 75, 21, 19]) == 3 # Check some edge cases that are easy to work out by hand.', 'assert specialFilter([1]) == 0', 'assert specialFilter([]) == 0']",HumanEval/146
"
def get_max_triples(n):
    """""" Вам дано положительное целое число n. Вам нужно создать целочисленный массив a длины n. Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1. Верните количество троек (a[i], a[j], a[k]) элемента a, где i < j < k, а a[i] + a[j] + a[k] кратно 3. Пример: Вход: n = 5 Выход: 1 Объяснение: a = [1, 3, 7, 13, 21] Единственная допустимая тройка — (1, 7, 13).""""""
","['assert get_max_triples(5) == 1', 'assert get_max_triples(6) == 4', 'assert get_max_triples(10) == 36', 'assert get_max_triples(100) == 53361']",HumanEval/147
"
def bf(planet1, planet2):
    '''
    There are eight planets in our solar system: the closerst to the Sun 
    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
    Uranus, Neptune.
    Write a function that takes two planet names as strings planet1 and planet2. 
    The function should return a tuple containing all planets whose orbits are 
    located between the orbit of planet1 and the orbit of planet2, sorted by 
    the proximity to the sun. 
    The function should return an empty tuple if planet1 or planet2
    are not correct planet names. 
    Examples
    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
    bf(""Earth"", ""Mercury"") ==> (""Venus"")
    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
    '''
","['assert bf(""Jupiter"", ""Neptune"") == (""Saturn"", ""Uranus""), ""First test error: "" + str(len(bf(""Jupiter"", ""Neptune"")))', 'assert bf(""Earth"", ""Mercury"") == (""Venus"",), ""Second test error: "" + str(bf(""Earth"", ""Mercury""))', 'assert bf(""Mercury"", ""Uranus"") == (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn""), ""Third test error: "" + str(bf(""Mercury"", ""Uranus""))', 'assert bf(""Neptune"", ""Venus"") == (""Earth"", ""Mars"", ""Jupiter"", ""Saturn"", ""Uranus""), ""Fourth test error: "" + str(bf(""Neptune"", ""Venus"")) # Check some edge cases that are easy to work out by hand.', 'assert bf(""Earth"", ""Earth"") == ()', 'assert bf(""Mars"", ""Earth"") == ()', 'assert bf(""Jupiter"", ""Makemake"") == ()']",HumanEval/148
"
def sorted_list_sum(lst):
    """"""Напишите функцию, которая принимает список строк в качестве параметра, удаляет из него строки нечетной длины и возвращает результирующий список в отсортированном порядке. Список всегда является списком строк и никогда не является массивом чисел, и он может содержать дубликаты. Порядок списка должен быть возрастающим по длине каждого слова, и вы должны вернуть список, отсортированный по этому правилу. Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке. Функция должна возвращать список строк в отсортированном порядке. Вы можете предположить, что все слова будут иметь одинаковую длину. Например: assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""] assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]""""""
","['assert sorted_list_sum([""aa"", ""a"", ""aaa""]) == [""aa""]', 'assert sorted_list_sum([""school"", ""AI"", ""asdf"", ""b""]) == [""AI"", ""asdf"", ""school""]', 'assert sorted_list_sum([""d"", ""b"", ""c"", ""a""]) == []', 'assert sorted_list_sum([""d"", ""dcba"", ""abcd"", ""a""]) == [""abcd"", ""dcba""] # Check some edge cases that are easy to work out by hand.', 'assert sorted_list_sum([""AI"", ""ai"", ""au""]) == [""AI"", ""ai"", ""au""]', 'assert sorted_list_sum([""a"", ""b"", ""b"", ""c"", ""c"", ""a""]) == []', 'assert sorted_list_sum([\'aaaa\', \'bbbb\', \'dd\', \'cc\']) == [""cc"", ""dd"", ""aaaa"", ""bbbb""]']",HumanEval/149
"
def x_or_y(n, x, y):
    """"""Простая программа, которая должна возвращать значение x, если n является простым числом, и должна возвращать значение y в противном случае. Примеры: for x_or_y(7, 34, 12) == 34 for x_or_y(15, 8, 5) == 5""""""
","['assert x_or_y(7, 34, 12) == 34', 'assert x_or_y(15, 8, 5) == 5', 'assert x_or_y(3, 33, 5212) == 33', 'assert x_or_y(1259, 3, 52) == 3', 'assert x_or_y(7919, -1, 12) == -1', 'assert x_or_y(3609, 1245, 583) == 583', 'assert x_or_y(91, 56, 129) == 129', 'assert x_or_y(6, 34, 1234) == 1234 # Check some edge cases that are easy to work out by hand.', 'assert x_or_y(1, 2, 0) == 0', 'assert x_or_y(2, 2, 0) == 2']",HumanEval/150
"
def double_the_difference(lst):
    '''
    Given a list of numbers, return the sum of squares of the numbers
    in the list that are odd. Ignore numbers that are negative or not integers.
    
    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0  
   
    If the input list is empty, return 0.
    '''
","['assert double_the_difference([]) == 0 , ""This prints if this assert fails 1 (good for debugging!)""', 'assert double_the_difference([5, 4]) == 25 , ""This prints if this assert fails 2 (good for debugging!)""', 'assert double_the_difference([0.1, 0.2, 0.3]) == 0 , ""This prints if this assert fails 3 (good for debugging!)""', 'assert double_the_difference([-10, -20, -30]) == 0 , ""This prints if this assert fails 4 (good for debugging!)"" # Check some edge cases that are easy to work out by hand.', 'assert double_the_difference([-1, -2, 8]) == 0, ""This prints if this assert fails 5 (also good for debugging!)""', 'assert double_the_difference([0.2, 3, 5]) == 34, ""This prints if this assert fails 6 (also good for debugging!)"" lst = list(range(-99, 100, 2)) odd_sum = sum([i**2 for i in lst if i%2!=0 and i > 0])', 'assert double_the_difference(lst) == odd_sum , ""This prints if this assert fails 7 (good for debugging!)""']",HumanEval/151
"
def compare(game,guess):
    """""" Думаю, мы все помним это чувство, когда наконец становится известен результат какого-то долгожданного события. Чувства и мысли, которые у вас возникают в этот момент, определенно стоит записать и сравнить. Ваша задача — определить, правильно ли человек угадал результаты ряда матчей. Вам даны два массива оценок и догадок одинаковой длины, где каждый индекс показывает совпадение. Верните массив той же длины, обозначающий, насколько далеко отстояла каждая догадка. Если угадали правильно, значение равно 0, а если нет, то значение равно абсолютной разнице между догадкой и оценкой. пример: compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3] compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]""""""
","['assert compare([1,2,3,4,5,1],[1,2,3,4,2,-2])==[0,0,0,0,3,3], ""This prints if this assert fails 1 (good for debugging!)""', 'assert compare([0,0,0,0,0,0],[0,0,0,0,0,0])==[0,0,0,0,0,0], ""This prints if this assert fails 1 (good for debugging!)""', 'assert compare([1,2,3],[-1,-2,-3])==[2,4,6], ""This prints if this assert fails 1 (good for debugging!)""', 'assert compare([1,2,3,5],[-1,2,3,4])==[2,0,0,1], ""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!)""']",HumanEval/152
"
def Strongest_Extension(class_name, extensions):
    """"""Вам будет предоставлено имя класса (строка) и список расширений. Расширения будут использоваться для загрузки дополнительных классов в класс. Сила расширения следующая: пусть CAP будет количеством заглавных букв в имени расширения, а SM будет количеством строчных букв в имени расширения, сила задается дробью CAP - SM. Вам следует найти самое сильное расширение и вернуть строку в следующем формате: ClassName.StrongestExtensionName. Если есть два или более расширения с одинаковой силой, вам следует выбрать то, которое стоит первым в списке. Например, если вам предоставлен ""Slices"" в качестве класса и список расширений: ['SErviNGSliCes', 'Cheese', 'Stufed'], то вы должны вернуть 'Slices.SErviNGSliCes', поскольку 'SErviNGSliCes' является самым сильным расширением (его сила равна -1). Пример: для Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'""""""
","[""assert Strongest_Extension('Watashi', ['tEN', 'niNE', 'eIGHt8OKe']) == 'Watashi.eIGHt8OKe'"", ""assert Strongest_Extension('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']) == 'Boku123.YEs.WeCaNe'"", ""assert Strongest_Extension('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']) == '__YESIMHERE.NuLl__'"", ""assert Strongest_Extension('K', ['Ta', 'TAR', 't234An', 'cosSo']) == 'K.TAR'"", ""assert Strongest_Extension('__HAHA', ['Tab', '123', '781345', '-_-']) == '__HAHA.123'"", ""assert Strongest_Extension('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-']) == 'YameRore.okIWILL123'"", ""assert Strongest_Extension('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW']) == 'finNNalLLly.WoW' # Check some edge cases that are easy to work out by hand."", ""assert Strongest_Extension('_', ['Bb', '91245']) == '_.Bb'"", ""assert Strongest_Extension('Sp', ['671235', 'Bb']) == 'Sp.671235'""]",HumanEval/153
"
def cycpattern_check(a , b):
    """"""Вам даны 2 слова. Вам нужно вернуть True, если второе слово или любая из его ротаций является подстрокой в первом слове cycpattern_check(""abcd"",""abd"") => False cycpattern_check(""hello"",""ell"") => True cycpattern_check(""whassup"",""psus"") => False cycpattern_check(""abab"",""baa"") => True cycpattern_check(""efef"",""eeff"") => False cycpattern_check(""himenss"",""simen"") => True""""""
","['assert cycpattern_check(""xyzw"",""xyw"") == False , ""test #0""', 'assert cycpattern_check(""yello"",""ell"") == True , ""test #1""', 'assert cycpattern_check(""whattup"",""ptut"") == False , ""test #2""', 'assert cycpattern_check(""efef"",""fee"") == True , ""test #3""', 'assert cycpattern_check(""abab"",""aabb"") == False , ""test #4""', 'assert cycpattern_check(""winemtt"",""tinem"") == True , ""test #5""']",HumanEval/154
"
def even_odd_count(num):
    """""" Дано целое число. вернуть кортеж, который имеет количество четных и нечетных цифр соответственно. Пример: even_odd_count(-12) ==> (1, 1) even_odd_count(123) ==> (1, 2)""""""
","['assert even_odd_count(7) == (0, 1)', 'assert even_odd_count(-78) == (1, 1)', 'assert even_odd_count(3452) == (2, 2)', 'assert even_odd_count(346211) == (3, 3)', 'assert even_odd_count(-345821) == (3, 3)', 'assert even_odd_count(-2) == (1, 0)', 'assert even_odd_count(-45347) == (2, 3)', 'assert even_odd_count(0) == (1, 0) # Check some edge cases that are easy to work out by hand.', 'assert True']",HumanEval/155
"
def int_to_mini_roman(number):
    """"""Дано положительное целое число, получить его эквивалент в виде римской цифры в виде строки и вернуть его в нижнем регистре. Ограничения: 1 <= num <= 1000 Примеры: >>> int_to_mini_roman(19) == 'xix' >>> int_to_mini_roman(152) == 'clii' >>> int_to_mini_roman(426) == 'cdxxvi'""""""
","[""assert int_to_mini_roman(19) == 'xix'"", ""assert int_to_mini_roman(152) == 'clii'"", ""assert int_to_mini_roman(251) == 'ccli'"", ""assert int_to_mini_roman(426) == 'cdxxvi'"", ""assert int_to_mini_roman(500) == 'd'"", ""assert int_to_mini_roman(1) == 'i'"", ""assert int_to_mini_roman(4) == 'iv'"", ""assert int_to_mini_roman(43) == 'xliii'"", ""assert int_to_mini_roman(90) == 'xc'"", ""assert int_to_mini_roman(94) == 'xciv'"", ""assert int_to_mini_roman(532) == 'dxxxii'"", ""assert int_to_mini_roman(900) == 'cm'"", ""assert int_to_mini_roman(994) == 'cmxciv'"", ""assert int_to_mini_roman(1000) == 'm' # Check some edge cases that are easy to work out by hand."", 'assert True']",HumanEval/156
"
def right_angle_triangle(a, b, c):
    '''
    Given the lengths of the three sides of a triangle. Return True if the three
    sides form a right-angled triangle, False otherwise.
    A right-angled triangle is a triangle in which one angle is right angle or 
    90 degree.
    Example:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''
","['assert right_angle_triangle(3, 4, 5) == True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert right_angle_triangle(1, 2, 3) == False', 'assert right_angle_triangle(10, 6, 8) == True', 'assert right_angle_triangle(2, 2, 2) == False', 'assert right_angle_triangle(7, 24, 25) == True', 'assert right_angle_triangle(10, 5, 7) == False', 'assert right_angle_triangle(5, 12, 13) == True', 'assert right_angle_triangle(15, 8, 17) == True', 'assert right_angle_triangle(48, 55, 73) == True # Check some edge cases that are easy to work out by hand.', 'assert right_angle_triangle(1, 1, 1) == False, ""This prints if this assert fails 2 (also good for debugging!)""', 'assert right_angle_triangle(2, 2, 10) == False']",HumanEval/157
"
def find_max(words):
    """""" Напишите функцию, которая принимает список строк. Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк имеют максимальное количество уникальных символов, верните то, которое стоит первым в лексикографическом порядке. find_max([""name"", ""of"", ""string""]) == ""string"" find_max([""name"", ""enam"", ""game""]) == ""enam"" find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""""""""
","['assert (find_max([""name"", ""of"", ""string""]) == ""string""), ""t1""', 'assert (find_max([""name"", ""enam"", ""game""]) == ""enam""), \'t2\'', 'assert (find_max([""aaaaaaa"", ""bb"", ""cc""]) == ""aaaaaaa""), \'t3\'', 'assert (find_max([""abc"", ""cba""]) == ""abc""), \'t4\'', 'assert (find_max([""play"", ""this"", ""game"", ""of"",""footbott""]) == ""footbott""), \'t5\'', 'assert (find_max([""we"", ""are"", ""gonna"", ""rock""]) == ""gonna""), \'t6\'', 'assert (find_max([""we"", ""are"", ""a"", ""mad"", ""nation""]) == ""nation""), \'t7\'', 'assert (find_max([""this"", ""is"", ""a"", ""prrk""]) == ""this""), \'t8\' # Check some edge cases that are easy to work out by hand.', 'assert (find_max([""b""]) == ""b""), \'t9\'', 'assert (find_max([""play"", ""play"", ""play""]) == ""play""), \'t10\'']",HumanEval/158
"
def eat(number, need, remaining):
    """"""Вы голодный кролик, и вы уже съели определенное количество морковок, но теперь вам нужно съесть больше морковок, чтобы завершить дневной рацион. вы должны вернуть массив [общее количество съеденных морковок после ваших приемов пищи, количество морковок, оставшихся после ваших приемов пищи] если оставшихся морковок недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны. Пример: * eat(5, 6, 10) -> [11, 4] * eat(4, 8, 9) -> [12, 1] * eat(1, 10, 10) -> [11, 0] * eat(2, 11, 5) -> [7, 0] Переменные: @number : целое число количество съеденных вами морковок. @need : целое число количество морковок, которые вам нужно съесть. @remaining : целое число — количество оставшейся моркови на складе Ограничение: * 0 <= количество <= 1000 * 0 <= потребность <= 1000 * 0 <= оставшееся <= 1000 Развлекайтесь :)""""""
","['assert True, ""This prints if this assert fails 1 (good for debugging!)""', 'assert eat(5, 6, 10) == [11, 4], ""Error""', 'assert eat(4, 8, 9) == [12, 1], ""Error""', 'assert eat(1, 10, 10) == [11, 0], ""Error""', 'assert eat(2, 11, 5) == [7, 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 eat(4, 5, 7) == [9, 2], ""Error""', 'assert eat(4, 5, 1) == [5, 0], ""Error""']",HumanEval/159
"
def do_algebra(operator, operand):
    """"""Даны два списка оператор и операнд. Первый список содержит основные алгебраические операции, а второй список представляет собой список целых чисел. Используйте два указанных списка для построения алгебраического выражения и возврата оценки этого выражения. Основные алгебраические операции: Сложение ( + ) Вычитание ( - ) Умножение ( * ) Деление с округлением ( // ) Возведение в степень ( ** ) Пример: оператор['+', '*', '-'] массив = [2, 3, 4, 5] результат = 2 + 3 * 4 - 5 => результат = 9 Примечание: длина списка операторов равна длине списка операндов минус один. Операнд представляет собой список неотрицательных целых чисел. Список операторов содержит по крайней мере один оператор, а список операндов содержит по крайней мере два операнда.""""""
","[""assert do_algebra(['**', '*', '+'], [2, 3, 4, 5]) == 37"", ""assert do_algebra(['+', '*', '-'], [2, 3, 4, 5]) == 9"", 'assert do_algebra([\'//\', \'*\'], [7, 3, 4]) == 8, ""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!)""']",HumanEval/160
"
def solve(s):
    """"""Вам дана строка s. если s[i] — это буква, поменяйте ее регистр с нижнего на верхний или наоборот, в противном случае оставьте все как есть. Если строка не содержит букв, поменяйте ее на противоположную. Функция должна вернуть полученную строку. Примеры resolve(""1234"") = ""4321"" resolve(""ab"") = ""AB"" resolve(""#a@C"") = ""#A@c""""""""
","['assert solve(""AsDf"") == ""aSdF""', 'assert solve(""1234"") == ""4321""', 'assert solve(""ab"") == ""AB""', 'assert solve(""#a@C"") == ""#A@c""', 'assert solve(""#AsdfW^45"") == ""#aSDFw^45""', 'assert solve(""#6@2"") == ""2@6#"" # Check some edge cases that are easy to work out by hand.', 'assert solve(""#$a^D"") == ""#$A^d""', 'assert solve(""#ccc"") == ""#CCC"" # Don\'t remove this line:']",HumanEval/161
"
def string_to_md5(text):
    """""" Дана строка 'text', вернуть ее эквивалентную строку md5-хэша. Если 'text' — пустая строка, вернуть None. >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'""""""
","[""assert string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'"", ""assert string_to_md5('') == None"", ""assert string_to_md5('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'"", ""assert string_to_md5('password') == '5f4dcc3b5aa765d61d8327deb882cf99' # Check some edge cases that are easy to work out by hand."", 'assert True']",HumanEval/162
"
def generate_integers(a, b):
    """""" Даны два положительных целых числа a и b, вернуть четные цифры между a и b в порядке возрастания. Например: generate_integers(2, 8) => [2, 4, 6, 8] generate_integers(8, 2) => [2, 4, 6, 8] generate_integers(10, 14) => []""""""
","['assert generate_integers(2, 10) == [2, 4, 6, 8], ""Test 1""', 'assert generate_integers(10, 2) == [2, 4, 6, 8], ""Test 2""', 'assert generate_integers(132, 2) == [2, 4, 6, 8], ""Test 3""', 'assert generate_integers(17,89) == [], ""Test 4"" # 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!)""']",HumanEval/163