def sorted_list_sum(lst):
    """Напишите функцию, которая принимает список строк в качестве параметра,
    удаляет из него строки с нечетной длиной
    и возвращает результирующий список в отсортированном порядке.
    Список всегда является списком строк и никогда не является массивом чисел
    и может содержать дубликаты.
    Порядок списка должен быть по возрастанию длины каждого слова, и
    вы должны вернуть список, отсортированный по этому правилу.
    Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
    Функция должна возвращать список строк в отсортированном порядке.
    Вы можете предположить, что все слова имеют одинаковую длину.
    Например:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Напишите функцию, которая принимает список строк в качестве параметра,
    удаляет строки с нечетной длиной,
    и возвращает список результатов в отсортированном порядке.
    Список всегда состоит из строк и никогда из массива чисел,
    может содержать дубликаты.
    Порядок списка должен быть по возрастанию длины каждого слова, вам
    нужно вернуть список, отсортированный в соответствии с этим правилом.
    Если два слова одной длины, сортируйте список по алфавиту.
    Функция должна вернуть список строк в отсортированном порядке.
    Вы можете предположить, что все слова будут одной длины .
    Например:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Напишите функцию, которая принимает список строк в качестве параметра,
    удаляет строки, которые имеют нечётную длину,
    и возвращает список результатов в отсортированном порядке,
    Список всегда является списком строк и никогда массивом чисел,
    и может содержать дубликаты.
    Порядок списка должен быть возрастающим по длине каждого слова, и вы
    должны вернуть список, отсортированный в соответствии с этим правилом.
    Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
    Функция должна вернуть список строк в отсортированном порядке.
    Вы можете предположить, что все слова будут иметь одинаковую длину.
    Например:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Простая программа, которая должна возвращать значение x, если n является
    простым числом, и должна возвращать значение y в противном случае.

    Примеры:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Простая программа, которая должна вернуть значение x, если n
    простое число и должно вернуть значение y в противном случае.

    Примеры:
    например x_or_y(7, 34, 12) == 34
    например x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Учитывая список чисел, верните сумму квадратов чисел
    в списке, которые являются нечётными. Игнорируйте отрицательные или нецелые числа.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Если входной список пуст, верните 0.
    '''

def double_the_difference(lst):
    '''
    Дан список чисел, вернуть сумму квадратов чисел
    в списке, которые являются нечетными. Игнорировать числа, которые являются отрицательными или не целыми.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Если входной список пуст, вернуть 0.
    '''

def double_the_difference(lst):
    '''
    Для заданного списка чисел возвращает сумму квадратов чисел в списке,
    которые являются нечетными. Игнорирует числа, которые отрицательные
    или не являются целыми числами.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Если входной список пуст, возвращает 0.
    '''


def compare(game,guess):
    """Я думаю, мы все помним это чувство, когда результат какого-то долгожданного
    события наконец-то известен. Чувства и мысли, которые у вас возникают в этот момент,
    определенно стоит записать и сравнить.
    Ваша задача — определить, правильно ли человек угадал результаты ряда матчей.
    Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс показывает матч.
    Верните массив той же длины, обозначающий, насколько отдаленным было каждое предположение. Если они угадали правильно,
    значение равно 0, а если нет, то значение равно абсолютной разнице между предположением и оценкой.

    пример:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Я думаю, все мы помним это чувство, когда результат какого-то долгожданного
    события наконец-то становится известен. Чувства и мысли, которые вы испытываете в этот момент.
    определенно стоит записать и сравнить.
    Ваша задача - определить, правильно ли человек угадал результаты ряда матчей.
    Вам даны два массива оценок и угадываний одинаковой длины, где каждый индекс указывает на совпадение.
    Верните массив той же длины, обозначающий, насколько далека была каждая догадка. Если они угадали правильно,
    то значение равно 0, а если нет, то значение равно абсолютной разнице между угадыванием и оценкой.

    пример:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

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

    пример:

    сравнение([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    сравнение([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """Вам будет дано имя класса (строка) и список расширений.
    Расширения должны использоваться для загрузки дополнительных классов в класс.
    Сила расширения определяется следующим образом: пусть CAP — это количество
    заглавных букв в имени расширения, а SM — количество строчных букв в имени расширения.
    Сила вычисляется как дробь CAP - SM.
    Нужно найти самое сильное расширение и вернуть строку в формате:
    ClassName.StrongestExtensionName.
    Если два или более расширений имеют одинаковую силу, нужно выбрать первое в списке.

    Например, если дано имя класса "Slices" и список расширений:
    ['SErviNGSliCes', 'Cheese', 'StuFfed'], то следует вернуть 'Slices.SErviNGSliCes',
    так как 'SErviNGSliCes' имеет силу -1.

    Пример:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Вам будет дано имя класса (строка) и список расширений.
    Расширения используются для загрузки дополнительных классов в класс.
    Сила расширения заключается в следующем: Пусть CAP это количество заглавных
    букв в имени расширения, и пусть SM это количество строчных букв
    в имени расширения, сила расширения определяется дробью CAP - SM.
    Вы должны найти самое сильное расширение и вернуть строку в таком
    формате: ClassName.StrongestExtensionName.
    Если существует два или более расширений с одинаковой силой, следует
    выбрать то, которое стоит первым в списке.
    Например, если вам дан класс "Slices" и список
    расширений: ['SErviNGSliCes', 'Cheese', 'StuFfed'], то вы должны
    вернуть 'Slices.SErviNGSliCes', поскольку 'SErviNGSliCes' является самым сильным расширением
    (его сила равна -1).
    Пример:
    для Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Вам будет предоставлено имя класса (строка) и список расширений.
    Расширения будут использоваться для загрузки дополнительных классов в класс.
    Сила расширения выглядит следующим образом: пусть CAP будет числом заглавных
    букв в имени расширения, а SM будет числом строчных
    букв в имени расширения, сила задается разностью CAP - SM.
    Вы должны найти самое сильное расширение и вернуть строку в следующем формате: ClassName.StrongestExtensionName.
    Если есть два или более расширения с одинаковой силой, вам следует
    выбрать то, которое стоит первым в списке.
    Например, если вам дан "Slices" в качестве класса и список
    расширений: ['SErviNGSliCes', 'Cheese', 'Stufed'], то вам следует
    вернуть 'Slices.SERviNGSliCes', поскольку 'SErviNGSliCes' является самым сильным расширением
    (его сила равна -1).
    Пример:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a, b):
    """ Вам даны 2 слова. Нужно вернуть True, если второе слово или его любая ротация является подстрокой первого
    слова.
    cycpattern_check("abcd", "abd") => False
    cycpattern_check("hello", "ell") => True
    cycpattern_check("whassup", "psus") => False
    cycpattern_check("abab", "baa") => True
    cycpattern_check("efef", "eeff") => False
    cycpattern_check("himenss", "simen") => True
    """

def cycpattern_check(a , b):
    """Вам дано 2 слова. Вам необходимо вернуть True, если второе слово или любое из его вращений является подстрокой в первом слове
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Вам даны 2 слова. Вам нужно вернуть True, если второе слово или любая из его ротаций является подстрокой в первом слове
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Для данного целого числа возвращает кортеж, содержащий количество чётных и нечётных цифр соответственно.

     Пример:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Дано целое число. Возвращает кортеж, содержащий количество четных и нечетных цифр соответственно.

     Пример:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """Дано положительное целое число. Необходимо перевести его в римскую цифру и вернуть
    в нижнем регистре.
    Ограничения: 1 <= num <= 1000

    Примеры:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Дано положительное целое число, получить его эквивалент в виде римской цифры в виде строки и вернуть его в нижнем регистре.
    Ограничения: 1 <= num <= 1000

    Примеры:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Получив положительное целое число, получите его эквивалент римской цифры в виде строки,
    и верните его в нижнем регистре.
    Ограничения: 1 <= num <= 1000

    Примеры:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Даны длины трех сторон треугольника. Верните True, если три
    стороны образуют прямоугольный треугольник, False в противном случае.
    Прямоугольный треугольник — это треугольник, в котором один угол прямой или
    90 градусов.
    Пример:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

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

def right_angle_triangle(a, b, c):
    '''
    Даны длины трех сторон треугольника. Возвращает True, если эти три стороны
    образуют прямоугольный треугольник, иначе False.
    Прямоугольный треугольник — это треугольник, в котором один угол является прямым
    (90 градусов).
    Пример:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Напишите функцию, которая принимает список строк.
    В списке присутствуют разные слова. Верните слово с максимальным числом
    уникальных символов. Если несколько строк имеют максимальное количество уникальных
    символов, верните тот, который стоит первым в лексикографическом порядке.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

def find_max(words):
    """Напишите функцию, которая принимает список строк.
    Список содержит разные слова. Верните слово с максимальным количеством
    уникальных символов. Если несколько строк имеют максимальное количество
    уникальных символов, верните то, которое стоит первым в лексикографическом порядке.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    Ты голодный кролик, и уже съел определенное количество морковок,
    но теперь тебе нужно съесть больше, чтобы получить дневное количество пищи.
    Функция должна вернуть массив из [ общее количество съеденных морковок после приема пищи,
                                      количество оставшихся морковок после еды ]
    Если не хватает оставшихся морковок, ты съешь все оставшиеся морковки, но все равно останешься голодным.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Переменные:
    @number : целое число
        количество морковок, которые ты уже съел.
    @need : целое число
        количество морковок, которые тебе нужно съесть.
    @remaining : целое число
        количество оставшихся морковок, которые есть в запасе

    Ограничения:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Приятного аппетита :)
    """

def eat(number, need, remaining):
    """
    Ты голодный кролик, и уже съел некоторое количество морковок,
    но теперь тебе нужно съесть ещё, чтобы завершить приемы пищи на день. .
    Ты должен вернуть набор, в котором будет:
    [ общее количество съеденных морковок после еды,
      количество оставшихся морковок после еды ]
    Если оставшихся морковок недостаточно, ты съешь все, что осталось, но все равно останешься голодным.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Переменные:
    @number : целое число
        количество морковок, которые ты съел.
    @need : целое число
        количество морковок, которые тебе нужно съесть.
    @remaining : целое число
        количество оставшихся морковок в запасе

    Ограничения:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Удачи :)
    """

def eat(number, need, remaining):
    """
    Вы голодный кролик, и вы уже съели определённое количество моркови,
    Но теперь вам нужно есть больше моркови, чтобы завершить дневной приём пищи.
    Вы должны вернуть массив [ общее количество съеденной моркови после еды,
                                    количество моркови, оставшейся после еды ]
    Если останется недостаточно моркови, вы съедите всю оставшуюся морковь, но всё равно будете голодны.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Переменные:
    @number : целое число
        количество моркови, которую вы съели.
    @need : целое число
        количество моркови, которое нужно съесть.
    @remaining : целое число
        количество оставшейся моркови имеется в наличии

    Ограничить:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Развлекайтесь:)
    """


def do_algebra(operator, operand):
    """
    Даны два списка: операторов и операндов. Первый список содержит базовые операции алгебры,
    а второй — список целых чисел. Используйте оба списка для построения алгебраического
    выражения и верните результат его вычисления.

    Основные алгебраические операции:
    Сложение ( + )
    Вычитание ( - )
    Умножение ( * )
    Целочисленное деление ( // )
    Возведение в степень ( ** )

    Пример:
    operator = ['+', '*', '-']
    operand = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Примечание:
        Длина списка операторов равна длине списка операндов минус один.
        Список операндов содержит только неотрицательные целые числа.
        Список операторов содержит хотя бы один оператор, а список операндов — хотя бы два операнда.
    """

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

    Основные операции алгебры:
    Addition ( + )
    Subtraction ( - )
    Multiplication ( * )
    Floor division ( // )
    Exponentiation ( ** )

    Пример:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Примечание:
        Длина списка операторов равна длине списка операндов минус один.
        Операнд это список неотрицательных целых чисел.
        Список операторов имеет по меньшей мере один оператор, а список операндов имеет по меньшей мере два операнда.

    """

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

    выражения и возврата оценки этого выражения.

    Основные алгебраические операции:
    Сложение ( + )
    Вычитание ( - )
    Умножение ( * )
    Деление с точностью до десятого ( // )
    Возведение в степень ( ** )

    Пример:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Примечание:
    Длина списка операторов равна длине списка операндов минус один.
    Операнд — это список неотрицательных целых чисел.
    Список операторов содержит по крайней мере один оператор, а список операндов содержит по крайней мере два операнда.

    """


def solve(s):
    """Вам дается строка s.
    Если s[i] является буквой, переверните её регистр с нижнего на верхний или наоборот,
    в противном случае оставьте всё как есть.
    Если строка не содержит букв, переверните строку.
    Функция должна вернуть полученную строку.
    Примеры
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Дана строка s.
    Если s[i] является буквой, измените ее регистр с нижнего на верхний или наоборот.
    В противном случае оставьте символ как есть.
    Если строка не содержит букв, разверните строку.
    Функция должна возвращать результирующую строку.

    Примеры:
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Вам дана строка s.
    если s[i] — это буква, поменяйте ее регистр с нижнего на верхний или наоборот,
    в противном случае оставьте все как есть.
    Если строка не содержит букв, поменяйте ее местами.
    Функция должна вернуть полученную строку.
    Примеры
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Дана строка 'text'. Необходимо вернуть её эквивалент в виде md5 хеша.
    Если строка 'text' пуста, вернуть None.

    Пример:
    string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Получив строку 'text', верните её эквивалентную строку md5 hash.
    Если 'text' является пустой строкой, верните None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Для строки 'text' вернуть ее эквивалентную хэш-строку md5.
    Если 'text' — пустая строка, вернуть None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    Данная функция принимает два положительных целых числа a и b и возвращает четные числа между a и b в порядке возрастания.

    Примеры:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Имея два положительных целых числа a и b, возвращаем чётные цифры между a
    и b, в порядке возрастания.

    Например:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Если даны два положительных целых числа a и b, верните четные цифры между a
    и b в порядке возрастания.

    Например:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """