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

    Примечание:
    * не изменяйте исходный массив.

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

def sort_array(array):
    """
    Учитывая массив неотрицательных целых чисел, вернуть копию данного массива после сортировки,
    вы сортируете данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса) нечетна,
    или отсортируйте его по убыванию, если сумма (первое значение индекса, последнее значение индекса) четна.

    Примечание:
    * не изменяйте данный массив.

    Examples:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Дан массив неотрицательных целых чисел, вернуть копию данного массива после сортировки,
    вы отсортируете данный массив в порядке возрастания, если сумма (первое значение индекса, последнее значение индекса)
    нечетная,
    или отсортируете его в порядке убывания, если сумма (первое значение индекса, последнее значение индекса) четная.

    Примечание:
    * не изменяйте данный массив.

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


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

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

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


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

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

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

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

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

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    Вам будет дана строка слов, и ваша задача подсчитать число
    скуки. Скука — это предложение, которое начинается со слова «я».
    Предложения разделяются знаками '.', '?' или '!'.

    Например:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Вам дана строка слов, и ваша задача - подсчитать количество
    скучных предложений. Скучное предложение - это предложение, которое начинается со слова "I".
    Предложения разделяются знаками '.', '?', или '!'.

    Например:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Вам будет дана строка слов, и ваша задача — подсчитать количество
    скук. Скука — это предложение, которое начинается со слова «I».
    Предложения разделяются символами «.», «?» или «!».

    Например:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    Создайте функцию, которая принимает 3 числа.
    Возвращает true, если одно из чисел равно сумме двух других, и все числа являются целыми числами.
    Возвращает false в любых других случаях.

    Примеры
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Создайте функцию, которая принимает 3 числа.
    Возвращает значение true, если одно из чисел равно сумме двух других чисел, а все числа являются целыми числами.
    Возвращает false во всех остальных случаях.

    Examples
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


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

    Примеры:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

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

    Примеры:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

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

    Примеры:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Вам дан список целых чисел.
    Необходимо найти наибольшее простое число и вернуть сумму его цифр.

    Примеры:
    Для lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] результат должен быть 10
    Для lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] результат должен быть 25
    Для lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] результат должен быть 13
    Для lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] результат должен быть 11
    Для lst = [0,81,12,3,1,21] результат должен быть 3
    Для lst = [0,8,1,2,1,7] результат должен быть 7
    """

def skjkasdkd(lst):
    """Вам дан список целых чисел.
    Нужно найти наибольшее простое значение и вернуть сумму его цифр.

    Примеры:
    Для lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] вывод должен быть 10
    Для lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] вывод должен быть 25
    Для lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] вывод должен составлять 13
    Для lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] вывод должен быть 11
    Для lst = [0,81,12,3,1,21] вывод должен быть равен 3
    Для lst = [0,8,1,2,1,7] вывод должен быть равен 7
    """

def skjkasdkd(lst):
    """Вам выдан список целых чисел.
    Вам нужно найти наибольшее простое значение и вернуть сумму его цифр.
    Примеры:
    Для lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] вывод должен быть 10
    Для lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] вывод должен быть 25
    Для lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] вывод должен быть 13
    Для lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] вывод должен быть 11
    Для lst = [0,81,12,3,1,21] вывод должен быть 3
    Для lst = [0,8,1,2,1,7] вывод должен быть 7
    """


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

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

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


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

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

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


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

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

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


def count_upper(s):
    """
    Дана строка s, подсчитать количество заглавных гласных букв на четных индексах.

    Например:
    count_upper('aBCdEf') возвращает 1
    count_upper('abcdefg') возвращает 0
    count_upper('dBBE') возвращает 0
    """

def count_upper(s):
    """
    Учитывая строку s, посчитайте количество гласных в верхнем регистре в чётных индексах.

    Например:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    Дана строка s, подсчитайте количество заглавных гласных в четных индексах.

    Например:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


def closest_integer(value):
    '''
    Создать функцию, которая принимает значение (строку), представляющую число,
    и возвращает ближайшее к нему целое число. Если число равноудалено от двух целых чисел,
    округлить его в сторону от нуля.

    Примеры:
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

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

def closest_integer(value):
    '''
    Создайте функцию, которая принимает значение (строку), представляющее число, и возвращает ближайшее к нему целое число.
    Если число равноудалено от двух целых чисел, округлите его в сторону от нуля.

    Примеры
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Note:
    Округление от нуля означает, что если заданное число равноудалено
    от двух целых чисел, то вы должны вернуть то, которое
    наиболее удалено от нуля. Например, closer_integer("14.5") должно
    возвращать 15, а closer_integer("-14.5") должно возвращать -15.
    '''

def closest_integer(value):
    '''
    Создайте функцию, которая принимает значение (строку), представляющее число
    и возвращает ближайшее к нему целое число. Если число равноудалено
    от двух целых чисел, округлите его от нуля.

    Примеры
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Примечание:
    Округление от нуля означает, что если данное число равно удалено
    от двух целых чисел, вам следует вернуть то,
    которое максимально удалено от нуля. Например, closest_integer("14.5")
    должен вернуть 15, и closest_integer("-14.5") должен вернуть -15.
    '''


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

    Примеры:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

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

    Примеры:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

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

    Примеры:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Вам будет дана строка слов, разделенных запятыми или пробелами. Ваша задача —
    разбить строку на слова и вернуть массив этих слов.

    Например:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Вам будет предоставлена строка слов, разделенных запятыми или пробелами. Ваша задача —
    разбить строку на слова и вернуть массив слов.

    Например:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Вам будет дана строка слов, разделённых запятыми или пробелами. Ваша задача,
    разделить строку на слова и вернуть массив слов.

    Например:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


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

    Например:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

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

    Например:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

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

    Например:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Вам даны два положительных целых числа n и m, и ваша задача — вычислить
    среднее значение целых чисел от n до m (включая n и m).
    Округлите результат до ближайшего целого числа и преобразуйте его в двоичный формат.
    Если n больше m, верните -1.
    Пример:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Вам даны два положительных целых числа n и m, и ваша задача — вычислить
    среднее значение целых чисел от n до m (включая n и m).
    Округлите ответ до ближайшего целого числа и преобразуйте его в двоичное.
    Если n больше m, верните -1.
    Пример:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Вам даны два положительных целых числа n и m, и ваша задача состоит в том, чтобы вычислить
    среднее из целых чисел от n до m (включая n и m).
    Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный.
    Если n больше m, возвращается -1.
    Пример:
    ounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Дан список положительных целых чисел x. вернуть отсортированный список всех
    элементов, в которых нет ни одной четной цифры.

    Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.

    Например:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Дан список положительных целых чисел x. вернитет отсортированный список всех
    элементов, в которых нет чётной цифры.

    Примечание: Возвращённый список должен быть отсортирован в порядке возрастания.

    Например:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Дан список положительных целых чисел x. выведите отсортированный список всех
    элементов, которые не содержат ни одной четной цифры.

    Примечание: Выведенный список должен быть отсортирован в порядке возрастания.

    Например:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Дан массив целых чисел, отсортируйте числа, которые находятся в диапазоне от 1 до 9 включительно,
    переверните получившийся массив, а затем замените каждую цифру её соответствующим названием из
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Например:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> сортировка arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> переворот arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      возвращает ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Если массив пуст, вернуть пустой массив:
      arr = []
      возвращает []

      Если массив содержит какие-либо странные числа, игнорируйте их:
      arr = [1, -1, 55]
            -> сортировка arr -> [-1, 1, 55]
            -> переворот arr -> [55, 1, -1]
      возвращает = ['One']
    """

