def intersection(interval1, interval2):
    """给定两个区间，
    每个区间是一个整数对。例如，区间 = (start, end) = (1, 2)。
    给定的区间是闭区间，这意味着区间 (start, end)
    包括 start 和 end。
    对于每个给定的区间，假设其 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 intersection(interval1, interval2):
    """给定两个区间，
    每个区间是一个整数对。例如，区间 = (start, end) = (1, 2)。
    给定的区间是闭区间，这意味着区间 (start, end)
    包括起始点和结束点。
    对于每个给定的区间，假设其起始点小于或等于结束点。
    你的任务是确定这两个区间的交集的长度
    是否是一个质数。
    例如，区间 (1, 3)、(2, 4) 的交集是 (2, 3)
    其长度是 1，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):
    """给定两个区间，
    其中每个区间是一对整数。例如，区间 = (start, end) = (1, 2)。
    给定的区间是封闭的，这意味着区间 (start, end)
    包括 start 和 end。
    对于每个给定的区间，假设其 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 表示。
    注意：如果 arr 为空，则返回 None。

    示例：
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    你将得到一个整数数组 arr，你需要返回
    数组中每个数字的绝对值乘以其符号的积，
    符号由 1、-1 或 0 表示。
    注意：如果 arr 为空，返回 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 和 B 经过的单元格的值进行有序列表（我们将它们称为 lst_A 和 lst_B）后，lst_A 按字典顺序小于 lst_B，换句话说，存在一个整数
    索引 i，则认为路径 A（长度为 k）小于路径 B（长度为 k） (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 个单元格（不一定是不同的）。
    不一定完全相同）。
    您不能离开网格。
    如果出现以下情况，则认为长度为 k 的路径 A 小于长度为 k 的路径 B
    将 A 和 B 经过的单元格上的值有序列出（我们称之为 l
    让我们称它们为 lst_A 和 lst_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 minPath(grid, k):
    """
    给定一个具有 N 行和 N 列（N >= 2）的网格和一个正整数 k，
    网格的每个单元格包含一个值。范围 [1, N * N] 内的每个整数
    在网格的单元格中出现一次。

    你必须在网格中找到最小的路径，路径长度为 k。你可以从
    任何单元格开始，在每一步中，你可以移动到任何相邻的
    单元格，换句话说，你可以前往与当前单元格共享边的
    单元格。
    请注意，路径长度 k 意味着访问正好 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 tri(n):
    """每个人都知道斐波那契数列，数学家们在过去几个世纪里深入研究了它。
    然而，人们不知道的是 Tribonacci 数列。
    Tribonacci 数列由以下递归定义：
    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，你需要返回 Tribonacci 数列的前 n + 1 个数字的列表。
    示例：
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """每个人都知道斐波那契数列，在过去的几个世纪里，数学家们对它进行了深入研究。然而，人们不知道的是Tribonacci数列。Tribonacci数列由递归定义：
    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，你必须返回Tribonacci数列的前 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):
    """给定一个数字列表。
    需要返回给定列表中平方数的和，
    首先将列表中的每个元素向上取整。
    示例：
    对于 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):
    """给定一个数字列表。
    您需要返回给定列表中平方数的和，
    首先将列表中的每个元素四舍五入到上整数（上限）。
    示例：
    对于 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]，输出应为 29
    对于 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):
    '''
    创建一个返回一个tuple（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):
    """
    给定一个字符串 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):
    """
    给定一个字符串 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):
    """创建一个函数，该函数接受一个表示文件名的字符串，如果文件名有效，则返回
    “是”，否则返回“否”。
    当且仅当满足以下所有条件时，文件名才被视为有效：
    - 文件名中的数字不应超过三位（'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' 和 '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' 和 '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倍数的列表条目。
    然后函数将返回所有条目的和。

    示例：
    对于 lst = [1,2,3] 输出应为 6
    对于 lst = []  输出应为 0
    对于 lst = [-1,-5,2,-1,-5]  输出应为 -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
        * sentence 只包含字母
    """

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
        * 句子只包含字母
    """


def simplify(x, n):
    """你的任务是实现一个函数，用于简化表达式 x * n。
    如果 x * n 计算结果为整数，函数返回 True，否则返回 False。
    x 和 n 都是分数的字符串表示形式，格式如下：
    <分子>/<分母>，其中分子和分母都是正整数。

    你可以假设 x 和 n 是有效的分数，并且分母不为零。

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

def simplify((x, n):
    """您的任务是实现一个函数来简化表达式
    x * n。如果x * n的计算结果为整数，则该函数返回 True，否则返回 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 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 get_max_triples(n):
    """
    给定一个正整数 n。您必须创建一个长度为 n 的整数数组 a。
    对于每个 i（1 ≤ i ≤ n），a[i] 的值 = i * i - i + 1。
    返回 a 的三元组 (a[i], a[j], a[k]) 的数量，其中 i < j < k，
    并且 a[i] + a[j] + a[k] 是 3 的倍数。

    示例：
    输入：n = 5
    输出：1
    解释：
    a = [1, 3, 7, 13, 21]
    唯一有效的三元组是 (1, 7, 13)。
    """

def get_max_triples(n):
    """
    给定一个正整数n，你需要创建一个长度为n的整数数组a。
        每个 i (1 ≤ i ≤ n), a[i]的值是 i * i - i + 1.
        返回数组a中满足i < j < k且a[i] + a[j] + a[k]是3的倍数的三元组（a[i], a[j], a[k]）的数量。

    示例：
        Input: n = 5
        Output: 1
        Explanation:
        a = [1, 3, 7, 13, 21]
        唯一有效的三元组是 (1, 7, 13)。
    """

def get_max_triples(n):
    """
    给定一个正整数 n。您必须创建一个长度为 n 的整数数组 a。
        对于每个 i（1 ≤ i ≤ n），a[i] 的值 = i * i - i + 1。
        返回 a 的三元组 (a[i], a[j], a[k]) 的数量，其中 i < j < k，
    并且 a[i] + a[j] + a[k] 是 3 的倍数。

    示例：
        Input: n = 5
        Output: 1
        Explanation:
        a = [1, 3, 7, 13, 21]
        The only valid triple is (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")
    '''


