from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 检查给定的数字列表中，是否有任意两个数字之间的距离小于给定的阈值。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 检查给定的数字列表中，是否有任意两个数字之间的距离小于
    给定的阈值。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], Threshold: float) -> bool:
    """ 检查给定的数字列表中是否有任何两个数字彼此之间的距离小于
    给定的阈值。
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 该函数的输入是一个包含多组嵌套括号的字符串。您的目标是
    将这些组分离成单独的字符串，并返回其中的列表。
    独立的括号组必须平衡（每个打开的括号都正确闭合），并且不能相互嵌套
    忽略输入字符串中的任何空格。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 此函数的输入是包含多组嵌套括号的字符串。您的目标是
    将这些组分成单独的字符串并返回这些字符串的列表。
    单独的组是平衡的（每个左括号都正确闭合）并且不相互嵌套
    忽略输入字符串中的任何空格。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 这个函数的输入是一个包含多个嵌套括号组的字符串。你的目标是
    将这些组分开并返回这些组的列表。
    分开的组是平衡的（每个开括号都有正确闭合），且没有相互嵌套
    忽略输入字符串中的任何空格。
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ 给定一个正浮点数，它可以被分解为整数部分（小于此给定数的最大整数）
    和小数部分（剩余部分总是小于1）。

    返回数字的小数部分。
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ 给定一个正浮点数，它可以分解为
    整数部分（小于给定数字的最大整数）和小数
    （剩余部分始终小于 1）。

    返回数字的小数部分。
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """  给定一个正浮点数，它可以被分解为
    整数部分（小于给定数的最大整数）和小数部分
    （剩余部分总是小于1）。

    返回数字的小数部分。
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 给定一个银行账户的存款和取款操作列表，该账户初始余额为零。
    你的任务是检测账户余额是否在某个时刻低于零，
    如果是，函数应返回 True。否则应返回 False。
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 您将获得一个银行账户存款和取款操作列表，该列表以零余额开始。您的任务是检测账户余额是否在任何时候低于零，并且
    此时函数应返回 True。否则它应该返回 False。
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 给定一个银行账户的存款和取款操作列表，该账户初始
    余额为零。您的任务是检测账户余额是否在任何时候低于零，并且
    此时函数应返回 True。否则应返回 False。
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 对于给定的输入数字列表，计算该数据集的平均绝对偏差
    以数据集的均值为中心。
    平均绝对偏差是指每个元素与中心点（此处为均值）之间
    绝对差值的平均值，其公式为：
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 对于给定的输入数字列表，计算此数据集平均值周围的平均绝对偏差。
    平均绝对偏差是每个元素与中心点（在本例中为平均值）之间的平均绝对差异：
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 对于给定的输入数字列表，计算该数据集的平均绝对偏差。
    平均绝对偏差是两者之间的平均绝对差元素和中心点（在本例中为平均值）：
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 在输入列表 numbers 的每两个连续元素之间插入一个数字 'delimeter'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 在输入列表 `numbers' 的每两个连续元素之间插入一个数字 'delimeter'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 在输入列表`numbers'的每两个连续元素之间插入一个数字 “delimeter”。
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 该函数的输入是一个字符串，代表多个用空格分隔的括号嵌套组。
    对于每一组，输出括号嵌套的最深层级。
    例如，(()()) 最多有两层嵌套，而 ((())) 则有三层。

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 此函数的输入是一个字符串，表示多个用空格分隔的嵌套括号组。
    对于每个组，输出括号嵌套的最深层次。
    例如，(()()) 的最大嵌套层次为2，而 ((())) 的嵌套层次为3。

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 此函数的输入是一个字符串，表示多个用空格分隔的嵌套括号组。
    对于每个组，输出括号嵌套的最深层次。
    例如，(()()) 的最大嵌套层次为二，而 ((())) 的嵌套层次为三。

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 过滤输入字符串列表，仅保留包含给定子字符串的字符串
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 过滤输入的字符串列表，仅包含给定子字符串
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 仅筛选输入字符串列表中包含给定子串的字符串
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 对于给定的整数列表，返回一个由列表中所有整数的和与积组成的元组。
    空和等于0，空积等于1。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 对于给定的整数列表，返回一个由列表中所有整数的和与乘积组成的元组。
    空和应等于 0，空乘积应等于 1。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 对于给定的整数列表，返回一个包含列表中所有整数的和与积的元组。
    空列表的和应为0，空列表的积应为1。
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 从给定的整数列表中，生成一个列表，包含到当前时刻为止序列中的滚动最大元素。
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 从给定的整数列表中，生成一个列表，包含到当前时刻为止在序列中找到
    的滚动最大元素。
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 从给定的整数列表中，生成一个滚动最大元素列表，直到序列中给定的时刻。
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ 测试给定字符串是否是回文 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 找到以提供的字符串开头的最短回文。
    算法思想很简单：
    - 找到提供字符串中最长的回文后缀。
    - 将回文后缀之前的字符串前缀的反转附加到字符串的末尾。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 测试给定的字符串是否为回文 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 找到以给定字符串开头的最短回文。
    算法思路简单：
    -查找所提供字符串中最长的回文后缀。
    -将回文后缀前的前缀字符串反转后添加到字符串末尾。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 测试给定的字符串是否为回文 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 查找以提供的字符串开头的最短回文。
    算法思想很简单：
    - 查找提供的字符串中最长的回文后缀。
    - 将回文后缀之前的字符串前缀的反向附加到字符串末尾。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ 输入是两个仅由1和0组成的字符串a和b。
    对这些输入执行二进制异或运算，并将结果也作为字符串返回。
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """输入两个仅由1和0组成的字符串a和b。
    对这些输入执行二进制XOR，并以字符串形式返回结果。
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ 输入是两个仅由 1 和 0 组成的字符串 a 和 b。
    对这些输入执行二进制异或，并以字符串形式返回结果。
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 在字符串列表中，返回最长的一个。如果有多个长度相同的字符串，则返回第一个。如果输入列表为空，则返回 None。
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 在字符串列表中，返回最长的字符串。如果有多个
    长度相同的字符串时，返回第一个字符串。如果输入列表为空，则返回 None。
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 从字符串列表中，返回最长的一个。在多个字符串长度相同的情况下，返回第一个。
    如果输入列表为空，则返回 None。
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ 返回两个整数 a 和 b 的最大公约数
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 返回输入字符串中从最短到最长的所有前缀列表
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 返回输入字符串从最短到最长的所有前缀的列表
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 返回输入字符串从最短到最长的所有前缀列表
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ 返回一个字符串，其中包含从0到n（包括n）的以空格分隔的数字。
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 返回一个包含空格分隔的数字的字符串，从 0 到 n（含）。
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ 给定一个字符串，找出它由多少个不同的字符（不区分大小写）组成
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ 给定一个字符串，找出它由多少个不同的字符（不考虑大小写）组成
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    “”“ 给定一个字符串，找出它由多少个不同的字符（不区分大小写）组成
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 输入的函数是一个表示音符的特殊ASCII格式的字符串。
    您的任务是解析这个字符串并返回一个整数列表，对应于每个音符持续的拍数。

    这里有一个示例:
    'o' - 全音符，持续四拍
    'o|' - 二分音符，持续两拍
    '.|' - 四分音符，持续一拍

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 此函数的输入是一个字符串，表示以特殊ASCII格式表示的音乐音符。
    你的任务是解析这个字符串并返回一个整数列表，表示每个音符持续
    的拍数。

    这是一个图例：
    'o' - 全音符，持续四拍
    'o|' - 半音符，持续两拍
    '.|' - 四分音符，持续一拍

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 此函数的输入是一个表示音乐音符的特殊ASCII格式的字符串。
    你的任务是解析这个字符串并返回一个整数列表，对应于每个音符持续的拍数。

    这里有一个图例：
    'o' - 全音符，持续四拍
    'o|' - 二分音符，持续两拍
    '.|' - 四分音符，持续一拍

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


def how_many_times(string: str, substring: str) -> int:
    """ 找出给定子字符串在原始字符串中出现的次数。计算重叠的情况。
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int：
    “”“ 查找给定子字符串在原始字符串中可以找到的次数。对重叠的个案进行计数。
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ 查找给定子字符串在原始字符串中出现的次数。计算重叠的情况。
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ 输入是一个用空格分隔的数字字符串，从 'zero' 到 'nine'。
    有效的选择是 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 和 'nine'。
    返回按从小到大排序的数字字符串
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ 输入是一个以空格分隔的数字字符串，从 'zero' 到 'nine'。
    有效选项是 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 和 'nine'。
    返回按数字从小到大排序的字符串
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 从提供的数字列表（长度至少为 2）中选择并返回两个最接近的数字，并按顺序返回它们（数字较小，数字较大）。
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 从提供的数字列表（长度至少为2）中选择并返回两个最接近的数字，
    并按顺序返回（较小的数字，较大的数字）。
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
     (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
     (2.0, 2.0)
     """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 从提供的数字列表（长度至少为二）中选择并返回两个最接近的
    数字，并按顺序返回（较小的数字，较大的数字）。
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 给定一个数字列表（至少包含两个元素），对该列表应用线性变换，
    使得最小的数字变为0，最大的数字变为1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    “”“ 给定数字列表（至少包含两个元素），对该列表应用线性变换，
    使得最小的数字变为0，最大的数字变为1
     >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 给定数字列表（至少包含两个元素），对该列表应用线性变换，
    使得最小数字变为 0，最大数字变为 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 过滤给定列表中的任何 Python 值，仅保留整数
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 筛选给定列表中的任何python值，仅保留整数
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
     """过滤给定列表中的所有 Python 值，仅保留整数
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    ”“”


def strlen(string: str) -> int:
    """ 返回给定字符串的长度
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ 对于给定数字 n，找出能整除 n 且小于 n 的最大数字
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ 对于给定的数 n，找出能平分 n 且小于 n 的最大的数
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ 对于给定的数字 n，找到小于 n 的最大约数
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ 返回给定整数的质因数列表，按从小到大的顺序排列。
    每个因数出现的次数应与其在因式分解中出现的次数相对应。
    输入数字应等于所有因数的乘积
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ 按从小到大的顺序返回给定整数的质因数列表。
    每个因数列出的次数应与它在因数分解中出现的次数相对应。
    输入数字应等于所有因数的乘积
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 从整数列表中，删除所有出现超过一次的元素。
    保持元素的顺序与输入中的顺序相同。
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 从整数列表中删除所有出现过一次以上的元素。
    保持剩余元素的顺序与输入相同。
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 从整数列表中，移除所有出现多次的元素。
    保持剩余元素的顺序与输入相同。
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ 对于给定的字符串，将小写字符翻转为大写，将大写字符翻转为小写。
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ 对于给定字符串，将小写字母转为大写字母，将大写字母转为小写字母。
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ 对于给定的字符串，将小写字符转换为大写，大写字符转换为小写。
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ 将字符串列表连接成单个字符串
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ 将字符串列表连接成一个单一字符串
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ 将字符串列表拼接成一个单一字符串
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 过滤输入字符串列表，仅保留以给定前缀开头的字符串。
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 仅过滤以给定前缀开头的字符串输入列表。
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 筛选输入字符串列表，仅保留以给定前缀开头的字符串。
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """只返回列表中的正数。
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """返回列表中仅有的正数。
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    “”“返回列表中仅有的正数。
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """如果给定的数字是质数，则返回 true，否则返回 false。
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """如果给定数字为素数，则返回 true，否则返回 false。
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    计算在点 x 处具有系数 xs 的多项式。
    返回 xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs 是多项式的系数。
    find_zero 找到 x 使得 poly(x) = 0。
    find_zero 仅返回一个零点，即使有多个。
    此外，find_zero 仅接受具有偶数个系数的列表 xs，
    并且最大非零系数保证
    有解。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    在点 x 处计算具有系数 xs 的多项式。
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs 是多项式的系数。
    find_zero 查找 x，使得 poly(x) = 0。
    find_zero 仅返回零点，即使有很多。
    此外，find_zero 仅接受具有偶数个系数的列表 xs
    和最大的非零系数，因为它保证
    有一个解决方案。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    计算在点 x 处，系数为 xs 的多项式。
    返回 xs[0] + xs[1] * x + xs[2] * x^2 + .... + xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs 为多项式的系数。
    find_zero 找到 x 使得 poly(x) = 0
    find_zero 仅返回一个零点（即使存在多个）
    此外，find_zero 仅接受有偶数个系数的列表 xs，
    且，最大非零系数有解。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """此函数接受一个列表 l 并返回一个列表 l'，使得
    l' 在索引不被三整除的位置与 l 相同，而在被三整除的索引位置的值
    等于 l 对应索引的值，但已排序。
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """此函数接受一个列表 l 并返回一个列表 l'，使得
    l' 在其索引不被3整除的位置的值与 l 相同，而在被3整除的索引位置的值
    等于 l 对应索引的值，但已排序。
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """此函数接受一个列表 l 并返回一个列表 l'，使得
    l' 在不能被三整除的索引上与 l 相同，而在可以被三整除的索引上的值等于
    l 的相应索引的值，但已排序。
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """返回列表中排序后的唯一元素
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """返回列表中的最大元素。
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """返回数字 7 在小于 n 且能被 11 或 13 整除的整数中出现的次数。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """返回小于 n 的整数中，能被 11 或 13 整除的数字中出现数字 7 的次数。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """返回在能被11或13整除的小于n的整数中，数字7出现的次数。
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """此函数接受一个列表 l 并返回一个列表 l'，使得
    l' 在奇数索引处与 l 相同，而其在偶数索引处的值等于
    l 的偶数索引的值，但已排序。
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """此函数接受一个列表 l 并返回一个列表 l'，使得
    l' 在奇数索引处与 l 相同，而在偶数索引处的值等于
    l 的偶数索引处的值，但已排序。
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    返回通过循环三个字符一组编码的字符串。
    """
    # 将字符串分割成组。每组长度为3。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 循环每组中的元素。除非组中元素少于3个。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    以使用 encode_cyclic 函数编码的字符串作为输入，返回解码后的字符串。
    """

def encode_cyclic(s: str):
    """
    返回通过循环三个字符一组编码的字符串。
    """
    # 将字符串分割成组。每组长度为3。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 循环每组中的元素。除非组中元素少于3个。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    输入使用 encode_cyclic 函数编码的字符串。返回解码后的字符串。
    """

def encode_cyclic(s: str):
    """
    返回按三个字符循环分组的编码字符串。
    """
    # 将字符串分割为若干组。每组长度为3。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 每组中的循环元素。除非组中元素少于3个。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    输入用 encode_cyclic 函数编码的字符串。返回解码后的字符串。
    """


def prime_fib(n: int):
    """
    prime_fib 返回第 n 个既是斐波那契数又是质数的数字。
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib 返回第n个斐波那契数且是质数的数字。
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero 接受一个整数列表作为输入。
    如果列表中有三个不同的元素之和为零，则返回 True，
    否则返回 False。

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero 接受一个整数列表作为输入。
    如果列表中有三个不同的元素之和为零，则返回True，
    否则返回 False。

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero 以整数列表作为输入。
    如果列表中有三个不同的元素的总和为零，则返回 True，否则返回 False。

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    想象一下有一条道路，这条道路是完全笔直的、无限长的。
    n 辆车从左向右行驶；同时，另一组 n 辆车
    正在从右向左行驶。两组车一开始相距非常远。
    所有的车都以相同的速度行驶。当一辆从左向右行驶的车撞到
    一辆从右向左行驶的车时，我们说两辆车发生了碰撞。
    然而，这些车是无限坚固和强大的；因此，它们继续按原来的
    轨迹行驶，就像它们没有发生碰撞一样。

    这个函数输出发生碰撞的数量。
    """

def car_race_collision(n: int):
    """
    想象一条完美笔直的无限长的道路。
    n辆车从左向右行驶；同时，另一组n辆车
    从右向左行驶。两组车开始时彼此非常远。
    所有车的速度相同。当一辆从左向右行驶的车
    撞上一辆从右向左行驶的车时，称为碰撞。
    然而，这些车是无限坚固和强壮的；因此，它们继续
    按照原来的轨迹行驶，就像没有碰撞一样。

    这个函数输出这样的碰撞次数。
    """


def incr_list(l: list):
    """返回一个列表，其中的元素增加1。
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """返回元素增加1的列表。
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero 接受一个整数列表作为输入。
    如果列表中有两个不同的元素相加为零，则返回 True，
    否则返回 False。
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero 接受一个整数列表作为输入。
    如果列表中有两个不同的元素相加为零，则返回 True，否则返回 False。
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """将输入数字 x 的数值进制更改为 base。
    返回转换后的字符串表示。
    进制数小于 10。
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """输入数字 x 的数值基数更改为 base。
    返回转换后的字符串表示。
    基数小于 10。
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """将输入数字x的数值基数更改为base。
    转换后返回字符串表示。
    基数小于 10。
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """给定边长和高，返回三角形的面积。
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """给定边长和高，返回三角形的面积。
    >>>triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Fib4 数列是一个类似于斐波那契数列的序列，其定义如下：
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    请编写一个函数来高效地计算 fib4 数列的第 n 个元素。不要使用递归。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    ""Fib4 数字序列是一个类似于斐波那契数列的序列，定义如下：
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)。
    请编写一个函数来高效地计算 fib4 数列的第 n 个元素。请勿使用递归。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 数字序列是类似于斐波那契数列的序列，其定义如下：
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)。
    请编写一个函数来高效计算 fib4 数字序列的第 n 个元素。请勿使用递归。
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """返回列表l中元素的中位数。
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """返回列表 l 中元素的中位数。
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median（l： list）：
    “”“返回列表 l 中元素的中位数。
    >>> median （[3， 1， 2， 4， 5]）
    3
    >>> median （[-10， 4， 6， 1000， 10， 20]）
    15.0
    """


def is_palindrome(text: str):
    """
    检查给定字符串是否为回文字符串
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    检查给定字符串是否是回文
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """返回 2^n 模 p（注意数值）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """返回 2^n 模 p（注意数值）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    ”“”