def by_length(arr):
    """
    Получив массив целых чисел, отсортируйте целые числа в диапазоне от 1 до 9 включительно,
    Переверните полученный массив, а затем замените каждую цифру на соответствующее имя из
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Например:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      вернуть ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Если массив пуст, верните пустой массив:
      arr = []
      return []

      Если в массиве есть какое-либо странное число, игнорируйте его:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Учитывая массив целых чисел, отсортируйте те из них, которые находятся в диапазоне от 1 до 9 включительно,
    переверните полученный массив, а затем замените каждую цифру на соответствующее ей имя из списка
    «Один», „Два“, „Три“, „Четыре“, „Пять“, „Шесть“, „Семь“, „Восемь“, „Девять“.

    Например:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return [«Восемь», «Пять», «Четыре», «Три», «Два», «Два», «Один», «Один»].

      Если массив пуст, верните пустой массив:
      arr = []
      return []

      Если в массиве есть какое-либо странное число, игнорируйте его:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


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

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

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


def even_odd_palindrome(n):
    """
    Учитывая положительное целое число n, верните кортеж, имеющий число чётных и нечётных
    целочисленных палиндромов, попадающих в range(1, n), включительно.

    Пример 1:

        Ввод: 3
        Вывод: (1, 2)
        Пояснение:
        Целочисленный палиндром равен 1, 2, 3. Один из них чётный, а два нечётных.

    Пример 2:

        Ввод: 12
        Вывод: (4, 6)
        Пояснение:
        Целочисленный палиндром равен 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Четыре из них чётные, а 6 нечётные.

    Примечание:
        1. 1 <= n <= 10^3
        2. возвращенный кортеж имеет количество чётных и нечётных целых палиндромов соответственно.
    """

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

    Пример 1:

        Input: 3
        Output: (1, 2)
        Explanation:
        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.

    Пример 2:

        Input: 12
        Output: (4, 6)
        Explanation:
        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.

    Примечание:
        1. 1 <= n <= 10^3
        2. возвращаемый кортеж имеет количество четных и нечетных целых палиндромов соответственно.
    """

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

    Пример 1:

        Ввод: 3
        Вывод: (1, 2)
        Пояснение:
        Целочисленные палиндромы: 1, 2, 3. Один из них четный, и два из них нечетные.

    Пример 2:

        Ввод: 12
        Вывод: (4, 6)
        Пояснение:
        Целочисленные палиндромы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Четыре из них четные, а шесть из них нечетные.

    Примечание:
        1. 1 <= n <= 10^3
        2. Возвращаемый кортеж содержит количество четных и нечетных целочисленных палиндромов соответственно.
    """


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

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

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


def move_one_ball(arr):
    """У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N]. Числа в массиве будут
    расположены в случайном порядке. Ваша задача — определить, возможно ли получить массив, отсортированный
    в неубывающем порядке, выполнив следующую операцию над данным массивом:
        Разрешается выполнить операцию правого сдвига любое количество раз.

    Одна операция правого сдвига означает сдвиг всех элементов массива на одну позицию вправо.
    Последний элемент массива будет перемещен в начало массива, т.е. на индекс 0.

    Если возможно получить отсортированный массив, выполнив вышеописанную операцию,
    верните True, иначе верните False.
    Если данный массив пуст, верните True.

    Примечание: Гарантируется, что элементы массива уникальны.

    Например:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Объяснение: Выполнив 2 правых сдвига, можно получить массив, отсортированный в неубывающем порядке.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Объяснение: Невозможно получить массив, отсортированный в неубывающем порядке, выполнив любое количество правых
    сдвигов.

    """

def move_one_ball(arr):
    """У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа
    в массиве будут упорядочены случайным образом. Ваша задача это определить, можно ли
    получить массив, отсортированный в неубывающем порядке, выполнив
    следующую операцию над данным массивом:
        Вам разрешено выполнять операцию правой смены любое количество раз.

    Одна операция сдвига вправо означает сдвиг всех элементов массива на одну
    позицию в правом направлении. Последний элемент массива будет перемещён в
    начальную позицию в массиве, то есть 0-й индекс.

    Если можно получить отсортированный массив, выполнив описанную выше операцию,
    то верните True, иначе верните False.
    Если данный массив пуст, верните True.

    Примечание. Приведённый список гарантированно содержит уникальные элементы.

    Для примера:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Пояснение: Выполнив 2 операции сдвига вправо, можно получить неубывающий порядок
                 может быть достигнут неубывающий порядок для данного массива.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Объяснение:Невозможно получить неубывающий порядок для данного
                массива, выполнив любое количество операций сдвига вправо.

    """

def move_one_ball(arr):
    """У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N]. Числа в массиве будут упорядочены случайным образом. Ваша
    задача — определить,
    возможно ли получить массив, отсортированный в неубывающем порядке, выполнив
    следующую операцию над данным массивом:

    Вы можете выполнять операцию сдвига вправо любое количество раз.

    Одна операция сдвига вправо означает сдвиг всех элементов массива на одну
    позицию в правильном направлении. Последний элемент массива будет перемещен в
    начальную позицию в массиве, т. е. на 0-й индекс.

    Если возможно получить отсортированный массив, выполнив указанную выше операцию,
    то верните True, иначе верните False.

    Если данный массив пуст, то верните True.

    Примечание: данный список гарантированно содержит уникальные элементы.

    Например:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Объяснение: Выполнив 2 операции сдвига вправо, можно добиться неубывания порядка для данного массива.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Объяснение: Невозможно получить неубывающую упорядоченность для данного
                массива, выполняя любое количество операций сдвига вправо.

    """


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

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

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


def histogram(test):
    """
    Дана строка, содержащая строчные буквы, разделённые пробелами.
    Функция должна возвращать словарь, в котором ключами будут буквы, встречающиеся наиболее часто,
    а значениями — количество их повторений. Если несколько букв встречаются одинаковое количество раз,
    нужно возвращать все такие буквы.

    Примеры:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}
    """

def histogram(test):
    """При заданной строке, представляющей строчные буквы, разделенные пробелом, возвращает словарь
    букв с наибольшим количеством повторений и соответствующим количеством значений.
    Если несколько букв встречаются одинаково, возвращает их все.

    Пример:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Дана строка, представляющая собой строчные буквы, разделенные пробелами, вернуть словарь
    букв с наибольшим повторением и содержащий соответствующее количество.
    Если несколько букв встречаются одинаково, вернуть их все.

    Пример:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


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

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

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