def sorted_list_sum(lst):
    """编写一个函数，接受一个字符串列表作为参数，
    从中删除长度为奇数的字符串，
    并返回按排序顺序排列的结果列表，
    该列表始终是字符串列表，而不是数字数组，
    并且它可能包含重复项。
    列表的顺序应按每个单词的长度升序排列，并且您
    应该返回按该规则排序的列表。
    如果两个单词的长度相同，则按字母顺序对列表进行排序。
    该函数应返回按排序顺序排列的字符串列表。
    您可以假设所有单词的长度都相同。
    例如：
    sorted_list_sum(["aa", "a", "aaa"]) => ["aa"]
    sorted_list_sum(["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 sorted_list_sum(["aa", "a", "aaa"]) => ["aa"]
    assert sorted_list_sum(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """一个简单的程序，如果 n 是素数，则返回 x 的值，否则返回 y 的值。

    示例：
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """一个简单的程序，如果 n 是质数，则返回 x 的值，
    否则返回 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 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,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,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）。
    示例：
    对于 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）。.
    示例:
    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 cycpattern_check(a , b):
    """给定两个单词。如果第二个单词或其任何旋转是第一个单词的子字符串，则需要返回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):
    """您有两个单词。如果第二个单词或其任何旋转是第一个单词的子字符串，则需要返回 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 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 : integer
        你已经吃掉的胡萝卜数量。
    @need : integer
        你需要吃的胡萝卜数量。
    @remaining : integer
        库存中剩余的胡萝卜数量

    约束条件:
    * 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 : integer
        你已经吃掉的胡萝卜数量。
    @need : integer
        你需要吃的胡萝卜数量。
    @remaining : integer
        库存中剩余的胡萝卜数量。

    约束:
    * 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 ：integer
    你已经吃过的胡萝卜数量。
    @need ：integer
    你需要吃的胡萝卜数量。
    @remaining ：integer
    库存中剩余的胡萝卜数量

    限制：
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    玩得开心 :)
    """


def do_algebra(operator, operand):
    """
    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，
    第二个列表是一个整数列表。使用这两个给定的列表构建代数表达式并返回该表达式的计算结果。

    基本代数运算：
    加法 ( + )
    减法 ( - )
    乘法 ( * )
    整数除法 ( // )
    幂运算 ( ** )

    示例：
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    注意：
        operator 列表的长度等于 operand 列表的长度减一。
        operand 是一个非负整数的列表。
        operator 列表至少有一个运算符，operand 列表至少有两个操作数。

    """

def do_algebra(operator, operand):
    """
    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，
    第二个列表是一个整数列表。使用这两个给定的列表构建代数表
    达式并返回该表达式的计算结果。

    基本代数运算：
    加法 ( + )
    减法 ( - )
    乘法 ( * )
    整数除法 ( // )
    幂运算 ( ** )

    示例：
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    注意：
        operator 列表的长度等于 operand 列表的长度减一。
        operand 是一个非负整数的列表。
        operator 列表至少有一个运算符，operand 列表至少有两个操作数。

    """

def do_algebra(operator, operand):
    """
    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，
    第二个列表是一个整数列表。使用这两个给定的列表构建代数表达式并返回该表达式的计算结果。

    基本代数运算:
    加法 ( + )
    减法 ( - )
    乘法 ( * )
    整数除法 ( // )
    幂运算 ( ** )

    示例:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    注意:
        operator 列表的长度等于 operand 列表的长度减一。
        operand 是一个非负整数的列表。
        operator 列表至少有一个运算符，operand 列表至少有两个操作数。

    """


def solve(s):
    """给定一个字符串 s。
    如果 s[i] 是字母，则将其大小写反转，从小写变为大写或反之，
    否则保持不变。
    如果字符串不包含字母，则反转字符串。
    函数应返回结果字符串。
    示例
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def resolve(s):
    """给定一个字符串 s。
    如果 s[i] 是字母，则将其大小写从小写反转为大写或反之，
    否则保持原样。
    如果字符串不包含字母，则反转字符串。
    该函数应返回结果字符串。
    示例
    resolve("1234") = "4321"
    resolve("ab") = "AB"
    resolve("#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 哈希等效字符串。
    如果“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) => []
    """