def modp(n: int, p: int):
    """返回2^n模p（注意数值）。
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    通过将字母表中的每个字符移动 5 位来返回编码后的字符串。
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    输入使用encode_shift函数编码的字符串。返回解码后的字符串。
    """

def encode_shift(s: str):
    """
    返回通过在字母表中每个字符移动5位编码的字符串。
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    输入使用encode_shift函数编码的字符串。返回解码后的字符串。
    """


def remove_vowels(text):
    """
    remove_vowels 是一个函数，接受字符串并返回去除元音的字符串。
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels 是一个函数，接收字符串并返回去除元音后的字符串。
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels 是一个函数，传入字符串，返回去除元音的字符串。
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """如果列表 l 中的所有数字都小于阈值 t，则返回 True。
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """如果列表 l 中的所有数字都低于阈值 t，则返回 True。
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """将两个数字 x 和 y 相加
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """将两个数字 x 和 y相加
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    检查两个单词是否具有相同的字符。
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    检查两个单词是否有相同的字符。
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """返回第 n 个斐波那契数。
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """返回第n个斐波那契数字。
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
     “”“返回第 n 个斐波那契数。
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets 是一个由 "<" 和 ">" 组成的字符串。
    如果每个开括号都有一个对应的闭括号，则返回 True。

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

def correct_bracketing(brackets: str):
    """ 括号是由“<”和“>”组成的字符串。
    如果每个开头括号都有相应的结尾括号，则返回 True。
    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """如果列表元素单调递增或递减，则返回 True。
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic（l： list）：
    “”“如果列表元素单调递增或递减，则返回 True。
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """返回两个列表的排序后的唯一公共元素。
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """返回两个列表中排序后的唯一公共元素。
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """返回两个列表中已排序的唯一共同元素。
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """返回 n 的最大质因数。假设 n > 1 且不是质数。
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """返回n的最大质因数。假设n > 1且不是质数。
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n 是一个将数字从 1 加到 n 的函数。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n 是一个对 1 到 n 之间的数字求和的函数。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_too_n是一个对从1到n的数字求和的函数。
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets 是一个由 "(" 和 ")" 组成的字符串。
    如果每个开括号都有一个对应的闭括号，则返回 True。

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