def odd_count(lst):
    """Данная функция принимает список строк, где каждая строка состоит только из цифр, и возвращает список.
    Каждый элемент i выходного списка должен быть строкой:
    "the number of odd elements in the string i of the input.", где все i должны быть заменены на количество нечетных цифр в i-й строке входного списка.

    Пример:
    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3', "11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
    "the number of odd elements 8n the str8ng 8 of the 8nput."]

def odd_count(lst):
    """Данный список строк, где каждая строка состоит только из цифр, возвращает список.
    Каждый элемент i выходных данных должен быть "количеством нечетных элементов в строке i входных данных". где все i должны быть заменены на количество
    нечетных цифр в i-й строке входных данных.

    >>> odd_count(['1234567'])
    ["количество нечетных элементов 4в строке 4входа."]
    >>> odd_count(['3',"11111111"])
    ["количество нечетных элементов 1в строке 1входа.",
    "количество нечетных элементов 8в строке 8входа."]
    """

def odd_count(lst):
    """Дан список строк, где каждая строка состоит только из цифр, выведите список.
    Каждый элемент i в выходных данных должен быть в виде "количество нечетных элементов в
    строке i входных данных.", где все i заменяются на количество нечетных цифр в i-й строке входных данных.

    >>> odd_count(['1234567'])
    ["число нечетных элементов 4в строке 4 4nput."]
    >>> odd_count(['3',"11111111"])
    ["число нечетных элементов 1в строке 1 1nput.",
    "число нечетных элементов 8в строке 8 8nput."]
    """


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

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

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


import math

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

    Пример 1:
        Вход:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Выход: 6

    Пример 2:
        Вход:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Выход: 5

    Пример 3:
        Вход:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Выход: 0

    Ограничения:
        * все колодцы имеют одинаковую длину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
    а каждая 1 в строке представляет собой единицу воды.
    Каждому колодцу соответствует ведро, которое можно использовать для извлечения из него воды,
    и все ведра имеют одинаковую вместимость.
    Ваша задача — использовать ведра для опорожнения колодцев.
    Выведите количество раз, которое вам нужно использовать ведра.

    Пример 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    Пример 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    Пример 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    Ограничения:
        * все скважины имеют одинаковую длину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Вам дана прямоугольная сетка с колодцами. Каждый ряд представляет собой один колодец,
    а каждая 1 в ряду представляет собой единицу воды.
    У каждого колодца есть соответствующее ведро, из которого можно набирать воду,
    причем все вёдра имеют одинаковую вместимость.
    Ваша задача - использовать вёдра, чтобы опустошить колодцы.
    Выведите количество раз, которое вам нужно опустить ведра.

    Пример 1:
        Ввод:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Вывод: 6

    Пример 2:
        Ввод:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Вывод: 5

    Пример 3:
        Ввод:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Вывод: 0

    Ограничения:
        * все скважины имеют одинаковую длину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


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

    Должно быть реализовано так:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    В этой Кате вам нужно отсортировать массив неотрицательных целых чисел по
    количеству единиц в их двоичном представлении в порядке возрастания.
    Для одинакового количества единиц сортируйте на основе десятичного значения.

    Это должно быть реализовано следующим образом:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

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

    Оно должно быть реализовано так:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """


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

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

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


