Instruction:
Реши задачу по программированию
{function}

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
    """

    sorted_numbers = sorted(numbers)
    for i in range(len(sorted_numbers) - 1):
        if sorted_numbers[i + 1] - sorted_numbers[i] < threshold:
            return True
    return False


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

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

    cnt, group, results = 0, "", []
    for ch in paren_string:
        if ch == "(": cnt += 1
        if ch == ")": cnt -= 1
        if ch != " ": group += ch
        if cnt == 0:
            if group != "": results.append(group)
            group = ""
    return results


Instruction:
Напишите программу по строке документации
{function}

def truncate_number(number: float) -> float:
    """На вход подается положительное число с плавающей точкой, оно может быть разложено на целую часть (наибольшее целое число, не превосходящее числа, данного на вход), и на дробную часть (всегда меньше 1). Верните дробную часть числа в десятичном формате .
    Примеры:
        truncate_number(3.5)
        0.5
    """


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

from typing import List

def below_zero(operations: List[int]) -> bool:
    """Дан список операций по пополнению и снятию средств с банковского счета, который начинается с нулевого баланса. Ваша задача состоит в том, чтобы определить: если в какой-то момент баланс счета становится меньше нуля, функция должна вернуть True. В противном случае она должна вернуть False.
    Примеры:
        below_zero([1, 2, 3])
        False
        below_zero([1, 2, -4, 5])
        True
    """

    account = 0
    for operation in operations:
        account += operation
        if account < 0:
            return True
    return False


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """Для данного списка входных чисел вычислите Среднее абсолютное отклонение от среднего значения этого набора данных. Среднее абсолютное отклонение - это средняя абсолютная разница между каждым элементом и центральной точкой (в данном случае среднее значение): MAD = среднее значение |x - x _ mean|.
    Примеры:
        mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
        1.0
    """

    mean = sum(numbers) / len(numbers)
    return sum(abs(x - mean) for x in numbers) / len(numbers)


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """Вставьте число-разделитель (delimeter) между каждыми двумя последовательными элементами входного списка (numbers).
    Примеры:
        intersperse([], 4)
        []
        intersperse([1, 2, 3], 4)
        [1, 4, 2, 4, 3]
    """

    res = []
    for i in range(len(numbers)):
        res.append(numbers[i])
        if i != len(numbers) - 1:
            res.append(delimeter)
    return res


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """Входными данными для этой функции является строка, представленная несколькими группами вложенных круглых скобок, разделенных пробелами. Для каждой группы выведите самый глубокий уровень вложенности круглых скобок. Например, (()()) имеет максимум два уровня вложенности, в то время как ((())) имеет три.
    Примеры:
        parse_nested_parens('(()()) ((())) () ((())()())')
        [2, 3, 1, 3]
    """

    def count_depth(s: str) -> int:
        max_depth, cnt = 0, 0
        for ch in s:
            if ch == "(": cnt += 1
            if ch == ")": cnt -= 1
            max_depth = max(max_depth, cnt)
        return max_depth

    return [count_depth(s) for s in paren_string.split(" ") if s != ""]


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """Отфильтруйте входной список строк (strings), оставив строки, которые содержат данную подстроку (substring).
    Примеры:
        filter_by_substring([], 'a')
        []
        filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
        ['abc', 'bacd', 'array']
    """

[{'strings': ['banana', 'apple', 'kiwi', 'peach'], 'substring': 'a'}, {'strings': ['hello', 'world', 'python', 'numpy', 'pandas'], 'substring': 'py'}, {'strings': [], 'substring': ''}, {'strings': ['abc', 'bcd', 'cbd', 'dbc', 'cda'], 'substring': 'bc'}, {'strings': ['a', 'ab', 'abc', 'abcd', 'abcde', 'bcde', 'cde'], 'substring': 'cd'}, {'strings': ['123', '456', '789', '101112'], 'substring': '12'}, {'strings': ['cat', 'dog', 'elephant', 'rhinoceros', 'seagull'], 'substring': 'e'}, {'strings': ['supercalifragilisticexpialidocious', 'antidisestablishmentarianism', 'floccinaucinihilipilification'], 'substring': 'ili'}, {'strings': ['moon', 'stars', 'sun', 'planets'], 'substring': 's'}, {'strings': ['earth', 'mars', 'jupiter', 'saturn', 'uranus'], 'substring': 's'}]

return list(filter(lambda s: substring in s, strings))


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """Для данного списка (numbers) целых чисел верните кортеж, состоящий из суммы и произведения всех целых чисел в списке. Сумма пустого списка должна быть равна 0, а произведение должно быть равно 1.
    Примеры:
        sum_product([])
        (0, 1)
        sum_product([1, 2, 3, 4])
        (10, 24)
    """

    s, p = 0, 1
    for number in numbers:
        s += number
        p *= number
    return s, p


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """Из данного списка целых чисел сгенерируйте список скользящего максимума, найденного в диапазоне от начала списка до очередного рассматриваемого элемента в последовательности (правая граница диапазона сдвигается на 1 элемент).
    Примеры:
        rolling_max([1, 2, 3, 2, 3, 4, 2])
        [1, 2, 3, 3, 3, 4, 4]
    """

return [max(numbers[:(i+1)]) for i in range(len(numbers))]


Instruction:
Реши задачу по программированию
{function}

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

def make_palindrome(string: str) -> str:
    """ Найдите самый короткий палиндром, который начинается с заданной строки.

Идея алгоритма проста:
- Найдите самый длинный постфикс данной строки, который является палиндромом.
- Добавьте в конец строки развернутый префикс строки, который идет перед палиндромным суффиксом.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

[{'string': 'race'}, {'string': 'level'}, {'string': 'tenet'}, {'string': 'noon'}, {'string': 'redder'}, {'string': 'refer'}, {'string': 'dewed'}, {'string': 'madam'}, {'string': 'malayalam'}, {'string': 'radar'}]

    if is_palindrome(string):
        return string
    for i in range(len(string)):
        if is_palindrome(string[i:]):
            return string + string[i-1::-1]


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Входными данными являются две строки a и b, состоящие только из 1s и 0s.
Выполните двоичное XOR для этих входных данных и верните результат также в виде строки
    Примеры:
        string_xor('010', '110')
        '100'
    """

return "".join(str(int(a[i]) ^ int(b[i])) for i in range(len(a)))


Instruction:
Напишите программу по строке документации
{function}

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """Из списка строк верните самую длинную. Верните первую строку в случае наличия нескольких строк одинаковой длины. Верните None, если входной список пустой.
    Примеры:
        longest([])

        longest(['a', 'b', 'c'])
        'a'
        longest(['a', 'bb', 'ccc'])
        'ccc'
    """

    if not strings:
        return None

    maxlen = max(len(x) for x in strings)
    for s in strings:
        if len(s) == maxlen:
            return s


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def greatest_common_divisor(a: int, b: int) -> int:
    """Верните наибольший общий делитель двух целых чисел a и b.
    Примеры:
        greatest_common_divisor(3, 5)
        1
        greatest_common_divisor(25, 15)
        5
    """

    def query_gcd(a: int, b: int) -> int:
        return a if b == 0 else query_gcd(b, a % b)
    return query_gcd(a, b)


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

from typing import List

def all_prefixes(string: str) -> List[str]:
    """Верните список всех префиксов от самого короткого до самого длинного во входной строке.
    Примеры:
        all_prefixes('abc')
        ['a', 'ab', 'abc']
    """

[{'string': 'Hello there!'}, {'string': 'abracadabra'}, {'string': '12345'}, {'string': '       '}, {'string': 'racecar'}, {'string': 'bananas'}, {'string': 'abcdefg'}, {'string': '1234567890'}, {'string': '1234'}, {'string': 'python'}]

['H', 'He', 'Hel', 'Hell', 'Hello', 'Hello ', 'Hello t', 'Hello th', 'Hello the', 'Hello ther', 'Hello there', 'Hello there!']

['a', 'ab', 'abr', 'abra', 'abrac', 'abraca', 'abracad', 'abracada', 'abracadab', 'abracadabr', 'abracadabra']

['r', 'ra', 'rac', 'race', 'racec', 'raceca', 'racecar']

['b', 'ba', 'ban', 'bana', 'banan', 'banana', 'bananas']

['a', 'ab', 'abc', 'abcd', 'abcde', 'abcdef', 'abcdefg']

['p', 'py', 'pyt', 'pyth', 'pytho', 'python']

return [string[:(i + 1)] for i in range(len(string))]


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def string_sequence(n: int) -> str:
    """Верните строку, содержащую разделенные пробелом числа от 0 до n включительно.
    Примеры:
        string_sequence(0)
        '0'
        string_sequence(5)
        '0 1 2 3 4 5'
    """


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def count_distinct_characters(string: str) -> int:
    """Дана строка (string), выясните, из скольких различных символов (независимо от регистра) она состоит.
    Примеры:
        count_distinct_characters('xyzXYZ')
        3
        count_distinct_characters('Jerry')
        4
    """

[{'string': 'AbCdEfG'}, {'string': 'banana'}, {'string': '1234567890'}, {'string': 'hello123'}, {'string': 'The quick brown fox jumps over the lazy dog'}, {'string': 'THISISALONGSTRINGWITHNOSPACES'}, {'string': 'aaaabbbbccccddddeeeeffffgggghhhhiiii'}, {'string': 'AaBbCcDdEeFfGgHhIi'}, {'string': 'hello world'}, {'string': '1,2,3... go!'}]


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def parse_music(music_string: str) -> List[int]:
    """На вход подается строка, представляющая собой музыкальные ноты в специальном ASCII формате.
Ваша задача состоит в том, чтобы проанализировать эту строку и вернуть список целых чисел, соответствующих тому, сколько ударов длится каждая нота.