def correct_bracketing(brackets: str):
    """ 括号是由“(”和“) ”组成的字符串。
    如果每个开头括号都有相应的结尾括号，则返回 True。

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


def derivative(xs: list):
    """ xs 表示多项式的系数。
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    以相同形式返回此多项式的导数。
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs表示多项式的系数。
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     以相同形式返回该多项式的导数。
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs 表示多项式的系数。
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     返回该多项式的导数，形式相同。
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """FibFib 数字序列是一个类似于斐波那契序列的序列，其定义如下：
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)。
    请编写一个函数来高效地计算 fibfib 数字序列的第 n 个元素。
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib数列是一个类似于Fibbonacci数列的序列，其定义如下：
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    请编写一个函数，以有效地计算fibfib数列的第n个元素。
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib 数字序列是一个类似于斐波那契序列的序列，其定义如下：
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    请编写一个函数来高效地计算 fibfib 数字序列的第 n 个元素。
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
添加更多测试用例。
"""

def vowels_count(s):
    """编写一个函数 vowels_count，该函数接受一个表示单词的字符串作为输入，
    并返回字符串中元音的数量。在这种情况下，元音是 'a', 'e', 'i', 'o', 'u'。
    这里，'y' 也是一个元音，但仅当它位于给定单词的末尾时。

    示例：
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
添加更多测试用例。
"""

