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

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

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


from typing import List

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

from typing import List

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

from typing import List

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


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

    Возвращает дробную часть числа.
    >>> truncate_number(3.5)
    0.5
    """

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

    Верните дробный остаток числа.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Учитывая положительное число с плавающей запятой, его можно разложить на
    и целая часть (наибольшее целое число, меньшее данного числа) и десятичные дроби
    (остаточная часть всегда меньше 1).

    Вернуть десятичную часть числа.
    >>> truncate_number(3.5)
    0.5
    """


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

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

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


from typing import List

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

from typing import List

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

from typing import List

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


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

from typing import List

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

from typing import List

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


from typing import List

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

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

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

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

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

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

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

from typing import List

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

из typing import List

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


from typing import List, Tuple

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

from typing import List, Tuple

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

from typing import List, Tuple

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


from typing import List, Tuple

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

from typing import List, Tuple

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

from typing import List, Tuple

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


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

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

def is_palindrome(string: str) -> bool:
    """ Test if given string is a palindrome """
    return string == string[::-1]

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


from typing import List

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

from typing import List

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

from typing import List

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


from typing import List, Optional

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

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

from typing import List, Optional

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

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

from typing import List, Optional

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

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


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

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


from typing import List

def all_prefixes(string: str) -> List[str]:
    """Возвращает список всех префиксов данной строки от самого короткого до самого длинного.

    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

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


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

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

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


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

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

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


from typing import List

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

    Вот легенда:
    'o' - целая нота, длится четыре удара
    'o|' - половинная нота, длится два удара
    '.|' - четвертная нота, длится один удар

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

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

    Вот легенда:
    'o' — целая нота, длится четыре доли
    'o|' — половинная нота, длится две доли
    '.|' — четвертная нота, длится одну долю

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

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

        Вот легенда:
        'o' - целая нота, длится четыре тактов
        'o|' - половинная нота, длится две тактов
        '.|' - четвёртная нота, длится одну долю такта

        >>> parse_music('o o| .| o| o| .| .| .| .| o o')
        [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
        """


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

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

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


from typing import List

def sort_numbers(numbers: str) -> str:
    """ Входные данные — это разделенная пробелами строка чисел от «нуля» до «девяти».
    Допустимые варианты: «ноль», «один», «два», «три», «четыре», «пять», «шесть», «семь», «восемь» и «девять».
    Верните строку с числами, отсортированными от наименьшего к наибольшему
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """Вводится строка, содержащая числительные от 'zero' до 'nine'.
    Допустимые варианты: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' и 'nine'.
    Верните строку с числами, отсортированными от наименьшего к наибольшему.

    Пример:
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Input - это разделенная пробелами строка числительных от" нуля "до" девяти ".
    Допустимые варианты: «ноль», «один», «два», «три», «четыре», «пять», «шесть», «семь», «восемь» и «девять».
    Возвращает строку с числительными, отсортированными от наименьшего к наибольшему
    >>> sort_numbers('three one five')
    'one three five'
    """


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

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

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


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

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

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


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

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

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


def strlen(string: str) -> int:
    """ Возвращает длину заданной строки
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Вернуть длину заданной строки
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


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

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

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


from typing import List

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

from typing import List

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

from typing import List

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


from typing import List

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

from typing import List

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

from typing import List

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


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

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

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


from typing import List

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

from typing import List

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

from typing import List

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


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

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

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


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

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


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

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

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


import math

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

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

import math

