humaneval_kk.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) False >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3) True""""""
","['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]:
    """""" Бұл функцияның кірісі кірістірілген жақшалардың бірнеше топтарын қамтитын жол болып табылады. Сіздің мақсатыңыз - бұл топты бөлек жолдарға бөліп, олардың тізімін қайтару. Бөлек топтар теңдестірілген (әрбір ашық жақша дұрыс жабылған) және бір-бірінің ішінде кірістірілмеген. Енгізу жолындағы бос орындарды елемеңіз. >>> бөлек_жақша_топтары('( ) (( )) (( )( ))') ['()', '(())', '(()())']""""""
","[""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-ден кіші) бөлшектеуге болады. Санның ондық бөлігін қайтарыңыз. >>> кесілген_сан(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 мәнін қайтаруы керек. >>> нөлден төмен([1, 2, 3]) жалған >>> нөлден төмен ([1, 2, -4, 5]) Рас""""""
","['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]:
    """""" «Сандар» енгізу тізімінің әрбір екі дәйекті элементтерінің арасына «шектеуіш» санын енгізіңіз >>> 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', 'массив']""""""
","[""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-ге тең болуы керек. >>> қосынды_өнім([]) (0, 1) >>> қосынды_өнім([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:
    """""" Енгізу тек 1 және 0 сандарынан тұратын екі a және b жолы болып табылады. Осы кірістерде екілік 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]:
    """""" Жолдар тізімінен ең ұзынды қайтарыңыз. Бірдей ұзындықтағы бірнеше жолдар болған жағдайда біріншісін қайтарыңыз. Енгізу тізімі бос болған жағдайда Ешбір мәнін қайтарыңыз. >>> ең ұзын([]) >>> ең ұзын(['a', 'b', 'c']) 'a' >>> ең ұзын(['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 сандарының ең үлкен ортақ бөлгішін қайтару >>> ең үлкен_ортақ_бөлгіш(3, 5) 1 >>> ең_ортақ_бөлгіш(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:
    """""" Берілген ішкі жолды бастапқы жолда қанша рет табуға болатынын табыңыз. Қайталанатын жағдайларды санау. >>> қанша_рет('', 'а') 0 >>> қанша_рет('ааа', 'а') 3 >>> қанша_рет('ааа', 'а') 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]:
    """""" Берілген сандар тізімінен (ұзындығы кемінде екі) бір-біріне ең жақын екеуін таңдап, қайтарыңыз және оларды ретімен қайтарыңыз (аз сан, үлкенірек сан). >>> ең жақын_элементтерді табу([1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) (2.0, 2.2) >>> ең жақын_элементтерді табу([1.0, 2.0, 3.0, 4.0, 5.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]:
    """""" Тек бүтін сандар үшін кез келген питон мәндерінің берілген тізімін сүзіңіз >>> 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-ден кіші ең үлкен санды табыңыз >>> ең үлкен_бөлгіш(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]:
    """"""Берілген бүтін санның жай көбейткіштерінің тізімін ең кішіден ең үлкенге қарай қайтару. Факторлардың әрқайсысы факторизацияда қанша рет пайда болатынына сәйкес келетін реттердің тізімі болуы керек. Енгізілген сан барлық факторлардың көбейтіндісіне тең болуы керек >>> көбейткіштерге бөлу(8) [2, 2, 2] >>> көбейткіштерге бөлу(25) [5, 5] >>> көбейткіштерге бөлу(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]:
    """""" Бүтін сандар тізімінен бірнеше рет кездесетін барлық элементтерді жойыңыз. Элементтердің ретін енгізудегідей қалдырыңыз. >>> көшірмелерді_жою([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', 'массив'], 'a') ['abc', 'массив']""""""
","[""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):
    """""" Тізімдегі тек оң сандарды қайтарыңыз. >>> оңды алу([-1, 2, -4, 5, 6]) [2, 5, 6] >>> оңды алу([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):
    """""" Берілген сан жай болса ақиқат мәнін, ал кері жағдайда жалған мәнін қайтарады. >>> i_preme(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):
    """""" Көпмүшені x нүктесінде xs коэффициенттерімен бағалайды. қайтару 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):
    """""" Көпмүшені x нүктесінде xs коэффициенттерімен бағалайды. қайтару 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, бірақ сұрыпталған. >>> 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):
    """""" Тізімдегі сұрыпталған бірегей элементтерді қайтару >>> бірегей ([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):
    """""" 11 немесе 13-ке бөлінетін n-ден кіші бүтін сандарда 7 цифрының пайда болу санын қайтарыңыз. >>> 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-дің жұп көрсеткіштерінің мәндеріне тең, бірақ сұрыпталған. >>> сұрыптау_жұп([1, 2, 3]) [1, 2, 3] >>> сұрыптау_жұп([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_nero кіріс ретінде бүтін сандар тізімін қабылдайды. ол тізімде нөлге тең үш түрлі элемент болса, True мәнін, ал кері жағдайда False мәнін қайтарады. >>> нөлге_үштік_қосынды([1, 3, 5, 0]) Жалған >>> үш есе_қосынды нөлге([1, 3, -2, 1]) Дұрыс >>> нөлге_үштік_қосынды([1, 2, 3, 7]) Жалған > >> нөлге_үштік_қосынды([2, 4, -5, 3, 9, 7]) Дұрыс >>> нөлге_үштік_қосынды([1]) Жалған""""""
","['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_nero кіріс ретінде бүтін сандар тізімін алады. ол тізімде нөлге тең екі түрлі элемент болса, True мәнін қайтарады, ал кері жағдайда False мәнін қайтарады. >>> жұптар_қосынды_нөл([1, 3, 5, 0]) False >>> pairs_sum_to_nero([1, 3, -2, 1]) False >>> pairs_to_sero([1, 2, 3, 7]) False > >> жұптар_қосынды_нөл([2, 4, -5, 3, 5, 7]) Дұрыс >>> жұптар_қосынды_нөл([1]) жалған""""""
","['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):
    """""" Бүйір ұзындығы және үшбұрыш үшін жоғары қайтару ауданы берілген. >>> үшбұрыштың_ауданы(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). fib4 сандар тізбегінің n-ші элементін тиімді есептеу үшін функцияны жазыңыз. Рекурсияны қолданбаңыз. >>> 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 тізімдегі элементтердің медианасын қайтарыңыз. >>> медиана([3, 1, 2, 4, 5]) 3 >>> медиана([-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 — жолды қабылдайтын және дауысты дыбыссыз жолды қайтаратын функция. >>> дауыстыларды_жою('') '' >>> дауыстыларды_жою(""abcdef
ghijklm"") 'bcdf
ghjklm' >>> дауыстыларды_жою('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):
    """""" l тізіміндегі барлық сандар t шегінен төмен болса, True мәнін қайтарыңыз. >>> табалдырықтан төмен ([1, 2, 4, 10], 100) Рас >>> табалдырықтан төмен ([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 санын қосыңыз >>> қосу(2, 3) 5 >>> қосу(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') Дұрыс >>> same_chars('abcd', 'dddddddabc') Дұрыс >>> same_chars('dddddddabc', 'abcd') Дұрыс >>> same_chars('eabcd' , 'dddddddabc') False >>> same_chars('abcd', 'dddddddabce') False >>> same_chars('eabcdzzzz', 'ddddzzzzzzzzdddddabc') Жалған""""""
","[""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, егер әрбір ашылатын жақшада сәйкес жабу жақшасы болса. >>> дұрыс_жақша(""<"") Жалған >>> дұрыс_жақша(""<>"") Дұрыс >>> дұрыс_жақша(""<<><>>"") Шын >>> дұрыс_жақша(""><<>"") қате""""""
","['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 - тізім элементтері монотонды түрде өседі немесе азаяды. >>> монотонды([1, 2, 4, 20]) Дұрыс >>> монотонды([1, 20, 4, 10]) жалған >>> монотонды([4, 1, 0, -10]) дұрыс""""""
","['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):
    """""" Екі тізім үшін сұрыпталған бірегей ортақ элементтерді қайтарыңыз. >>> ортақ([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]) [1, 5, 653] >>> ортақ([ 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 > 1 деп алайық және жай емес. >>> ең үлкен_жай_фактор(13195) 29 >>> ең үлкен_жай_фактор(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-ге дейінгі сандарды қосатын функция. >>> қосындысы_n(30) 465 >>> қосындысы_n(100) 5050 >>> қосындысы_n(5) 15 >>> қосындысы_n(10) 55 >>> қосындысы_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, егер әрбір ашылатын жақшада сәйкес жабу жақшасы болса. >>> дұрыс_жақша(""("") Жалған >>> дұрыс_жақша(""()"") Ақиқат >>> дұрыс_жақша(""(()())"") Шын >>> дұрыс_жақша("")(()"") жалған""""""
","['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 + .... Осы көпмүшенің туындысын сол пішінде қайтарыңыз. >>> туынды([3, 1, 2, 4, 5]) [1, 4, 12, 20] >>> туынды([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) + фибфиб(n-2) + фибфиб(n-3). Фибфиб сандар тізбегінің n-ші элементін тиімді есептеу үшін функцияны жазыңыз. >>> 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 бүтін санының цифрларын дөңгелек жылжытыңыз, цифрларды жылжыту арқылы оңға жылжытыңыз және нәтижені жол ретінде қайтарыңыз. Егер shift > сандар саны болса, сандарды кері қайтарыңыз. >>> 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):
    """"""""Теріс емес бүтін түйіндері бар ағаштың тармағын көрсететін массив берілгенде, сіздің міндетіңіз түйіндердің бірін жұлып алып, оны қайтару болып табылады. Алынған түйін ең кіші жұп мәні бар түйін болуы керек. Егер ең кішісі бірдей бірнеше түйін болса жұп мән табылды, ең кіші индексі бар түйінді қайтарады, [ең кіші_мән, оның индексі ], жұп мәндер болмаса немесе берілген массив бос болса, [] мәнін қайтарыңыз : [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):
    """"""Бүтін сандар массивінің массивін ескере отырып, алапты палиндромдық ету үшін өзгерту қажет элементтердің ең аз санын табыңыз. Палиндромдық массив – алға және кері қарай бірдей оқылатын массив. Бір өзгерісте бір элементті кез келген басқа элементке өзгертуге болады. Мысалы: ең кіші_өзгеріс([1,2,3,5,4,7,9,6]) == 4 ең кіші_өзгеріс([1, 2, 3, 4, 3, 2, 2]) == 1 ең кіші_өзгеріс([ 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):
    """""" Берілген сан 3 жай санның көбейтіндісі болса ақиқат, ал болмаса жалған болатын функцияны жазыңыз. (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):
    """"""Сіздің тапсырмаңыз - егер x саны n-дің қарапайым дәрежесі болса, ақиқат, ал басқа жағдайларда жалған болатын функцияны жазу. x - n-дің қарапайым күші, егер n**int=x Мысалы: қарапайым күш(1, 4) => ақиқат қарапайым күш(2, 2) => ақиқат қарапайым қуат(8, 2) => ақиқат қарапайым қуат(3, 2) => жалған қарапайым күш(3, 1) => жалған қарапайым қуат(5, 3) => жалған""""""
","['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» таңбалары болады. Қосымша таңбалар пішімге көмектесу үшін бар. Мысалдар: ондық_то_екілік(15) # ""db1111db"" ондық_то_екілік(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) => Өтірік""""""
","['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):
    """"""Бұл семестрдің соңғы аптасы және мұғалім студенттерге баға қоюы керек. Мұғалім бағалаудың алгоритмін өзі құрастырады. Жалғыз мәселе - ол бағалау үшін пайдаланған кодты жоғалтты. Ол сізге кейбір студенттер үшін GPA тізімін берді және сіз келесі кестені пайдаланып әріптік бағалар тізімін шығара алатын функцияны жазуыңыз керек: GPA | Әріптік баға 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 Мысал: [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, әйтпесе False мәнін қайтаратын функцияны жазыңыз Мысалдар prime_length('Hello') == True prime_length('abcdcba') == True prime_length('kittens') == True prime_length («қызғылт сары») == Жалған""""""
","[""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 натурал сан берілген болса, 1-мен басталатын немесе аяқталатын n-таңбалы оң бүтін сандар сандарын қайтарыңыз.""""""
","['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 бүтін Шектеулер: 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)] алу_жолы([], 1) == [] алу_жолы([[], [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] * сұрыптау_массив([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('hi') 'lm' шифрлау('asdfghjkl') қайтарады 'ewhjklnop' шифрлау('gf') қайтарады 'kj' шифрлау('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):
    """"""Сізге бүтін сандар тізімі беріледі. Тізімнің 2-ші ең кіші элементін қайтаратын next_smallest() функциясын жазыңыз. Егер мұндай элемент болмаса, None мәнін қайтарыңыз. келесі_кіші([1, 2, 3, 4, 5]) == 2 келесі_кіші([5, 1, 4, 3, 2]) == 2 келесі_кіші([]) == Ешбір келесі_кіші([1, 1]) == Жоқ""""""
","['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):
    """""" Сізге сөздер тізбегі беріледі, сіздің міндетіңіз - зерігулердің санын санау. Жалығу – «Мен» сөзінен басталатын сөйлем. Сөйлемдер '.', '?' арқылы бөлінген. немесе '!'. Мысалы: >>> is_bored(""Hello world"") 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('Бұл хабар') '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:""банан"", ""a"":""apple""}) False мәнін қайтаруы керек. check_dict_case({""Аты"":""Джон"", ""Жасы"":""36"", ""Қала"":""Хьюстон""}) 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 бүтін санның массивін қайтаратын функцияны орындаңыз. мысалы: санау_жоғары(5) => [2,3] дейін_ санау (11) => [2,3,5,7] дейін_ санау (0) => [] жоғары_ санау(20) => [2,3,5, 7,11,13,17,19] санау_жоғары(1) => []_жоғары_ санау(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):
    """""" Екі бүтін санды қабылдайтын және олардың бірлік цифрларының көбейтіндісін қайтаратын функцияны аяқтаңыз. Кіріс әрқашан жарамды деп есептеңіз. Мысалдар: multiply(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 қайтаруы керек. Мысалы: таңдау_саны(12, 15) = 14 таңдау_саны(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):
    """""" натурал сандар тізімі берілген. жұп цифры жоқ барлық элементтердің сұрыпталған тізімін қайтарады. Ескерту: Қайтарылған тізім өсу ретімен сұрыпталуы керек. Мысалы: >>> бірегей_сандар([15, 33, 1422, 1]) [1, 15, 33] >>> бірегей_сандар([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] -> сұрыптау arr -> [1, 1, 2, 2, 3, 4, 5, 8] -> кері arr - > [8, 5, 4, 3, 2, 2, 1, 1] қайтару [""Сегіз"", ""Бес"", ""Төрт"", ""Үш"", ""Екі"", ""Екі"", ""Бір"", ""Бір"" ""] Массив бос болса, бос массивді қайтарыңыз: arr = [] қайтару [] Егер массивте қандай да бір оғаш сан болса, оны елемеу керек: arr = [1, -1 , 55] -> сұрыптау arr -> [-1, 1, 55] -> кері arr -> [55, 1, -1] қайтару = ['Бір']""""""
","['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):
    """"""Параметр ретінде n қабылдайтын f функциясын орындаңыз және i индексіндегі элементтің мәні, егер i жұп болса, i факториалы немесе 1-ден i-ге дейінгі сандардың қосындысы болатындай етіп, n өлшемінің тізімін қайтарады. 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):
    """"""Бүтін сандардың массивін қабылдайтын және цифрларының қосындысы > 0 болатын элементтердің санын қайтаратын count_nums функциясын жазыңыз. Егер сан теріс болса, оның бірінші таңбаланған цифры теріс болады: мысалы -123 -1, 2 таңбалы цифрлары бар. , және 3. >>> санау_сандары([]) == 0 >>> санау_сандары([-1, 11, -11]) == 1 >>> санау_сандары([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[1], arr[2], ..., arr[N] бүтін сандардан тұратын ""arr"" массиві бар. Жиымдағы сандар кездейсоқ реттелген болады. Сіздің міндетіңіз берілген массивте келесі операцияны орындау арқылы азаймайтын тәртіпте сұрыпталған массив алу мүмкіндігін анықтау болып табылады: Оңға жылжыту операциясын кез келген рет орындауға рұқсат етілген. Бір оңға жылжыту операциясы массивтің барлық элементтерін бір позицияға дұрыс бағытта жылжытуды білдіреді. Массивтің соңғы элементі массивтегі бастапқы орынға, яғни 0-ші индекске жылжытылады. Жоғарыдағы әрекетті орындау арқылы сұрыпталған массивді алу мүмкін болса, True мәнін қайтарыңыз, әйтпесе False мәнін қайтарыңыз. Егер берілген массив бос болса, True мәнін қайтарады. Ескертпе: Берілген тізімде бірегей элементтердің болуына кепілдік беріледі. Мысалы: move_one_ball([3, 4, 5, 1, 2])==>Нағыз Түсіндіру: 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 барлық элементтерін жұп ету үшін, «ИӘ» қайтарыңыз. Әйтпесе, «ЖОҚ» деп қайтарыңыз. Мысалы: алмасу([1, 2, 3, 4], [1, 2, 3, 4]) => ""ИӘ"" алмасу([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):
    """"""Бос орынға бөлінген кіші әріптерді білдіретін жолды ескере отырып, ең көп қайталанатын және сәйкес сандарды қамтитын әріп сөздігін қайтарыңыз. Бірнеше әріптер бірдей болса, олардың барлығын қайтарыңыз. Мысал: гистограмма('ab c') == {'a': 1, 'b': 1, 'c': 1} гистограмма('abb a') == {'a': 2, 'b': 2} гистограмма('abca b') == {'a': 2, 'b': 2} гистограмма('bbbb a') == {'b': 4} гистограмма('') == {}""""""
","['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 екі жол беріледі, c тіліндегі кез келген таңбаға тең s ішіндегі барлық таңбаларды жою керек, содан кейін нәтиже жолы палиндром екенін тексеріңіз. Жол палиндром деп аталады, егер ол алға қарай бірдей кері оқылса. Тексеру үшін нәтиже жолын және 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']) [""4nput str4ng 4n 4n тақ элементтердің саны.""] >>> odd_count(['3',""11111111""]) [""тақ элементтер саны 1n 1nput str1ng 1."", ""8nput str8ng 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):
    """""" Бүтін сандар массиві берілген сандардың кез келген бос емес ішкі жиынының ең аз қосындысын табыңыз. Мысал 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 судың бір бірлігін білдіреді. Әрбір ұңғымада одан су алуға болатын сәйкес шелек бар және барлық шелектердің сыйымдылығы бірдей. Сіздің міндетіңіз - ұңғымаларды босату үшін шелектерді пайдалану. Шелектерді түсіру қажет санын шығарыңыз. 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):
    """"""Бұл Катада сіз теріс емес бүтін сандар массивін өсу ретімен олардың екілік көрсетіліміндегі бірліктердің санына қарай сұрыптауыңыз керек. Ұқсас бірлік саны үшін ондық мәнге қарай сұрыптаңыз. Ол келесідей орындалуы керек: >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5] >>> sort_array([-2, -3, - 4, -5, -6]) == [-6, -5, -4, -3, -2] >>> сұрыптау_массив([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):
    """""" жолы мен натурал n саны берілген болса, сізге бұл сөздер s жолында пайда болуы үшін, дәл n дауыссыз дыбыстан тұратын s жолындағы барлық сөздердің тізімін қайтаратын функцияны орындау тапсырылды. Егер s жолы бос болса, функция бос тізімді қайтаруы керек. Ескерту: енгізу жолында тек әріптер мен бос орындар бар деп болжауға болады. Мысалдар: select_words(""Мэридің кішкентай қозысы болды"", 4) ==> [""кішкентай""] select_words(""Мэридің кішкентай қозысы болды"", 3) ==> [""Мэри"", ""қозы""] select_words(""қарапайым"" бос орын"", 2) ==> [] select_words(""Сәлем әлем"", 4) ==> [""әлем""] select_words(""Сэм ағай"", 3) ==> [""Ағай""]""""""
","['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(""жылдам"") ==> """" 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):
    """"""Бүтін сандардың массиві және k оң бүтін саны берілген болса, arr ішіндегі ең көп k саны бар k ұзындығының сұрыпталған тізімін қайтарыңыз. 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 бүтін саны берілген болса, arr бірінші k элементтерінен ең көбі екі цифры бар элементтердің қосындысын қайтарыңыз. Мысал: Енгізу: 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):
    """""" оң бүтін саны берілген болса, тақ сандары бар сұрыпталған тізімді коллатц ретімен қайтарыңыз. Collatz болжамы математикадағы келесідей анықталған реттілікке қатысты болжам: кез келген 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,3,5,7,8,10,12 айлар үшін 1 күннен кем емес немесе 31 күннен жоғары. Ал күндер саны 4,6,9,11 айлар үшін 1-ден кем немесе 30 күннен жоғары емес. Ал, ай үшін күндер саны 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') => Өтірік""""""
","[""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)) ==> ""NO"" қиылысы((-1, 1), (0, 4)) ==> ""NO"" қиылысы( (-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):
    """"""Сізге бүтін сандардың массиві берілген және 1, -1 немесе 0 арқылы берілген массивтегі әрбір санның барлық белгілерінің көбейтіндісіне көбейтілген бүтін сандардың шамаларының қосындысын қайтару керек. Ескерту: бос arr үшін None мәнін қайтарыңыз. Мысал: >>> өнім_белгілері([1, 2, 2, -4]) == -9 >>> өнім_таңбалары([0, 1]) == 0 >>> өнім_белгілері([]) == Ешқайсысы""""""
","['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 >= 2) және k оң бүтін саны бар тор берілген болса, тордың әрбір ұяшығы мәнді қамтиды. [1, N * N] ауқымындағы әрбір бүтін сан тордың ұяшықтарында дәл бір рет пайда болады. Тордағы ұзындығы k ең аз жолды табу керек. Сіз кез келген ұяшықтан бастай аласыз және әр қадамда көрші ұяшықтардың кез келгеніне ауыса аласыз, басқаша айтқанда, ағымдағы ұяшықпен жиегі ортақ ұяшықтарға өтуге болады. Ұзындығы k жол дәл k ұяшыққа кіруді білдіретінін ескеріңіз (міндетті түрде бөлек емес). Тордан шығуға БОЛМАЙДЫ. А жолы (ұзындығы k) В жолынан (ұзындығы k) кіші болып саналады, егер A және B өтетін ұяшықтардағы мәндердің реттелген тізімдерін жасағаннан кейін (оларды lst_A және lst_B деп атаймыз), lst_A лексикографиялық тұрғыдан lst_B мәнінен аз, басқаша айтқанда, lst_A[i] < lst_B[i] болатындай бүтін i индексі бар (1 <= i <= k) және кез келген j (1 <= j < i) үшін бізде lst_A[ j] = lst_B[j]. Жауап бірегей болатынына кепілдік беріледі. Ең аз жол өтетін ұяшықтардағы мәндердің реттелген тізімін қайтарыңыз. Мысалдар: Кіріс: тор = [ [1,2,3], [4,5,6], [7,8,9]], k = 3 Шығыс: [1, 2, 1] Кіріс: тор = [ [ 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 тақ болса. Мысалы: три(2) = 1 + (2/2) = 2 три(4) = 3 три(3) = три(2) + три(1) + три(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 қайтарыңыз. Мысалы: цифр(1) == 1 цифр(4) == 0 цифр(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 мәнін қайтарыңыз. Ескерту: Егер нақты сан жол ретінде ұсынылса, өзгермелі нүкте болуы мүмкін. немесе , салыстыру_бір(1, 2.5) ➞ 2.5 салыстыру_бір(1, ""2,3"") ➞ ""2,3"" салыстыру_бір(""5,1"", ""6"") ➞ ""6"" салыстыру_бір(""1"", 1) ➞ Жоқ""""""
","['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 оң жұп санның қосындысы ретінде жазуға болатындығын бағалаңыз Мысал: тең_қосынды_жұп(4) == Жалған_тең_қосынды_жұп(6) == Жалған_қосынды_жұп(8) == Шын""""""
","['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(""Мысал"") == ""Мысалы"" fix_spaces(""1-мысал"") = = ""1-мысал"" fix_spaces(""2-мысал"") == ""_Мысал_2"" fix_spaces(""3-мысал"") == ""_Мысал-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] үшін шығыс be 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-мысал: Енгізу: сөйлем = «жүзуге барайық» Шығару: «go for» Шектеулер: * 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 өрнегін жеңілдететін функцияны жүзеге асыру. Функция егер x * n бүтін санға бағаланса, True мәнін, ал кері жағдайда 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):
    """""" Берілген бүтін сандар тізімін цифрларының қосындысына қарай өсу ретімен сұрыптайтын функцияны жазыңыз. Ескерту: сандарының қосындысы ұқсас бірнеше элемент болса, оларды бастапқы тізімдегі индексіне қарай тапсырыс беріңіз. Мысалы: >>> ұпайлар бойынша реттілік([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11] >>> ұпайлар бойынша реттілік([]) == [ ]""""""
","['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 оң бүтін саны берілген. Ұзындығы n болатын бүтін a массивін жасау керек. Әрбір i (1 ≤ i ≤ n) үшін a[i] = i * i - i + 1 мәні. a үштік санын (a[i], a[j], a[k]) қайтарыңыз мұндағы 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):
    """"""Қарапайым бағдарлама, егер n жай сан болса, х мәнін қайтаруы керек, ал әйтпесе y мәнін қайтаруы керек. Мысалдар: x_or_y(7, 34, 12) үшін == 34 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 болады, ал егер жоқ болса, мән болжам мен ұпай арасындағы абсолютті айырмашылық болып табылады. мысал: салыстыру([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3] салыстыру( [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', 'StuFfed'], онда сіз 'Slices.SErviNGSliCes' қайтаруыңыз керек, өйткені 'SErviNGSliCes' ең күшті кеңейтім болып табылады. (оның күші -1). Мысал: ең күшті_кеңейтілім үшін('менің_сыныбым', ['AA', 'бол', 'CC']) == 'менің_сыныбым.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):
    """""" Бүтін сан берілген. сәйкесінше жұп және тақ сандар саны бар кортежді қайтарыңыз. Мысал: жұп_тақ_саны(-12) ==> (1, 1) жұп_тақ_саны(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 <= сан <= 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([""аты"", ""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):
    """"""Сіз аш қоянсыз және сіз сәбіздің белгілі бір санын жеп қойғансыз, бірақ қазір күндізгі тамақты аяқтау үшін көбірек сәбіз жеу керек. сіз [ тамақтан кейін жеген сәбіздің жалпы саны, тамақтан кейін қалған сәбіз саны ] массивін қайтаруыңыз керек, егер қалған сәбіз жеткіліксіз болса, қалған сәбіздің барлығын жейсіз, бірақ әлі де аш боласыз. Мысал: * жеу(5, 6, 10) -> [11, 4] * жеу(4, 8, 9) -> [12, 1] * жеу(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] әріп болса, оның регистрін төменнен жоғарыға немесе керісінше ауыстырыңыз, әйтпесе оны сол күйінде сақтаңыз. Егер жолда әріптер болмаса, жолды кері айналдырыңыз. Функция нәтижелі жолды қайтаруы керек. Мысалдар шешу(""1234"") = ""4321"" шешу(""ab"") = ""AB"" шешу(""#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):
    """""" «Мәтін» жолын ескере отырып, оның md5 хэш-балама жолын қайтарыңыз. Егер «мәтін» бос жол болса, None мәнін қайтарыңыз. >>> string_to_md5('Сәлем әлем') == '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 арасындағы жұп сандарды өсу ретімен қайтарыңыз. Мысалы: gener_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