def vowels_count(s):
    """编写一个函数 vowels_count，以表示单词的字符串作为输入，并返回字符串中元音的数量。
    在这种情况下，元音是 'a'、'e'、'i'、'o'、'u'。这里，'y' 也是一个元音，但只有当它位于给定单词的末尾时才是元音。

    示例：
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
添加更多测试用例。
"""

def vowels_count(s):
    """编写一个函数 vowels_count，该函数接受一个表示单词的字符串作为输入，
    并返回字符串中元音的数量。
    在这种情况下，元音是 'a', 'e', 'i', 'o', 'u'。这里，'y' 也是
    一个元音，但仅当它位于给定单词的末尾时。

    示例：
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """对整数 x 中的数字进行循环移位，将数字向右移动 shift 位，
    并以字符串形式输出。
    如果 shift > 该数字的位数，则输出时将该数字反转。
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """循环移动整数 x 的数字，将数字向右移动 shift 位
    并将结果作为字符串返回。
    如果 shift > 数字的位数，返回数字反转。
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """循环移位整数 x 的数字，将数字向右移位
    并将结果作为字符串返回。
    如果移位 > 数字的位数，返回反向的数字。
    >>>circular_shift(12, 1)
    "21"
    >>>circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """任务
    编写一个函数，该函数接受一个字符串作为输入，并返回仅大写字符的
    ASCII码之和。

    示例:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """任务
    编写一个函数，以字符串作为输入，并返回仅大写字符的 ASCII 码总和。

    示例：
    digitSum("") => 0
    digitSum("abAB") => 131
    digitSum("abcCd") => 67
    digitSum("helloE") => 69
    digitSum("woArBld") => 131
    digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    ""任务
    编写一个函数，该函数接受一个字符串作为输入，并返回仅大写字符的
    ASCII码之和。

    示例:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    在这个任务中，你将得到一个字符串，表示分布在水果篮中的苹果和橙子的数量。
    这个篮子里有苹果、橙子和芒果。给定一个表示橙子和苹果总数的字符串和一个表示篮子中
    水果总数的整数，返回篮子中芒果的数量。
    例如：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    在这个任务中，你将得到一个字符串，表示分布在一个水果篮子中的苹果和橙子的数量，
    水果篮里装着苹果、橙子和芒果。
    给一个字符串代表橘子和苹果的总数和一个整数代表篮子中水果总数，
    返回篮子中芒果的数量。
    例如：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    在这个任务中，您将获得一个字符串，表示一篮子水果中
    分配的苹果和橙子的数量。
    该篮子包含苹果、橙子和芒果。给定表示橙子和苹果总数的
    字符串，以及表示水果总数的整数，
    返回篮子中芒果水果的数量。
    例如：
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "给定一个表示树枝的数组，其中包含非负整数节点，
    你的任务是摘取一个节点并返回。
    被摘取的节点应该是具有最小偶数值的节点。
    如果找到多个具有相同最小偶数值的节点，返回索引最小的那个节点。

    被摘取的节点应该以列表的形式返回，格式为 [ 最小值, 其索引 ]，
    如果没有偶数值或给定的数组为空，返回 []。

    示例 1：
        输入：[4,2,3]
        输出：[2, 1]
        解释：2 是最小的偶数值，且 2 的索引最小。

    示例 2：
        输入：[1,2,3]
        输出：[2, 1]
        解释：2 是最小的偶数值，且 2 的索引最小。

    示例 3：
        输入：[]
        输出：[]

    示例 4：
        输入：[5, 0, 3, 0, 4, 2]
        输出：[0, 1]
        解释：0 是最小的偶数值，但有两个零，
             所以我们选择第一个零，它的索引最小。

    约束条件：
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "给定一个表示具有非负整数节点的树的分支的数组
    您的任务是摘取其中一个节点并返回它。
    摘取的节点应该是具有最小偶数值的节点。
    如果发现多个具有相同最小偶数值的节点，则返回具有最小索引的节点。

    摘取的节点应在列表中返回，[smalest_value，其索引]，
    如果没有偶数值或给定的数组为空，则返回[]。

    示例 1：
    输入：[4,2,3]
    输出：[2, 1]
    说明：2 具有最小偶数值，2 具有最小索引。

    示例 2：
    输入：[1,2,3]
    输出：[2, 1]
    说明：2 具有最小偶数值，2 具有最小索引。

    示例 3：
    输入：[]
    输出：[]

    示例 4：
    输入：[5, 0, 3, 0, 4, 2]
    输出：[0, 1]
    解释：0 是最小值，但有两个零，
    因此我们将选择具有最小索引的第一个零。

    约束条件：
    * 1 <= nodes.length <= 10000
    * 0 <= node.value
    """

def pluck(arr):
    """
    "给定一个表示树的分支的数组，该数组具有非负整数节点
    你的任务是摘取其中一个节点并返回它。
    被摘取的节点应该是具有最小偶数值的节点。
    如果找到多个具有相同最小偶数值的节点，则返回具有最小索引的节点。

    被摘取的节点应以列表形式返回，[ 最小值, 其索引 ]，
    如果没有偶数值或给定数组为空，则返回 []。

    示例 1:
        输入: [4,2,3]
        输出: [2, 1]
        解释: 2 是最小的偶数值，并且 2 具有最小的索引。

    示例 2:
        输入: [1,2,3]
        输出: [2, 1]
        解释: 2 是最小的偶数值，并且 2 具有最小的索引。

    示例 3:
        输入: []
        输出: []

    示例 4:
        输入: [5, 0, 3, 0, 4, 2]
        输出: [0, 1]
        解释: 0 是最小值，但有两个零，
                     所以我们将选择第一个零，它具有最小的索引。

    约束条件:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    给定一个非空的正整数列表。
    返回一个大于零且其频率大于或等于其值的最大整数。
    整数出现的频率是它在列表中出现的次数。
    如果不存在，则返回 -1。
    示例：
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    给定一个非空的正整数列表。返回大于零且频率大于
    或等于其自身值的最大整数。
    整数的频率是它在列表中出现的次数。
    如果不存在这样的值，返回 -1。
    示例：
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    给定一个非空的正整数列表。返回大于零且频率大于或等于整数本身值的最大整数。
    整数的频率是它在列表中出现的次数。
    如果不存在这样的值，则返回 -1。
    示例：
    search([4, 1, 2, 2, 3, 1]) == 2
    search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
    search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    给定整数列表，以奇怪的顺序返回列表。
    奇怪的排序是从最小值开始，
    然后是剩余整数的最大值，然后是最小值，依此类推。

    示例：
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list（lst）：
    '''
    给定整数列表，以奇怪的顺序返回列表。
    奇怪的排序是从最小值开始，
    然后是剩余整数的最大值，然后是最小值，依此类推。

    例子：
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    给定一个三角形的三边长度。如果三边构成一个有效的三角形，就将该
    三角形的面积四舍五入到小数点后两位并返回。否则返回 -1。
    当任意两边之和大于第三边时，三边构成一个有效的三角形。
    示例：
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    给定三角形三边的长度。如果三边形成一个有效三角形，则返回四舍五入到小数点后 2 位的三角形面积。
    否则返回 -1
    当任意两边之和大于第三边时，三边构成一个有效三角形。
    示例：
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    给定一个三角形的三边长度。如果三边构成一个有效的三角形，返回
    该三角形的面积，保留两位小数。
    否则返回 -1
    三边构成一个有效的三角形，当任意两边之和大于
    第三边时。
    示例：
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    编写一个函数，如果对象 q 会飞，则返回 True，否则返回 False。
    对象 q 会飞的条件是它是平衡的（它是一个回文列表）并且其元素的和小于或等于最大可能重量 w。

    示例：
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 小于最大可能重量，但它是不平衡的。

    will_it_fly([3, 2, 3], 1) ➞ False
    # 它是平衡的，但 3+2+3 大于最大可能重量。

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 小于最大可能重量，并且它是平衡的。

    will_it_fly([3], 5) ➞ True
    # 3 小于最大可能重量，并且它是平衡的。
    '''