def poly(xs: list, x: float):
    """
    Оценивает полином с коэффициентами 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 принимает только список xs с четным числом коэффициентов
    и наибольшим ненулевым коэффициентом, поскольку это гарантирует
    решение.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

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

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


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

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

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


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

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

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


def max_element(l: list):
    """Возвращает максимальный элемент в списке.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


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

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

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


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

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

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


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_cyclic, и возвращает декодированную строку.
    """

def encode_cyclic(s: str):
    """
    возвращает закодированную строку путем циклического перебора групп из трех символов.
    """
    # split string to groups. Each of length 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycle elements in each group. Unless group has fewer elements than 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

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

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_cyclic. Возвращает декодированную строку.
    """


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

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

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


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

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

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


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

    Эта функция выводит количество таких столкновений.
    """

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

    Эта функция выводит количество таких столкновений.
    """

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

    Эта функция выводит количество таких столкновений.
    """


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

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


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

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

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


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

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

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


def triangle_area(a, h):

    """Напишите функцию, которая принимает длину стороны и высоту, и возвращает площадь треугольника.
    >>> triangle_area(5, 3)
    7.5
    """

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


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

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

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


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


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

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


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

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

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


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. Возвращает декодированную строку.
    """

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. Возвращает расшифрованную строку.
    """

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. Возвращает декодированную строку.
    """


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

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


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

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


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

def add(x: int, y: int):
    """Сложение двух чисел x и y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


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

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

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


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

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

def fib(n: int):
    """Возвращает n-ное число Фибоначчи.

    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets — это строка, содержащая символы "<" и ">".
    Функция возвращает True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

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

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets — это строка, состоящая из символов "<" и ">".
    return True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


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

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

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


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]

    """

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]

    """

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]

    """


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

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

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


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

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

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


def correct_bracketing(brackets: str):
    """ brackets — строка, состоящая из символов "(" и ")".
    Возвращает True, если каждая открывающая скобка имеет соответствующую закрывающую скобку.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ скобки - это строка из "(" and ")".
    возвращает значение True, если каждой открывающей скобке соответствует закрывающая скобка.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets — это строка, содержащая символы "(" и ")".
    возвращать True, если каждая открывающая скобка имеет соответствующую закрывающую.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


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

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


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

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

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


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

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

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Добавьте больше тестовых случаев.
"""

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

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Add more test cases.
"""

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

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


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

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

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


def digitSum(s):
    """Задача
    Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму ASCII-кодов
    только заглавных букв.

    Примеры:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Задача
    Напишите функцию, которая принимает строку в качестве аргумента и возвращает сумму ASCII-кодов только заглавных символов.

    Примеры:
    digitSum("") => 0
    digitSum("abAB") => 131
    digitSum("abcCd") => 67
    digitSum("helloE") => 69
    digitSum("woArBld") => 131
    digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Задача
    Напишите функцию, которая принимает строку в качестве входных данных и возвращает сумму только верхних символов

    кодов ASCII.

    Примеры:
    digitSum("") => 0
    digitSum("abAB") => 131
    digitSum("abcCd") => 67
    digitSum("helloE") => 69
    digitSum("woArBld") => 131
    digitSum("aAaaaXa") => 153
    """


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

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

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