Вот легенда:
'о' - целая нота, длится четыре удара
'о|' - половинная нота, длится два удара
'.|' - четверть ноты, длится один удар.
    Примеры:
        parse_music('o o| .| o| o| .| .| .| .| o o')
        [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

    def count_beats(note: str) -> int:
        if note == "o": return 4
        elif note == "o|": return 2
        elif note == ".|": return 1

    if music_string == "": return []
    return list(map(count_beats, music_string.split(" ")))


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def how_many_times(string: str, substring: str) -> int:
    """Найдите, сколько раз данная подстрока встречается в исходной строке. Подсчитайте случаи с перекрытием.
    Примеры:
        how_many_times('', 'a')
        0
        how_many_times('aaa', 'a')
        3
        how_many_times('aaaa', 'aa')
        3
    """

[{'string': 'ababa', 'substring': 'aba'}, {'string': 'abcdefg', 'substring': 'efg'}, {'string': 'abababab', 'substring': 'aba'}, {'string': 'hello world', 'substring': 'o'}, {'string': 'aaaabbbbcccc', 'substring': 'bb'}, {'string': '12211221122', 'substring': '122'}, {'string': 'racecar', 'substring': 'car'}, {'string': 'mississippi', 'substring': 'ss'}, {'string': 'thequickbrownfox', 'substring': 'fox'}, {'string': 'fizzbuzz', 'substring': 'zz'}]

    occurences = 0
    for i in range(len(string)):
        if string[i:].startswith(substring):
            occurences += 1
    return occurences


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def sort_numbers(numbers: str) -> str:
    """Входные данные представляют собой разделенную пробелами строку цифр от 'zero' до 'nine'.
Допустимыми элементами являются: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
Верните строку с допустимыми элементами, отсортированными от наименьшего к наибольшему.
    Примеры:
        sort_numbers('three one five')
        'one three five'
    """

[{'numbers': 'four eight two'}, {'numbers': 'nine'}, {'numbers': 'one six two four nine'}, {'numbers': 'two seven eight zero five'}, {'numbers': 'nine zero'}, {'numbers': 'seven three one'}, {'numbers': 'two two three three four five six'}, {'numbers': 'zero five four one seven eight two six'}, {'numbers': 'nine eight seven six five four three two one zero'}, {'numbers': 'two zero nine four five six'}]

zero one two three four five six seven eight nine

    to_int = {'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9}

    if numbers == "": return ""
    return " ".join(sorted(numbers.split(" "), key=lambda n: to_int[n]))


Instruction:
Реши задачу по программированию
{function}

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """Из предоставленного списка чисел (длиной не менее двух) выберите и верните два наиболее близких друг к другу и верните их по порядку (меньшее число, большее число).
    Примеры:
        find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
        (2.0, 2.2)
        find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
        (2.0, 2.0)
    """

    numbers.sort()
    min_diff = float("inf")
    min_pair = None
    for l, r in zip(numbers[:-1], numbers[1:]):
        diff = r - l
        if diff < min_diff:
            min_diff = diff
            min_pair = (l, r)
    return min_pair


Instruction:
Реализуй функцию(ии) на языке Python
{function}

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]
    """

    ma, mi = max(numbers), min(numbers)
    k = 1 / (ma - mi)
    return list(map(lambda x: (x - mi) * k, numbers))


Instruction:
Напишите программу по строке документации
{function}

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """Отфильтровать данный список из любых значений, допустимых в python, оставив только целые числа.
    Примеры:
        filter_integers(['a', 3.14, 5])
        [5]
        filter_integers([1, 2, 3, 'abc', {}, []])
        [1, 2, 3]
    """

return list(filter(lambda x: type(x) == int, values))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def strlen(string: str) -> int:
    """Верните длину входной строки.
    Примеры:
        strlen('')
        0
        strlen('abc')
        3
    """

[{'string': 'Hello, World!'}, {'string': '12345'}, {'string': ' '}, {'string': 'This is a long string that has many characters in it'}, {'string': 'abcdefghijklmnopqrstuvwxyz'}, {'string': 'Testing testing 123'}, {'string': 'The quick brown fox jumps over the lazy dog'}, {'string': 'one\ntwo\nthree\nfour\nfive'}, {'string': '1234567890'}, {'string': 'This string has a \n newline character'}]


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def largest_divisor(n: int) -> int:
    """Для заданного числа n найдите наибольшее число, на которое n делится без остатка, меньшее n.
    Примеры:
        largest_divisor(15)
        5
    """

    for i in range(2, n):
        if n % i == 0: return n // i
    return 1


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def factorize(n: int) -> List[int]:
    """Верните список простых множителей заданного целого числа в порядке от наименьшего к наибольшему. Каждый из множителей должен быть указан столько раз, сколько раз он встречается в факторизации. Входное число должно быть равно произведению всех множителей.
    Примеры:
        factorize(8)
        [2, 2, 2]
        factorize(25)
        [5, 5]
        factorize(70)
        [2, 5, 7]
    """

    import math
    fact = []
    i = 2
    while i <= int(math.sqrt(n) + 1):
        if n % i == 0:
            fact.append(i)
            n //= i
        else:
            i += 1

    if n > 1:
        fact.append(n)
    return fact


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

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

    num_cnt = dict()
    for number in numbers:
        if number not in num_cnt:
            num_cnt[number] = 0
        num_cnt[number] += 1
    return [number for number in numbers if num_cnt[number] == 1]


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def flip_case(string: str) -> str:
    """Для заданной строки преобразовать строчные символы в прописные, а прописные в строчные.
    Примеры:
        flip_case('Hello')
        'hELLO'
    """

[{'string': '123abc'}, {'string': 'Toggle Me'}, {'string': 'Flipping cases is so easy!'}, {'string': 'Flipping Cases Is So Easy!'}, {'string': 'Python Is Fun'}, {'string': 'toGGlE Me'}, {'string': 'fLiP YOuR cAsE'}, {'string': '1234'}, {'string': 'TOGGLE ME'}, {'string': 'toggle me'}]

return "".join(map(lambda x: x.swapcase(), string))


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List

def concatenate(strings: List[str]) -> str:
    """Объединить список строк в одну строку.
    Примеры:
        concatenate([])
        ''
        concatenate(['a', 'b', 'c'])
        'abc'
    """

[{'strings': ['apple', 'banana', 'orange']}, {'strings': ['python', 'is', 'a', 'great', 'language']}, {'strings': ['Rock', 'Paper', 'Scissors']}, {'strings': ['123', '456', '789']}, {'strings': ['Hello']}, {'strings': ['hello']}, {'strings': ['', 'world']}, {'strings': ['Python', 'is', 'a', 'programming', 'language']}, {'strings': ['a']}, {'strings': ['', '', '']}]


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """Отфильтруйте входной список строк, выбрав только те, которые начинаются с заданного префикса.
    Примеры:
        filter_by_prefix([], 'a')
        []
        filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
        ['abc', 'array']
    """

[{'strings': [], 'prefix': ''}, {'strings': ['abc', 'abcd', 'abcde'], 'prefix': 'abc'}, {'strings': ['xyz', 'efg', 'hij'], 'prefix': 'a'}, {'strings': ['cat', 'dog', 'bat'], 'prefix': 'elephant'}, {'strings': ['apple', 'banana', 'orange', 'apricot', 'kiwi'], 'prefix': 'ap'}, {'strings': ['a', 'ab', 'abc', 'ba', 'bb', 'bc'], 'prefix': 'a'}, {'strings': ['zzz', 'zzz', 'zzz'], 'prefix': 'z'}, {'strings': ['hello', 'world', 'house'], 'prefix': 'h'}, {'strings': ['apple', 'orange', 'banana'], 'prefix': 'b'}, {'strings': ['python', 'java', 'javascript', 'c++'], 'prefix': 'java'}]

return list(filter(lambda x: x.startswith(prefix), strings))


Instruction:
Реши задачу по программированию
{function}

def get_positive(l: list):
    """Верните только положительные числа списка.
    Примеры:
        get_positive([-1, 2, -4, 5, 6])
        [2, 5, 6]
        get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
        [5, 3, 2, 3, 9, 123, 1]
    """


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def is_prime(n):
    """Верните True, если данное число является простым, и False в противном случае.
    Примеры:
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

    if n <= 1: return False
    n_sqrt = 1
    while n_sqrt ** 2 < n: n_sqrt += 1
    for i in range(2, min(n_sqrt + 1, n)):
        if n % i == 0:
            return False
    return True


Instruction:
Напишите программу по строке документации
{function}

import math

def poly(xs: list, x: float):
    """
    Оценить полином с коэффициентами xs в точке x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs - это полиномиальные коэффициенты.
find_zero ищет такой x, что poly(x) = 0.
find_zero возвращает только одну нулевую точку, даже если их несколько.
Более того, find_zero принимает на вход список, который имеет четное количество коэффициентов, а также старший коэффициент гарантировано ненулевой, что гарантирует существование решения.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

    dxs = [xs[i] * i for i in range(1, len(xs))]
    def func(x):
        return poly(xs, x)
    def derivative(x):
        return poly(dxs, x)

    x, tol = 0, 1e-5
    for _ in range(1000):
        fx = func(x)
        dfx = derivative(x)
        if abs(fx) < tol: break
        x = x - fx / dfx

    return x


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def sort_third(l: list):
    """Эта функция принимает список l и возвращает список l' такой, что l' идентичен l в индексах, не кратных трем, а его значения в индексах, кратных трем, равны значениям соответствующих идексов l, но отсортированны.
    Примеры:
    sort_third([1, 2, 3])
    [1, 2, 3]
    sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

    third = [l[i] for i in range(len(l)) if i % 3 == 0]
    third.sort()
    return [third[i // 3] if i % 3 == 0 else l[i] for i in range(len(l))]


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def unique(l: list):
    """Верните отсортированные уникальные элементы списком.
    Примеры:
    unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

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 all(type(x) in [int, float] for x in l), "invalid inputs"
    return max(l)


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def fizz_buzz(n: int):
    """Верните количество раз, когда цифра 7 встречается в записи целых чисел меньше n, которые делятся на 11 или 13.
    Примеры:
    fizz_buzz(50)
    0
    fizz_buzz(78)
    2
    fizz_buzz(79)
    3
    """

    cnt = 0
    for i in range(n):
        if i % 11 == 0 or i % 13 == 0:
            cnt += len(list(filter(lambda c: c == "7", str(i))))
    return cnt


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def sort_even(l: list):
    """Эта функция принимает список l и возвращает список l' такой, что l' совпадает с l в нечетных индексах, а его значения в четных индексах равны значениям четных индексов l, но отсортированы.
    Примеры:
    sort_even([1, 2, 3])
    [1, 2, 3]
    sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

    even = [l[i] for i in range(len(l)) if i % 2 == 0]
    even.sort()
    return [even[i // 2] if i % 2 == 0 else l[i] for i in range(len(l))]


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def encode_cyclic(s: str):
    """
    возвращает закодированную строку, путем зацикливания групп из трех символов.
    """
    # разбивает строку на группы. Каждая длины 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # зацикливает элементы в каждой группе. Если только в группе не меньше 3 элементов.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    на вход принимает строку, закодированную функцией encode_cyclon. Возвращает декодированную строку.
    """

[{'s': 'abcdefghijk'}, {'s': 'abcdefghijklmnopqrstuvwxyz'}, {'s': '1234567890'}, {'s': 'The quick brown fox jumps over the lazy dog.'}, {'s': 'Testing 123, testing 123.'}, {'s': 'abc'}, {'s': 'ab'}, {'s': 'a'}, {'s': ''}, {'s': 'foo bar'}]

eThu qkicr bnowo fjx pumos rveh tle yazo dg.

    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    groups = [(group[2] + group[:2]) if len(group) == 3 else group for group in groups]
    return "".join(groups)


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def prime_fib(n: int):
    """prime_fib возвращает n-е число, которое является числом Фибоначчи, и также является простым.
    Примеры:
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

    import random
    def miller_rabin(n, k=10):
        """Test if n is prime using the Miller-Rabin primality test."""
        if n < 2:
            return False
        if n == 2 or n == 3:
            return True
        if n % 2 == 0:
            return False

        r = 0
        d = n - 1
        while d % 2 == 0:
            r += 1
            d //= 2

        for _ in range(k):
            a = random.randint(2, n - 2)
            x = pow(a, d, n)
            if x == 1 or x == n - 1:
                continue
            for _ in range(r - 1):
                x = pow(x, 2, n)
                if x == n - 1:
                    break
            else:
                return False

        return True

    c_prime = 0
    a, b = 0, 1
    while c_prime < n:
        a, b = b, a + b
        if miller_rabin(b):
            c_prime += 1
    return b


Instruction:
Реши задачу по программированию
{function}

def triples_sum_to_zero(l: list):
    """Triples_sum_to_zero принимает на вход список целых чисел. Он возвращает True, если в списке есть три различных элемента, сумма которых равна нулю, и False в противном случае.
    Примеры:
    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

    for i in range(len(l)):
        for j in range(len(l)):
            for k in range(len(l)):
                if i != j and i != k and j != k and l[i] + l[j] + l[k] == 0:
                    return True
    return False


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def car_race_collision(n: int):
    """Представьте себе дорогу, как идеально прямую бесконечно длинную линию.
n машин едут слева направо; одновременно справа налево едет другое множество из n автомобилей. Два множества автомобилей начинают движение очень далеко друг от друга. Все автомобили движутся с одинаковой скоростью. Считается, что два автомобиля сталкиваются, когда автомобиль, движущийся слева направо, сталкивается с автомобилем, движущимся справа налево. Однако автомобили бесконечно прочны, так что они продолжают двигаться по своей траектории, как если бы не сталкивались.
Эта функция выводит количество таких столкновений.
    """


Instruction:
Напишите программу по строке документации
{function}

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]
    """


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def pairs_sum_to_zero(l):
    """pairs_sum_to_zero принимает на вход список целых чисел. он возвращает True, если в списке есть два различных элемента, сумма которых равна нулю, и False в противном случае.
    Примеры:
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

    for i in range(len(l)):
        for j in range(len(l)):
            if i != j and l[i] + l[j] == 0:
                return True
    return False


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def change_base(x: int, base: int):
    """Измените основание входного числа x на base. Верните строковое представление числа после перевода в новую систему счисления по основанию base. Переменная base может быть не больше 10.
    Примеры:
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

    if x == 0: return "0"
    ret = ""
    while x != 0:
        ret = str(x % base) + ret
        x //= base
    return ret


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def triangle_area(a, h):
    """Даны длина стороны и высота. Верните площадь треугольника.
    Примеры:
    triangle_area(5, 3)
    7.5
    """


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def fib4(n: int):
    """Числовая последовательность Fib4 — это последовательность, аналогичная последовательности Фиббоначчи, которая определяется следующим образом:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Напишите функцию для эффективного вычисления n-го элемента числовой последовательности fib4. Не используйте рекурсию.
    Примеры:
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

    if n == 0:
        return 0
    elif n == 1:
        return 0
    elif n == 2:
        return 2
    elif n == 3:
        return 0
    else:
        a, b, c, d = 0, 0, 2, 0
        for i in range(4, n + 1):
            a, b, c, d = b, c, d, a + b + c + d
        return d


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def median(l: list):
    """Верните медиану элементов списка l.
    Примеры:
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

    sorted_l = sorted(l)
    if len(l) % 2 == 1:
        return sorted_l[len(l) // 2]
    else:
        return (sorted_l[len(l) // 2 - 1] + sorted_l[len(l) // 2]) / 2


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def is_palindrome(text: str):
    """Проверить, является ли заданная строка палиндромом.
    Примеры:
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

[{'text': 'a'}, {'text': 'ab'}, {'text': 'abc'}, {'text': 'abca'}, {'text': 'racecar'}, {'text': 'never odd or even'}, {'text': 'step on no pets'}, {'text': 'Was it a car or a cat I saw?'}, {'text': 'radar'}, {'text': 'refer'}]


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

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
    """

    res, x = 1, 2
    while n != 0:
        if n % 2 == 1:
            res = res * x % p
        x = x * x % p
        n //= 2
    return res % p


Instruction:
Реши задачу по программированию
{function}

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):
    """
    принимает в качестве входной строки закодированную с помощью функции encode_shift строку. Возвращает декодированную строку.
    """

[{'s': 'abcdefghijklmnopqrstuvwxyz'}, {'s': 'encoded message with shift'}, {'s': 'abcde'}, {'s': 'vwxyz'}, {'s': 'hello world'}, {'s': 'the quick brown fox jumps over the lazy dog'}, {'s': 'éîøüñ'}, {'s': ''}, {'s': 'hello'}, {'s': 'world'}]

return "".join([chr((ord(ch) - ord("a") - 5 + 26) % 26 + ord("a")) for ch in s])


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def remove_vowels(text: str):
    """remove_vowels — это функция, которая принимает на вход строку и возвращает строку без гласных.
    Примеры:
    >>> remove_vowels('')
    ''
    >>> remove_vowels('abcdef
ghijklm')
    'bcdf
ghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

[{'text': 'hello'}, {'text': 'This is a Test!'}, {'text': 'i am using python'}, {'text': 'The quick brown fox jumps over the lazy dog.'}, {'text': 'This sentence has vowels: aeiou'}, {'text': 'strawberries and cream'}, {'text': 'Programming is fun'}, {'text': '1234567890'}, {'text': 'Python is awesome!'}, {'text': 'How are you today?'}]

return "".join(list(filter(lambda ch: ch not in "aeiouAEIOU", text)))


Instruction:
Напишите программу по строке документации
{function}

def below_threshold(l: list, t: int):
    """Возвращает True, если все числа в списке l меньше порога t.
    Примеры:
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def add(x: int, y: int):
    """Сложить два числа x и y.
    Примеры:
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def same_chars(s0: str, s1: str):
    """Проверить, состоят ли строки из одинаковых символов.
    Примеры:
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def fib(n: int):
    """Верните n-е число Фибоначчи.
    Примеры:
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

    if n == 0: return 0
    if n <= 2: return 1
    a, b = 1, 1
    for _ in range(3, n + 1):
        a, b, = b, a + b
    return b


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def correct_bracketing(brackets: str):
    """brackets представляет собой строку из «<» и «>». Вернуть True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.
    Примеры:
     >>> correct_bracketing('<')
    False
    >>> correct_bracketing('<>')
    True
    >>> correct_bracketing('<<><>>')
    True
    >>> correct_bracketing('><<>')
    False
    """

    cnt = 0
    for x in brackets:
        if x == "<": cnt += 1
        if x == ">": cnt -= 1
        if cnt < 0: return False
    return cnt == 0


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def monotonic(l: list):
    """Вернуть True, если элементы списка монотонно увеличиваются или уменьшаются.
    Примеры:
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

    inc, dec = True, True
    for i in range(len(l) - 1):
        if l[i] > l[i + 1]: inc = False
        if l[i] < l[i + 1]: dec = False
    return inc or dec


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def common(l1: list, l2: list):
    """Вернуть отсортированные уникальные общие для двух списков элементы.
    Примеры:
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]
    """


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def largest_prime_factor(n: int):
    """Верните наибольший простой делитель числа n. Предполагая, что n > 1 и не является простым числом.
    Примеры:
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

    isprime = [True] * (n + 1)
    for i in range(2, n + 1):
        if isprime[i]:
            for j in range(i + i, n, i):
                isprime[j] = False
    for i in range(n - 1, 0, -1):
        if isprime[i] and n % i == 0:
            return i


Instruction:
Реши задачу по программированию
{function}

def sum_to_n(n: int):
    """sum_to_n — это функция, которая находит сумму чисел от 1 до n.
    Примеры:
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def correct_bracketing(brackets: str):
    """brackets представляет собой строку из '(' и ')'. верните True, если каждая открывающая скобка строки имеет соответствующую закрывающую скобку.
    Примеры:
    >>> correct_bracketing('(')
    False
    >>> correct_bracketing('()')
    True
    >>> correct_bracketing('(()())')
    True
    >>> correct_bracketing(')(()')
    False
    """

    cnt = 0
    for x in brackets:
        if x == "(": cnt += 1
        if x == ")": cnt -= 1
        if cnt < 0: return False
    return cnt == 0


Instruction:
Напишите программу по строке документации
{function}

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

return [xs[i] * i for i in range(1, len(xs))]


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def fibfib(n: int):
    """Последовательность чисел FibFib - это последовательность, аналогичная последовательности чисел Фибоначчи, которая определяется следующим образом:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Напишите функцию для эффективного вычисления n-го элемента последовательности чисел fibfib.
    Примеры:
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

    if n == 0 or n == 1:
        return 0
    elif n == 2:
        return 1
    a, b, c = 0, 0, 1
    for _ in range(3, n + 1):
        a, b, c = b, c, a + b + c
    return c


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

FIX = """
Добавить больше тестовых примеров.
"""

def vowels_count(s):
    """Напишите функцию vowels_count, которая принимает на вход строку, представляющую слово и возвращает количество гласных в строке. Гласные в данном случае — «a», «e», «i», «o», «u». Здесь «y» также является гласной, но только тогда, когда она стоит в конце данного слова.
    Примеры:
    >>> vowels_count('abcde')
    2
    >>> vowels_count('ACEDY')
    3
    """

    if s == "": return 0
    cnt = len(list(filter(lambda ch: ch in "aeiouAEIOU", s)))
    if s[-1] in "yY": cnt += 1
    return cnt


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def circular_shift(x, shift):
    """Циклический сдвиг цифр целого числа x - нужно сдвинуть цифры вправо на shift и вернуть результат в виде строки.
Если shift > количества цифр в x, верните цифры в обратном порядке.
    Примеры:
    >>> circular_shift(12, 1)
    '21'
    >>> circular_shift(12, 2)
    '12'
    """

    s = str(x)
    if shift > len(s): return s[::-1]
    shift %= len(s)
    if shift == 0:
        return s
    else:
        return s[len(s) - shift:] + s[:len(s) - shift]


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def digitSum(s):
    """Напишите функцию, которая принимает на вход строку и возвращает сумму ASCII кодов символов в верхнем регистре.
    Примеры:
        digitSum('') => 0
        digitSum('abAB') => 131
        digitSum('abcCd') => 67
        digitSum('helloE') => 69
        digitSum('woArBld') => 131
        digitSum('aAaaaXa') => 153
    """

return sum([ord(ch) for ch in s if ch.isupper()])


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def fruit_distribution(s,n):
    """В этом задании даётся строка, обозначающая количество яблок и апельсинов, разложенных в корзине с фруктами. эта корзина содержит яблоки, апельсины и плоды манго. На вход подается строка, представляющая общее количество апельсинов и яблок и целое число, обозначающее общее количество фруктов в корзине. верните количество плодов манго в корзине.
    Примеры:
        fruit_distribution('5 apples and 6 oranges', 19) ->19 - 5 - 6 = 8
        fruit_distribution('0 apples and 1 oranges',3) -> 3 - 0 - 1 = 2
        fruit_distribution('2 apples and 3 oranges', 100) -> 100 - 2 - 3 = 95
        fruit_distribution('100 apples and 1 oranges',120) -> 120 - 100 - 1 = 19
    """

[{'s': '10 apples and 20 oranges', 'n': 50}, {'s': '3 apples and 4 oranges', 'n': 9}, {'s': '7 apples and 8 oranges', 'n': 30}, {'s': '2 apples and 0 oranges', 'n': 5}, {'s': '0 apples and 0 oranges', 'n': 10}, {'s': '0 apples and 1 oranges', 'n': 1}, {'s': '10 apples and 0 oranges', 'n': 15}, {'s': '3 apples and 5 oranges', 'n': 12}, {'s': '5 apples and 5 oranges', 'n': 12}, {'s': '8 apples and 2 oranges', 'n': 15}]

    words = s.split(" ")
    c1, c2 = int(words[0]), int(words[3])
    assert n - c1 - c2 >= 0, "invalid inputs" # $_CONTRACT_$

    return n - c1 - c2


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def pluck(arr):
    """Дается массив, представляющий ветвь дерева, имеющего в узлах неотрицательные целые числа, ваша задача — выбрать один из узлов и вернуть его. Выбранный узел должен быть узлом с наименьшим четным значением. Если найдено несколько узлов с одинаковым наименьшим четным значением, верните узел с наименьшим индексом.
Выбранный узел должен быть возвращен в виде списка [наименьшее значение, его индекс],
Если четных значений нет или данный массив пуст, верните [].
 Пример 1:
     Input: [4,2,3]
     Output: [2, 1]
     Пояснение: 2 имеет наименьшее четное значение,  и 2 имеет наименьший индекс.
 Пример 2:
     Input: [1,2,3]
     Output: [2, 1]
     Пояснение: 2 имеет наименьшее четное значение, и 2 имеет наименьший индекс.
 Пример 3:
     Input: []
     Output: []
 Пример 4:
     Input: [5, 0, 3, 0, 4, 2]
     Output: [0, 1]
     Пояснение: 0 — наименьшее значение, но есть два нуля, поэтому мы выберем первый ноль, имеющий наименьший индекс.
 Ограничения:
         * 1 <= nodes.length <= 10000
         * 0 <= node.value
    """

    if all(val % 2 == 1 for val in arr): return []
    min_even = min(filter(lambda x: x % 2 == 0, arr))
    for i in range(len(arr)):
        if arr[i] == min_even:
            return [min_even, i]


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def search(lst):
    """ Вам дан непустой список целых положительных чисел. Верните наибольшее целое число, которое больше нуля и имеет частоту, большую или равную значению самого числа.
Частота целого числа — это количество раз, которое оно появляется в списке.
Если такого значения не существует, верните -1.
     Примеры:
     search([4, 1, 2, 2, 3, 1]) == 2
     search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
     search([5, 5, 4, 4, 4]) == -1
    """

    count = dict()
    for num in lst:
        if num not in count:
            count[num] = 0
        count[num] += 1
    ans = -1
    for num, cnt in count.items():
        if cnt >= num:
            ans = max(ans, num)
    return ans


Instruction:
Реши задачу по программированию
{function}

def strange_sort_list(lst):
   """
   Дан список целых чисел, верните список в странном порядке. Странная сортировка - это когда вы начинаете с минимального значения, затем идет максимальное значение оставшихся целых чисел, затем минимальное и так далее.
 Примеры:
 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([]) == []
    """

    sorted_list = sorted(lst)
    ans, i, j = [], 0, len(sorted_list) - 1
    while i < j:
        ans.append(sorted_list[i])
        ans.append(sorted_list[j])
        i += 1
        j -= 1
    if i == j: ans.append(sorted_list[i])
    return ans


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def triangle_area(a, b, c):
     """
    Даны длины трёх сторон треугольника. Верните площадь треугольника, округленную до 2х знаков после запятой, если три стороны образуют правильный треугольник. В противном случае верните -1.
Три стороны образуют правильный треугольник, когда сумма любых двух сторон больше третьей стороны.
  Примеры:
 triangle_area(3, 4, 5) == 6.00
 triangle_area(1, 2, 10) == -1
    """

    if a + b <= c or a + c <= b or b + c <= a: return -1
    p = (a + b + c) / 2
    return round((p * (p - a) * (p - b) * (p - c)) ** 0.5, 2)


Instruction:
Напишите программу по строке документации
{function}

def will_it_fly(q,w):
    """
    Напишите функцию, которая возвращает True, если объект q полетит, и False в противном случае.
Объект q полетит, если он сбалансирован (если является палиндромным списком) и сумма его элементов меньше или равна максимально возможному весу w.
 Примеры:
 will_it_fly([1, 2], 5) ➞ False
 # 1+2 — вес меньше максимально возможного, но он несбалансирован.
 will_it_fly([3, 2, 3], 1) ➞ False
 # сбалансирован, но 3+2+3 — это больше максимально возможного веса.
 will_it_fly([3, 2, 3], 9) ➞ True
 # 3+2+3 меньше максимально возможного веса, список сбалансирован.
 will_it_fly([3], 5) ➞ True
 #3 имеет вес меньше максимально возможного и список сбалансирован.
    """


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def smallest_change(arr):
    """Даётся массив целых чисел, найдите минимальное количество элементов, которые необходимо изменить, чтобы массив стал палиндромным. Палиндромный массив — это массив, который читается одинаково в прямом и обратном поряде. Одно изменение подразумевает, что вы можете заменить один элемент на любой другой элемент.
 Примеры:
 smallest_change([1,2,3,5,4,7,9,6]) == 4
 smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
 smallest_change([1, 2, 3, 2, 1]) == 0
    """

    arr_reversed, cnt = arr[::-1], 0
    for i in range(len(arr) // 2):
        if arr[i] != arr_reversed[i]:
            cnt += 1
    return cnt


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def total_match(lst1, lst2):
    """
    Напишите функцию, которая принимает на вход два списка строк и возвращает список, в котором общее количество символов во всех строках меньше, чем в другом списке.
если в двух списках одинаковое количество символов, верните первый список.
 Примеры:
 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']
    """

    c1, c2 = sum(map(lambda s: len(s), lst1)), sum(map(lambda s: len(s), lst2))
    return lst1 if c1 <= c2 else lst2


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def is_multiply_prime(a):
    """Напишите функцию, которая возвращает True, если заданное число является произведением трех простых чисел и False в противном случае. Учтите, что (a) меньше 100.
 Пример:
 is_multiply_prime(30) == True
 30 = 2 * 3 * 5
    """

    if a <= 1: return False
    isprime = [True] * (a + 1)
    for i in range(2, a + 1):
        if isprime[i]:
            for j in range(i + i, a + 1, i):
                isprime[j] = False
    cnt, tmp = 0, a
    for i in range(2, a + 1):
        while isprime[i] and tmp % i == 0:
            tmp //= i
            cnt += 1
    return cnt == 3


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def is_simple_power(x, n):
    """Ваша задача — написать функцию, которая возвращает true, если число x является простой степенью n, и false в остальных случаях.
x — простая степень n, если n**int=x.
 Примеры:
 is_simple_power(1, 4) => true
 is_simple_power(2, 2) => true
 is_simple_power(8, 2) => true
 is_simple_power(3, 2) => false
 is_simple_power(3, 1) => false
 is_simple_power(5, 3) => false
    """

    if x == 1: return True
    if n == 0: return x == 0
    if n == 1: return x == 1
    if n == -1: return abs(x) == 1
    p = n
    while abs(p) <= abs(x):
        if p == x: return True
        p = p * n
    return False


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def iscube(a):
    """
    Напишите функцию, которая принимает на вход целое число a и возвращает True, если оно является кубом некоторого целого числа.
Примечание: вы можете предположить, что ввод всегда действителен.
 Примеры:
 iscube(1) ==> True
 iscube(2) ==> False
 iscube(-1) ==> True
 iscube(64) ==> True
 iscube(0) ==> True
 iscube(180) ==> False
    """

    a = abs(a)
    return int(round(a ** (1. / 3))) ** 3 == a


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

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.
    """

return len(list(filter(lambda x: x in "2357BD", num)))


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def decimal_to_binary(decimal):
    """Вам будет дано число в десятичной форме, и ваша задача — преобразовать его в двоичный формат. Функция должна возвращать строку, в которой каждый символ представляет собой двоичное число. Каждый символ в строке будет равен «0» или «1».
В начале и в конце строки будет дополнительная пара символов «db».
Дополнительные символы нужны для форматирования.
 Примеры:
 decimal_to_binary(15)   # возвращает 'db1111db'
 decimal_to_binary(32)   # возвращает 'db100000db'
    """


Instruction:
Реши задачу по программированию
{function}

def is_happy(s):
    """Вам дана строка s. Ваша задача — проверить, счастливая строка или нет. Строка считается счастливой, если ее длина не менее 3 и каждые 3 последовательные буквы различны.
 Примеры:
     is_happy(a) => False
     is_happy(aa) => False
     is_happy(abcd) => True
     is_happy(aabb) => False
     is_happy(adb) => True
     is_happy(xyy) => False
    """

    if len(s) < 3: return False
    for i in range(len(s) - 2):
        if s[i] == s[i + 1] or s[i] == s[i + 2] or s[i + 1] == s[i + 2]:
            return False
    return True


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def numerical_letter_grade(grades):
    """Это последняя неделя семестра, и учитель должен выставить студентам оценки. Учительница разработала собственный алгоритм выставления оценок. Единственная проблема в том, что она потеряла код, который использовала для выставления оценок. Она предоставила вам список оценок GPAs некоторых студентов, и вам нужно написать функцию, которая сможет вывести список буквенных оценок, используя следующую таблицу:
             GPA       |    Letter grade
               4.0                A+
             > 3.7                A
             > 3.3                A-
             > 3.0                B+
             > 2.7                B
             > 2.3                B-
             > 2.0                C+
             > 1.7                C
             > 1.3                C-
             > 1.0                D+
             > 0.7                D
             > 0.0                D-
               0.0                E
 Пример:
     grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

    def to_letter_grade(score):
      if score == 4.0:
        return "A+"
      elif score > 3.7:
        return "A"
      elif score > 3.3:
        return "A-"
      elif score > 3.0:
        return "B+"
      elif score > 2.7:
        return "B"
      elif score > 2.3:
        return "B-"
      elif score > 2.0:
        return "C+"
      elif score > 1.7:
        return "C"
      elif score > 1.3:
        return "C-"
      elif score > 1.0:
        return "D+"
      elif score > 0.7:
        return "D"
      elif score > 0.0:
        return "D-"
      else:
        return "E"

    return [to_letter_grade(x) for x in grades]


Instruction:
Напишите программу по строке документации
{function}

def prime_length(string):
    """Напишите функцию, которая принимает на вход строку и возвращает True, если длина строки является простым числом, или False в противном случае.
Примеры:
     prime_length('Hello') == True
     prime_length('abcdcba') == True
     prime_length('kittens') == True
     prime_length('orange') == False
    """

[{'string': 'a'}, {'string': 'ab'}, {'string': 'abc'}, {'string': 'abcd'}, {'string': 'abcde'}, {'string': 'abcdef'}, {'string': 'abcdefg'}, {'string': 'abcdefgh'}, {'string': 'abcdefghi'}, {'string': 'zyxwvutsrqponmlkjihgfedcba'}]

    def is_prime(a):
        return not (a < 2 or any(a % x == 0 for x in range(2, int(a ** 0.5) + 1)))

    return is_prime(len(string))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def starts_one_ends(n):
    """Дано положительное целое число n, верните количество n-значных положительных целых чисел, которые начинаются или заканчиваются на 1.
    """

    if n == 1: return 1
    return 18 * 10 ** (n - 2)


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def solve(N):
    """Дано положительное целое число N, верните общую сумму его цифр в двоичном формате.
    Примеры:
         Для N = 1000 сумма цифр будет равна 1, выход должен быть «1».
         Для N = 150 сумма цифр будет равна 6, на выходе должно быть «110».
         Для N = 147 сумма цифр будет равна 12, на выходе должно быть «1100».
     Переменные:
         @N целое число
              Ограничения: 0 ≤ N ≤ 10000.
     Выход:
          строка двоичного числа
    """

    s = sum(map(lambda x: int(x), str(N)))
    return bin(s)[2:]


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def add(lst):
    """Дан непустой список целых чисел lst. Сложите четные элементы с нечетными индексами.
Примеры:
 add([4, 2, 6, 7]) ==> 2
    """

    s = 0
    for i in range(1, len(lst), 2):
        if lst[i] % 2 == 0:
            s += lst[i]
    return s


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def anti_shuffle(s):
    """Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
Упорядоченная версия строки — это строка, в которой все слова (разделенные пробелом) заменены новым словом, в котором все символы расположены в порядке возрастания, основываясь на значении ascii.
Примечание. В предложении следует сохранить порядок слов и пробелов.
Примеры:
     anti_shuffle('Hi') возвращает 'Hi'
     anti_shuffle('hello') возвращает 'ehllo'
     anti_shuffle('Hello World!!!') возвращает 'Hello !!!Wdlor'
    """

[{'s': '12345'}, {'s': '\n\n123 456\n789\n'}, {'s': 'Mary had a little lamb'}, {'s': 'Racecar'}, {'s': '!!!'}, {'s': 'The quick brown fox jumps over the lazy dog.'}, {'s': 'This is a test.'}, {'s': '1, 2, 3, testing!'}, {'s': 'Quick brown fox'}, {'s': 'The quick brown fox jumps over the lazy dog'}]

Teh cikqu bnorw fox jmpsu eorv eht alyz .dgo

Teh cikqu bnorw fox jmpsu eorv eht alyz dgo

    words = s.split(" ")
    return " ".join(map(lambda x: "".join(sorted(x, key=lambda ch: ord(ch))), words))


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def get_row(lst, x):
    """Вам предоставляются двумерные данные в виде вложенных списков, которые похожи на матрицу, однако, в отличие от матриц, каждая строка может содержать разное количество столбцов.    Дано lst и целое число x, найдите в списке целые числа равные x и верните список кортежей [(x1, y1), (x2, y2) ...] таких, что каждый кортеж представляет собой координату — (строку, столбец), начиная с 0.
Первоначально отсортируйте координаты по строкам в порядке возрастания.
Также отсортируйте координаты строки по столбцам в порядке убывания.
Примеры:
     get_row([
       [1,2,3,4,5,6],
       [1,2,3,4,1,6],
       [1,2,3,4,5,1]
     ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
     get_row([], 1) == []
     get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

    res = []
    for i, l in enumerate(lst):
        for j in range(len(l) - 1, -1, -1):
            if l[j] == x: res.append((i, j))
    return res


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def sort_array(array):
    """Дан массив неотрицательных целых чисел, верните копию данного массива после сортировки. Вы отсортируете данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетна, или отсортируете его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) четная.     Примечание:
     * не изменяйте данный массив.
Примеры:
     * sort_array([]) => []
     * sort_array([5]) => [5]
     * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
     * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

    if array == []: return []
    return sorted(array, reverse=(array[0]+array[-1]) % 2 == 0)


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def encrypt(s):
    """Создайте функцию encrypt, которая принимает строку в качестве аргумента и возвращает строку, зашифрованную при помощи измененного алфавита.
Алфавит следует модифицировать таким образом, чтобы буквы смещались вниз на два умноженное на два места.
Примеры:
     encrypt('hi') возвращает 'lm'
     encrypt('asdfghjkl') возвращает 'ewhjklnop'
     encrypt('gf') возвращает 'kj'
     encrypt('et') возвращает 'ix'
    """

    d = 'abcdefghijklmnopqrstuvwxyz'
    return "".join(map(lambda ch: chr((ord(ch) - ord("a") + 4) % 26 + ord("a")) if ch in d else ch, s))


Instruction:
Реши задачу по программированию
{function}

def next_smallest(lst):
    """Вам дан список целых чисел.
Напишите функцию next_smallest(), которая возвращает второй наименьший элемент списка.
Верните None, если такого элемента нет.
Примеры:
    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

    if len(lst) <= 1: return None
    sorted_list = sorted(lst)
    for x in sorted_list:
        if x != sorted_list[0]:
            return x


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def is_bored(S):
    """Вам дан список слов, ваша задача — посчитать количество скуки. Скука – это предложение, которое начинается с буквы «I».
Предложения разделяются символами «.», «?» или '!'.
Примеры:
    is_bored('Hello world')
    0
    is_bored('The sky is blue. The sun is shining. I love this weather')
    1
    """

[{'S': 'I am very happy today. I love spending time with my friends.'}, {'S': 'I want to eat pizza for dinner. What do you think, should we order pizza?'}, {'S': 'I enjoy reading books. They help me learn new things.'}, {'S': 'I forgot my phone in the car. Oh no, now I have to go back and get it.'}, {'S': 'In the morning, I like to have a cup of coffee to start my day off right. How about you?'}, {'S': 'Have you ever gone skydiving before? I did it once and it was amazing.'}, {'S': 'I think I want to try cooking something new for dinner tonight. Do you have any favorite recipes?'}, {'S': 'The movie we saw last night was really good, but I think I would have enjoyed it more if I had some popcorn. Do you like popcorn?'}, {'S': 'I love to read books. What about you?'}, {'S': 'I have a lot of work to do today. I wish I could take a nap instead.'}]

    sentences = map(lambda x: x.strip(), ((S.replace("?", ".")).replace("!", ".")).split("."))
    return len([s for s in sentences if s.startswith("I ")])


Instruction:
Напишите программу по строке документации
{function}

def any_int(x, y, z):
    """
    Создайте функцию, которая принимает на вход 3 числа.
Возвращает True, если одно из чисел равно сумме двух других и все числа являются целыми числами.
Возвращает False в любых других случаях.
Примеры:
    any_int(5, 2, 7) ➞ True
    any_int(3, 2, 2) ➞ False
    any_int(3, -2, 1) ➞ True
    any_int(3.6, -2.2, 2) ➞ False
    """

    if type(x) != int or type(y) != int or type(z) != int: return False
    return x == y + z or y == x + z or z == y + x


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def encode(message):
    """Напишите функцию, которая принимает на вход сообщение и кодирует его таким образом, что меняет регистр всех букв, заменяет все гласные в сообщении буквой, которая стоит на 2 позиции дальше по порядку от этой гласной в английском алфавите.
Рассматриваются только буквы.
Примеры:
    encode('test')
    'TGST'
    encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

[{'message': 'abcdefghijklmnopqrstuvwxyz'}, {'message': 'ZYXWVUTSRQPONMLKJIHGFEDCBA'}, {'message': 'Python is awesome'}, {'message': 'Quick brown fox jumps over the lazy dog'}, {'message': 'The quick brown fox jumps over the lazy dog'}, {'message': 'Every good boy does fine'}, {'message': 'ABCDEF'}, {'message': 'The cat in the hat'}, {'message': 'to be or not to be'}, {'message': 'Testing encode function'}]

tHG QWKCK BRQWN FQX JWMPS QVGR THG LCZY DQG

    def switch_case(ch):
        if ord("A") <= ord(ch) <= ord("Z"):
            return chr(ord(ch) + 32)
        elif ord("a") <= ord(ch) <= ord("z"):
            return chr(ord(ch) - 32)
        else:
            return ch

    def vowel_change(ch):
        return ch if ch not in "aeiouAEIOU" else chr(ord(ch) + 2)

    m = "".join(map(switch_case, message))
    return "".join(map(vowel_change, m))


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

    def is_prime(a):
        return not (a < 2 or any(a % x == 0 for x in range(2, int(a ** 0.5) + 1)))
    sorted_list = sorted(lst)[::-1]
    for x in sorted_list:
        if is_prime(x):
            return sum(map(lambda ch: int(ch), str(x)))


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def check_dict_case(dict):
    """Дан словарь, верните True, если все ключи представляют собой строки в нижнем регистре или все ключи являются строками в верхнем регистре, в противном случае верните False.
Функция должна возвращать False, если данный словарь пуст.
Примеры:
    check_dict_case({'a':'apple', 'b':'banana'}) возвращает True.
    check_dict_case({'a':'apple', 'A':'banana', 'B':'banana'}) возвращает False.
    check_dict_case({'a':'apple', 8:'banana', 'a':'apple'}) возвращает False.
    check_dict_case({'Name':'John', 'Age':'36', 'City':'Houston'}) возвращает False.
    check_dict_case({'STATE':'NC', 'ZIP':'12345'}) возвращает True.
    """

    keys = list(dict.keys())
    if keys == []: return False
    lower, upper = True, True
    for k in keys:
        if type(k) != str:
            lower = upper = False
            break
        if not k.islower(): lower = False
        if not k.isupper(): upper = False
    return lower or upper


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def count_up_to(n):
    """Реализуйте функцию, которая принимает на вход неотрицательное целое число и возвращает массив из первых n целых чисел, которые являются простыми числами и меньше n.
Примеры:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

    ans = []
    isprime = [True] * (n + 1)
    for i in range(2, n):
        if isprime[i]:
            ans.append(i)
            for j in range(i + i, n, i):
                isprime[j] = False
    return ans


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def multiply(a, b):
    """Напишите функцию, которая принимает два целых числа и возвращает произведение их единичных разрядов.. Предположим, что входные данные всегда действительны.
Примеры:
    multiply(148, 412) возвращает 16.
    multiply(19, 28) возвращает 72.
    multiply(2020, 1851) возвращает 0.
    multiply(14,-15) возвращает 20.
    """

return int(str(a)[-1]) * int(str(b)[-1])


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def count_upper(s):
    """Дана строка s, подсчитайте количество гласных в верхнем регистре на четных индексах.
Примеры:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

[{'s': 'DbdOH'}, {'s': 'abcDEf'}, {'s': 'AEOIU'}, {'s': 'XYZ'}, {'s': 'uEi'}, {'s': 'ABCD'}, {'s': 'hhEErrRR'}, {'s': 'AbCdEfGhIjKlMnOpQrStUvWxYz'}, {'s': 'UOIEA'}, {'s': 'bbcefg'}]

    cnt = 0
    for i in range(0, len(s), 2):
        if s[i] in "AEIOU":
            cnt += 1
    return cnt


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def closest_integer(value):
    """
    Напишите функцию, которая принимает на вход строку value, представляющее число, и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел, округлите вверх по модулю.
Примеры:
    closest_integer('10')
    10
    closest_integer('15.3')
    15
    Примечание:
    Округление вверх по модулю означает, что если данное число равноудалено от двух целых чисел, то вам следует вернуть то, которое находится дальше всего от нуля. Например, close_integer('14.5') должна вернуть 15, а close_integer('-14.5') должна вернуть -15.
    """

    def rounding(val):
        if abs(val - int(val)) != 0.5:
            return round(val)
        if val > 0:
            return int(val) + 1
        else:
            return int(val) - 1
    return rounding(float(value))


Instruction:
Реши задачу по программированию
{function}

def make_a_pile(n):
    """Дано целое положительное число n, вам нужно сложить груду камней из n уровней.
На первом уровне n камней.
Количество камней на следующем уровне:
    - следующее нечетное число, если n нечетно
    - следующее четное число, если n четно.
Верните количество камней на каждом уровне в виде списка, где элемент по индексу i представляет количество камней на уровне (i+1).
     Примеры:
        make_a_pile(3)
        [3, 5, 7]
    """

    ans, num = [], n
    for _ in range(n):
        ans.append(num)
        num += 2
    return ans


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def words_string(s):
    """На вход даётся строка слов, разделенных запятыми или пробелами. Ваша задача — разбить строку на слова и вернуть список слов.
Примеры:
    words_string('Hi, my name is John') == ['Hi', 'my', 'name', 'is', 'John']
    words_string('One, two, three, four, five, six') == ['One', 'two', 'three', 'four', 'five', 'six']
    """

[{'s': ',,,,'}, {'s': ' '}, {'s': 'Elephant,giraffe,,lion,zebra'}, {'s': 'Hi,there is,a lot,of,space   ,     ,'}, {'s': '        '}, {'s': 'apple,'}, {'s': 'cat dog, fish'}, {'s': 'hello,  world'}, {'s': 'One,two ,  three , four'}, {'s': 'The quick brown fox jumps over the lazy dog'}]

['Elephant', 'giraffe', 'lion', 'zebra']

['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']

    words = (s.replace(",", " ")).split()
    return [word for word in words if word != ""]


Instruction:
Напишите программу по строке документации
{function}

def choose_num(x, y):
    """Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, функция должна вернуть -1.
    Примеры:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

    if x > y: return -1
    if x == y: return y if y % 2 == 0 else -1
    return y if y % 2 == 0 else y - 1


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

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'
    """

    if n > m: return -1
    avg = round((n + m) / 2)
    return bin(avg)


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def unique_digits(x):
    """Дан список натуральных чисел x. Верните отсортированный список всех элементов, в которых нет четных цифр.    Примечание. Возвращаемый список должен быть отсортирован по возрастанию.
    Примеры:
    unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    unique_digits([152, 323, 1422, 10])
    []
    """

    def judge(x):
        for ch in str(x):
            if int(ch) % 2 == 0:
                return False
        return True
    return sorted(list(filter(judge, x)))


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def by_length(arr):
    """Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно, разверните полученный массив, а затем замените каждую цифру соответствующим именем из списка "Один", "Два", "Три", "Четыре", "Пять", "Шесть", "Семь", "Восемь", "Девять".
    Примеры:
      arr = [2, 1, 1, 4, 5, 8, 2, 3] -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Восемь", "Пять", "Четыре", "Три", "Два", "Два", "Один", "Один"]
      Если массив пуст, верните пустой массив:
      arr = []
      return []
      Если в массиве есть какое-то странное число, игнорируйте его:
      arr = [1, -1 , 55] -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ["Один"]
    """

['Nine', 'Eight', 'Seven', 'Six', 'Five', 'Four', 'Three', 'Two', 'One']

['Nine', 'Eight', 'Six', 'Five', 'Five', 'Two', 'One', 'One']

['Nine', 'Eight', 'Seven', 'Five', 'Four', 'Three', 'Two', 'One']

['Nine', 'Eight', 'Seven', 'Six', 'Five', 'Four', 'Three', 'Two', 'One']

['Three', 'Three', 'Three', 'Three', 'Three', 'Three']

['Nine', 'Eight', 'Seven', 'Six', 'Five', 'Four', 'Three', 'Two', 'One']

['Nine', 'Nine', 'Nine', 'Eight', 'Eight', 'Eight', 'Seven', 'Seven', 'Seven', 'One', 'One', 'One']

['Nine', 'Eight', 'Seven', 'Six', 'Five', 'Three', 'Two', 'One']

['Nine', 'Eight', 'Seven', 'Six', 'Four']

    def to_word(x: int) -> str:
      if x == 1:
        return "One"
      elif x == 2:
        return "Two"
      elif x == 3:
        return "Three"
      elif x == 4:
        return "Four"
      elif x == 5:
        return "Five"
      elif x == 6:
        return "Six"
      elif x == 7:
        return "Seven"
      elif x == 8:
        return "Eight"
      else:
        return "Nine"
    sorted_list, ans = sorted(arr)[::-1], []
    for x in sorted_list:
      if 1 <= x <= 9:
        ans.append(to_word(x))
    return ans


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def f(n):
    """Реализуйте функцию f, которая принимает n в качестве параметра и возвращает список размера n, такой, что значение элемента с индексом i является факториалом i, если i четное, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i — это перемножение чисел от 1 до i (1 * 2 * ... * i).
    Примеры:
      f(5) == [1, 2, 6, 24, 15]
    """

    if n == 0: return []
    if n == 1: return [1]
    if n == 2: return [1, 2]

    ans = [1, 2]
    for i in range(3, n + 1):
        if i % 2 == 1:
            ans.append(ans[-2] + (i - 1) + i)
        else:
            ans.append(ans[-2] * (i - 1) * i)
    return ans


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def even_odd_palindrome(n):
    """Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных целочисленных палиндромов, попадающих в диапазон (1, n) включительно.
    Примеры:
        Input: 3
        Output: (1, 2)
        Пояснение:
        Целочисленные палиндромы — это 1, 2, 3. один из них четный, а два нечетных.

        Input: 12
        Output: (4, 6)
        Пояснение:
        Целочисленные палиндромы — это 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Четыре из них четные, а 6 — нечетные.
        Примечание:
        1. 1 <= n <= 10^3
        2. возвращаемый кортеж включает в себя количество четных и нечетных целочисленных палиндромов соответственно.
    """

    odd_cnt, even_cnt = 0, 0
    for i in range(1, n + 1):
        if str(i) == str(i)[::-1]:
            if i % 2 == 1:
                odd_cnt += 1
            else:
                even_cnt += 1
    return even_cnt, odd_cnt


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def count_nums(arr):
    """Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0. Если число отрицательное, то его первая цифра со знаком будет отрицательной: например. -123 это -1, 2 и 3.
    Примеры:
        count_nums([]) == 0
        count_nums([-1, 11, -11]) == 1
        count_nums([1, 1, 2]) == 3
    """

    def judge(x: int) -> int:
        l = list(str(x))
        if l[0] == "-":
            l = l[1:]
            l = list(map(int, l))
            l[0] = -l[0]
        else:
            l = list(map(int, l))
        return 1 if sum(l) > 0 else 0
    return sum(map(judge, arr))


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def move_one_ball(arr):
    """У нас есть массив arr из N целых чисел arr[1], arr[2], ..., arr[N]. Числа в массиве будут упорядочены случайным образом. Ваша задача — определить, можно ли отсортировать массив в неубывающем порядке, выполнив над данным массивом следующую операцию:
Вам разрешено выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию массива, т.е. на 0-й индекс.
Если можно получить отсортированный массив, выполнив описанную выше операцию, верните True, иначе верните False.
Если данный массив пуст, верните True.
Примечание. Данный список гарантированно содержит уникальные элементы.
    Примеры:
    move_one_ball([3, 4, 5, 1, 2])==>True
    Пояснение: Выполнив две операции сдвига вправо, можно добиться неубывающего порядка для данного массива.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Пояснение: Невозможно получить неубывающий порядок для данного массива, выполнив любое количество операций сдвига вправо.
    """

    sorted_arr = sorted(arr)
    if arr == sorted_arr: return True
    for i in range(1, len(arr)):
        if arr[i:] + arr[:i] == sorted_arr:
            return True
    return False


Instruction:
Реши задачу по программированию
{function}

def exchange(lst1, lst2):
    """Реализуйте функцию, которая принимает на вход два списка чисел и определяет, можно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только из четных чисел.
Нет ограничений на количество обмениваемых элементов между lst1 и lst2.
Если можно поменять местами элементы между lst1 и lst2, чтобы сделать все элементы lst1 четными, верните «YES».
В противном случае верните «NO».
    Примеры:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => 'YES'
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => 'NO'
    Предполагается, что входные списки будут непустыми.
    """

    cnt_odd = len(list(filter(lambda x: x % 2 == 1, lst1)))
    cnt_even = len(list(filter(lambda x: x % 2 == 0, lst2)))
    return "YES" if cnt_odd <= cnt_even else "NO"


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def histogram(test):
    """Дана строка, представляющая собой строчные буквы, разделенные пробелами, верните словарь букв с наибольшим количеством повторений и содержащий их соответствующее количество.
Если несколько букв встречаются одинаково часто, верните их все.
    Примеры:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}
    """

[{'test': 'x y z x y z x'}, {'test': 'c a r s'}, {'test': 'h e l l o'}, {'test': 'a b b b b b'}, {'test': 'p u z z l e'}, {'test': 'a a a a a a a b b b b b b b'}, {'test': 'c c c c b b b a a a'}, {'test': 'p p p r r r'}, {'test': 'a b c d e f g'}, {'test': 'h i j j k l m m m n o o o o p'}]

    if test == "": return {}
    count, ans = dict(), dict()
    for word in test.split(" "):
        if word != "":
            if word not in count: count[word] = 0
            count[word] += 1
    mx = max(list(count.values()))
    for ch, c in count.items():
        if c == mx:
            ans[ch] = c
    return ans


Instruction:
Напишите программу по строке документации
{function}

def reverse_delete(s,c):
    """Даны две строки s и c, вам нужно удалить все символы в s, которые присутствуют в c, а затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается одинаково как в прямом, так и в обратном направлении.
Вы должны вернуть кортеж, содержащий получившуюся строку и значение True/False для проверки.
    Примеры:
    Для s = 'abcde', c = 'ae', ответ должен быть ('bcd',False)
    Для s = 'abcdef', c = 'b'  ответ должен быть ('acdef',False)
    Для s = 'abcdedcba', c = 'ab', ответ должен быть ('cdedc',True)
    """

    ss = "".join(filter(lambda ch: ch not in c, s))
    return ss, ss == ss[::-1]


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def odd_count(lst):
    """Дан список строк, где каждая строка состоит только из цифр, верните список. Каждый элемент i выходных данных должен представлять собой строку: 'the number of odd elements in the string i of the input.' где все i должны быть заменены количеством нечетных цифр в i-й строке входа.
    Примеры:
    odd_count(['1234567'])
    ['the number of odd elements 4n the str4ng 4 of the 4nput.']
    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.']
    """

['the number of odd elements 0n the str0ng 0 of the 0nput.']

['the number of odd elements 0n the str0ng 0 of the 0nput.', 'the number of odd elements 0n the str0ng 0 of the 0nput.', 'the number of odd elements 0n the str0ng 0 of the 0nput.']

['the number of odd elements 5n the str5ng 5 of the 5nput.', 'the number of odd elements 0n the str0ng 0 of the 0nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.']

['the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 5n the str5ng 5 of the 5nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.']

['the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.']

['the number of odd elements 0n the str0ng 0 of the 0nput.', 'the number of odd elements 0n the str0ng 0 of the 0nput.']

['the number of odd elements 3n the str3ng 3 of the 3nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.']

['the number of odd elements 4n the str4ng 4 of the 4nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.', 'the number of odd elements 4n the str4ng 4 of the 4nput.']

['the number of odd elements 2n the str2ng 2 of the 2nput.', 'the number of odd elements 2n the str2ng 2 of the 2nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.']

    ans, template = [], "the number of odd elements in the string i of the input."
    for s in lst:
        odd_cnt = len(list(filter(lambda ch: int(ch) % 2 == 1, s)))
        ans.append(template.replace("i", str(odd_cnt)))
    return ans


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

import math

def minSubArraySum(nums):
    """Дана последовательность целых чисел nums, найдите минимальную сумму любой непустой подпоследовательности чисел.
    Примеры:
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

    if all(x >= 0 for x in nums): return min(nums)
    s, ans = 0, 0
    for x in nums:
        s += x
        ans = min(ans, s)
        if s >= 0: s = 0
    return ans


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def max_fill(grid, capacity):
    import math
    """Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой одну скважину, а каждая единица в строке представляет одну единицу воды.
У каждого колодца есть соответствующее ведро, с помощью которого можно добывать из него воду, и все ведра имеют одинаковую вместимость.
Ваша задача — использовать ведра для опорожнения колодцев.
Выведите сколько раз вам нужно будет опустить ведра.
    Примеры:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0
        Ограничения:
        * все колодцы имеют одинаковую длину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

    ans = 0
    for l in grid:
        ans += math.ceil(sum(l) / capacity)
    return ans


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def sort_array(arr):
    """В этом задании вам нужно отсортировать массив целых чисел по количеству единиц в их двоичном представлении значений их модулей в порядке возрастания.
Для одинакового количества единиц выполните сортировку на основе их десятичного значения.
Должно быть реализовано так:
    sort_array([1, 5, 2, 3, 4]) == [1, 2, 4, 3, 5]
    sort_array([-2, -3, -4, -5, -6]) == [-4, -2, -6, -5, -3]
    sort_array([1, 0, 2, 3, 4]) ==  [0, 1, 2, 4, 3]
    """

    from functools import cmp_to_key
    def cmp(x: int, y: int) -> int:
        x1 = len(list(filter(lambda ch: ch == "1", bin(x))))
        y1 = len(list(filter(lambda ch: ch == "1", bin(y))))
        if x1 != y1: return x1 - y1
        return x - y
    return sorted(arr, key=cmp_to_key(cmp))


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def select_words(s, n):
    """Даны строка s и натуральное число n, вам было поручено реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в том порядке, в котором эти слова появляются в строке s.
Если строка s пуста, функция должна вернуть пустой список.
Примечание: вы можете предположить, что входная строка содержит только буквы и пробелы.
    Примеры:
    select_words('Mary had a little lamb', 4) ==> ['little']
    select_words('Mary had a little lamb', 3) ==> ['Mary', 'lamb']
    select_words('simple white space', 2) ==> []
    select_words('Hello world', 4) ==> ['world']
    select_words('Uncle sam', 3) ==> ['Uncle']
    """

[{'s': 'apple banana cherry', 'n': 3}, {'s': 'random words are fun to write', 'n': 5}, {'s': 'the quick brown fox jumps over the lazy dog', 'n': 6}, {'s': 'the cat in the hat', 'n': 2}, {'s': 'jingle bells jingle bells jingle all the way', 'n': 8}, {'s': 'Python is a popular programming language', 'n': 3}, {'s': '', 'n': 1}, {'s': 'this is a test string with multiple words containing different numbers of consonants', 'n': 7}, {'s': 'quack quack goes the duck', 'n': 2}, {'s': 'ThE qUiCk BrOwN fOx JuMpS oVeR tHe LaZy DoG', 'n': 6}]

    ans = []
    for word in s.split(" "):
        if word != "":
            c_cnt = len(list(filter(lambda ch: ch not in "aeiouAEIOU", word)))
            if c_cnt == n: ans.append(word)
    return ans


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def get_closest_vowel(word):
    """На вход подается слово word. Ваша задача — найти ближайшую  с правой стороны слова гласную, стоящую между двумя согласными с учетом регистра.
Гласные в начале и конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, соответствующей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы.
    Примеры:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

    def is_vowel(ch: str) -> bool:
        return ch in "aeiouAEIOU"
    for i in range(len(word) - 2, 0, -1):
        if is_vowel(word[i]) and not is_vowel(word[i-1]) and not is_vowel(word[i+1]):
            return word[i]
    return ""


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def match_parens(lst):
    """Вам дан список из двух строк, обе строки состоят только из открывающих скобок '(' или закрывающих скобок ')'.
Ваша задача — проверить, можно ли объединить две строки в каком-то порядке, чтобы полученная строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в ней сбалансированы. Например: строка «(())()» хорошая, а строка «())» — нет.
Верните «Yes», если есть способ создать хорошую строку, и верните «No» в противном случае.
    Примеры:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    """

    def valid_parens(s: str) -> bool:
        cnt = 0
        for ch in s:
            cnt = cnt + 1 if ch == "(" else cnt - 1
            if cnt < 0: return False
        return cnt == 0
    return "Yes" if valid_parens(lst[0] + lst[1]) or valid_parens(lst[1] + lst[0]) else "No"


Instruction:
Реши задачу по программированию
{function}

def maximum(arr, k):
    """Дан массив целых чисел arr и положительное целое число k, верните отсортированный список длины k с k максимальных чисел в arr.
    Пример 1:
        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]
    Пример 2:
        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]
    Пример 3:
        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]
    Примечание:
        1. Длина массива будет в диапазоне [1, 1000].
        2. Элементы массива будут находиться в диапазоне [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def solution(lst):
    """Дан непустой список целых чисел, верните сумму всех нечетных элементов, находящихся на четных позициях.
    Примеры:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

return sum(lst[i] for i in range(len(lst)) if i % 2 == 0 and lst[i] % 2 == 1)


Instruction:
Напишите программу по строке документации
{function}

def add_elements(arr, k):
    """Дан непустой массив целых чисел arr и целое число k, верните сумму элементов из первых k элементов arr, состоящих из не более двух цифр.
    Примеры:
        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3
    Ограничения:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

    def digits(x: int) -> int:
        s = str(x)
        return len(s) - 1 if s[0] == "-" else len(s)
    return sum(filter(lambda x: digits(x) <= 2, arr[:k]))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def get_odd_collatz(n):
    """Дано положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца — это математическая гипотеза, касающаяся последовательности, определяемой следующим образом: она начинается с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, следующий член равен половине предыдущего. Если предыдущий член нечетный, следующий член равен 3м предыдущим плюс 1. Гипотеза состоит в том, что независимо от значения n последовательность всегда будет достигать 1.
    Примечание:
        1. Коллатц(1) — это [1].
        2. Возвращаемый список должен быть отсортирован по возрастанию.
    Примеры:
        get_odd_collatz(5) возвращает [1, 5] # Последовательность коллатца для 5 — это [5, 16, 8, 4, 2, 1], нечетными числами являются только 1 и 5.
    """

    ans, x = [], n
    while x != 1:
        if x % 2 == 1: ans.append(x)
        x = x // 2 if x % 2 == 0 else x * 3 + 1
    ans.append(1)
    return sorted(ans)


Instruction:
Допишите код на языке Python в соответствии с условием, приведенным в описании
{function}

def valid_date(date):
    """Вам нужно написать функцию, которая проверяет заданную строку даты и возвращает True, если дата корректна, в противном случае — False.
Дата корректна, если соблюдены все следующие правила:
1. Строка даты не пуста.
2. Количество дней не менее 1 и не более 31 дня для 1,3,5,7,8,10,12 месяцев. А количество дней не менее 1 и не более 30 дней для 4,6,9,11 месяцев. При этом количество дней не менее 1 и не более 29 для месяца 2.
3. Число месяцев не должно быть меньше 1 и больше 12.
4. Дата должна быть в формате: мм-дд-гггг.
    Примеры:
        valid_date('03-11-2000') => True
        valid_date('15-01-2012') => False
        valid_date('04-0-2040') => False
        valid_date('06-04-2020') => True
        valid_date('06/04/2020') => False
    """

    days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if len(date) != 10: return False
    if date[2] != "-" or date[5] != "-": return False
    m, d, y = date[:2], date[3:5], date[6:]
    if not m.isdigit() or not d.isdigit() or not y.isdigit(): return False
    m, d = int(m), int(d)
    if not 1 <= m <= 12: return False
    if not 1 <= d <= days[m-1]: return False
    return True


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def split_words(txt):
    """Дана строка слов, верните список слов, разделенных пробелами. Если в тексте нет пробелов, вам следует разделить слова по запятым ',' если запятых нет, вы должны вернуть количество строчных букв строки, стоящих на нечетных местах в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Примеры:
        split_words('Hello world!') ➞ ['Hello', 'world!']
        split_words('Hello,world!') ➞ ['Hello', 'world!']
        split_words('abcdef') == 3
    """

[{'txt': 'Hello?'}, {'txt': 'abc deg'}, {'txt': 'aaa,bbb'}, {'txt': 'Hello World!'}, {'txt': '123,456'}, {'txt': 'abc123'}, {'txt': 'Hello , world !'}, {'txt': 'apple, banana, orange, grapefruit'}, {'txt': '1234'}, {'txt': 'HELLO WORLD'}]

['apple,', 'banana,', 'orange,', 'grapefruit']

    whitespace = tuple(' \n\r\t')
    if any([x in txt for x in whitespace]): return txt.split()
    if "," in txt: return txt.split(",")
    cnt = 0
    for ch in txt:
        if ch.islower() and (ord(ch) - ord("a")) % 2 == 1: cnt += 1
    return cnt


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def is_sorted(lst):
    """Дан список чисел, укажите, отсортированы ли они по возрастанию. Если в списке имеется более одного дубликата одного и того же числа, верните False. Предположим, что нет отрицательных чисел, а есть только целые числа.
    Примеры:
        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
    """

    count = dict()
    for x in lst:
        if x not in count: count[x] = 0
        count[x] += 1
        if count[x] > 2: return False
    return lst == sorted(lst)


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def intersection(interval1, interval2):
    """Вам даны два интервала, каждый из которых представляет собой пару целых чисел. Например, интервал = (начало, конец) = (1, 2).
Данные интервалы являются закрытыми, что означает, что интервал (начало, конец) включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его концу.
Ваша задача — определить, является ли длина пересечения этих двух интервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) — это (2, 3), длина которого равна 1, что не является простым числом.
Если длина пересечения является простым числом, верните «YES», в противном случае верните «NO».
Если два интервала не пересекаются, верните «NO».
Примеры:
 intersection((1, 2), (2, 3)) ==> 'NO'
 intersection((-1, 1), (0, 4)) ==> 'NO'
 intersection((-3, -1), (-5, 5)) ==> 'YES'
    """

    def is_prime(a):
        return not (a < 2 or any(a % x == 0 for x in range(2, int(a ** 0.5) + 1)))
    if interval1[0] > interval2[0]: interval1, interval2 = interval2, interval1
    l, r = interval2[0], min(interval1[1], interval2[1])
    return "YES" if is_prime(r - l) else "NO"


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def prod_signs(arr):
    """Вам дан массив целых чисел, и вам нужно вернуть сумму модулей этих целых чисел, умноженных на произведение всех знаков каждого числа в массиве, представленных в виде 1, -1 или 0.
    Примечание: верните None для пустого arr.
    Примеры:
    prod_signs([1, 2, 2, -4]) == -9
    prod_signs([0, 1]) == 0
    prod_signs([]) == None
    """

    if arr == []: return None
    if 0 in arr: return 0
    s, sgn = 0, 1
    for x in arr:
        s += abs(x)
        sgn *= (x // abs(x))
    return s * sgn