def will_it_fly(q,w):
    '''
    编写一个函数，如果对象 q 会飞，则返回 True，否则返回 False。
    如果对象 q 是平衡的（它是一个回文列表），并且其元素的总和小于或等于最大可能重量 w，则对象 q 会飞。

    示例：
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 小于最大可能重量，但它是不平衡的。

    will_it_fly([3, 2, 3], 1) ➞ False
    # 它是平衡的，但 3+2+3 大于最大可能重量。

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 小于最大可能重量，并且它是平衡的。

    will_it_fly([3], 5) ➞ True
    # 3 小于最大可能重量，并且是平衡的。
    '''


def smallest_change(arr):
    """
    给定一个整数数组 arr，找出需要更改的最小元素数量，
    使数组成为回文数组。回文数组是指正反读都相同的数组。
    在一次更改中，你可以将一个元素更改为任何其他元素。

    例如：
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    给定一个整数数组 arr，要使其成为回文数组，请找出需要更改的最小元素数量。
    回文数组是指正反读都相同的数组。
    在一次更改中，可将某元素更改为其他任何元素。

    例如：
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    编写一个函数，该函数接受两个字符串列表，并返回字符总数较少的列表。

    如果两个列表的字符数相同，则返回第一个列表。

    示例
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    编写一个函数，接受两个字符串列表，并返回列表中所有字符串的字符总数小于另一个列表的列表。

    如果两个列表的字符数相同，则返回第一个列表。

    示例
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    编写一个函数，该函数传入两个字符串列表，返回字符总数较少的列表。

    如果两个列表的字符数相同，则返回第一个列表。

    示例
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """编写一个函数，当给定的数字是3个质数的乘积时返回true，
    否则返回false。
    已知(a)小于100。
    示例：
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a)：
    “”“编写一个函数，如果给定的数字是3个质数的乘积则返回True，
    否则返回False。
    知道(a)小于 100。
    示例：
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """编写一个函数，如果给定的数字是3个质数的乘积则返回true，
    否则返回false。
    知道(a)小于100。
    示例：
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """你的任务是编写一个函数，如果一个数字 x 是 n 的简单幂，则返回 true，否则返回 false。
    如果 n**int=x，则 x 是 n 的简单幂
    例如：
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """你的任务是编写一个函数，如果一个数字 x 是 n 的简单幂，则返回 true
    否则返回 false。
    如果 n**int=x，则 x 是 n 的简单幂
    例如：
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """您的任务是编写一个函数，如果数字 x 是 n 的简单幂，则返回 true，否则返回 false。
    如果 n**int=x，则 x 是 n 的简单幂
    例如：
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    编写一个函数，该函数接受一个整数 a，并返回 True
    如果这个整数是某个整数的立方。
    注意：你可以假设输入总是有效的。
    示例：
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    编写一个函数，接收一个整数 a，并在该整数是
    某个整数的立方时返回 True。
    注意：你可以假设输入始终有效。
    示例:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    编写一个函数，接受一个整数 a，如果该整数是某个整数的立方，则返回 True 。
    注意：您可以假设输入始终有效。
    示例：
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """你需要编写一个函数，该函数接收一个十六进制数字作为字符串，
    并计算其中是质数的十六进制数字的个数（质数是大于1的自然数，
    且不能被两个更小的自然数相乘得到）。
    十六进制数字包括 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F。
    质数包括 2, 3, 5, 7, 11, 13, 17,...
    因此你需要确定以下数字的个数：2, 3, 5, 7,
    B (=十进制 11), D (=十进制 13)。
    注意：你可以假设输入总是正确的或为空字符串，
    且符号 A, B, C, D, E, F 总是大写。
    示例：
    对于 num = "AB"，输出应为 1。
    对于 num = "1077E"，输出应为 2。
    对于 num = "ABED1A33"，输出应为 4。
    对于 num = "123456789ABCDEF0"，输出应为 6。
    对于 num = "2020"，输出应为 2。
    """