def pluck(arr):
    """
    "Дан массив, представляющий ветвь дерева, которая имеет неотрицательные целые узлы
    ваша задача — выдернуть один из узлов и вернуть его.
    Выдернутый узел должен быть узлом с наименьшим четным значением.
    Если найдено несколько узлов с одинаковым наименьшим четным значением, вернуть узел с наименьшим индексом.

    Выдернутый узел должен быть возвращен в списке, [smalest_value, its index],
    Если нет четных значений или заданный массив пуст, вернуть [].

    Пример 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 — наименьшее значение, но есть два нуля, поэтому мы выберем первый ноль, который имеет наименьший индекс.

    Constraints:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Дан массив, представляющий ветвь дерева, имеющую узлы неотрицательного целого числа.
    ваша задача это вырвать один из узлов и вернуть его.
    Выдернутый узел должен быть узлом с наименьшим чётным значением.
    Если найдено несколько узлов с одинаковым наименьшим чётным значением, верните узел с наименьшим индексом.

    Выдернутый узел должен быть возвращён в виде списка [ smallest_value, its index ],
    Если чётных значений нет или данный массив пуст, верните [].

    Пример 1:
        Ввод: [4,2,3]
        Вывод: [2, 1]
        Пояснение: 2 имеет наименьшее четное значение, а 2 это наименьший индекс.

    Пример 2:
        Ввод: [1,2,3]
        Вывод: [2, 1]
        Пояснение: 2 имеет наименьшее четное значение, а 2 это наименьший индекс.

    Пример 3:
        Ввод: []
        Вывод: []

    Пример 4:
        Ввод: [5, 0, 3, 0, 4, 2]
        Вывод: [0, 1]
        Пояснение: 0 это наименьшее четное значение, но есть два нуля,
                     поэтому мы выберем первый ноль, имеющий наименьший индекс.

    Ограничения:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Дан массив, представляющий ветвь дерева, которая имеет неотрицательные целые узлы
    ваша задача — выдернуть один из узлов и вернуть его.
    Выдернутый узел должен быть узлом с наименьшим четным значением.
    Если найдено несколько узлов с одинаковым наименьшим четным значением, вернуть узел с наименьшим индексом.

    Выдернутый узел должен быть возвращен в списке [smalest_value, its index],
    Если нет четных значений или заданный массив пуст, вернуть [].

    Example 1:
        Input: [4,2,3]
        Output: [2, 1]
        Explanation: 2 имеет наименьшее четное значение, а 2 имеет наименьший индекс.

    Example 2:
        Input: [1,2,3]
        Output: [2, 1]
        Explanation: 2 имеет наименьшее четное значение, а 2 имеет наименьший индекс.

    Example 3:
        Input: []
        Output: []

    Example 4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        Explanation: 0 — наименьшее значение, но есть два нуля, поэтому мы выберем первый ноль, который имеет наименьший индекс.

    Constraints:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


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

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

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


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([]) == []
    '''

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([]) == []
    '''

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([]) == []
    '''


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

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

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


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 меньше максимально возможного веса, и он сбалансирован.
    '''

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 меньше максимально возможного веса и сбалансирован.
    '''

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 меньше максимального возможного веса и он сбалансирован.
    '''


def smallest_change(arr):
    """
    По заданному массиву arr целых чисел найти минимальное количество элементов, которое
    нужно изменить, чтобы сделать массив палиндромным. Палиндромный массив это массив, который
    читается одинаково вперёд и назад. Одним изменением вы можете изменить один элемент на любой другой.

    Например:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