def get_closest_vowel(word):
    """Вам дано слово. Ваша задача — найти ближайшую гласную, которая стоит между
    двумя согласными с правой стороны слова (с учетом регистра).

    Гласные в начале и конце не учитываются. Верните пустую строку, если вы не
    нашли ни одной гласной, удовлетворяющей вышеуказанному условию.

    Вы можете предположить, что данная строка содержит только английские буквы.

    Пример:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Вам дано слово. Ваша задача найти ближайшую гласную, которая находится между
    двумя согласными с правой стороны слова (чувствительные к регистру).

    Гласные в начале и в конце не считаются. Верните пустую строку, если вы не
    нашли каких-либо гласных, отвечающих вышеуказанному условию.

     Вы можете предположить, что данная строка содержит только английские буквы.

    Пример:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Дано слово. Ваша задача — найти ближайшую гласную, которая находится между
    двумя согласными в правой части слова (учитывая регистр).

    Гласные в начале и в конце не учитываются. Верните пустую строку, если не нашли
    гласную, соответствующую указанному условию.

    Можно считать, что данная строка состоит только из английских букв.

    Пример:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Вам дан список из двух строк, обе строки состоят только из открытых
    скобок '(' или закрытых скобок ')'.
    Ваша задача — проверить, возможно ли объединить две строки в
    некотором порядке, чтобы полученная строка была хорошей.
    Строка S считается хорошей тогда и только тогда, когда все скобки в S
    сбалансированы. Например: строка '(())()' хорошая, а строка
    '())' — нет.
    Верните 'Да', если есть способ создать хорошую строку, и верните 'Нет' в противном случае.

    Примеры:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Вам дан список из двух строк, обе из которых состоят только из открытых
    скобок '(' или закрытых скобок ')'.
    Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в
    некотором порядке так, чтобы итоговая строка была успешной.
    Строка S считается успешной, если и только все скобки в S
    сбалансированы. Например: строка '(())()' является успешной, тогда как строка
    '())' нет.
    Выведите 'Да', если способ формирования успешной строки существует, и 'Нет' во всех остальных случаях.

    Примеры:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

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

    Примеры:
     match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Дан массив arr целых чисел и положительное целое число k, вернуть отсортированный список длины k с максимальным
    количеством k чисел в arr.

    Пример 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    Пример 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    Пример 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Примечание:
        1. Длина массива будет в диапазоне от [1, 1000].
        2. Элементы в массиве будут в диапазоне от [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Дано массив arr целых чисел и положительное целое число k, верните отсортированный список
    длины k с максимальными числами k в arr.

    Пример 1:

        Ввод: arr = [-3, -4, 5], k = 3
        Вывод: [-4, -3, 5]

    Пример 2:

        Ввод: arr = [4, -4, 4], k = 2
        Вывод: [4, 4]

    Пример 3:

        Ввод: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Вывод: [2]

    Примечание:
        1. Длина массива будет находиться в диапазоне [1, 1000].
        2. Элементы в массиве будут находиться в диапазоне [-1000, 1000].
        3.0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Дан массив arr целых чисел и положительное целое число k, вернуть отсортированный список
    длины k с максимальным количеством k чисел в arr.

    Пример 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    Пример 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    Пример 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

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


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

    Примеры:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

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

    Примеры
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Учитывая непустой список целых чисел, верните сумму всех нечётных элементов, находящихся в чётных позициях.

    Примеры
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Дано непустой массив целых чисел arr и целое число k. Необходимо вернуть
    сумму элементов с не более чем двумя цифрами из первых k элементов массива arr.

    Пример:

        Ввод: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Вывод: 24 # сумма 21 + 3

    Ограничения:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Дан непустой массив целых чисел arr и целое число k, вернуть
    сумму элементов с не более чем двумя цифрами из первых k элементов arr.

    Пример:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

    Constraints:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Учитывая непустой массив целых чисел arr и целое число k, верните
    сумму элементов не более чем с двумя цифрами из первых k элементов обр.

    Пример:

        Ввод: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Вывод: 24 # sum of 21 + 3

    Ограничения:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Дано положительное целое число n. Необходимо вернуть отсортированный список, содержащий все нечётные числа из последовательности Коллатца.

    Гипотеза Коллатца — это гипотеза в математике, которая описывает последовательность, определяемую следующим образом:
    начинаем с любого положительного целого числа n. Каждый следующий элемент получается из предыдущего следующим образом:
    если предыдущий элемент чётный, следующий элемент равен половине предыдущего.
    Если предыдущий элемент нечётный, следующий элемент равен 3 умножить на предыдущий и прибавить 1.
    Гипотеза Коллатца утверждает, что независимо от начального значения n, последовательность всегда завершится числом 1.

    Примечания:
        1. Коллатц(1) = [1].
        2. Возвращённый список отсортирован в порядке возрастания.

    Например:
    get_odd_collatz(5) возвращает [1, 5] # Последовательность Коллатца для 5: [5, 16, 8, 4, 2, 1], поэтому нечётными числами будут только 1 и 5.
    """

def get_odd_collatz(n):
    """
    Дано положительное целое число n, вернуть отсортированный список, содержащий нечетные числа в последовательности
    Коллатца.

    Гипотеза Коллатца — это гипотеза в математике, которая касается последовательности, определяемой
    следующим образом: начните с любого положительного целого числа n. Затем каждый член получается из
    предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине
    предыдущего члена. Если предыдущий член нечетный, то следующий член равен 3 предыдущий член плюс 1. Гипотеза заключается
    в том, что независимо от значения n последовательность всегда достигнет 1.

    Примечание:
        1. Коллатца(1) — это [1].
        2. возвращенный список, отсортированный по возрастанию.

    Например:
    get_odd_collatz(5) возвращает [1, 5] # Последовательность Коллатца для 5 равна [5, 16, 8, 4, 2, 1], поэтому нечетные числа равны только 1, а 5.
    """

def get_odd_collatz(n):
    """
    Если задано целое положительное число n, верните отсортированный список, в котором есть нечётные числа в последовательности Коллатца.

    Гипотеза Коллатца - это математическая гипотеза, касающаяся последовательности, определённой
    следующим образом: начнём с любого целого положительного числа n. Затем каждый член получается из
    предыдущего следующим образом: если предыдущий член чётный, то следующий член равен половине предыдущего.
    Если предыдущий член нечётный, то следующий член в 3 раза больше предыдущего
    плюс 1. Предполагается, что независимо от значения n, последовательность всегда будет достигать 1.

    Примечание:
        1. Collatz(1) это [1].
        2. возвращаемый список, отсортированный в порядке возрастания.

    Например:
    get_odd_collatz(5) возвращает [1, 5] # Последовательность коллатца для 5 равна [5, 16, 8, 4, 2, 1], поэтому нечётные числа равны только 1, и 5.
    """