def hex_key(num):
    """你的任务是编写一个函数，接收
    一个十六进制数作为字符串，并计算出十六进制数中素数的数量（素数或素数是大于 1 的自然数，不是两个较小自然数的乘积）。
    十六进制数字为 0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F。
    素数为 2、3、5、7、11、13、17、...
    因此，你必须确定以下数字的数量：2、3、5、7、
    B（=十进制 11）、D（=十进制 13）。
    注意：你可以假设输入始终是正确的或空字符串，
    并且符号 A、B、C、D、E、F 是始终为大写。
    示例：
    对于 num =“AB”，输出应为 1。
    对于 num =“1077E”，输出应为 2。
    对于 num =“ABED1A33”，输出应为 4。
    对于 num =“123456789ABCDEF0”，输出应为 6。
    对于 num =“2020”，输出应为 2。
    “””

def hex_key(num):
    """你被委托编写一个函数，该函数接收
    一个十六进制数字作为字符串，并计算其中是质数的十六进制
    数字的数量（质数是大于1的自然数，且不能表示为两个较小的自然数的乘积）。
    十六进制数字是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F。
    质数是 2, 3, 5, 7, 11, 13, 17,...
    因此，你需要确定以下数字的数量：2, 3, 5, 7,
    B（= 十进制 11），D（= 十进制 13）。
    注意：你可以假设输入总是正确的或为空字符串，
    并且符号 A, B, C, D, E, F 始终为大写。
    示例：
    对于 num = "AB"，输出应该是 1。
    对于 num = "1077E"，输出应该是 2。
    对于 num = "ABED1A33"，输出应该是 4。
    对于 num = "123456789ABCDEF0"，输出应该是 6。
    对于 num = "2020"，输出应该是 2。
    """


def decimal_to_binary(decimal):
    """您将获得一个十进制形式的数字，您的任务是将其转换为二进制格式。该函数应返回一个字符串，每个字符代表一个二进制数字。字符串中的每个字符将是“0”或“1”。

    字符串的开头和结尾将有两个额外的字符“db”。
    额外的字符用于帮助格式化。

    示例：
    decimal_to_binary(15) # 返回“db1111db”
    decimal_to_binary(32) # 返回“db100000db”
    """

def decimal_to_binary(decimal):
    """你将得到一个十进制形式的数字，你的任务是将其转换为
    二进制格式。该函数应该返回一个字符串，每个字符代表一个二进制
    数字。字符串中的每个字符将是'0'或'1'。

    字符串的开头和结尾会有两个额外的字符'db'。
    这些额外的字符用于帮助格式化。

    示例：
    decimal_to_binary(15)   # 返回 "db1111db"
    decimal_to_binary(32)   # 返回 "db100000db"
    """

def decimal_to_binary(decimal):
    """给你一个十进制数字，你的任务是将其转换为二进制格式。
    该函数会返回一个字符串，每个字符表示一个二进制数。
    字符串中的每个字符将为‘0’或‘1’。

    字符串的开头和结尾会出现两个附加的字符‘db’。
    附加的字符是用来帮助调整格式的。

    Examples:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """给定一个字符串 s。
    你的任务是检查字符串是否是快乐的。
    如果字符串的长度至少为3且每3个连续的字母都是不同的，则字符串是快乐的。
    例如：
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """给定一个字符串 s。
    您的任务是检查该字符串是否满足条件。
    如果字符串的长度至少为 3，并且每 3 个连续字母都不同，则该字符串满足条件
    例如：
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """给定一个字符串 s。
    你的任务是检查字符串是否快乐。
    如果字符串的长度至少为 3，并且每 3 个连续的字母都是不同的，那么这个字符串就是快乐字符串。
    例如：
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """这是学期的最后一周，老师必须给学生打分。
    老师一直在制作自己的评分算法。
    唯一的问题是，她丢失了用于评分的代码。
    她给了你一些学生的GPA列表，你需要编写一个函数，
    该函数可以使用下表输出字母成绩列表：
             GPA       |    字母成绩
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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

def numerical_letter_grade(grades):
    """现在是学期的最后一周，老师必须给学生们打分。
    给学生打分。老师一直在自制评分算法。
    唯一的问题是，她丢失了用于评分的代码。
    她给了你一些学生的平均学分绩点列表，你必须写一个
    你必须使用下表编写一个可以输出字母成绩列表的函数：
             GPA       |    字母成绩
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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

def numeric_letter_grade(grades):
    """这是学期的最后一周，老师必须给学生评分。老师一直在制定自己的评分算法。
    唯一的问题是，她丢失了用于评分的代码。
    她给了你一些学生的 GPA 列表，你必须编写一个函数，该函数可以使用下表输出字母等级列表：
    GPA | 字母等级
    4.0 A+
    > 3.7 A
    > 3.3 A-
    > 3.0 B+
    > 2.7 B
    > 2.3 B-
    > 2.0 C+
    > 1.7 C
    > 1.3 C-
    > 1.0 D+
    > 0.7 D
    > 0.0 D-
    0.0 E

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


def prime_length(string):
    """编写一个函数，接收一个字符串，如果字符串长度是质数则返回True，否则返回False
    例子
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """编写一个函数，接收一个字符串，如果字符串长度是
    质数则返回True，否则返回False
    示例
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """编写一个以字符串表示的函数，
    如果字符串长度是质数则返回True，否则返回False
    示例
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    给定一个正整数 n，返回以 1 开头或 1 结尾的 n 位
    正整数的数量。
    """

def starts_one_ends(n):
    """
    给定正整数 n，返回以 1 开头或结尾的 n 位
    正整数的个数。
    """

def starts_one_ends(n):
    """
    给定一个正整数 n，返回以 1 开头或结尾的 n 位正整数的数量。
    """


def solve(N):
    """给定一个正整数 N，返回其数字之和的二进制表示。

    示例
        对于 N = 1000，数字之和为 1，输出应为 "1"。
        对于 N = 150，数字之和为 6，输出应为 "110"。
        对于 N = 147，数字之和为 12，输出应为 "1100"。

    变量:
        @N 整数
              约束: 0 ≤ N ≤ 10000。
    输出:
         一个二进制数字的字符串
    """

def solve(N):
    """给定一个正整数 N，返回其数字在二进制表示下的总和。

    示例
    当 N = 1000时，数字之和为 1，输出应为“1”。
    当 N = 150时，数字之和为 6，输出应为“110”。
    当 N = 147时，数字之和为 12，输出应为“1100”。

    变量：
    @N 整数
            约束：0 ≤ N ≤ 10000。
    输出：
    一串二进制数
    """