```python
def smallest_change(arr):
    """
    Дано массив arr целых чисел. Найдите минимальное количество изменений, которые
    необходимо внести, чтобы массив стал палиндромом. Палиндромный массив — это массив,
    который читается одинаково как слева направо, так и справа налево. В одном изменении
    можно изменить один элемент на любой другой.

    Примеры:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Дано множество целых чисел arr, найдите минимальное количество элементов, которые
    нужно изменить, чтобы сделать массив палиндромным. Палиндромный массив — это массив, который
    читается одинаково вперед и назад. За одно изменение вы можете изменить один элемент на любой другой элемент.

    Например:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


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

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

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


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

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

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


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

def is_simple_power(x, n):
    """Ваша задача написать функцию, которая возвращает истину, если число x - это простая
    степень n, и возвращает ложь в других случаях.
    x - это простая степень n, если nk = x
    Например:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Функция принимает целое число a и возвращает True,
    если это число является кубом некоторого целого числа.
    Примечание: предполагается, что ввод всегда действителен.
    Примеры:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

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

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


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 всегда заглавные.
    Примеры:
    For num = "AB" the output should be 1.
    For num = "1077E" the output should be 2.
    For num = "ABED1A33" the output should be 4.
    For num = "123456789ABCDEF0" the output should be 6.
    For num = "2020" the output should be 2.
    """

def hex_key(num):
    """Вам было поручено написать функцию, которая получает
    шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных цифр,
    которые являются простыми числами (простое число, или простое число, это натуральное число,
    большее 1, которое не является произведением двух меньших натуральных чисел).
    Шестнадцатеричные цифры равны 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Простые числа это 2, 3, 5, 7, 11, 13, 17,...
    Итак, вам нужно определить количество следующих цифр: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    Примечание. вы можете предположить, что ввод всегда правильный или
    пустая строка, а символы A,B,C,D,E,F всегда заглавные.
    Примеры:
    Для num = "AB" вывод должен быть равен 1.
    Для num = "1077E" вывод должен быть равен 2.
    Для num = "ABED1A33" вывод должен быть равен 4.
    Для num = "123456789ABCDEF0" выход должен быть равен 6.
    Для num = "2020" вывод должен быть равен 2.
    """

def hex_key(num):
    """Вам было задано написать функцию, которая получает
    шестнадцатеричное число в виде строки и подсчитывает количество шестнадцатеричных
    цифр, которые являются простыми (простое число, или прайм, - это натуральное число
    больше 1, которое не является произведением двух меньших натуральных чисел).
    Шестнадцатеричные цифры - это 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Прайм-числа - это 2, 3, 5, 7, 11, 13, 17,...
    Поэтому вам нужно определить число из следующих цифр: 2, 3, 5, 7,
    B (=десятичное 11), D (=десятичное 13).
    Примечание: вы можете считать, что вводимые данные всегда верны или являются пустой строкой,
    а символы A,B,C,D,E,F всегда прописные.
    Примеры:
    Для num = «AB» на выходе должно получиться 1.
    Для num = «1077E» на выходе должно быть 2.
    Для num = «ABED1A33» должно быть 4.
    Для num = «123456789ABCDEF0» вывод должен быть 6.
    Для num = «2020» вывод должен быть 2.
    """


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

    В начале и в конце строки будут добавлены дополнительные символы 'db'.
    Эти дополнительные символы нужны для помощи в форматировании.

    Примеры:
    decimal_to_binary(15)   # возвращает "db1111db"
    decimal_to_binary(32)   # возвращает "db100000db"
    """

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

    В начале и в конце строки будет пара дополнительных символов «db».

    Дополнительные символы нужны для помощи с форматом.

    Примеры:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Вам будет дано число в десятичной форме, и ваша задача это преобразовать его в
    двоичный формат. Функция должна возвращать строку, каждый символ которой представляет двоичное число. Каждый символ в
    строке будет '0' или '1'.

    В начале и в конце строки будут добавлены символы 'db'
    Дополнительные символы здесь, чтобы помочь с форматом.

    Примеры:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


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

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

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


```python
def numerical_letter_grade(grades):
    """Это последняя неделя семестра, и преподаватель должна выставить оценки
    студентам. Преподаватель разработала собственный алгоритм оценки.
    Проблема в том, что она потеряла код, который использовала для оценивания.
    Она предоставила вам список GPA студентов, и вам нужно написать
    функцию, которая выводит список буквенных оценок, используя следующую таблицу:
             GPA       |    Буквенная оценка
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Пример:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Это последняя неделя семестра, и учитель должен ставить оценки
    студентам. Учительница разрабатывает свой собственный алгоритм выставления оценок.
    Единственная проблема в том, что она потеряла код, который использовала для оценки.
    Она дала вам список средних баллов для некоторых студентов, и вы должны написать
    функцию, которая может выводить список буквенных оценок с помощью следующей таблицы:
             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 numerical_letter_grade(grades):
    """Это последняя неделя семестра, и преподаватель должен выставить оценки
    студентам. Преподаватель создал свой собственный алгоритм для выставления оценок.
    Единственная проблема в том, что она потеряла код, который использовала для выставления оценок.
    Она дала вам список средних баллов некоторых студентов, и вам нужно написать
    функцию, которая может вывести список буквенных оценок, используя следующую таблицу:
             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

    Example:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


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

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

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


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

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

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


def solve(N):
    """Дано положительное целое число N, возвращает общую сумму его цифр в двоичной системе счисления.

    Пример:
        Для N = 1000, сумма цифр будет равна 1, вывод должен быть "1".
        Для N = 150, сумма цифр будет равна 6, вывод должен быть "110".
        Для N = 147, сумма цифр будет равна 12, вывод должен быть "1100".

    Переменные:
        @N целое число
             Ограничения: 0 ≤ N ≤ 10000.
    Вывод:
         строка с двоичным числом
    """