def valid_date(date):
    """Вам нужно написать функцию, которая проверяет заданную строку с датой и
    возвращает True, если дата действительна, иначе False.
    Дата считается действительной, если выполнены все следующие правила:
    1. Строка с датой не пуста.
    2. Количество дней не меньше 1 и не больше 31 для месяцев 1, 3, 5, 7, 8, 10, 12. Количество дней не меньше 1 и не больше 30 для месяцев 4, 6, 9, 11. И количество дней не меньше 1 и не больше 29 для месяца 2.
    3. Месяцы не должны быть меньше 1 или больше 12.
    4. Дата должна быть в формате: mm-dd-yyyy

    например:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Вам необходимо написать функцию, которая проверяет заданную строку даты и
    возвращает True, если дата действительна, в противном случае False.
    Дата действительна, если выполняются все следующие правила:
    1. Строка даты не пустая.
    2. Количество дней не меньше 1 и не больше 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней не меньше 1 и не больше 30 дней для месяцев 4,6,9,11. И количество дней не меньше 1 и не больше 29 для месяца 2.
    3. Месяцы не должны быть меньше 1 и не больше 12.
    4. Дата должна быть в формате: mm-dd-yyyy

    например:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => Ложь

    valid_date('04-0-2040') => Ложь

    valid_date('06-04-2020') => Истина

    valid_date('06/04/2020') => Ложь
    """

def valid_date(date):
    """ Вы должны написать функцию, которая проверяет заданную строку даты и
    возвращает значение True, если дата действительна, в противном случае значение False.
    Дата действительна, если соблюдены все следующие правила:
    1. Строка даты не является пустой.
    2. Количество дней не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней не меньше 1 и больше 30 дней для месяцев 4,6,9,11. И, количество дней не меньше 1 и не больше 29 за месяц 2.
    3. Количество месяцев не должно быть меньше 1 или больше 12.
    4. Дата должна быть в формате: мм-дд-гггг

    например:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Данная функция принимает строку слов и возвращает список слов, разделенных по пробелам.
    Если в тексте нет пробелов, то необходимо разделить строку по запятым ','.
    Если в тексте нет ни пробелов, ни запятых, нужно вернуть количество строчных букв,
    чей порядковый номер в алфавите является нечётным (ord('a') = 0, ord('b') = 1, ..., ord('z') = 25).

    Примеры:
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

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

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


def is_sorted(lst):
    '''
    Дано список чисел. Возвращает True, если числа отсортированы по возрастанию.
    Если в списке более 1 дубликата одного и того же числа, возвращает False. Предполагается, что числа целые и нет
    отрицательных.

    Примеры:
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Дан список чисел, верните, отсортированы ли они
    по возрастанию или нет. Если в списке есть больше 1 дубликата одинакового числа,
    верните False. Предположите, что отрицательных чисел нет, и только целые числа.

    Примеры:
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Дан список чисел, верните, отсортированы ли они
    в порядке возрастания. Если список содержит более одного дубликата одного
    числа, верните False. Предполагается, что числа” неотрицательные и являются целыми.

    Примеры
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


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

    Примеры ввода/вывода:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

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

    [input/output] samples:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """ Вам даны два интервала,
    где каждый интервал представляет собой пару целых чисел. Например, interval = (start, end) = (1, 2).
    Заданные интервалы замкнуты, что означает, что интервал (start, end)
    включает в себя как начало, так и конец.
    Для каждого заданного интервала предполагается, что его начало меньше или равно его концу.
    Ваша задача это определить, является ли длина пересечения этих двух
    интервалов простым числом.
    Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
    длина которого равна 1, что не является простым числом.
    Если длина пересечения является простым числом, верните "YES",
    в противном случае верните "NO".
    Если два интервала не пересекаются, верните "NO".

    [ввод/вывод] образцы:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


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

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

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

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Вам дан массив arr целых чисел, и вы должны вернуть
    сумму величин целых чисел, умноженную на произведение всех знаков
    каждого числа в массиве, представленного 1, -1 или 0.
    Примечание: для пустого массива возвращается None.

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Дана сетка с N строками и N столбцами (N >= 2) и положительное целое число k.
    Каждая ячейка сетки содержит уникальное целое число в диапазоне [1, N * N].

    Необходимо найти минимальный путь длины k в сетке. Вы можете начать с любой
    ячейки, и на каждом шаге перемещаться в соседние ячейки (те, которые разделяют
    общую сторону с текущей ячейкой).
    Путь длины k означает посещение ровно k ячеек (не обязательно различных).
    Выход за пределы сетки НЕ РАЗРЕШАЕТСЯ.
    Путь A (длины k) считается меньше пути B (длины k), если
    после создания отсортированных списков значений в ячейках, через которые проходят A и B
    (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами,
    существует целочисленный индекс i (1 <= i <= k) такой, что lst_A[i] < lst_B[i] и для всех j (1 <= j < i) имеем
    lst_A[j] = lst_B[j].
    Гарантируется, что ответ однозначен.
    Верните упорядоченный список значений в ячейках, через которые проходит минимальный путь.

    Примеры:

        Ввод: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Вывод: [1, 2, 1]

        Ввод: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Вывод: [1]
    """

def minPath(grid, k):
    """
    Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
    каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
    включительно появляется ровно один раз на ячейках сетки.

    Вам нужно найти минимальный путь длины k в сетке. Можно начать
    из любой ячейки, и на каждом шагу вы можете перейти в любую из соседних ячеек,
    другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашим текущей
    клеткой.
    Обратите внимание, что путь длиной k означает посещение ровно k ячеек (не
    обязательно различный).
    Вы НЕ МОЖЕТЕ выйти из сети.
    Путь A (длиной k) считается меньшим, чем путь B (длиной k), если
    после составления упорядоченных списков значений в ячейках A и B идут
    через (назовем их lst_A и lst_B), lst_A лексикографически меньше
    другими словами, чем lst_B, существует целочисленный индекс i (1 <= i <= k)
    такие, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) у нас есть
    lst_A[j] = lst_B[j].
    Гарантируется, что ответ уникален.
    Верните упорядоченный список значений ячеек, через которые проходит минимальный путь.

    Примеры:

        Ввод: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Вывод: [1, 2, 1]

        Ввод: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Вывод: [1]
    """

def minPath(grid, k):
    """
    Дана сетка с N строками и N столбцами (N >= 2) и положительное целое число k,
    каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
    включительно встречается ровно один раз в ячейках сетки.

    Вам нужно найти минимальный путь длины k в сетке. Вы можете начать
    с любой ячейки, и на каждом шаге вы можете перейти в любую из соседних ячеек,
    другими словами, вы можете перейти в ячейки, которые имеют общее ребро с вашей текущей
    ячейкой.
    Обратите внимание, что путь длины k означает посещение ровно k ячеек (не обязательно
    отличающихся).
    Вы НЕ МОЖЕТЕ выйти за пределы сетки.
    Путь A (длиной k) считается меньшим, чем путь B (длиной k), если
    после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A
    лексикографически меньше lst_B, другими словами, существует целочисленный индекс i (1 <= i <= k),
    такой, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) имеем
    lst_A[j] = lst_B[j].
    Гарантируется, что ответ уникален.
    Вернуть упорядоченный список значений в ячейках, через которые проходит минимальный путь.

    Примеры:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """


def tri(n):
    """Каждый знает последовательность Фибоначчи, она была тщательно изучена
    математиками на протяжении последних столетий. Однако люди не знают о последовательности Трибоначчи.
    Последовательность Трибоначчи определяется рекуррентно:
    tri(1) = 3
    tri(n) = 1 + n / 2, если n четное.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетное.
    Например:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Вам дается неотрицательное целое число n, и вы должны вернуть список из
    n + 1 первых чисел последовательности Трибоначчи.
    Примеры:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Все знают последовательность Фибоначчи, её глубоко изучали математики в
    последние пару веков. Однако люди не знают последовательности Трибоначчи.
    Последовательность Трибоначчи определяется повторяемостью:
    tri(1) = 3
    tri(n) = 1 + n / 2, если n чётно.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечётно.
    Например:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Вам дано неотрицательное целое число n, вам нужно вернуть список из
    первых n + 1 чисел последовательности Трибоначчи.
    Примеры:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Все знают последовательность Фибоначчи, она была глубоко изучена математиками в последние пару столетий. Однако люди не
    знают последовательность Трибоначчи.
    Последовательность Трибоначчи определяется рекуррентностью:
    tri(1) = 3
    tri(n) = 1 + n / 2, если n четное.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетное.
    Например:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
    = 2 + 3 + 3 = 8
    Вам дано неотрицательное целое число n, вы должны вернуть список
    первых n + 1 чисел последовательности Трибоначчи.
    Примеры:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Дано положительное целое число n, вернуть произведение нечетных цифр.
    Верните 0, если все цифры четные.
    Например:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Дано целое положительное число  n, выведите произведение нечетных цифр.
    Выведите 0, если все цифры четные.
    Например:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Учитывая положительное целое число n, верните произведение нечётных цифр.
    Верните 0, если все цифры чётные.
    Например:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
    Функция должна возвращать True тогда и только тогда, когда существует допустимая подпоследовательность скобок,
    где хотя бы одна скобка в подпоследовательности вложена.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Создайте функцию, которая принимает на ввод строку, содержащую только квадратные скобки.
    Функция должна возвращать True тогда и только тогда, когда существует допустимая подпоследовательность скобок
    где хотя бы одна квадратная скобка в подпоследовательности является вложенной.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Создайте функцию, которая принимает строку, содержащую только квадратные скобки.
    Функция должна возвращать True, только если существует действительная подпоследовательность скобок,
    где хотя бы одна скобка в подпоследовательности вложена.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """Вам дан список чисел.
    Вам нужно вернуть сумму квадратов чисел в данном списке,
    сначала округлите каждый элемент списка до ближайшего большего целого (Ceiling).
    Примеры:
    Для lst = [1,2,3] вывод должен быть 14
    Для lst = [1,4,9] вывод должен быть 98
    Для lst = [1,3,5,7] вывод должен быть 84
    Для lst = [1.4,4.2,0] вывод должен быть 29
    Для lst = [-2.4,1,1] вывод должен быть 6

    """