def solve(N):
    """给定一个正整数 N，返回其数字在二进制表示下的总和。

    示例
        对于 N = 1000，数字之和为 1，输出应为 "1"。
        对于 N = 150，数字之和为 6，输出应为 "110"。
        对于 N = 147，数字之和为 12，输出应为 "1100"。

    变量：
        @N integer
             约束条件: 0 ≤ N ≤ 10000.
    输出：
         一个二进制字符串
    """


def add(lst):
    """给定一个非空整数列表 lst。将位于奇数索引的偶数元素相加。

    示例:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """给定一个非空的整数列表 lst。添加位于奇数索引处的偶数元素。

    示例：
    add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    “”“给定一个非空整数列表 lst。将位于奇数索引的偶数元素相加。

    例子：
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    编写一个函数，该函数接收一个字符串并返回其有序版本。
    字符串的有序版本是一个字符串，其中所有单词（由空格分隔）
    都被替换为一个新单词，新单词中的所有字符按
    基于 ASCII 值的升序排列。
    注意：你应该保持句子中单词和空格的顺序。

    例如：
    anti_shuffle('Hi') 返回 'Hi'
    anti_shuffle('hello') 返回 'ehllo'
    anti_shuffle('Hello World!!!') 返回 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    编写一个函数，接受一个字符串并返回其有序版本。
    有序版本的字符串，即一个字符串，其中所有单词（以空格分隔）
    都被一个新单词替换，其中所有字符都按
    ASCII 值升序排列。
    注意：您应该保持句子中单词和空格的顺序。

    例如：
    anti_shuffle('Hi') 返回 'Hi'
    anti_shuffle('hello') 返回 'ehllo'
    anti_shuffle('Hello World!!!') 返回 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    编写一个函数，接收一个字符串并返回它的有序版本。
    字符串的有序版本是一个字符串，其中所有单词（用空格分隔）
    都被一个新词替换，新词中的所有字符按 ascii 值升序排列。
    升序排列。
    注意：应保持句子中单词和空格的顺序。

    例如：
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    给定一个二维数据，作为嵌套列表，
    类似于矩阵，但与矩阵不同的是，
    每一行可能包含不同数量的列。
    给定 lst 和整数 x，找到列表中的整数 x，
    并返回元组列表 [(x1, y1), (x2, y2) ...]，使得
    每个元组是一个坐标 - (行, 列)，从 0 开始。
    首先按行升序排序坐标。
    同时，按列降序排序行的坐标。

    示例：
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    给你一个二维数据，作为嵌套列表，
    与矩阵类似，但与矩阵不同的是，
    每行可能包含不同数量的列。
    给定 lst 和整数 x，在列表中查找整数 x，
    并返回元组列表 [(x1, y1), (x2, y2) ...] 使得
    每个元组都是一个坐标 - （行，列），从 0 开始。
    最初按行升序对坐标进行排序。
    另外，按列按降序对行坐标进行排序。

    示例：
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    给定一个二维数据，作为嵌套列表，
    它类似于矩阵，但与矩阵不同，
    每行可能包含不同数量的列。
    给定 lst 和整数 x，在列表中查找整数 x，
    并返回元组列表 [(x1, y1), (x2, y2) ...]，其中
    每个元组都是一个坐标 - (行, 列)，从 0 开始。
    首先按行按升序对坐标进行排序。
    另外，按列按降序对行的坐标进行排序。

    示例：
    get_row([
    [1,2,3,4,5,6],
    [1,2,3,4,1,6],
    [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def 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):
    """
    给定一个非负整数数组，返回排序后的数组副本，
    如果数组中第一个元素和最后一个元素的和是奇数，则按升序排序，
    如果和是偶数，则按降序排序。

    注意：
    * 不要更改给定的数组。

    示例：
    * 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') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """

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 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()，返回列表中第二小的元素。
    如果没有这样的元素，则返回 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 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 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。

    示例
    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。

    示例
    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):
    """
    编写一个函数，接收一个消息，并以这样一种方式进行编码：
    交换所有字母的大小写，将消息中所有元音替换为该元音在
    英文字母表中向后移动两位的字母。
    假设只有字母。

    示例：
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    编写一个函数，该函数接受一个消息，并以这样的方式对其进行编码，
    使得它交换所有字母的大小写，将消息中的所有元音字母
    替换为英语字母表中该元音字母后面两个
    位置的字母。
    假设只有字母。

    示例：
    >>> 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 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"}) 应返回 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 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):
    """输出一个函数，该函数接收两个整数并返回
    它们个位数字的乘积。
    假设输入总是有效的。
    示例：
    multiply(148, 412) 应返回 16。
    multiply(19, 28) 应返回 72。
    multiply(2020, 1851) 应返回 0。
    multiply(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'） 返回 1
    count_upper（'abcdefg'） 返回 0
    count_upper（'dBBE'） 返回 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

    注意：
    远离零舍入意味着如果给定的数字与两个整数等距，则您应该返回距离零最远的数字。例如，closest_integer("14.5") 应返回 15，而 closest_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。
    示例：
    rounded_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 = []
      return []

      如果数组中有任何奇怪的数字，忽略它：
      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]
      return ["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 之间的整数进行排序，
    反转结果数组，然后用其对应的名称替换每个数字，从
    “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]
    return ["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 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):
    """ 实现以 n 为参数的函数 f，
    并返回一个大小为 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，返回一个元组，该元组包含范围 (1, 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 even_odd_palindrome(n):
    """
    给定一个正整数 n，返回一个元组，其中包含在范围(1, n)内的偶数和奇数
    整数回文的数量，包括 n.

    示例 1:

        Input: 3
        Output: (1, 2)
        解释:
        整数回文是 1, 2, 3。其中一个是偶数，两个是奇数.

    示例 2:

        Input: 12
        Output: (4, 6)
        解释:
        整数回文是 1, 2, 3, 4, 5, 6, 7, 8, 9, 11。其中四个是偶数，六个是奇数.

    注意:
        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):
    """我们有一个由 N 个整数组成的数组 'arr' 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"。
    否则，返回 "NO"。
    例如：
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
     It is assumed that the input lists will be non-empty.
    """


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 应为“输入字符串 i 中奇数元素的个数”。其中所有 i 都应替换为输入的第 i 个字符串中的奇数数字的数量。

    >>> odd_count(['1234567'])
    ["输入中字符串 4 中奇数元素的数量。"]
    >>> odd_count(['3',"11111111"])
    ["输入中字符串 1 中奇数元素的数量.",
    "输入中字符串 8 中奇数元素的数量."]
    """

def odd_count(lst):
    """给定一个字符串列表，其中每个字符串仅由数字组成，返回一个列表。
    输出的每个元素 i 应为“输入的字符串 i 中奇数元素的数量”。其中所有 i 都应替换为
    输入的第 i 个字符串中的奇数数字的数量。

    >>> odd_count(['1234567'])
    ["输入的字符串 4 中的奇数元素的数量。"]
    >>> odd_count(['3',"11111111"])
    ["输入的字符串 1 中的奇数元素的数量。",
    "输入的字符串 8 中的奇数元素的数量。"]
    """

def odd_count(lst):
    """给定一个字符串列表，其中每个字符串仅由数字组成，返回一个列表。
    输出的每个元素 i 应为“输入字符串i中奇数元素的数量。” 其中所有的 i 应替换为
    输入中第 i 个字符串中的奇数数字的数量。

    >>> odd_count(['1234567'])
    ["输入中字符串 4 中奇数元素的数量。"]
    >>> odd_count(['3',"11111111"])
    ["输入中字符串 1 中奇数元素的数量。",
     "输入中字符串 8 中奇数元素的数量。"]
    """


def minSubArraySum(nums):
    """
    给定一个整数数组 nums，找出 nums 中任意非空子数组的最小和。
    示例
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    给定一个整数数组nums，求nums的任何非空子数组
    的最小和。
    示例
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    给定一个整数数组 nums，找到 nums 的任意非空
    子数组的最小和。
    示例
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


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

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

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


def sort_array(arr):
    """
    在这个编程挑战 (Kata)中，你需要根据二进制表示中1的数量对非负整
    数数组进行升序排序。
    对于相同数量的1，按十进制值排序。

    必须这样实现：
    >>> 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):
    """
    在这个 Kata 中，您必须根据二进制表示中的 1 的数量按升序对非负整数数组进行排序。
    对于相同数量的 1，则根据十进制值排序。

    它必须像这样实现：
    >>> 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):
    """
    在这个Kata编程练习中，你需要根据二进制表示中1的数量对非负整数数组进行升序排序。
    对于相同数量的1，按十进制值排序。

    必须这样实现：
    >>> 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 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 才被认为是好的。例如：字符串 '(())()' 是好的，而字符串 '())' 不是。
    如果有办法生成好的字符串，则返回 'Yes'，否则返回 'No'。

    示例：
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    给定一个包含两个字符串的列表，两个字符串都只由左
    括号 '(' 或右括号 ')' 组成。
    你的任务是检查是否可以通过某种顺序连接这两个字符串，
    使得结果字符串是好的。
    当且仅当字符串 S 中的所有括号都是平衡的时，字符串 S
    被认为是好的。例如：字符串 '(())()' 是好的，而字符串
    '())' 不是。
    如果有办法构造一个好的字符串，返回 'Yes'，否则返回 'No'。

    示例：
    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 的排序列表，
    其中包含 arr 中最大的 k 个数字。

    示例 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的排序列表，
    其中包含arr中最大的k个数字。

    示例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 的排序列表，其中包含 arr 中的最大 k 个数字。

    示例 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 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，返回 arr 的前 k 个元素中最多两位数的元素之和。

    示例：

    输入：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，返回
    arr 的前 k 个元素中最多有两位数的元素的和。

    示例：

          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，返回
    arr 的前 k 个元素中最多有两位数的元素的和。

    示例：

          输入: 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 get_odd_collatz(n):
    """
    给定一个正整数 n，返回一个排序后的列表，其中包含 collatz 序列中的奇数。

    Collatz 猜想是数学中的一个猜想，涉及一个序列的定义如下：从任何正整数 n 开始。
    然后每一项是从前一项得到的，规则如下：如果前一项是偶数，下一项是前一项的一半。
    如果前一项是奇数，下一项是前一项的 3 倍加 1。猜想是无论 n 的值是多少，序列总会到达 1。

    注意：
    1. Collatz(1) 是 [1]。
    2. 返回的列表按升序排序。

    例如：
    get_odd_collatz(5) returns [1, 5] # 5 的 collatz 序列是[5, 16, 8, 4, 2, 1], 因此奇数只有 1 和 5.
    """

def get_odd_collatz(n):
    """
    给定一个正整数 n，返回一个包含 collatz 序列中奇数的排序列表。

    Collatz 猜想是数学中的一个猜想，它涉及一个定义如下的序列：从任何正整数 n 开始。然后从前一项获得每一项，如下所示：如果前一项为偶数，则下一项为前一项的一半。如果前一项是奇数，则下一项是前一项的 3 倍加 1。猜想是无论 n 是什么值，序列总会达到 1。

    注意：
    1. Collatz(1) 为 [1]。
    2. 返回按升序排序的列表。

    例如：
    get_odd_collatz(5) 返回 [1, 5] # 5 的 collatz 序列为 [5, 16, 8, 4, 2, 1]，所以奇数只有 1 和 5.
    “””