def solve(N):
    """Дано положительное целое число N, верните общую сумму его цифр в двоичной системе исчисления.

    Пример
        Для N = 1000, сумма цифр будет 1 выход должен быть "1".
        Для N = 150, сумма цифр будет 6 выход должен быть "110".
        Для N = 147, сумма цифр будет 12 выход должен быть "1100".

    Переменные:
        @N integer
             Ограничители: 0 ≤ N ≤ 10000.
    Выход:
        строка двоичных чисел
    """

def solve(N):
    """Учитывая положительное целое число N, верните общую сумму его цифр в двоичном формате.

    Пример
        Для N = 1000, сумма цифр будет равна 1, на выходе должно быть "1".
        Для N = 150, сумма цифр будет равна 6, на выходе должно быть "110".
        Для N = 147, сумма цифр будет равна 12, на выходе должно быть "1100".

    Переменные:
        @N integer
             Ограничения: 0 ≤ N ≤ 10000.
    Вывод:
         a string of binary number
    """


```python
def add(lst):
    """Дан непустой список целых чисел lst. Сложить четные элементы, которые находятся на нечетных индексах.

    Примеры:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Дан непустой список целых чисел lst. Добавьте чётные элементы, которые находятся по нечётным индексам..

    Примеры:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Дается непустой список целых чисел lst. Добавьте четные элементы, которые находятся на нечетных индексах.

    Примеры:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
    Упорядоченная версия строки — это строка, в которой все слова (разделенные пробелами)
    заменены на новые слова, где все символы расположены в порядке возрастания по значению ASCII.
    Примечание: следует сохранить порядок слов и пробелов в предложении.

    Например:
    anti_shuffle('Hi') возвращает 'Hi'
    anti_shuffle('hello') возвращает 'ehllo'
    anti_shuffle('Hello World!!!') возвращает 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Напишите функцию, которая принимает строку и возвращает ее упорядоченную версию.
    Упорядоченная версия строки — это строка, в которой все слова (разделенные пробелом)
    заменены новым словом, в котором все символы расположены в порядке возрастания на основе значения ASCII.
    Примечание: следует сохранять порядок слов и пробелов в предложении.

    Например:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Напишите функцию, которая принимает строку и возвращает её упорядоченную версию.
    Упорядоченная версия строки это строка, в которой все слова (разделённые пробелом)
    заменяются новым словом, в котором все символы расположены в
    в порядке возрастания на основе значения ascii.
    Примечание: В предложении следует соблюдать порядок слов и пробелов.

    Например:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Вам предоставлены двухмерные данные в виде вложенных списков,
    которые похожи на матрицу; однако, в отличие от матриц,
    каждая строка может содержать разное количество столбцов.
    Учитывая список и целое число x, найдите числа x в списке
    и выдайте список кортежей [(x1, y1), (x2, y2) ...], где
    каждый кортеж - это координата (строка, столбец), начиная с 0.
    Координаты должны быть отсортированы сначала по строкам в порядке возрастания.
    Также отсортируйте координаты строки по столбцам в порядке убывания.

    Примеры:
    get_row([
      [1, 2, 3, 4, 5, 6],
      [1, 2, 3, 4, 1, 6],
      [1, 2, 3, 4, 5, 1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Вам даны двумерные данные в виде вложенных списков,
    которые похожи на матрицы, однако, в отличие от матриц,
    каждая строка может содержать разное количество столбцов.
    Для заданного lst и целого числа x найдите целые числа x в списке,
    и верните список кортежей, [(x1, y1), (x2, y2) ...] такой, что
    каждый кортеж является координатой - (строка, столбцы), начиная с 0.
    Сначала отсортируйте координаты по строкам в порядке возрастания.
    Также отсортируйте координаты строки по столбцам в порядке убывания.

    Примеры:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Вам предоставляются 2-х мерные данные, в виде вложенных списков,
    которые похожи на матрицу, однако, в отличие от матриц,
    каждая строка может содержать разное количество столбцов.
    По данному lst и целому числу x находим в списке целые числа x,
    и возвращяем список кортежей, [(x1, y1), (x2, y2) ...] таким, что
    каждый кортеж представляет собой координату - (row, columns), начинающуюся с 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)]
    """