def sum_squares(lst):
    """Вам дан список чисел.
    Необходимо вернуть сумму квадратов чисел в списке, предварительно округлив
    каждый элемент в списке вверх до ближайшего целого (Ceiling).

    Примеры:
    Для lst = [1,2,3] результат должен быть 14
    Для lst = [1,4,9] результат должен быть 98
    Для lst = [1,3,5,7] результат должен быть 84
    Для lst = [1.4,4.2,0] результат должен быть 29
    Для lst = [-2.4,1,1] результат должен быть 6
    """

def sum_squares(lst):
    """Вам дан список чисел.
    Вам нужно вернуть сумму квадратов чисел в данном списке,
    округляя каждый элемент списка до верхнего значения int(Ceiling).
    Примеры:
    Для lst = [1,2,3] результат должен быть 14
    Для lst = [1,4,9] результат должен быть 98
    Для lst = [1,3,5,7] результат должен быть 84
    Для lst = [1.4,4.2,0] результат должен быть 299
    Для lst = [-2.4,1,1] результат должен быть 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Создайте функцию, которая возвращает True, если последний символ
    в данной строке является буквой и не является частью слова, и False в противном случае.
    Примечание: "слово" — это группа символов, разделённых пробелами.

    Примеры:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Создайте функцию, которая возвращает True, если последний символ
    заданной строки является буквенным символом и не является
    частью слова, и False в противном случае.
    Примечание: «слово» — это группа символов, разделенных пробелом.

    Примеры:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Создание функции, возвращающей значение True, если последний символ
    данной строки является буквенным символом и не является
    частью слова, а в противном случае False.
    Примечание: слово это группа символов, разделённых пробелом.

    Примеры:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


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

    Примеры:
    can_arrange([1, 2, 4, 3, 5]) = 3
    can_arrange([1, 2, 3]) = -1
    """

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

    Примеры:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

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

    Примеры:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Создайте функцию, которая возвращает кортеж (a, b), где 'a' — это
    наибольшее из отрицательных целых чисел, а 'b' — это наименьшее
    из положительных целых чисел в списке.
    Если отрицательных или положительных целых чисел нет, верните их как None.

    Примеры:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Создайте функцию, которая возвращает кортеж (a, b), где 'a' — это
    наибольшее из отрицательных целых чисел, а 'b' — наименьшее
    из положительных целых чисел в списке.
    Если нет отрицательных или положительных целых чисел, возвратите их как None.

    Примеры:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Создать функцию, которая возвращает кортеж (a, b), где 'a' есть
    наибольшее из отрицательных целых чисел, а 'b' это наименьшее
    из целых положительных чисел в списке.
    Если отрицательных или положительных целых чисел нет, верните их как None.

    Примеры:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Создайте функцию, которая принимает целые числа, числа с плавающей запятой или строки, представляющие
    вещественные числа, и возвращает большее из них в том же типе данных.
    Если значения равны, возвращает None.
    Примечание: если действительное число  представлено в виде строки, разделителем десятичной части может быть как точка, так и запятая.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие
    действительные числа, и возвращает наибольшую переменную в ее данном типе переменной.
    Возвращает None, если значения равны.
    Примечание: Если действительное число представлено в виде строки, десятичный разделитель может быть точкой или запятой.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие
    действительные числа, и возвращает большую переменную в заданном типе переменной.
    Верните None, если значения равны.
    Примечание: если действительное число представлено в виде строки, плавающая точка может быть . или ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Определяет, можно ли заданное число n представить в виде суммы ровно 4 положительных четных чисел.
    Примеры:
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Оцените, можно ли данное число n записать в виде суммы ровно 4 положительных чётных чисел
    Пример
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Оцените, можно ли данное число n записать как сумму ровно 4 положительных четных чисел.
    Пример
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Бразильский факториал определяется как:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    где n > 0

    Например:
    >>> special_factorial(4)
    288

    Функция принимает целое число в качестве вводных данных и должна вернуть
    специальный факториал этого числа.
    """

def special_factorial(n):
    """Бразильский факториал определяется как:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    где n > 0

    Например:
    >>> special_factorial(4)
    288

    Функция получит целое число в качестве входных данных и должна вывести специальный
    факториал этого целого числа.
    """

def special_factorial(n):
    """Бразильский факториал определяется как:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    где n > 0

    Например:
    >>> special_factorial(4)
    288

    Функция получит целое число на вход и должна вернуть специальный
    факториал этого целого числа.
    """


def fix_spaces(text):
    """
    Дана строка текста, замените все пробелы в ней на подчеркивания,
    а если строка содержит более 2 последовательных пробелов,
    то замените все последовательные пробелы на -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Получив строку текста, замените все пробелы в нём на подчеркивания,
    и если строка имеет более 2 последовательных пробелов,
    замените все последовательные пробелы на -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Дана строка текста, замените все пробелы на подчеркивания,
    и если строка содержит более 2 последовательных пробелов,
    замените все последовательные пробелы на -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает
    'Yes', если имя файла допустимо, и возвращает 'No' в противном случае.
    Имя файла считается допустимым, если и только если выполняются все следующие условия:
    - В имени файла не должно быть более трех цифр ('0'-'9').
    - Имя файла содержит ровно одну точку '.'
    - Подстрока перед точкой не должна быть пустой и начинаться с буквы
    латинского алфавита ('a'-'z' и 'A'-'Z').
    - Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
    Примеры:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (имя должно начинаться с буквы латинского алфавита)
    """

def file_name_check(file_name):
    """Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает
    'Yes', если имя файла допустимо, и возвращает 'No' в противном случае.
    Имя файла считается действительным тогда и только в том случае, если выполняются все следующие условия
    выполняются:
    - В имени файла не должно быть более трёх цифр ('0'-'9').
    - Имя файла содержит ровно одну точку '.'
    - Подстрока перед точкой не должна быть пустой, и она начинается с буквы
    латинского алфавита ('a'-'z' and 'A'-'Z').
    - Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
    Примеры:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (название должно начинаться с буквы латинского алфавита)
    """


def sum_squares(lst):
    """
    Эта функция принимает список целых чисел. Для каждого элемента в списке функция возводит его в квадрат, если индекс этого элемента
    кратен 3, и в куб, если индекс кратен 4, но не кратен 3. Элементы, индексы которых не кратны ни 3, ни 4, остаются без изменений.
    Затем функция возвращает сумму всех элементов списка.

    Примеры:
    Для lst = [1,2,3] вывод должен быть 6
    Для lst = [ ] вывод должен быть 0
    Для lst = [-1,-5,2,-1,-5] вывод должен быть -126
    """

def sum_squares(lst):
    """"
    Эта функция будет принимать список целых чисел. Для всех записей в списке функция должна возвести в квадрат целочисленную запись, если её
    индекс кратен 3 и будет кубически преобразовать целочисленную запись, если её индекс кратен 4, а не кратен 3. Функция не будет
    изменять элементы списка, индексы которых не кратны 3 или 4. Затем функция возвращает сумму всех записей.

    Примеры:
    Для lst = [1,2,3] вывод должен быть равен 6
    Для lst = [] вывод должен быть равен 0
    Для lst = [-1,-5,2,-1,-5] вывод должен быть -126
    """

def sum_squares(lst):
    """"
    Эта функция примет список целых чисел. Для всех записей в списке функция должна возводить в квадрат целочисленную элемент, если ее индекс является
    кратный 3 и будет возводить целочисленную элемент в куб, если его индекс кратен 4, а не кратен 3. Функция не будет
    изменить записи в списке, индексы которых не кратны 3 или 4. Затем функция возвращает сумму всех записей.

    Examples:
    For lst = [1,2,3] the output should be 6
    For lst = []  the output should be 0
    For lst = [-1,-5,2,-1,-5]  the output should be -126
    """


def words_in_sentence(sentence):
    """
    Вам даётся строка, представляющая предложение,
    предложение содержит несколько слов, разделённых пробелом,
    и вы должны вернуть строку, содержащую слова из исходного предложения,
    длины которых являются простыми числами,
    Порядок слов в новой строке должен быть таким же, как и в исходной.

    Пример 1:
        Ввод: sentence = "This is a test"
        Вывод: "is"

    Пример 2:
        Ввод: sentence = "lets go for swimming"
        Вывод: "go for"

    Ограничения:
        * 1 <= len(sentence) <= 100
        * предложение содержит только буквы
    """

def words_in_sentence(sentence):
    """
    Вам дана строка, представляющая собой предложение.
    Предложение содержит несколько слов, разделенных пробелами,
    и необходимо вернуть строку, содержащую слова из исходного предложения,
    длина которых является простым числом,
    порядок слов в новой строке должен оставаться таким же, как в исходном предложении.

    Пример 1:
        Ввод: sentence = "This is a test"
        Вывод: "is"

    Пример 2:
        Ввод: sentence = "lets go for swimming"
        Вывод: "go for"

    Ограничения:
        * 1 <= len(sentence) <= 100
        * sentence содержит только буквы
    """

def words_in_sentence(sentence):
    """
    Вам дана строка, представляющая предложение,
    предложение содержит несколько слов, разделенных пробелом,
    и вам нужно вернуть строку, содержащую слова из исходного предложения,
    длина которых является простым числом,
    порядок слов в новой строке должен быть таким же, как и в исходной.

    Пример 1:
        Input: sentence = "This is a test"
        Output: "is"

    Пример 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    Constraints:
        * 1 <= len(sentence) <= 100
        * sentence contains only letters
    """


def simplify(x, n):
    """Ваша задача — реализовать функцию, которая упростит выражение
    x * n. Функция возвращает True, если x * n определяется как целое число, и False
    в противном случае. Как x, так и n являются строковыми представлениями дроби и имеют следующий формат:
    <числитель>/<знаменатель>, где и числитель, и знаменатель — это положительные целые числа.

    Вы можете предположить, что x и n являются корректными дробями и не имеют нуля в знаменателе.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Ваша задача это реализовать функцию, которая упростит выражение
    x * n. Функция возвращает True, если x * n вычисляется как целое число, и False
    иначе. И x, и n являются строковым представлением дроби и имеют следующий формат:
    <numerator>/<denominator>, где и числитель, и знаменатель являются положительными целыми числами.

    Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Ваша задача — реализовать функцию, которая упростит выражение
    x * n. Функция возвращает True, если x * n вычисляется как целое число, и False
    в противном случае. Оба значения x и n являются строковыми представлениями дроби и имеют следующий формат:
    <числитель>/<знаменатель>, где и числитель, и знаменатель являются положительными целыми числами.

    Можно предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    Напишите функцию, которая сортирует заданный список целых чисел
    в порядке возрастания по сумме их цифр.
    Примечание: если имеется несколько элементов с одинаковой суммой цифр,
    упорядочьте их по индексу в исходном списке.

    Например:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Функция сортирует список целых чисел по возрастанию суммы их цифр.
    Примечание: если несколько чисел имеют одинаковую сумму цифр, сортирует их по индексу в исходном списке.

    Например:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Напишите функцию, которая сортирует заданный список целых чисел
    в порядке возрастания в соответствии с суммой их цифр.
    Примечание: если есть несколько элементов с одинаковой суммой их цифр,
    упорядочьте их на основе их индекса в исходном списке.

    Например:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает
    количество элементов в массиве, которые больше 10 и обе,
    первая и последняя, цифры числа нечётные (1, 3, 5, 7, 9).
    Например:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Напишите функцию, которая берет массив чисел в качестве входных данных и выводит
    количество элементов массива, которые больше 10, и обе, первая и последняя, цифры числа являются нечетными (1, 3, 5, 7, 9).
    Например:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Напишите функцию, которая принимает на вход массив чисел и возвращает
    количество элементов в массиве, которые больше 10 и обе
    первая и последняя цифры числа нечетные (1, 3, 5, 7, 9).
    Например:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Вам дано целое положительное число n. Вы должны создать целочисленный массив a длины n.
        Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
        Верните количество троек (a[i], a[j], a[k]) из a, где i < j < k,
    и a[i] + a[j] + a[k] кратны 3.

    Пример：
        Вход: n = 5
        Выход: 1
        Объяснение:
        a = [1, 3, 7, 13, 21]
        Единственная правильная тройка - (1, 7, 13).
    """

def get_max_triples(n):
    """
    Вам дано положительное целое число n. Необходимо создать массив целых чисел a длины n.
        Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
        Верните количество троек (a[i], a[j], a[k]) из массива a, где i < j < k,
    и a[i] + a[j] + a[k] делится на 3.

    Пример:
        Ввод: n = 5
        Вывод: 1
        Пояснение:
        a = [1, 3, 7, 13, 21]
        Единственная подходящая тройка — (1, 7, 13).
    """

def get_max_triples(n):
    """
    Вам дано положительное целое число n. Вам необходимо создать целочисленный массив a длиной n.
        Для каждого i (1 ≤ i ≤ n), значение a[i] = i * i - i + 1.
        Возвращают число троек (a[i], a[j], a[k]) a где i < j < k,
    и a[i] + a[j] + a[k] кратно 3.

    Пример:
        Ввод: n = 5
        Вывод: 1
        Пояснение:
        a = [1, 3, 7, 13, 21]
        Единственная действительная тройка это (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    В нашей солнечной системе восемь планет: самая близкая к Солнцу — Меркурий, следующая — Венера, затем Земля, Марс,
    Юпитер, Сатурн, Уран, Нептун.
    Напишите функцию, которая принимает два названия планет как строки planet1 и planet2.
    Функция должна возвращать кортеж, содержащий все планеты, орбиты которых
    расположены между орбитой planet1 и орбитой planet2, отсортированные по
    близости к Солнцу.
    Функция должна возвращать пустой кортеж, если planet1 или planet2
    не являются правильными названиями планет.
    Примеры
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    В нашей солнечной системе восемь планет: ближайшая к Солнцу — Меркурий, затем Венера, Земля, Марс, Юпитер, Сатурн,
    Уран, Нептун.
    Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
    Функция должна возвращать кортеж, содержащий все планеты, орбиты которых
    находятся между орбитами planet1 и planet2, упорядоченные по
    близости к Солнцу.
    Функция должна вернуть пустой кортеж, если planet1 или planet2 — это некорректные названия планет.
    Примеры:
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    В нашей Солнечной системе восемь планет: ближе всего к Солнцу
    это Меркурий, следующий - Венера, затем Земля, Марс, Юпитер, Сатурн,
    Уран, Нептун.
    Напишите функцию, которая принимает два имени планет как строки planet1 и planet2.
    Функция должна возвращать кортеж, содержащий все планеты, орбиты которых
    расположены между орбитой planet1 и орбитой planet2, отсортированные по
    близости к солнцу.
    Функция должна вернуть пустой кортеж, если planet1 или planet2
    это неправильные названия планет.
    Примеры
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''