def get_odd_collatz(n):
    """
    给定一个正整数 n，返回一个排序后的列表，其中包含 collatz 序列中的奇数。

    Collatz 猜想是数学中的一个猜想，涉及一个序列的定义
    如下：从任何正整数 n 开始。然后每一项是从前一项
    得到的，规则如下：如果前一项是偶数，下一项是
    前一项的一半。如果前一项是奇数，下一项是前一项的 3 倍
    加 1。猜想是无论 n 的值是多少，序列总会到达 1。

    注意：
        1. Collatz(1) 是 [1]。
        2. 返回的列表按升序排序。

    例如：
    get_odd_collatz(5) 返回 [1, 5] # 5 的 collatz 序列是 [5, 16, 8, 4, 2, 1]，所以奇数只有 1 和 5。
    """


def valid_date(date):
    """你需要编写一个函数来验证给定的日期字符串，
    如果日期有效则返回True，否则返回False。
    如果满足以下所有规则，则日期有效：
    1. 日期字符串不能为空。
    2. 对于月份1,3,5,7,8,10,12，天数不少于1且不多于31天。对于月份4,6,9,11，天数不少于1且不多于30天。对于月份2，天数不少于1且不多于29天。
    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、3、5、7、8、10、12 月份，天数不少于 1 天或高于 31 天。对于 4、6、9、11 月份，天数不少于 1 天或高于 30 天。对于 2 月份，天数不少于 1 天或高于 29 天。
    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、3、5、7、8、10、12 月份，天数不少于 1 天或高于 31 天。对于 4、6、9、11 月份，天数不少于 1 天或高于 30 天。对于 2 月
    份，天数不少于 1 天或高于 29 天。
    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 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):
    '''
    给定一个数字列表，返回它们是否按升序排序。如果列表中有超过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 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
    '''