{"text": ["from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" 检查给定的数字列表中，是否有任意两个数字之间的距离小于给定的阈值。\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\"", "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" 检查给定的数字列表中，是否有任意两个数字之间的距离小于\n    给定的阈值。\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\"", "from typing import List\n\ndef has_close_elements(numbers: List[float], Threshold: float) -> bool:\n    \"\"\" 检查给定的数字列表中是否有任何两个数字彼此之间的距离小于\n    给定的阈值。\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" 该函数的输入是一个包含多组嵌套括号的字符串。您的目标是\n    将这些组分离成单独的字符串，并返回其中的列表。\n    独立的括号组必须平衡（每个打开的括号都正确闭合），并且不能相互嵌套\n    忽略输入字符串中的任何空格。\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\"", "from typing import List\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" 此函数的输入是包含多组嵌套括号的字符串。您的目标是\n    将这些组分成单独的字符串并返回这些字符串的列表。\n    单独的组是平衡的（每个左括号都正确闭合）并且不相互嵌套\n    忽略输入字符串中的任何空格。\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\"", "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" 这个函数的输入是一个包含多个嵌套括号组的字符串。你的目标是\n    将这些组分开并返回这些组的列表。\n    分开的组是平衡的（每个开括号都有正确闭合），且没有相互嵌套\n    忽略输入字符串中的任何空格。\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\""]}
{"text": ["def truncate_number(number: float) -> float:\n    \"\"\" 给定一个正浮点数，它可以被分解为整数部分（小于此给定数的最大整数）\n    和小数部分（剩余部分总是小于1）。\n\n    返回数字的小数部分。\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\"", "def truncate_number(number: float) -> float:\n    \"\"\" 给定一个正浮点数，它可以分解为\n    整数部分（小于给定数字的最大整数）和小数\n    （剩余部分始终小于 1）。\n\n    返回数字的小数部分。\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\"", "def truncate_number(number: float) -> float:\n    \"\"\"  给定一个正浮点数，它可以被分解为\n    整数部分（小于给定数的最大整数）和小数部分\n    （剩余部分总是小于1）。\n\n    返回数字的小数部分。\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\" 给定一个银行账户的存款和取款操作列表，该账户初始余额为零。\n    你的任务是检测账户余额是否在某个时刻低于零，\n    如果是，函数应返回 True。否则应返回 False。\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\"", "from typing import List\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\" 您将获得一个银行账户存款和取款操作列表，该列表以零余额开始。您的任务是检测账户余额是否在任何时候低于零，并且\n    此时函数应返回 True。否则它应该返回 False。\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\"", "from typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\" 给定一个银行账户的存款和取款操作列表，该账户初始\n    余额为零。您的任务是检测账户余额是否在任何时候低于零，并且\n    此时函数应返回 True。否则应返回 False。\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" 对于给定的输入数字列表，计算该数据集的平均绝对偏差\n    以数据集的均值为中心。\n    平均绝对偏差是指每个元素与中心点（此处为均值）之间\n    绝对差值的平均值，其公式为：\n    MAD = average | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\"", "from typing import List\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" 对于给定的输入数字列表，计算此数据集平均值周围的平均绝对偏差。\n    平均绝对偏差是每个元素与中心点（在本例中为平均值）之间的平均绝对差异：\n    MAD = average | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\"", "from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" 对于给定的输入数字列表，计算该数据集的平均绝对偏差。\n    平均绝对偏差是两者之间的平均绝对差元素和中心点（在本例中为平均值）：\n    MAD = average | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" 在输入列表 numbers 的每两个连续元素之间插入一个数字 'delimeter'\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\"", "from typing import List\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" 在输入列表 `numbers' 的每两个连续元素之间插入一个数字 'delimeter'\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\"", "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" 在输入列表`numbers'的每两个连续元素之间插入一个数字 “delimeter”。\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" 该函数的输入是一个字符串，代表多个用空格分隔的括号嵌套组。\n    对于每一组，输出括号嵌套的最深层级。\n    例如，(()()) 最多有两层嵌套，而 ((())) 则有三层。\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\"", "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" 此函数的输入是一个字符串，表示多个用空格分隔的嵌套括号组。\n    对于每个组，输出括号嵌套的最深层次。\n    例如，(()()) 的最大嵌套层次为2，而 ((())) 的嵌套层次为3。\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\"", "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" 此函数的输入是一个字符串，表示多个用空格分隔的嵌套括号组。\n    对于每个组，输出括号嵌套的最深层次。\n    例如，(()()) 的最大嵌套层次为二，而 ((())) 的嵌套层次为三。\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" 过滤输入字符串列表，仅保留包含给定子字符串的字符串\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\"", "from typing import List\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" 过滤输入的字符串列表，仅包含给定子字符串\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" 仅筛选输入字符串列表中包含给定子串的字符串\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\" 对于给定的整数列表，返回一个由列表中所有整数的和与积组成的元组。\n    空和等于0，空积等于1。\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\"", "from typing import List, Tuple\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\" 对于给定的整数列表，返回一个由列表中所有整数的和与乘积组成的元组。\n    空和应等于 0，空乘积应等于 1。\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\" 对于给定的整数列表，返回一个包含列表中所有整数的和与积的元组。\n    空列表的和应为0，空列表的积应为1。\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" 从给定的整数列表中，生成一个列表，包含到当前时刻为止序列中的滚动最大元素。\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\"", "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" 从给定的整数列表中，生成一个列表，包含到当前时刻为止在序列中找到\n    的滚动最大元素。\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\"", "from typing import List, Tuple\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" 从给定的整数列表中，生成一个滚动最大元素列表，直到序列中给定的时刻。\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\""]}
{"text": ["def is_palindrome(string: str) -> bool:\n    \"\"\" 测试给定字符串是否是回文 \"\"\"\n    return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n    \"\"\" 找到以提供的字符串开头的最短回文。\n    算法思想很简单：\n    - 找到提供字符串中最长的回文后缀。\n    - 将回文后缀之前的字符串前缀的反转附加到字符串的末尾。\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\"", "def is_palindrome(string: str) -> bool:\n    \"\"\" 测试给定的字符串是否为回文 \"\"\"\n    return string == string[::-1] \n\ndef make_palindrome(string: str) -> str:\n    \"\"\" 找到以给定字符串开头的最短回文。\n    算法思路简单：\n    -查找所提供字符串中最长的回文后缀。\n    -将回文后缀前的前缀字符串反转后添加到字符串末尾。\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\"", "def is_palindrome(string: str) -> bool:\n    \"\"\" 测试给定的字符串是否为回文 \"\"\"\n    return string == string[::-1]\n\ndef make_palindrome(string: str) -> str:\n    \"\"\" 查找以提供的字符串开头的最短回文。\n    算法思想很简单：\n    - 查找提供的字符串中最长的回文后缀。\n    - 将回文后缀之前的字符串前缀的反向附加到字符串末尾。\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\" 输入是两个仅由1和0组成的字符串a和b。\n    对这些输入执行二进制异或运算，并将结果也作为字符串返回。\n    >>> string_xor('010', '110')\n    '100'\n    \"\"\"", "from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\"输入两个仅由1和0组成的字符串a和b。\n    对这些输入执行二进制XOR，并以字符串形式返回结果。\n    >>> string_xor('010', '110')\n    '100'\n    \"\"\"", "from typing import List\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\" 输入是两个仅由 1 和 0 组成的字符串 a 和 b。\n    对这些输入执行二进制异或，并以字符串形式返回结果。\n    >>> string_xor('010', '110')\n    '100'\n    \"\"\""]}
{"text": ["from typing import List, Optional\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\" 在字符串列表中，返回最长的一个。如果有多个长度相同的字符串，则返回第一个。如果输入列表为空，则返回 None。\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\"", "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\" 在字符串列表中，返回最长的字符串。如果有多个\n    长度相同的字符串时，返回第一个字符串。如果输入列表为空，则返回 None。\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\"", "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\" 从字符串列表中，返回最长的一个。在多个字符串长度相同的情况下，返回第一个。\n    如果输入列表为空，则返回 None。\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\""]}
{"text": ["def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" 返回两个整数 a 和 b 的最大公约数\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\"", "def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" 返回两个整数 a 和 b 的最大公约数\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\"", "def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" 返回两个整数 a 和 b 的最大公约数\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\""]}
{"text": ["from typing import List\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" 返回输入字符串中从最短到最长的所有前缀列表\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\"", "from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" 返回输入字符串从最短到最长的所有前缀的列表\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\"", "from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" 返回输入字符串从最短到最长的所有前缀列表\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\""]}
{"text": ["def string_sequence(n: int) -> str:\n    \"\"\" 返回一个字符串，其中包含从0到n（包括n）的以空格分隔的数字。\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\"", "def string_sequence(n: int) -> str:\n    \"\"\" 返回一个包含空格分隔的数字的字符串，从 0 到 n（含）。\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\"", "def string_sequence(n: int) -> str:\n    \"\"\" 返回一个字符串，其中包含从0到n（包括n）的以空格分隔的数字。\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\""]}
{"text": ["def count_distinct_characters(string: str) -> int:\n    \"\"\" 给定一个字符串，找出它由多少个不同的字符（不区分大小写）组成\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\"", "def count_distinct_characters(string: str) -> int:\n    \"\"\" 给定一个字符串，找出它由多少个不同的字符（不考虑大小写）组成\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\"", "def count_distinct_characters(string: str) -> int:\n    “”“ 给定一个字符串，找出它由多少个不同的字符（不区分大小写）组成\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" 输入的函数是一个表示音符的特殊ASCII格式的字符串。\n    您的任务是解析这个字符串并返回一个整数列表，对应于每个音符持续的拍数。\n\n    这里有一个示例:\n    'o' - 全音符，持续四拍\n    'o|' - 二分音符，持续两拍\n    '.|' - 四分音符，持续一拍\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\"", "from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" 此函数的输入是一个字符串，表示以特殊ASCII格式表示的音乐音符。\n    你的任务是解析这个字符串并返回一个整数列表，表示每个音符持续\n    的拍数。\n\n    这是一个图例：\n    'o' - 全音符，持续四拍\n    'o|' - 半音符，持续两拍\n    '.|' - 四分音符，持续一拍\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\"", "from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" 此函数的输入是一个表示音乐音符的特殊ASCII格式的字符串。\n    你的任务是解析这个字符串并返回一个整数列表，对应于每个音符持续的拍数。\n\n    \n    这里有一个图例：\n    'o' - 全音符，持续四拍\n    'o|' - 二分音符，持续两拍\n    '.|' - 四分音符，持续一拍\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\""]}
{"text": ["def how_many_times(string: str, substring: str) -> int:\n    \"\"\" 找出给定子字符串在原始字符串中出现的次数。计算重叠的情况。\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\"", "def how_many_times(string: str, substring: str) -> int：\n    “”“ 查找给定子字符串在原始字符串中可以找到的次数。对重叠的个案进行计数。\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\"", "def how_many_times(string: str, substring: str) -> int:\n    \"\"\" 查找给定子字符串在原始字符串中出现的次数。计算重叠的情况。\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" 输入是一个用空格分隔的数字字符串，从 'zero' 到 'nine'。\n    有效的选择是 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 和 'nine'。\n    返回按从小到大排序的数字字符串\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\"", "from typing import List\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" 输入是一个用空格分隔的数字字符串，从 'zero' 到 'nine'。\n    有效的选择是 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 和 'nine'。\n    返回按从小到大排序的数字字符串\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\"", "from typing import List\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" 输入是一个以空格分隔的数字字符串，从 'zero' 到 'nine'。\n    有效选项是 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 和 'nine'。\n    返回按数字从小到大排序的字符串\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\" 从提供的数字列表（长度至少为 2）中选择并返回两个最接近的数字，并按顺序返回它们（数字较小，数字较大）。\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n    (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n    (2.0, 2.0)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\" 从提供的数字列表（长度至少为2）中选择并返回两个最接近的数字，\n    并按顺序返回（较小的数字，较大的数字）。\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n     (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n     (2.0, 2.0)\n     \"\"\"", "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\" 从提供的数字列表（长度至少为二）中选择并返回两个最接近的\n    数字，并按顺序返回（较小的数字，较大的数字）。\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n    (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n    (2.0, 2.0)\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    \"\"\" 给定一个数字列表（至少包含两个元素），对该列表应用线性变换，\n    使得最小的数字变为0，最大的数字变为1\n    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\"", "from typing import List\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    “”“ 给定数字列表（至少包含两个元素），对该列表应用线性变换，\n    使得最小的数字变为0，最大的数字变为1\n     >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\"", "from typing import List\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    \"\"\" 给定数字列表（至少包含两个元素），对该列表应用线性变换，\n    使得最小数字变为 0，最大数字变为 1\n    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\""]}
{"text": ["from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n    \"\"\" 过滤给定列表中的任何 Python 值，仅保留整数\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    \"\"\"", "from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n    \"\"\" 筛选给定列表中的任何python值，仅保留整数\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    \"\"\"", "from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n     \"\"\"过滤给定列表中的所有 Python 值，仅保留整数\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    ”“”"]}
{"text": ["def strlen(string: str) -> int:\n    \"\"\" 返回给定字符串的长度\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\"", "def strlen(string: str) -> int:\n    \"\"\" 返回给定字符串的长度\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\"", "def strlen(string: str) -> int:\n    \"\"\" 返回给定字符串的长度\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\""]}
{"text": ["def largest_divisor(n: int) -> int:\n    \"\"\" 对于给定数字 n，找出能整除 n 且小于 n 的最大数字\n    >>> largest_divisor(15)\n    5\n    \"\"\"", "def largest_divisor(n: int) -> int:\n    \"\"\" 对于给定的数 n，找出能平分 n 且小于 n 的最大的数\n    >>> largest_divisor(15)\n    5\n    \"\"\"", "def largest_divisor(n: int) -> int:\n    \"\"\" 对于给定的数字 n，找到小于 n 的最大约数\n    >>> largest_divisor(15)\n    5\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" 返回给定整数的质因数列表，按从小到大的顺序排列。\n    每个因数出现的次数应与其在因式分解中出现的次数相对应。\n    输入数字应等于所有因数的乘积\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\"", "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" 返回给定整数的质因数列表，按从小到大的顺序排列。\n    每个因数出现的次数应与其在因式分解中出现的次数相对应。\n    输入数字应等于所有因数的乘积\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\"", "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" 按从小到大的顺序返回给定整数的质因数列表。\n    每个因数列出的次数应与它在因数分解中出现的次数相对应。\n    输入数字应等于所有因数的乘积\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\""]}
{"text": ["from typing import List\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" 从整数列表中，删除所有出现超过一次的元素。\n    保持元素的顺序与输入中的顺序相同。\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\"", "from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" 从整数列表中删除所有出现过一次以上的元素。\n    保持剩余元素的顺序与输入相同。\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\"", "from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" 从整数列表中，移除所有出现多次的元素。\n    保持剩余元素的顺序与输入相同。\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\""]}
{"text": ["def flip_case(string: str) -> str:\n    \"\"\" 对于给定的字符串，将小写字符翻转为大写，将大写字符翻转为小写。\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\"", "def flip_case(string: str) -> str:\n    \"\"\" 对于给定字符串，将小写字母转为大写字母，将大写字母转为小写字母。\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\"", "def flip_case(string: str) -> str:\n    \"\"\" 对于给定的字符串，将小写字符转换为大写，大写字符转换为小写。\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\""]}
{"text": ["from typing import List\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" 将字符串列表连接成单个字符串\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\"", "from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" 将字符串列表连接成一个单一字符串\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\"", "from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" 将字符串列表拼接成一个单一字符串\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\" 过滤输入字符串列表，仅保留以给定前缀开头的字符串。\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\"", "from typing import List\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\" 仅过滤以给定前缀开头的字符串输入列表。\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\" 筛选输入字符串列表，仅保留以给定前缀开头的字符串。\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\""]}
{"text": ["def get_positive(l: list):\n    \"\"\"只返回列表中的正数。\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\"", "def get_positive(l: list):\n    \"\"\"返回列表中仅有的正数。\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\"", "def get_positive(l: list):\n    “”“返回列表中仅有的正数。\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\""]}
{"text": ["def is_prime(n):\n    \"\"\"如果给定的数字是质数，则返回 true，否则返回 false。\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\"", "def is_prime(n):\n    \"\"\"如果给定数字为素数，则返回 true，否则返回 false。\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\"", "def is_prime(n):\n    \"\"\"如果给定的数字是质数，则返回 true，否则返回 false。\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\""]}
{"text": ["import math\n\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    计算在点 x 处具有系数 xs 的多项式。\n    返回 xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n    \"\"\" xs 是多项式的系数。\n    find_zero 找到 x 使得 poly(x) = 0。\n    find_zero 仅返回一个零点，即使有多个。\n    此外，find_zero 仅接受具有偶数个系数的列表 xs，\n    并且最大非零系数保证\n    有解。\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\"", "import math\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    在点 x 处计算具有系数 xs 的多项式。\n    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\ndef find_zero(xs: list):\n    \"\"\" xs 是多项式的系数。\n    find_zero 查找 x，使得 poly(x) = 0。\n    find_zero 仅返回零点，即使有很多。\n    此外，find_zero 仅接受具有偶数个系数的列表 xs\n    和最大的非零系数，因为它保证\n    有一个解决方案。\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\"", "import math\n\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    计算在点 x 处，系数为 xs 的多项式。\n    返回 xs[0] + xs[1] * x + xs[2] * x^2 + .... + xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n    \"\"\" xs 为多项式的系数。\n    find_zero 找到 x 使得 poly(x) = 0\n    find_zero 仅返回一个零点（即使存在多个）\n    此外，find_zero 仅接受有偶数个系数的列表 xs，\n    且，最大非零系数有解。\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\""]}
{"text": ["def sort_third(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在索引不被三整除的位置与 l 相同，而在被三整除的索引位置的值\n    等于 l 对应索引的值，但已排序。\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\"", "def sort_third(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在其索引不被3整除的位置的值与 l 相同，而在被3整除的索引位置的值\n    等于 l 对应索引的值，但已排序。\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\"", "def sort_third(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在不能被三整除的索引上与 l 相同，而在可以被三整除的索引上的值等于\n    l 的相应索引的值，但已排序。\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\""]}
{"text": ["def unique(l: list):\n    \"\"\"返回列表中排序后的唯一元素\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\"", "def unique(l: list):\n    \"\"\"返回列表中排序后的唯一元素\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\"", "def unique(l: list):\n    \"\"\"返回列表中排序后的唯一元素\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\""]}
{"text": ["def max_element(l: list):\n    \"\"\"返回列表中的最大元素。\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\"", "def max_element(l: list):\n    \"\"\"返回列表中的最大元素。\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\"", "def max_element(l: list):\n    \"\"\"返回列表中的最大元素。\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\""]}
{"text": ["def fizz_buzz(n: int):\n    \"\"\"返回数字 7 在小于 n 且能被 11 或 13 整除的整数中出现的次数。\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\"", "def fizz_buzz(n: int):\n    \"\"\"返回小于 n 的整数中，能被 11 或 13 整除的数字中出现数字 7 的次数。\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\"", "def fizz_buzz(n: int):\n    \"\"\"返回在能被11或13整除的小于n的整数中，数字7出现的次数。\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\""]}
{"text": ["def sort_even(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在奇数索引处与 l 相同，而其在偶数索引处的值等于\n    l 的偶数索引的值，但已排序。\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\"", "def sort_even(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在奇数索引处与 l 相同，而在偶数索引处的值等于\n    l 的偶数索引处的值，但已排序。\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\"", "def sort_even(l: list):\n    \"\"\"此函数接受一个列表 l 并返回一个列表 l'，使得\n    l' 在奇数索引处与 l 相同，而其在偶数索引处的值等于\n    l 的偶数索引的值，但已排序。\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\""]}
{"text": ["def encode_cyclic(s: str):\n    \"\"\"\n    返回通过循环三个字符一组编码的字符串。\n    \"\"\"\n    # 将字符串分割成组。每组长度为3。\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # 循环每组中的元素。除非组中元素少于3个。\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    以使用 encode_cyclic 函数编码的字符串作为输入，返回解码后的字符串。\n    \"\"\"", "def encode_cyclic(s: str):\n    \"\"\"\n    返回通过循环三个字符一组编码的字符串。\n    \"\"\"\n    # 将字符串分割成组。每组长度为3。\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # 循环每组中的元素。除非组中元素少于3个。\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    输入使用 encode_cyclic 函数编码的字符串。返回解码后的字符串。\n    \"\"\"", "def encode_cyclic(s: str):\n    \"\"\"\n    返回按三个字符循环分组的编码字符串。\n    \"\"\"\n    # 将字符串分割为若干组。每组长度为3。\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # 每组中的循环元素。除非组中元素少于3个。\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    输入用 encode_cyclic 函数编码的字符串。返回解码后的字符串。\n    \"\"\""]}
{"text": ["def prime_fib(n: int):\n    \"\"\"\n    prime_fib 返回第 n 个既是斐波那契数又是质数的数字。\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\"", "def prime_fib(n: int):\n    \"\"\"\n    prime_fib 返回第 n 个既是斐波那契数又是质数的数字。\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\"", "def prime_fib(n: int):\n    \"\"\"\n    prime_fib 返回第n个斐波那契数且是质数的数字。\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\""]}
{"text": ["def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero 接受一个整数列表作为输入。\n    如果列表中有三个不同的元素之和为零，则返回 True，\n    否则返回 False。\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\"", "def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero 接受一个整数列表作为输入。\n    如果列表中有三个不同的元素之和为零，则返回True，\n    否则返回 False。\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\"", "def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero 以整数列表作为输入。\n    ​​如果列表中有三个不同的元素的总和为零，则返回 True，否则返回 False。\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\""]}
{"text": ["def car_race_collision(n: int):\n    \"\"\"\n    想象一下有一条道路，这条道路是完全笔直的、无限长的。\n    n 辆车从左向右行驶；同时，另一组 n 辆车\n    正在从右向左行驶。两组车一开始相距非常远。\n    所有的车都以相同的速度行驶。当一辆从左向右行驶的车撞到\n    一辆从右向左行驶的车时，我们说两辆车发生了碰撞。\n    然而，这些车是无限坚固和强大的；因此，它们继续按原来的\n    轨迹行驶，就像它们没有发生碰撞一样。\n\n    这个函数输出发生碰撞的数量。\n    \"\"\"", "def car_race_collision(n: int):\n    \"\"\"\n    想象一条完美笔直的无限长的道路。\n    n辆车从左向右行驶；同时，另一组n辆车\n    从右向左行驶。两组车开始时彼此非常远。\n    所有车的速度相同。当一辆从左向右行驶的车\n    撞上一辆从右向左行驶的车时，称为碰撞。\n    然而，这些车是无限坚固和强壮的；因此，它们继续\n    按照原来的轨迹行驶，就像没有碰撞一样。\n\n    这个函数输出这样的碰撞次数。\n    \"\"\"", "def car_race_collision(n: int):\n    \"\"\"\n    想象一条完美笔直的无限长的道路。\n    n辆车从左向右行驶；同时，另一组n辆车\n    从右向左行驶。两组车开始时彼此非常远。\n    所有车的速度相同。当一辆从左向右行驶的车\n    撞上一辆从右向左行驶的车时，称为碰撞。\n    然而，这些车是无限坚固和强壮的；因此，它们继续\n    按照原来的轨迹行驶，就像没有碰撞一样。\n\n    这个函数输出这样的碰撞次数。\n    \"\"\""]}
{"text": ["def incr_list(l: list):\n    \"\"\"返回一个列表，其中的元素增加1。\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\"", "def incr_list(l: list):\n    \"\"\"返回元素增加1的列表。\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\"", "def incr_list(l: list):\n    \"\"\"返回一个列表，其中的元素增加1。\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\""]}
{"text": ["def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero 接受一个整数列表作为输入。\n    如果列表中有两个不同的元素相加为零，则返回 True，\n    否则返回 False。\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\"", "def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero 接受一个整数列表作为输入。\n    如果列表中有两个不同的元素相加为零，则返回 True，否则返回 False。\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\"", "def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero 接受一个整数列表作为输入。\n    如果列表中有两个不同的元素相加为零，则返回 True，\n    否则返回 False。\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\""]}
{"text": ["def change_base(x: int, base: int):\n    \"\"\"将输入数字 x 的数值进制更改为 base。\n    返回转换后的字符串表示。\n    进制数小于 10。\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\"", "def change_base(x: int, base: int):\n    \"\"\"输入数字 x 的数值基数更改为 base。\n    返回转换后的字符串表示。\n    基数小于 10。\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\"", "def change_base(x: int, base: int):\n    \"\"\"将输入数字x的数值基数更改为base。\n    转换后返回字符串表示。\n    基数小于 10。\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\""]}
{"text": ["def triangle_area(a, h):\n    \"\"\"给定边长和高，返回三角形的面积。\n    >>> triangle_area(5, 3)\n    7.5\n    \"\"\"", "def triangle_area(a, h):\n    \"\"\"给定边长和高，返回三角形的面积。\n    >>>triangle_area(5, 3)\n    7.5\n    \"\"\"", "def triangle_area(a, h):\n    \"\"\"给定边长和高，返回三角形的面积。\n    >>> triangle_area(5, 3)\n    7.5\n    \"\"\""]}
{"text": ["def fib4(n: int):\n    \"\"\"Fib4 数列是一个类似于斐波那契数列的序列，其定义如下：\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n    请编写一个函数来高效地计算 fib4 数列的第 n 个元素。不要使用递归。\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\"", "def fib4(n: int):\n    \"\"Fib4 数字序列是一个类似于斐波那契数列的序列，定义如下：\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)。\n    请编写一个函数来高效地计算 fib4 数列的第 n 个元素。请勿使用递归。\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\"", "def fib4(n: int):\n    \"\"\"Fib4 数字序列是类似于斐波那契数列的序列，其定义如下：\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)。\n    请编写一个函数来高效计算 fib4 数字序列的第 n 个元素。请勿使用递归。\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\""]}
{"text": ["def median(l: list):\n    \"\"\"返回列表l中元素的中位数。\n    >>> median([3, 1, 2, 4, 5])\n    3\n    >>> median([-10, 4, 6, 1000, 10, 20])\n    15.0\n    \"\"\"", "def median(l: list):\n    \"\"\"返回列表 l 中元素的中位数。\n    >>> median([3, 1, 2, 4, 5])\n    3\n    >>> median([-10, 4, 6, 1000, 10, 20])\n    15.0\n    \"\"\"", "def median（l： list）：\n    “”“返回列表 l 中元素的中位数。\n    >>> median （[3， 1， 2， 4， 5]）\n    3\n    >>> median （[-10， 4， 6， 1000， 10， 20]）\n    15.0\n    \"\"\""]}
{"text": ["def is_palindrome(text: str):\n    \"\"\"\n    检查给定字符串是否为回文字符串\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\"", "def is_palindrome(text: str):\n    \"\"\"\n    检查给定字符串是否是回文\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\"", "def is_palindrome(text: str):\n    \"\"\"\n    检查给定字符串是否是回文\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\""]}
{"text": ["def modp(n: int, p: int):\n    \"\"\"返回 2^n 模 p（注意数值）。\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    \"\"\"", "def modp(n: int, p: int):\n    \"\"\"返回 2^n 模 p（注意数值）。\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    ”“”", "def modp(n: int, p: int):\n    \"\"\"返回2^n模p（注意数值）。\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    \"\"\""]}
{"text": ["def encode_shift(s: str):\n    \"\"\"\n    通过将字母表中的每个字符移动 5 位来返回编码后的字符串。\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    输入使用encode_shift函数编码的字符串。返回解码后的字符串。\n    \"\"\"", "def encode_shift(s: str):\n    \"\"\"\n    返回通过在字母表中每个字符移动5位编码的字符串。\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    输入使用encode_shift函数编码的字符串。返回解码后的字符串。\n    \"\"\"", "def encode_shift(s: str):\n    \"\"\"\n    返回通过在字母表中每个字符移动5位编码的字符串。\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    输入使用encode_shift函数编码的字符串。返回解码后的字符串。\n    \"\"\""]}
{"text": ["def remove_vowels(text):\n    \"\"\"\n    remove_vowels 是一个函数，接受字符串并返回去除元音的字符串。\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\"", "def remove_vowels(text):\n    \"\"\"\n    remove_vowels 是一个函数，接收字符串并返回去除元音后的字符串。\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\"", "def remove_vowels(text):\n    \"\"\"\n    remove_vowels 是一个函数，传入字符串，返回去除元音的字符串。\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\""]}
{"text": ["def below_threshold(l: list, t: int):\n    \"\"\"如果列表 l 中的所有数字都小于阈值 t，则返回 True。\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\"", "def below_threshold(l: list, t: int):\n    \"\"\"如果列表 l 中的所有数字都低于阈值 t，则返回 True。\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\"", "def below_threshold(l: list, t: int):\n    \"\"\"如果列表 l 中的所有数字都低于阈值 t，则返回 True。\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\""]}
{"text": ["def add(x: int, y: int):\n    \"\"\"将两个数字 x 和 y 相加\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\"", "def add(x: int, y: int):\n    \"\"\"将两个数字 x 和 y相加\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\"", "def add(x: int, y: int):\n    \"\"\"将两个数字 x 和 y 相加\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\""]}
{"text": ["def same_chars(s0: str, s1: str):\n    \"\"\"\n    检查两个单词是否具有相同的字符。\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\"", "def same_chars(s0: str, s1: str):\n    \"\"\"\n    检查两个单词是否有相同的字符。\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\"", "def same_chars(s0: str, s1: str):\n    \"\"\"\n    检查两个单词是否具有相同的字符。\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\""]}
{"text": ["def fib(n: int):\n    \"\"\"返回第 n 个斐波那契数。\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\"", "def fib(n: int):\n    \"\"\"返回第n个斐波那契数字。\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\"", "def fib(n: int):\n     “”“返回第 n 个斐波那契数。\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\""]}
{"text": ["def correct_bracketing(brackets: str):\n    \"\"\" brackets 是一个由 \"<\" 和 \">\" 组成的字符串。\n    如果每个开括号都有一个对应的闭括号，则返回 True。\n\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" 括号是由“<”和“>”组成的字符串。\n    如果每个开头括号都有相应的结尾括号，则返回 True。\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" brackets 是一个由 \"<\" 和 \">\" 组成的字符串。\n    如果每个开括号都有一个对应的闭括号，则返回 True。\n\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\""]}
{"text": ["def monotonic(l: list):\n    \"\"\"如果列表元素单调递增或递减，则返回 True。\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\"", "def monotonic(l: list):\n    \"\"\"如果列表元素单调递增或递减，则返回 True。\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\"", "def monotonic（l： list）：\n    “”“如果列表元素单调递增或递减，则返回 True。\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\""]}
{"text": ["def common(l1: list, l2: list):\n    \"\"\"返回两个列表的排序后的唯一公共元素。\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n\n    \"\"\"", "def common(l1: list, l2: list):\n    \"\"\"返回两个列表中排序后的唯一公共元素。\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n\n    \"\"\"", "def common(l1: list, l2: list):\n    \"\"\"返回两个列表中已排序的唯一共同元素。\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n\n    \"\"\""]}
{"text": ["def largest_prime_factor(n: int):\n    \"\"\"返回 n 的最大质因数。假设 n > 1 且不是质数。\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\"", "def largest_prime_factor(n: int):\n    \"\"\"返回 n 的最大质因数。假设 n > 1 且不是质数。\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\"", "def largest_prime_factor(n: int):\n    \"\"\"返回n的最大质因数。假设n > 1且不是质数。\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\""]}
{"text": ["def sum_to_n(n: int):\n    \"\"\"sum_to_n 是一个将数字从 1 加到 n 的函数。\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\"", "def sum_to_n(n: int):\n    \"\"\"sum_to_n 是一个对 1​​ 到 n 之间的数字求和的函数。\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\"", "def sum_to_n(n: int):\n    \"\"\"sum_too_n是一个对从1到n的数字求和的函数。\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\""]}
{"text": ["def correct_bracketing(brackets: str):\n    \"\"\" brackets 是一个由 \"(\" 和 \")\" 组成的字符串。\n    如果每个开括号都有一个对应的闭括号，则返回 True。\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" 括号是由“(”和“) ”组成的字符串。\n    如果每个开头括号都有相应的结尾括号，则返回 True。\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" brackets 是一个由 \"(\" 和 \")\" 组成的字符串。\n    如果每个开括号都有一个对应的闭括号，则返回 True。\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\""]}
{"text": ["def derivative(xs: list):\n    \"\"\" xs 表示多项式的系数。\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n    以相同形式返回此多项式的导数。\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\"", "def derivative(xs: list):\n    \"\"\" xs表示多项式的系数。\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n     以相同形式返回该多项式的导数。\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\"", "def derivative(xs: list):\n    \"\"\" xs 表示多项式的系数。\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n     返回该多项式的导数，形式相同。\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\""]}
{"text": ["def fibfib(n: int):\n    \"\"\"FibFib 数字序列是一个类似于斐波那契序列的序列，其定义如下：\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)。\n    请编写一个函数来高效地计算 fibfib 数字序列的第 n 个元素。\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\"", "def fibfib(n: int):\n    \"\"\"FibFib数列是一个类似于Fibbonacci数列的序列，其定义如下：\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n    请编写一个函数，以有效地计算fibfib数列的第n个元素。\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\"", "def fibfib(n: int):\n    \"\"\"FibFib 数字序列是一个类似于斐波那契序列的序列，其定义如下：\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n    请编写一个函数来高效地计算 fibfib 数字序列的第 n 个元素。\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\""]}
{"text": ["FIX = \"\"\"\n添加更多测试用例。\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"编写一个函数 vowels_count，该函数接受一个表示单词的字符串作为输入，\n    并返回字符串中元音的数量。在这种情况下，元音是 'a', 'e', 'i', 'o', 'u'。\n    这里，'y' 也是一个元音，但仅当它位于给定单词的末尾时。\n\n    示例：\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\"", "FIX = \"\"\"\n添加更多测试用例。\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"编写一个函数 vowels_count，以表示单词的字符串作为输入，并返回字符串中元音的数量。\n    在这种情况下，元音是 'a'、'e'、'i'、'o'、'u'。这里，'y' 也是一个元音，但只有当它位于给定单词的末尾时才是元音。\n\n    示例：\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\"", "FIX = \"\"\"\n添加更多测试用例。\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"编写一个函数 vowels_count，该函数接受一个表示单词的字符串作为输入，\n    并返回字符串中元音的数量。\n    在这种情况下，元音是 'a', 'e', 'i', 'o', 'u'。这里，'y' 也是\n    一个元音，但仅当它位于给定单词的末尾时。\n\n    示例：\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\""]}
{"text": ["def circular_shift(x, shift):\n    \"\"\"对整数 x 中的数字进行循环移位，将数字向右移动 shift 位，\n    并以字符串形式输出。\n    如果 shift > 该数字的位数，则输出时将该数字反转。\n    >>> circular_shift(12, 1)\n    \"21\"\n    >>> circular_shift(12, 2)\n    \"12\"\n    \"\"\"", "def circular_shift(x, shift):\n    \"\"\"循环移动整数 x 的数字，将数字向右移动 shift 位\n    并将结果作为字符串返回。\n    如果 shift > 数字的位数，返回数字反转。\n    >>> circular_shift(12, 1)\n    \"21\"\n    >>> circular_shift(12, 2)\n    \"12\"\n    \"\"\"", "def circular_shift(x, shift):\n    \"\"\"循环移位整数 x 的数字，将数字向右移位\n    并将结果作为字符串返回。\n    如果移位 > 数字的位数，返回反向的数字。\n    >>>circular_shift(12, 1)\n    \"21\"\n    >>>circular_shift(12, 2)\n    \"12\"\n    \"\"\""]}
{"text": ["def digitSum(s):\n    \"\"\"任务\n    编写一个函数，该函数接受一个字符串作为输入，并返回仅大写字符的\n    ASCII码之和。\n\n    示例:\n        digitSum(\"\") => 0\n        digitSum(\"abAB\") => 131\n        digitSum(\"abcCd\") => 67\n        digitSum(\"helloE\") => 69\n        digitSum(\"woArBld\") => 131\n        digitSum(\"aAaaaXa\") => 153\n    \"\"\"", "def digitSum(s):\n    \"\"\"任务\n    编写一个函数，以字符串作为输入，并返回仅大写字符的 ASCII 码总和。\n\n    ​​示例：\n    digitSum(\"\") => 0\n    digitSum(\"abAB\") => 131\n    digitSum(\"abcCd\") => 67\n    digitSum(\"helloE\") => 69\n    digitSum(\"woArBld\") => 131\n    digitSum(\"aAaaaXa\") => 153\n    \"\"\"", "def digitSum(s):\n    \"\"任务\n    编写一个函数，该函数接受一个字符串作为输入，并返回仅大写字符的\n    ASCII码之和。\n\n    示例:\n        digitSum(\"\") => 0\n        digitSum(\"abAB\") => 131\n        digitSum(\"abcCd\") => 67\n        digitSum(\"helloE\") => 69\n        digitSum(\"woArBld\") => 131\n        digitSum(\"aAaaaXa\") => 153\n    \"\"\""]}
{"text": ["def fruit_distribution(s,n):\n    \"\"\"\n    在这个任务中，你将得到一个字符串，表示分布在水果篮中的苹果和橙子的数量。\n    这个篮子里有苹果、橙子和芒果。给定一个表示橙子和苹果总数的字符串和一个表示篮子中\n    水果总数的整数，返回篮子中芒果的数量。\n    例如：\n    fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n    \"\"\"", "def fruit_distribution(s,n):\n    \"\"\"\n    在这个任务中，你将得到一个字符串，表示分布在一个水果篮子中的苹果和橙子的数量，\n    水果篮里装着苹果、橙子和芒果。\n    给一个字符串代表橘子和苹果的总数和一个整数代表篮子中水果总数，\n    返回篮子中芒果的数量。\n    例如：\n    fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n    \"\"\"", "def fruit_distribution(s,n):\n    \"\"\"\n    在这个任务中，您将获得一个字符串，表示一篮子水果中\n    分配的苹果和橙子的数量。\n    该篮子包含苹果、橙子和芒果。给定表示橙子和苹果总数的\n    字符串，以及表示水果总数的整数，\n    返回篮子中芒果水果的数量。\n    例如：\n    fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n    \"\"\""]}
{"text": ["def pluck(arr):\n    \"\"\"\n    \"给定一个表示树枝的数组，其中包含非负整数节点，\n    你的任务是摘取一个节点并返回。\n    被摘取的节点应该是具有最小偶数值的节点。\n    如果找到多个具有相同最小偶数值的节点，返回索引最小的那个节点。\n\n    被摘取的节点应该以列表的形式返回，格式为 [ 最小值, 其索引 ]，\n    如果没有偶数值或给定的数组为空，返回 []。\n\n    示例 1：\n        输入：[4,2,3]\n        输出：[2, 1]\n        解释：2 是最小的偶数值，且 2 的索引最小。\n\n    示例 2：\n        输入：[1,2,3]\n        输出：[2, 1]\n        解释：2 是最小的偶数值，且 2 的索引最小。\n\n    示例 3：\n        输入：[]\n        输出：[]\n\n    示例 4：\n        输入：[5, 0, 3, 0, 4, 2]\n        输出：[0, 1]\n        解释：0 是最小的偶数值，但有两个零，\n             所以我们选择第一个零，它的索引最小。\n\n    约束条件：\n        * 1 <= nodes.length <= 10000\n        * 0 <= node.value\n    \"\"\"", "def pluck(arr):\n    \"\"\"\n    \"给定一个表示具有非负整数节点的树的分支的数组\n    您的任务是摘取其中一个节点并返回它。\n    摘取的节点应该是具有最小偶数值的节点。\n    如果发现多个具有相同最小偶数值的节点，则返回具有最小索引的节点。\n\n    摘取的节点应在列表中返回，[smalest_value，其索引]，\n    如果没有偶数值或给定的数组为空，则返回[]。\n\n    示例 1：\n    输入：[4,2,3]\n    输出：[2, 1]\n    说明：2 具有最小偶数值，2 具有最小索引。\n\n    示例 2：\n    输入：[1,2,3]\n    输出：[2, 1]\n    说明：2 具有最小偶数值，2 具有最小索引。\n\n    示例 3：\n    输入：[]\n    输出：[]\n\n    示例 4：\n    输入：[5, 0, 3, 0, 4, 2]\n    输出：[0, 1]\n    解释：0 是最小值，但有两个零，\n    因此我们将选择具有最小索引的第一个零。\n\n    约束条件：\n    * 1 <= nodes.length <= 10000\n    * 0 <= node.value\n    \"\"\"", "def pluck(arr):\n    \"\"\"\n    \"给定一个表示树的分支的数组，该数组具有非负整数节点\n    你的任务是摘取其中一个节点并返回它。\n    被摘取的节点应该是具有最小偶数值的节点。\n    如果找到多个具有相同最小偶数值的节点，则返回具有最小索引的节点。\n\n    被摘取的节点应以列表形式返回，[ 最小值, 其索引 ]，\n    如果没有偶数值或给定数组为空，则返回 []。\n\n    示例 1:\n        输入: [4,2,3]\n        输出: [2, 1]\n        解释: 2 是最小的偶数值，并且 2 具有最小的索引。\n\n    示例 2:\n        输入: [1,2,3]\n        输出: [2, 1]\n        解释: 2 是最小的偶数值，并且 2 具有最小的索引。\n\n    示例 3:\n        输入: []\n        输出: []\n    \n    示例 4:\n        输入: [5, 0, 3, 0, 4, 2]\n        输出: [0, 1]\n        解释: 0 是最小值，但有两个零，\n                     所以我们将选择第一个零，它具有最小的索引。\n\n    约束条件:\n        * 1 <= nodes.length <= 10000\n        * 0 <= node.value\n    \"\"\""]}
{"text": ["def search(lst):\n    '''\n    给定一个非空的正整数列表。\n    返回一个大于零且其频率大于或等于其值的最大整数。\n    整数出现的频率是它在列表中出现的次数。\n    如果不存在，则返回 -1。\n    示例：\n        search([4, 1, 2, 2, 3, 1]) == 2\n        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n        search([5, 5, 4, 4, 4]) == -1\n    '''", "def search(lst):\n    '''\n    给定一个非空的正整数列表。返回大于零且频率大于\n    或等于其自身值的最大整数。\n    整数的频率是它在列表中出现的次数。\n    如果不存在这样的值，返回 -1。\n    示例：\n        search([4, 1, 2, 2, 3, 1]) == 2\n        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n        search([5, 5, 4, 4, 4]) == -1\n    '''", "def search(lst):\n    '''\n    给定一个非空的正整数列表。返回大于零且频率大于或等于整数本身值的最大整数。\n    整数的频率是它在列表中出现的次数。\n    如果不存在这样的值，则返回 -1。\n    示例：\n    search([4, 1, 2, 2, 3, 1]) == 2\n    search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n    search([5, 5, 4, 4, 4]) == -1\n    '''"]}
{"text": ["def strange_sort_list(lst):\n    '''\n    给定整数列表，以奇怪的顺序返回列表。\n    奇怪的排序是从最小值开始，\n    然后是剩余整数的最大值，然后是最小值，依此类推。\n\n    示例：\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''", "def strange_sort_list（lst）：\n    '''\n    给定整数列表，以奇怪的顺序返回列表。\n    奇怪的排序是从最小值开始，\n    然后是剩余整数的最大值，然后是最小值，依此类推。\n\n    例子：\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''", "def strange_sort_list(lst):\n    '''\n    给定整数列表，以奇怪的顺序返回列表。\n    奇怪的排序是从最小值开始，\n    然后是剩余整数的最大值，然后是最小值，依此类推。\n\n    示例：\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''"]}
{"text": ["def triangle_area(a, b, c):\n    '''\n    给定一个三角形的三边长度。如果三边构成一个有效的三角形，就将该\n    三角形的面积四舍五入到小数点后两位并返回。否则返回 -1。\n    当任意两边之和大于第三边时，三边构成一个有效的三角形。\n    示例：\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''", "def triangle_area(a, b, c):\n    '''\n    给定三角形三边的长度。如果三边形成一个有效三角形，则返回四舍五入到小数点后 2 位的三角形面积。\n    否则返回 -1\n    当任意两边之和大于第三边时，三边构成一个有效三角形。\n    示例：\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''", "def triangle_area(a, b, c):\n    '''\n    给定一个三角形的三边长度。如果三边构成一个有效的三角形，返回\n    该三角形的面积，保留两位小数。\n    否则返回 -1\n    三边构成一个有效的三角形，当任意两边之和大于\n    第三边时。\n    示例：\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''"]}
{"text": ["def will_it_fly(q,w):\n    '''\n    编写一个函数，如果对象 q 会飞，则返回 True，否则返回 False。\n    对象 q 会飞的条件是它是平衡的（它是一个回文列表）并且其元素的和小于或等于最大可能重量 w。\n\n    示例：\n    will_it_fly([1, 2], 5) ➞ False \n    # 1+2 小于最大可能重量，但它是不平衡的。\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # 它是平衡的，但 3+2+3 大于最大可能重量。\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 小于最大可能重量，并且它是平衡的。\n\n    will_it_fly([3], 5) ➞ True\n    # 3 小于最大可能重量，并且它是平衡的。\n    '''", "def will_it_fly(q,w):\n    '''\n    编写一个函数，如果对象 q 会飞，则返回 True，否则返回 False。\n    对象 q 会飞的条件是它是平衡的（它是一个回文列表）并且其元素的和小于或等于最大可能重量 w。\n\n    示例：\n    will_it_fly([1, 2], 5) ➞ False \n    # 1+2 小于最大可能重量，但它是不平衡的。\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # 它是平衡的，但 3+2+3 大于最大可能重量。\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 小于最大可能重量，并且它是平衡的。\n\n    will_it_fly([3], 5) ➞ True\n    # 3 小于最大可能重量，并且它是平衡的。\n    '''", "def will_it_fly(q,w):\n    '''\n    编写一个函数，如果对象 q 会飞，则返回 True，否则返回 False。\n    如果对象 q 是平衡的（它是一个回文列表），并且其元素的总和小于或等于最大可能重量 w，则对象 q 会飞。\n\n    示例：\n    will_it_fly([1, 2], 5) ➞ False\n    # 1+2 小于最大可能重量，但它是不平衡的。\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # 它是平衡的，但 3+2+3 大于最大可能重量。\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 小于最大可能重量，并且它是平衡的。\n\n    will_it_fly([3], 5) ➞ True\n    # 3 小于最大可能重量，并且是平衡的。\n    '''"]}
{"text": ["def smallest_change(arr):\n    \"\"\"\n    给定一个整数数组 arr，找出需要更改的最小元素数量，\n    使数组成为回文数组。回文数组是指正反读都相同的数组。\n    在一次更改中，你可以将一个元素更改为任何其他元素。\n\n    例如：\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\"", "def smallest_change(arr):\n    \"\"\"\n    给定一个整数数组 arr，要使其成为回文数组，请找出需要更改的最小元素数量。\n    回文数组是指正反读都相同的数组。\n    在一次更改中，可将某元素更改为其他任何元素。\n\n    例如：\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\"", "def smallest_change(arr):\n    \"\"\"\n    给定一个整数数组 arr，找出需要更改的最小元素数量，\n    使数组成为回文数组。回文数组是指正反读都相同的数组。\n    在一次更改中，你可以将一个元素更改为任何其他元素。\n\n    例如：\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\""]}
{"text": ["def total_match(lst1, lst2):\n    '''\n    编写一个函数，该函数接受两个字符串列表，并返回字符总数较少的列表。\n\n    如果两个列表的字符数相同，则返回第一个列表。\n\n    示例\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''", "def total_match(lst1, lst2):\n    '''\n    编写一个函数，接受两个字符串列表，并返回列表中所有字符串的字符总数小于另一个列表的列表。\n\n    如果两个列表的字符数相同，则返回第一个列表。\n\n    示例\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''", "def total_match(lst1, lst2):\n    '''\n    编写一个函数，该函数传入两个字符串列表，返回字符总数较少的列表。\n\n    如果两个列表的字符数相同，则返回第一个列表。\n\n    示例\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''"]}
{"text": ["def is_multiply_prime(a):\n    \"\"\"编写一个函数，当给定的数字是3个质数的乘积时返回true，\n    否则返回false。\n    已知(a)小于100。\n    示例：\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\"", "def is_multiply_prime(a)：\n    “”“编写一个函数，如果给定的数字是3个质数的乘积则返回True，\n    否则返回False。\n    知道(a)小于 100。\n    示例：\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\"", "def is_multiply_prime(a):\n    \"\"\"编写一个函数，如果给定的数字是3个质数的乘积则返回true，\n    否则返回false。\n    知道(a)小于100。\n    示例：\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\""]}
{"text": ["def is_simple_power(x, n):\n    \"\"\"你的任务是编写一个函数，如果一个数字 x 是 n 的简单幂，则返回 true，否则返回 false。\n    如果 n**int=x，则 x 是 n 的简单幂\n    例如：\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\"", "def is_simple_power(x, n):\n    \"\"\"你的任务是编写一个函数，如果一个数字 x 是 n 的简单幂，则返回 true\n    否则返回 false。\n    如果 n**int=x，则 x 是 n 的简单幂\n    例如：\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\"", "def is_simple_power(x, n):\n    \"\"\"您的任务是编写一个函数，如果数字 x 是 n 的简单幂，则返回 true，否则返回 false。\n    如果 n**int=x，则 x 是 n 的简单幂\n    例如：\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\""]}
{"text": ["def iscube(a):\n    '''\n    编写一个函数，该函数接受一个整数 a，并返回 True\n    如果这个整数是某个整数的立方。\n    注意：你可以假设输入总是有效的。\n    示例：\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''", "def iscube(a):\n    '''\n    编写一个函数，接收一个整数 a，并在该整数是\n    某个整数的立方时返回 True。\n    注意：你可以假设输入始终有效。\n    示例:\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''", "def iscube(a):\n    '''\n    编写一个函数，接受一个整数 a，如果该整数是某个整数的立方，则返回 True 。\n    注意：您可以假设输入始终有效。\n    示例：\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''"]}
{"text": ["def hex_key(num):\n    \"\"\"你需要编写一个函数，该函数接收一个十六进制数字作为字符串，\n    并计算其中是质数的十六进制数字的个数（质数是大于1的自然数，\n    且不能被两个更小的自然数相乘得到）。\n    十六进制数字包括 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F。\n    质数包括 2, 3, 5, 7, 11, 13, 17,...\n    因此你需要确定以下数字的个数：2, 3, 5, 7, \n    B (=十进制 11), D (=十进制 13)。\n    注意：你可以假设输入总是正确的或为空字符串，\n    且符号 A, B, C, D, E, F 总是大写。\n    示例：\n    对于 num = \"AB\"，输出应为 1。\n    对于 num = \"1077E\"，输出应为 2。\n    对于 num = \"ABED1A33\"，输出应为 4。\n    对于 num = \"123456789ABCDEF0\"，输出应为 6。\n    对于 num = \"2020\"，输出应为 2。\n    \"\"\"", "def hex_key(num):\n    \"\"\"你的任务是编写一个函数，接收\n    一个十六进制数作为字符串，并计算出十六进制数中素数的数量（素数或素数是大于 1 的自然数，不是两个较小自然数的乘积）。\n    十六进制数字为 0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F。\n    素数为 2、3、5、7、11、13、17、...\n    因此，你必须确定以下数字的数量：2、3、5、7、\n    B（=十进制 11）、D（=十进制 13）。\n    注意：你可以假设输入始终是正确的或空字符串，\n    并且符号 A、B、C、D、E、F 是始终为大写。\n    示例：\n    对于 num =“AB”，输出应为 1。\n    对于 num =“1077E”，输出应为 2。\n    对于 num =“ABED1A33”，输出应为 4。\n    对于 num =“123456789ABCDEF0”，输出应为 6。\n    对于 num =“2020”，输出应为 2。\n    “””", "def hex_key(num):\n    \"\"\"你被委托编写一个函数，该函数接收\n    一个十六进制数字作为字符串，并计算其中是质数的十六进制\n    数字的数量（质数是大于1的自然数，且不能表示为两个较小的自然数的乘积）。\n    十六进制数字是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F。\n    质数是 2, 3, 5, 7, 11, 13, 17,...\n    因此，你需要确定以下数字的数量：2, 3, 5, 7,\n    B（= 十进制 11），D（= 十进制 13）。\n    注意：你可以假设输入总是正确的或为空字符串，\n    并且符号 A, B, C, D, E, F 始终为大写。\n    示例：\n    对于 num = \"AB\"，输出应该是 1。\n    对于 num = \"1077E\"，输出应该是 2。\n    对于 num = \"ABED1A33\"，输出应该是 4。\n    对于 num = \"123456789ABCDEF0\"，输出应该是 6。\n    对于 num = \"2020\"，输出应该是 2。\n    \"\"\""]}
{"text": ["def decimal_to_binary(decimal):\n    \"\"\"您将获得一个十进制形式的数字，您的任务是将其转换为二进制格式。该函数应返回一个字符串，每个字符代表一个二进制数字。字符串中的每个字符将是“0”或“1”。\n\n    字符串的开头和结尾将有两个额外的字符“db”。\n    额外的字符用于帮助格式化。\n\n    示例：\n    decimal_to_binary(15) # 返回“db1111db”\n    decimal_to_binary(32) # 返回“db100000db”\n    \"\"\"", "def decimal_to_binary(decimal):\n    \"\"\"你将得到一个十进制形式的数字，你的任务是将其转换为\n    二进制格式。该函数应该返回一个字符串，每个字符代表一个二进制\n    数字。字符串中的每个字符将是'0'或'1'。\n\n    字符串的开头和结尾会有两个额外的字符'db'。\n    这些额外的字符用于帮助格式化。\n\n    示例：\n    decimal_to_binary(15)   # 返回 \"db1111db\"\n    decimal_to_binary(32)   # 返回 \"db100000db\"\n    \"\"\"", "def decimal_to_binary(decimal):\n    \"\"\"给你一个十进制数字，你的任务是将其转换为二进制格式。\n    该函数会返回一个字符串，每个字符表示一个二进制数。\n    字符串中的每个字符将为‘0’或‘1’。\n\n    字符串的开头和结尾会出现两个附加的字符‘db’。\n    附加的字符是用来帮助调整格式的。\n\n    Examples:\n    decimal_to_binary(15)   # returns \"db1111db\"\n    decimal_to_binary(32)   # returns \"db100000db\"\n    \"\"\""]}
{"text": ["def is_happy(s):\n    \"\"\"给定一个字符串 s。\n    你的任务是检查字符串是否是快乐的。\n    如果字符串的长度至少为3且每3个连续的字母都是不同的，则字符串是快乐的。\n    例如：\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\"", "def is_happy(s):\n    \"\"\"给定一个字符串 s。\n    您的任务是检查该字符串是否满足条件。\n    如果字符串的长度至少为 3，并且每 3 个连续字母都不同，则该字符串满足条件\n    例如：\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\"", "def is_happy(s):\n    \"\"\"给定一个字符串 s。\n    你的任务是检查字符串是否快乐。\n    如果字符串的长度至少为 3，并且每 3 个连续的字母都是不同的，那么这个字符串就是快乐字符串。\n    例如：\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\""]}
{"text": ["def numerical_letter_grade(grades):\n    \"\"\"这是学期的最后一周，老师必须给学生打分。\n    老师一直在制作自己的评分算法。\n    唯一的问题是，她丢失了用于评分的代码。\n    她给了你一些学生的GPA列表，你需要编写一个函数，\n    该函数可以使用下表输出字母成绩列表：\n             GPA       |    字母成绩\n              4.0                A+\n            > 3.7                A \n            > 3.3                A- \n            > 3.0                B+\n            > 2.7                B \n            > 2.3                B-\n            > 2.0                C+\n            > 1.7                C\n            > 1.3                C-\n            > 1.0                D+ \n            > 0.7                D \n            > 0.0                D-\n              0.0                E\n    \n\n    示例:\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\"", "def numerical_letter_grade(grades):\n    \"\"\"现在是学期的最后一周，老师必须给学生们打分。\n    给学生打分。老师一直在自制评分算法。\n    唯一的问题是，她丢失了用于评分的代码。\n    她给了你一些学生的平均学分绩点列表，你必须写一个 \n    你必须使用下表编写一个可以输出字母成绩列表的函数：\n             GPA       |    字母成绩\n              4.0                A+\n            > 3.7                A \n            > 3.3                A- \n            > 3.0                B+\n            > 2.7                B \n            > 2.3                B-\n            > 2.0                C+\n            > 1.7                C\n            > 1.3                C-\n            > 1.0                D+ \n            > 0.7                D \n            > 0.0                D-\n              0.0                E\n    \n\n    示例：\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\"", "def numeric_letter_grade(grades):\n    \"\"\"这是学期的最后一周，老师必须给学生评分。老师一直在制定自己的评分算法。\n    唯一的问题是，她丢失了用于评分的代码。\n    她给了你一些学生的 GPA 列表，你必须编写一个函数，该函数可以使用下表输出字母等级列表：\n    GPA | 字母等级\n    4.0 A+\n    > 3.7 A\n    > 3.3 A-\n    > 3.0 B+\n    > 2.7 B\n    > 2.3 B-\n    > 2.0 C+\n    > 1.7 C\n    > 1.3 C-\n    > 1.0 D+\n    > 0.7 D\n    > 0.0 D-\n    0.0 E\n\n    示例：\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\""]}
{"text": ["def prime_length(string):\n    \"\"\"编写一个函数，接收一个字符串，如果字符串长度是质数则返回True，否则返回False\n    例子\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\"", "def prime_length(string):\n    \"\"\"编写一个函数，接收一个字符串，如果字符串长度是\n    质数则返回True，否则返回False\n    示例\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\"", "def prime_length(string):\n    \"\"\"编写一个以字符串表示的函数，\n    如果字符串长度是质数则返回True，否则返回False\n    示例\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\""]}
{"text": ["def starts_one_ends(n):\n    \"\"\"\n    给定一个正整数 n，返回以 1 开头或 1 结尾的 n 位\n    正整数的数量。\n    \"\"\"", "def starts_one_ends(n):\n    \"\"\"\n    给定正整数 n，返回以 1 开头或结尾的 n 位\n    正整数的个数。\n    \"\"\"", "def starts_one_ends(n):\n    \"\"\"\n    给定一个正整数 n，返回以 1 开头或结尾的 n 位正整数的数量。\n    \"\"\""]}
{"text": ["def solve(N):\n    \"\"\"给定一个正整数 N，返回其数字之和的二进制表示。\n    \n    示例\n        对于 N = 1000，数字之和为 1，输出应为 \"1\"。\n        对于 N = 150，数字之和为 6，输出应为 \"110\"。\n        对于 N = 147，数字之和为 12，输出应为 \"1100\"。\n    \n    变量:\n        @N 整数\n              约束: 0 ≤ N ≤ 10000。\n    输出:\n         一个二进制数字的字符串\n    \"\"\"", "def solve(N):\n    \"\"\"给定一个正整数 N，返回其数字在二进制表示下的总和。\n\n    示例\n    当 N = 1000时，数字之和为 1，输出应为“1”。\n    当 N = 150时，数字之和为 6，输出应为“110”。\n    当 N = 147时，数字之和为 12，输出应为“1100”。\n\n    变量：\n    @N 整数\n            约束：0 ≤ N ≤ 10000。\n    输出：\n    一串二进制数\n    \"\"\"", "def solve(N):\n    \"\"\"给定一个正整数 N，返回其数字在二进制表示下的总和。\n    \n    示例\n        对于 N = 1000，数字之和为 1，输出应为 \"1\"。\n        对于 N = 150，数字之和为 6，输出应为 \"110\"。\n        对于 N = 147，数字之和为 12，输出应为 \"1100\"。\n    \n    变量：\n        @N integer\n             约束条件: 0 ≤ N ≤ 10000.\n    输出：\n         一个二进制字符串\n    \"\"\""]}
{"text": ["def add(lst):\n    \"\"\"给定一个非空整数列表 lst。将位于奇数索引的偶数元素相加。\n\n\n    示例:\n        add([4, 2, 6, 7]) ==> 2 \n    \"\"\"", "def add(lst):\n    \"\"\"给定一个非空的整数列表 lst。添加位于奇数索引处的偶数元素。\n\n    示例：\n    add([4, 2, 6, 7]) ==> 2\n    \"\"\"", "def add(lst):\n    “”“给定一个非空整数列表 lst。将位于奇数索引的偶数元素相加。\n\n    例子：\n        add([4, 2, 6, 7]) ==> 2 \n    \"\"\""]}
{"text": ["def anti_shuffle(s):\n    \"\"\"\n    编写一个函数，该函数接收一个字符串并返回其有序版本。\n    字符串的有序版本是一个字符串，其中所有单词（由空格分隔）\n    都被替换为一个新单词，新单词中的所有字符按\n    基于 ASCII 值的升序排列。\n    注意：你应该保持句子中单词和空格的顺序。\n\n    例如：\n    anti_shuffle('Hi') 返回 'Hi'\n    anti_shuffle('hello') 返回 'ehllo'\n    anti_shuffle('Hello World!!!') 返回 'Hello !!!Wdlor'\n    \"\"\"", "def anti_shuffle(s):\n    \"\"\"\n    编写一个函数，接受一个字符串并返回其有序版本。\n    有序版本的字符串，即一个字符串，其中所有单词（以空格分隔）\n    都被一个新单词替换，其中所有字符都按\n    ASCII 值升序排列。\n    注意：您应该保持句子中单词和空格的顺序。\n\n    例如：\n    anti_shuffle('Hi') 返回 'Hi'\n    anti_shuffle('hello') 返回 'ehllo'\n    anti_shuffle('Hello World!!!') 返回 'Hello !!!Wdlor'\n    \"\"\"", "def anti_shuffle(s):\n    \"\"\"\n    编写一个函数，接收一个字符串并返回它的有序版本。\n    字符串的有序版本是一个字符串，其中所有单词（用空格分隔）\n    都被一个新词替换，新词中的所有字符按 ascii 值升序排列。\n    升序排列。\n    注意：应保持句子中单词和空格的顺序。\n\n    例如：\n    anti_shuffle('Hi') returns 'Hi'\n    anti_shuffle('hello') returns 'ehllo'\n    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\n    \"\"\""]}
{"text": ["def get_row(lst, x):\n    \"\"\"\n    给定一个二维数据，作为嵌套列表，\n    类似于矩阵，但与矩阵不同的是，\n    每一行可能包含不同数量的列。\n    给定 lst 和整数 x，找到列表中的整数 x，\n    并返回元组列表 [(x1, y1), (x2, y2) ...]，使得\n    每个元组是一个坐标 - (行, 列)，从 0 开始。\n    首先按行升序排序坐标。\n    同时，按列降序排序行的坐标。\n    \n    示例：\n    get_row([\n      [1,2,3,4,5,6],\n      [1,2,3,4,1,6],\n      [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\"", "def get_row(lst, x):\n    \"\"\"\n    给你一个二维数据，作为嵌套列表，\n    与矩阵类似，但与矩阵不同的是，\n    每行可能包含不同数量的列。\n    给定 lst 和整数 x，在列表中查找整数 x，\n    并返回元组列表 [(x1, y1), (x2, y2) ...] 使得\n    每个元组都是一个坐标 - （行，列），从 0 开始。\n    最初按行升序对坐标进行排序。\n    另外，按列按降序对行坐标进行排序。\n    \n    示例：\n    get_row([\n      [1,2,3,4,5,6],\n      [1,2,3,4,1,6],\n      [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\"", "def get_row(lst, x):\n    \"\"\"\n    给定一个二维数据，作为嵌套列表，\n    它类似于矩阵，但与矩阵不同，\n    每行可能包含不同数量的列。\n    给定 lst 和整数 x，在列表中查找整数 x，\n    并返回元组列表 [(x1, y1), (x2, y2) ...]，其中\n    每个元组都是一个坐标 - (行, 列)，从 0 开始。\n    首先按行按升序对坐标进行排序。\n    另外，按列按降序对行的坐标进行排序。\n\n    示例：\n    get_row([\n    [1,2,3,4,5,6],\n    [1,2,3,4,1,6],\n    [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\""]}
{"text": ["def sort_array(array):\n    \"\"\"\n    给定一个非负整数数组，返回排序后的数组副本。\n    如果第一个索引值和最后一个索引值的和是奇数，则按升序排序；\n    如果第一个索引值和最后一个索引值的和是偶数，则按降序排序。\n\n    注意：\n    * 不要改变给定的数组。\n\n    示例：\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\"", "def sort_array(array):\n    \"\"\"\n    给定一个非负整数数组，返回排序后的数组副本，\n    如果数组中第一个元素和最后一个元素的和是奇数，则按升序排序，\n    如果和是偶数，则按降序排序。\n\n    注意：\n    * 不要更改给定的数组。\n\n    示例：\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\"", "def sort_array(array):\n    \"\"\"\n    给定一个非负整数数组，排序后返回给定数组的副本，\n    如果总和（第一个索引值，最后一个索引值）为奇数，则按升序对给定数组进行排序，\n    如果总和（第一个索引值，最后一个索引值）为偶数，则按降序对给定数组进行排序。\n\n    注意：\n    * 不要更改给定的数组。\n\n    示例：\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\""]}
{"text": ["def encrypt(s):\n    \"\"\"创建一个函数 encrypt，该函数接受一个字符串作为参数，\n    并返回一个经过字母旋转加密的字符串。\n    字母表应以一种方式旋转，使字母向下移动两倍于两个位置。\n    例如：\n    encrypt('hi') returns 'lm'\n    encrypt('asdfghjkl') returns 'ewhjklnop'\n    encrypt('gf') returns 'kj'\n    encrypt('et') returns 'ix'\n    \"\"\"", "def encrypt(s):\n    \"\"\"创建一个函数 encrypt，以字符串为参数并\n    返回使用旋转字母表加密的字符串。\n    字母表应以一种方式旋转，使字母向下移动四个位置。\n    例如：\n    encrypt('hi') 返回 'lm'\n    encrypt('asdfghjkl') 返回 'ewhjklnop'\n    encrypt('gf') 返回 'kj'\n    encrypt('et') 返回 'ix'\n    \"\"\"", "def encrypt(s):\n    \"\"\"编写一个函数 encrypt，该函数接受字符串作为参数，\n    需输出一个经过字母旋转加密的字符串。\n    字母表应以以一种方式旋转，使得字母向下移动四个位置。\n    例如：\n    encrypt('hi') 输出 'lm'\n    encrypt('asdfghjkl') 输出 'ewhjklnop'\n    encrypt('gf') 输出 'kj'\n    encrypt('et') 输出 'ix'\n    \"\"\""]}
{"text": ["def next_smallest(lst):\n    \"\"\"\n    给定一个整数列表。\n    编写一个函数 next_smallest()，返回这个列表中第二小的元素。\n    如果没有这样的元素，则返回 None。\n    \n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\"", "def next_smallest(lst):\n    \"\"\"\n    给定一个整数列表。\n    编写一个函数 next_smallest()，返回列表中第二小的元素。\n    如果没有这样的元素，则返回 None。\n    \n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\"", "def next_smallest(lst):\n    \"\"\"\n    给你一个整数列表。\n    编写一个函数 next_smallest()，返回列表中第二小的元素。\n    如果不存在这样的元素，则返回 None。\n\n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\""]}
{"text": ["def is_bored(S):\n    \"\"\"\n    你将得到一个单词字符串，你的任务是统计无聊的数量。\n    无聊是指以单词 \"I\" 开头的句子。\n    句子是以“.”、“?”或“!”来分隔的。\n   \n    例如：\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\"", "def is_bored(S):\n    \"\"\"\n    你会得到一串单词，而你的任务就是数出无聊的句子的数量。无聊是指以 “I”开头的句子。\n    句子以“.”、“？”或“！”分隔。\n   \n    例如：\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\"", "def is_bored(S):\n    \"\"\"\n    你将得到一个单词字符串，你的任务是计算无聊的数量。\n    无聊是指以单词 \"I\" 开头的句子。\n    句子由 '.'、'?' 或 '!' 分隔。\n   \n    例如：\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\""]}
{"text": ["def any_int(x, y, z):\n    '''\n    创建一个接受 3 个数字的函数。\n    如果其中一个数字等于其他两个数字之和，并且所有数字都是整数，则返回 true。\n    在其他情况下返回 false。\n\n    示例\n    any_int(5, 2, 7) ➞ True\n\n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n\n    any_int(3.6, -2.2, 2) ➞ False\n\n    '''", "def any_int(x, y, z):\n    '''\n    创建一个函数，接收3个数字。\n    如果其中一个数字等于另外两个数字之和，并且所有数字都是整数，则返回true。\n    在其他任何情况下返回false。\n    \n    示例\n    any_int(5, 2, 7) ➞ True\n    \n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n    \n    any_int(3.6, -2.2, 2) ➞ False\n  \n\n    \n    '''", "def any_int(x, y, z):\n    '''\n    创建一个接收3个数字的函数。\n    如果其中一个数字等于另外两个数字之和，且所有数字都是整数，则返回 true。\n    在其他情况下返回false。\n    \n    示例\n    any_int(5, 2, 7) ➞ True\n    \n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n    \n    any_int(3.6, -2.2, 2) ➞ False\n  \n\n    \n    '''"]}
{"text": ["def encode(message):\n    \"\"\"\n    编写一个函数，接收一个消息，并以这样一种方式进行编码：\n    交换所有字母的大小写，将消息中所有元音替换为该元音在\n    英文字母表中向后移动两位的字母。\n    假设只有字母。\n    \n    示例：\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\"", "def encode(message):\n    \"\"\"\n    编写一个函数，该函数接受一个消息，并以这样的方式对其进行编码，\n    使得它交换所有字母的大小写，将消息中的所有元音字母\n    替换为英语字母表中该元音字母后面两个\n    位置的字母。\n    假设只有字母。\n    \n    示例：\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\"", "def encode(message):\n    \"\"\"\n    编写一个函数，接收一条消息，并进行编码，使其交换所有字母的大小写，将消息中的所有元音替换为英文字母表中该元音前 2 个位置的字母。\n    假设只有字母。\n\n    示例：\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\""]}
{"text": ["def skjkasdkd(lst):\n    \"\"\"给定一个整数列表。\n    需要找到最大的素数值并返回其数字之和。\n\n    示例：\n    对于 lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] 输出应为 10\n    对于 lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] 输出应为 25\n    对于 lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] 输出应为 13\n    对于 lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] 输出应为 11\n    对于 lst = [0,81,12,3,1,21] 输出应为 3\n    对于 lst = [0,8,1,2,1,7] 输出应为 7\n    \"\"\"", "def skjkasdkd(lst):\n    \"\"\"给你一个整数列表。\n    你需要找到最大的素数并返回其数字之和。\n\n    示例：\n    对于 lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]，输出应为 10\n    对于 lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]，输出应为 25\n    对于 lst = [1,3,1,32,5107,34,83​​278,109,163,23,2323,32,30,1,9,3]，输出应为 13\n    对于 lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] 输出应为 11\n    对于 lst = [0,81,12,3,1,21] 输出应为 3\n    对于 lst = [0,8,1,2,1,7] 输出应为 7\n    \"\"\"", "def skjkasdkd(lst):\n    \"\"\"给你一个整数列表。\n    你需要找到最大的素数并返回其数字之和。\n\n    示例：\n    对于 lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]，输出应为 10\n    对于 lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]，输出应为 25\n    对于 lst = [1,3,1,32,5107,34,83​​278,109,163,23,2323,32,30,1,9,3]，输出应为 13\n    对于 lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] 输出应为 11\n    对于 lst = [0,81,12,3,1,21] 输出应为 3\n    对于 lst = [0,8,1,2,1,7] 输出应为 7\n    \"\"\""]}
{"text": ["def check_dict_case(dict):\n    \"\"\"\n    给定一个字典，如果所有键都是小写字符串或所有键都是大写字符串，则返回 True，否则返回 False。\n    如果给定的字典为空，则该函数应返回 False。\n    示例：\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) 应返回 True。\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) 应返回 False。\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) 应返回 False。\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) 应返回 False。\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) 应返回 True。\n    \"\"\"", "def check_dict_case(dict):\n    \"\"\"\n    给定一个字典，如果所有键都是小写字符串或所有键都是\n    大写字符串，则返回True，否则返回False。\n    如果给定的字典为空，函数应返回False。\n    示例：\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) 应返回 True。\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) 应返回 False。\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) 应返回 False。\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) 应返回 False。\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) 应返回 True。\n    \"\"\"", "def check_dict_case(dict):\n    \"\"\"\n    给定一个字典，如果所有键都是小写字符串或所有键都是大写字符串，则返回True，\n    否则返回False。如果给定的字典为空，该函数应该返回False。\n    示例 :\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) should return True.\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) should return False.\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) should return False.\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) should return False.\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) should return True.\n    \"\"\""]}
{"text": ["def count_up_to(n):\n    \"\"\"实现一个函数，该函数接受一个非负整数作为输入，\n    并返回一个数组，包含前 n 个小于 n 的质数。\n    例如：\n    count_up_to(5) => [2,3]\n    count_up_to(11) => [2,3,5,7]\n    count_up_to(0) => []\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\n    count_up_to(1) => []\n    count_up_to(18) => [2,3,5,7,11,13,17]\n    \"\"\"", "def count_up_to(n):\n    \"\"\"实现一个函数，接收一个非负整数，并返回一个数组，其中包含小于n的前n个质数。\n    例如：“\n    count_up_to(5) => [2,3]\n    count_up_to(11) => [2,3,5,7]\n    count_up_to(0) => []\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\n    count_up_to(1) => []\n    count_up_to(18) => [2,3,5,7,11,13,17]\n    \"\"\"", "def count_up_to(n):\n    \"\"\"实现一个函数，该函数接受一个非负整数并返回前 n \n    个整数的数组，这些整数都是素数且小于 n。\n    例如：\n    count_up_to(5) => [2,3]\n    count_up_to(11) => [2,3,5,7]\n    count_up_to(0) => []\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\n    count_up_to(1) => []\n    count_up_to(18) => [2,3,5,7,11,13,17]\n    \"\"\""]}
{"text": ["def multiply(a, b):\n    \"\"\"完成一个函数，该函数接收两个整数并返回\n    它们个位数字的乘积。\n    假设输入总是有效的。\n    示例：\n    multiply(148, 412) 应返回 16。\n    multiply(19, 28) 应返回 72。\n    multiply(2020, 1851) 应返回 0。\n    multiply(14,-15) 应返回 20。\n    \"\"\"", "def multiply(a, b):\n    \"\"\"完成一个函数，该函数接收两个整数并返回\n    它们个位数字的乘积。\n    假设输入总是有效的。\n    示例：\n    multiply(148, 412) 应返回 16。\n    multiply(19, 28) 应返回 72。\n    multiply(2020, 1851) 应返回 0。\n    multiply(14,-15) 应返回 20。\n    \"\"\"", "def multiply(a, b):\n    \"\"\"输出一个函数，该函数接收两个整数并返回\n    它们个位数字的乘积。\n    假设输入总是有效的。\n    示例：\n    multiply(148, 412) 应返回 16。\n    multiply(19, 28) 应返回 72。\n    multiply(2020, 1851) 应返回 0。\n    multiply(14,-15) 应返回 20。\n    \"\"\""]}
{"text": ["def count_upper(s):\n    \"\"\"\n    给定一个字符串 s，计算偶数索引中大写元音字母的数量。\n    \n    例如：\n    count_upper('aBCdEf') 返回 1\n    count_upper('abcdefg') 返回 0\n    count_upper('dBBE') 返回 0\n    \"\"\"", "def count_upper(s):\n    \"\"\"\n    给定一个字符串 s，计算偶数索引中大写元音字母的数量。\n    \n    例如：\n    count_upper('aBCdEf') 返回 1\n    count_upper('abcdefg') 返回 0\n    count_upper('dBBE') 返回 0\n    \"\"\"", "def count_upper（s）：\n    \"\"\"\n    给定一个字符串 s，计算偶数索引中大写元音字母的数量。\n    \n    例如：\n    count_upper（'aBCdEf'） 返回 1\n    count_upper（'abcdefg'） 返回 0\n    count_upper（'dBBE'） 返回 0\n    \"\"\""]}
{"text": ["def closest_integer(value):\n    '''\n    创建一个函数，该函数接受一个表示数字的值（字符串）\n    并返回最接近它的整数。如果该数字与两个整数等距，\n    则将其向远离零的方向舍入。\n\n    示例\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    注意：\n    向远离零舍入意味着，如果给定的数字与两个整数\n    的距离相等，你应该返回距离零最远的\n    那个整数。例如，closest_integer(\"14.5\") 应该\n    返回 15，closest_integer(\"-14.5\") 应该返回 -15。\n    '''", "def closest_integer(value):\n    '''\n    创建一个函数，该函数接受一个表示数字的值（字符串）\n    并返回最接近该数字的整数。如果该数字与两个整数等距，则将其远离零舍入。\n\n    示例\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    注意：\n    远离零舍入意味着如果给定的数字与两个整数等距，则您应该返回距离零最远的数字。例如，closest_integer(\"14.5\") 应返回 15，而 closest_integer(\"-14.5\") 应返回 -15。\n    '''", "def closest_integer(value):\n    '''\n    创建一个函数，该函数接受一个表示数字的值（字符串）\n    并返回与其最接近的整数。如果这个数字与两个整数是等距的，\n    则从两个整数中取远离零的那个整数。\n\n    例子\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    注意：\n    离零舍入意味着如果给定的数字与两个整数的距离相等，则返回的应该是离零最远的那个。例如 closest_integer（“14.5“）应该返回 15，而 closest_integer（”-14.5”）应该返回 -15。\n    '''"]}
{"text": ["def make_a_pile(n):\n    \"\"\"\n    给定一个正整数 n，你需要堆一个有 n 层石头的堆。\n    第一层有 n 个石头。\n    下一层的石头数量是：\n        - 如果 n 是奇数，则为下一个奇数。\n        - 如果 n 是偶数，则为下一个偶数。\n    以列表形式返回每一层的石头数量，其中索引为 i 的元素表示第 (i+1) 层的石头数量。\n\n    示例：\n    >>> make_a_pile(3)\n    [3, 5, 7]\n    \"\"\"", "def make_a_pile(n):\n    \"\"\"\n    给定一个正整数 n，你需要堆一个有 n 层石头的堆。\n    第一层有 n 个石头。\n    下一层的石头数量是：\n        - 如果 n 是奇数，则为下一个奇数。\n        - 如果 n 是偶数，则为下一个偶数。\n    返回一个列表，其中索引 i 处的元素\n    表示第 (i+1) 层的石头数量。\n\n    示例：\n    >>> make_a_pile(3)\n    [3, 5, 7]\n    \"\"\"", "def make_a_pile（n）：\n    \"\"\"\n    给定一个正整数 n，你需要堆一个有 n 层石头的堆。\n    第一层有 n 颗石头。\n    下一层的石头数量为：\n        - 如果 n 为奇数，则为下一个奇数。\n        - 如果 n 为偶数，则为下一个偶数。\n    返回一个列表，其中索引 i 处的元素表示第 (i+1) 层的石头数量。\n\n    例子：\n    >>> make_a_pile（3）\n    [3, 5, 7]\n    \"\"\""]}
{"text": ["def words_string(s):\n    \"\"\"\n    给定一串用逗号或空格分隔的单词。你的任务是\n    将字符串分割成单词，并返回一个由单词组成的数组。\n    \n    例如：\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\"", "def words_string(s):\n    \"\"\"\n    你将得到一个由逗号或空格分隔的单词字符串。你的任务是\n    将字符串拆分成单词并返回一个单词数组。\n\n    例如：\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\"", "def words_string(s):\n    \"\"\"\n    您将获得一串由逗号或空格分隔的单词。您的任务是\n    将字符串拆分成单词并返回单词数组。\n\n    例如：\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\""]}
{"text": ["def choose_num(x, y):\n    \"\"\"该函数接收两个正数 x 和 y，并返回\n    范围 [x, y] 内最大的偶整数。如果 \n    没有这样的数，则函数应返回-1。\n\n    例如：\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\"", "def choose_num(x, y):\n    \"\"\"此函数接收两个正数 x 和 y，并返回范围\n    范围 [x, y] 内最大的偶整数。\n    如果没有这样的数字，则函数应返回 -1。\n\n    例如：\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\"", "def choose_num(x, y):\n    \"\"\"此函数接收两个正数 x 和 y，并返回范围 [x, y] 内最大的偶整数。\n    如果没有这样的数字，则函数应返回 -1。\n\n    例如：\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\""]}
{"text": ["def rounded_avg(n, m):\n    \"\"\"给定两个正整数n和m，你的任务是计算从n到m的整数（包括n和m）的平均值。\n    将答案四舍五入为最接近的整数，并转换为二进制。\n    如果n大于m，返回-1。\n    示例：\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\"", "def rounded_avg(n, m):\n    \"\"\"给定两个正整数 n 和 m，您的任务是计算\n    从 n 到 m（包括 n 和 m）的整数的平均值。\n    将答案四舍五入为最接近的整数并将其转换为二进制。\n    如果 n 大于 m，则返回 -1。\n    示例：\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\"", "def rounded_avg(n, m):\n    \"\"\"给定两个正整数 n 和 m，你的任务是计算从 n 到 m 的整数的\n    平均值（包括 n 和 m）。\n    将答案四舍五入到最接近的整数并将其转换为二进制。\n    如果 n 大于 m，返回 -1。\n    示例：\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\""]}
{"text": ["def unique_digits(x):\n    \"\"\"给定一个正整数列表x，返回一个排序后的列表，其所有元素中都没有偶数数字。\n\n    注意：返回的列表应按递增顺序排序。\n    \n    例如：\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\"", "def unique_digits(x):\n    \"\"\"给定一个正整数列表x。返回一个排序后的列表，其中所有\n    元素都没有偶数数字。\n\n    注意：返回的列表应按递增顺序排序。\n    \n    例如：\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\"", "def unique_digits(x):\n    \"\"\"给定一个正整数列表 x。返回一个排序后的列表，其中\n    所有元素都没有偶数数字。\n\n    注意：返回的列表应按递增顺序排序。\n    \n    例如：\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\""]}
{"text": ["def by_length(arr):\n    \"\"\"\n    给定一个整数数组，对1到9之间的整数进行排序，\n    反转排序后的数组，然后将每个数字替换为其对应的名称：\n    \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n    例如：\n      arr = [2, 1, 1, 4, 5, 8, 2, 3]   \n            -> 对arr排序 -> [1, 1, 2, 2, 3, 4, 5, 8] \n            -> 反转arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n      返回 [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n    \n      如果数组为空，返回一个空数组：\n      arr = []\n      return []\n    \n      如果数组中有任何奇怪的数字，忽略它：\n      arr = [1, -1 , 55] \n            -> 对arr排序 -> [-1, 1, 55]\n            -> 反转arr -> [55, 1, -1]\n      返回 = ['One']\n    \"\"\"", "def by_length(arr):\n    \"\"\"\n    给定一个整数数组，对介于 1 和 9 之间的整数进行排序、\n    将得到的数组反转，然后将每个数字替换为下列数组中的相应名称\n    \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n    例如：\n      arr = [2, 1, 1, 4, 5, 8, 2, 3]   \n            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n      return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n    \n      如果数组为空，则返回空数组:\n      arr = []\n      return []\n    \n      如果数组中有任何奇怪的数字，请忽略它:\n      arr = [1, -1 , 55] \n            -> sort arr -> [-1, 1, 55]\n            -> reverse arr -> [55, 1, -1]\n      return = ['One']\n    \"\"\"", "def by_length(arr):\n    \"\"\"\n    给定一个整数数组，对 1 到 9 之间的整数进行排序，\n    反转结果数组，然后用其对应的名称替换每个数字，从\n    “One”、“Two”、“Three”、“Four”、“Five”、“Six”、“Seven”、“Eight”、“Nine”。\n\n    例如：\n    arr = [2, 1, 1, 4, 5, 8, 2, 3]\n    -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]\n    -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n    return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n\n    如果数组为空，则返回一个空数组：\n    arr = []\n    return []\n\n    如果数组有任何奇怪的数字忽略它：\n    arr = [1, -1 , 55]\n    -> sort arr -> [-1, 1, 55]\n    -> reverse arr -> [55, 1, -1]\n    return = ['One']\n    \"\"\""]}
{"text": ["def f(n):\n    \"\"\" 实现函数f，该函数以n为参数，\n    并返回一个大小为n的列表，使得索引i处的元素值为i的阶乘，如果i是偶数，\n    否则为从1到i的数字之和。\n    i从1开始。\n    i的阶乘是从1到i的数字的乘积（1 * 2 * ... * i）。\n    示例：\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\"", "def f(n):\n    \"\"\" 实现以 n 为参数的函数 f，\n    并返回一个大小为 n 的列表，如果 i 为偶数，则索引 i 处元素的值是 i 的阶乘\n    否则是从 1 到 i 的数字之和。\n    i 从 1 开始。\n    i 的阶乘是从 1 到 i 的数字的乘积（1 * 2 * ... * i）。\n    示例：\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\"", "def f(n):\n    \"\"\" 实现一个函数 f，它接受 n 作为参数，\n    返回一个大小为 n 的列表，其中索引 i 处的元素值为 i 的阶乘（如果 i 是偶数），\n    或者是从 1 到 i 的数字和（如果 i 是奇数）。\n    i 从 1 开始。\n    i 的阶乘是从 1 到 i 的所有数字的乘积（1 * 2 * ... * i）。\n    示例：\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\""]}
{"text": ["def even_odd_palindrome(n):\n    \"\"\"\n    给定一个正整数 n，返回一个元组，该元组包含范围 (1, n)（含）内的偶数和奇数\n    整数回文数的数量。\n\n    示例 1:\n\n    输入：3\n    输出：(1, 2)\n    说明：\n    整数回文数为 1、2、3。其中一个为偶数，两个为奇数。\n\n    示例 2:\n\n    输入：12\n    输出：(4, 6)\n    说明：\n    整数回文数为 1、2、3、4、5、6、7、8、9、11。其中四个为偶数，六个为奇数。\n\n    注意：\n    1. 1 <= n <= 10^3\n    2. 返回的元组分别包含偶数和奇数整数回文数的数量。\n    \"\"\"", "def even_odd_palindrome(n):\n    \"\"\"\n    给定一个正整数 n，返回一个元组，其中包含在范围(1, n)内的偶数和奇数\n    整数回文的数量，包括 n.\n\n    示例 1:\n\n        Input: 3\n        Output: (1, 2)\n        解释:\n        整数回文是 1, 2, 3。其中一个是偶数，两个是奇数.\n\n    示例 2:\n\n        Input: 12\n        Output: (4, 6)\n        解释:\n        整数回文是 1, 2, 3, 4, 5, 6, 7, 8, 9, 11。其中四个是偶数，六个是奇数.\n\n    注意:\n        1. 1 <= n <= 10^3\n        2. 返回的元组分别包含偶数和奇数整数回文的数量.\n    \"\"\"", "def even_odd_palindrome(n):\n    \"\"\"\n    给定一个正整数 n，返回一个元组，包含在范围 (1, n) 内的偶数和\n    奇数整数回文数的数量（包括 n 本身）。\n\n    示例 1：\n\n        输入：3\n        输出：(1, 2)\n        解释：\n        整数回文数是 1、2、3。它们中有一个是偶数，两个是奇数。\n\n    示例 2：\n\n        输入：12\n        输出：(4, 6)\n        解释：\n        整数回文数是 1、2、3、4、5、6、7、8、9、11。四个是偶数，六个是奇数。\n\n    注意：\n        1. 1 <= n <= 10^3\n        2. 返回的元组分别包含偶数和奇数回文整数的数量。\n    \"\"\""]}
{"text": ["def count_nums(arr):\n    \"\"\"\n    编写一个函数 count_nums，它接受一个整数数组并返回\n    各位数字之和大于0的元素个数。\n    如果数字为负数，则其第一个有符号数字将为负数：\n    例如 -123 有有符号数字 -1、2 和 3。\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\"", "def count_nums(arr):\n    \"\"\"\n    编写一个函数 count_nums，该函数接受一个整数数组并返回\n    数字之和大于0的元素数量。\n    如果一个数字是负数，那么它的第一个符号位数字将是负数：\n    例如，-123 的符号位数字是 -1, 2 和 3。\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\"", "def count_nums(arr):\n    \"\"\"\n    编写一个函数 count_nums，它接受一个整数数组并返回\n    数字的各位数之和大于 0 的元素数量。\n    如果数字为负数，则其第一个有符号数字将为负数：\n    例如 -123 有有符号数字 -1、2 和 3。\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\""]}
{"text": ["def move_one_ball(arr):\n    \"\"\"我们有一个整数数组 'arr'，包含 N 个整数 arr[1], arr[2], ..., arr[N]。\n    数组中的数字将被随机排序。你的任务是确定是否可以通过对给定数组执行以下操作\n    来获得一个按递增顺序排序的数组：\n        你可以执行任意次数的右移操作。\n    \n    一次右移操作意味着将数组的所有元素向右移动一个位置。数组的最后一个元素将被\n    移动到数组的起始位置，即索引 0。\n\n    如果可以通过执行上述操作获得排序数组，则返回 True，否则返回 False。\n    如果给定数组为空，则返回 True。\n\n    注意：给定的列表保证有唯一元素。\n\n    例如：\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    解释：通过执行 2 次右移操作，可以使给定数组达到递增顺序。\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    解释：通过执行任意次数的右移操作，不可能使给定数组达到递增顺序。\n                \n    \"\"\"", "def move_one_ball(arr):\n    \"\"\"我们有一个数组 'arr'，包含 N 个整数 \n    arr[1]，arr[2]，...，arr[N]。数组中的数字是随机排序的。\n    你的任务是确定是否可以通过执行以下操作将数组排序\n    为非递减顺序：\n        你可以进行任意次数的右移操作。\n    \n    一次右移操作意味着将数组中的所有元素向右移动一个\n    位置。数组的最后一个元素将被移动到数组的起始\n    位置，即 0 索引位置。\n\n    如果可以通过执行上述操作获得排序后的数组，\n    则返回 True，否则返回 False。\n    如果给定数组为空，则返回 True。\n\n    注意：给定的列表保证具有唯一元素。\n\n    例如：\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    解释：通过执行 2 次右移操作，可以使给定数组\n                 达到非递减顺序。\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    解释：无法通过任何次数的右移操作使给定\n                数组达到非递减顺序。\n                \n    \"\"\"", "def move_one_ball(arr):\n    \"\"\"我们有一个由 N 个整数组成的数组 'arr' arr[1], arr[2], ..., arr[N]。\n    数组中的数字将随机排序。你的任务是确定是否\n    可以通过执行以下操作来获得按非降序排列的数组. \n    对给定数组进行以下操作：\n        您可以执行任意次数的右移操作。\n    \n    一次右移操作意味着将数组的所有元素移一位，即\n    向右移动一个位置。数组的最后一个元素将被移动到\n    数组中的起始位置，即第 0 个索引。 \n\n    如果执行上述操作能够得到排序后的数组\n    然后返回 True，否则返回 False。\n    如果给定数组为空则返回 True。\n\n    注意：保证给定的列表具有唯一的元素。\n\n    例如：\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    说明：通过执行2次右移操作，可以实现非降序排列。\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    说明：不可能获得给定的非递减顺序\n                数组通过执行任意数量的右移操作。\n                \n    \"\"\""]}
{"text": ["def exchange(lst1, lst2):\n    \"\"\"在这个问题中，你将实现一个函数，该函数接受两个数字列表，\n    并确定是否可以在它们之间交换元素，\n    使得 lst1 成为一个仅包含偶数的列表。\n    在 lst1 和 lst2 之间交换元素的数量没有限制。\n    如果可以在 lst1 和 lst2 之间交换元素，使得\n    lst1 的所有元素都是偶数，返回 \"YES\"。\n    否则，返回 \"NO\"。\n    例如：\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n    假设输入的列表都是非空的。\n    \"\"\"", "def exchange(lst1, lst2):\n    \"\"\"在此问题中，您将实现一个函数，该函数接受两个数字列表，\n    并确定是否可以在它们之间进行元素交换，\n    以使 lst1 成为仅包含偶数的列表。\n    lst1 和 lst2 之间交换元素的数量没有限制。\n    如果可以在 lst1 和 lst2 之间交换元素，\n    使 lst1 的所有元素都为偶数，则返回“YES”。\n    否则，返回“NO”。\n    例如：\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n    假设输入列表为非空。\n    \"\"\"", "def exchange(lst1, lst2):\n    \"\"\"在这个问题中，你将实现一个函数，该函数接受两个数字列表，\n    判断是否可以在它们之间进行元素交换，\n    使得 lst1 成为一个仅包含偶数的列表。\n    在 lst1 和 lst2 之间交换元素的数量没有限制。\n    如果可以在 lst1 和 lst2 之间交换元素，使得\n    lst1 的所有元素都是偶数，返回 \"YES\"。\n    否则，返回 \"NO\"。\n    例如：\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n     It is assumed that the input lists will be non-empty.\n    \"\"\""]}
{"text": ["def histogram(test):\n    \"\"\"给定一个以空格分隔的小写字母字符串，返回一个字典，\n    其中包含重复次数最多的字母及其对应的计数。\n    如果有多个字母具有相同的出现次数，返回所有这些字母。\n    \n    示例：\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\"", "def histogram(test):\n    \"\"\"给定一个表示空格分隔的小写字母的字符串，返回一个字典，其中包含重复次数最多且包含相应计数的字母。\n    如果多个字母出现次数相同，则返回所有字母。\n\n    示例：\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\"", "def histogram(test):\n    \"\"\"给定一个表示以空格分隔的小写字母的字符串，返回一个字典，\n    其中包含重复次数最多的字母及其对应的计数。\n    如果有多个字母具有相同的出现次数，返回所有这些字母。\n\n    示例：\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\""]}
{"text": ["def reverse_delete(s,c):\n    \"\"\"任务\n    给定两个字符串 s 和 c，你需要删除 s 中所有等于 c 中任意字符的字符\n    然后检查结果字符串是否为回文。\n    如果一个字符串正反读都一样，则称其为回文。\n    你应该返回一个包含结果字符串和检查结果 True/False 的元组。\n    示例\n    对于 s = \"abcde\", c = \"ae\"，结果应为 ('bcd',False)\n    对于 s = \"abcdef\", c = \"b\"，结果应为 ('acdef',False)\n    对于 s = \"abcdedcba\", c = \"ab\"，结果应为 ('cdedc',True)\n    \"\"\"", "def reverse_delete(s,c):\n    \"\"\"任务\n    给定两个字符串 s 和 c，您必须删除 s 中与 c 中的任何字符相同的所有字符\n    然后检查结果字符串是否为回文。\n    如果字符串从后往前读和从前往后读都一样，则该字符串称为回文。\n    您应该返回一个包含结果字符串和 True/False 的元组以供检查。\n    示例\n    对于 s = \"abcde\", c = \"ae\"，结果应为 ('bcd',False)\n    对于 s = \"abcdef\", c = \"b\"，结果应为 ('acdef',False)\n    对于 s = \"abcdedcba\", c = \"ab\"，结果应为 ('cdedc',True)\n    \"\"\"", "def reverse_delete(s,c):\n    \"\"\"任务\n    我们给出两个字符串 s 和 c，你必须删除 s 中与 c 中任意字符相同的所有字符\n    然后检查结果字符串是否为回文。\n    如果一个字符串从后往前读和从前往后读都一样，则该字符串称为回文。\n    你应该返回一个包含结果字符串和 True/False 的元组以供检查。\n    示例\n    对于 s = \"abcde\", c = \"ae\"，结果应为 ('bcd',False)\n    对于 s = \"abcdef\", c = \"b\"，结果应为 ('acdef',False)\n    对于 s = \"abcdedcba\", c = \"ab\"，结果应为 ('cdedc',True)\n    \"\"\""]}
{"text": ["def odd_count(lst):\n    \"\"\"给定一个字符串列表，其中每个字符串仅由数字组成，返回一个列表。\n    输出的每个元素 i 应为“输入字符串 i 中奇数元素的个数”。其中所有 i 都应替换为输入的第 i 个字符串中的奇数数字的数量。\n\n    >>> odd_count(['1234567'])\n    [\"输入中字符串 4 中奇数元素的数量。\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"输入中字符串 1 中奇数元素的数量.\",\n    \"输入中字符串 8 中奇数元素的数量.\"]\n    \"\"\"", "def odd_count(lst):\n    \"\"\"给定一个字符串列表，其中每个字符串仅由数字组成，返回一个列表。\n    输出的每个元素 i 应为“输入的字符串 i 中奇数元素的数量”。其中所有 i 都应替换为\n    输入的第 i 个字符串中的奇数数字的数量。\n\n    >>> odd_count(['1234567'])\n    [\"输入的字符串 4 中的奇数元素的数量。\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"输入的字符串 1 中的奇数元素的数量。\",\n    \"输入的字符串 8 中的奇数元素的数量。\"]\n    \"\"\"", "def odd_count(lst):\n    \"\"\"给定一个字符串列表，其中每个字符串仅由数字组成，返回一个列表。\n    输出的每个元素 i 应为“输入字符串i中奇数元素的数量。” 其中所有的 i 应替换为\n    输入中第 i 个字符串中的奇数数字的数量。\n\n    >>> odd_count(['1234567'])\n    [\"输入中字符串 4 中奇数元素的数量。\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"输入中字符串 1 中奇数元素的数量。\",\n     \"输入中字符串 8 中奇数元素的数量。\"]\n    \"\"\""]}
{"text": ["def minSubArraySum(nums):\n    \"\"\"\n    给定一个整数数组 nums，找出 nums 中任意非空子数组的最小和。\n    示例\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\"", "def minSubArraySum(nums):\n    \"\"\"\n    给定一个整数数组nums，求nums的任何非空子数组\n    的最小和。\n    示例\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\"", "def minSubArraySum(nums):\n    \"\"\"\n    给定一个整数数组 nums，找到 nums 的任意非空\n    子数组的最小和。\n    示例\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\""]}
{"text": ["import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    给定一个矩形井的网格。每一行代表一个井，\n    每行中的每个1代表一个单位的水。\n    每个井都有一个对应的桶可以用来从中抽水，\n    所有的桶都有相同的容量。\n    你的任务是使用桶来清空这些井。\n    输出需要放下桶的次数。\n\n    示例 1:\n        输入: \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        输出: 6\n\n    示例 2:\n        输入: \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        输出: 5\n    \n    示例 3:\n        输入: \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        输出: 0\n\n    约束条件:\n        * 所有井的长度相同\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[:,1].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\"", "import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    给定一个矩形网格的水井。每一行代表一个水井，\n    每一行中的1表示一个水单位。\n    每个水井都有一个相应的水桶，可以用来从水井中提取水，\n    所有水桶的容量相同。\n    你的任务是使用水桶来清空水井。\n    输出你需要降低水桶的次数。\n\n    示例 1：\n        输入： \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        输出：6\n\n    示例 2：\n        输入： \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        输出：5\n    \n    示例 3：\n        输入： \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        输出：0\n\n    约束条件：\n        * 所有水井的长度相同\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[:,1].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\"", "import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    给定一个矩形井的网格。每一行代表一个井，\n    每行中的每个1代表一个单位的水。\n    每个井都有一个对应的桶可以用来从中抽水，\n    所有的桶都有相同的容量。\n    你的任务是使用桶来清空这些井。\n    输出需要放下桶的次数。\n\n    示例  1:\n        Input: \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        Output: 6\n\n    示例  2:\n        Input: \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        Output: 5\n    \n    示例  3:\n        Input: \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        Output: 0\n\n    约束条件:\n        * 所有井的长度相同\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[:,1].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\""]}
{"text": ["def sort_array(arr):\n    \"\"\"\n    在这个编程挑战 (Kata)中，你需要根据二进制表示中1的数量对非负整\n    数数组进行升序排序。\n    对于相同数量的1，按十进制值排序。\n\n    必须这样实现：\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]\n    \"\"\"", "def sort_array(arr):\n    \"\"\"\n    在这个 Kata 中，您必须根据二进制表示中的 1 的数量按升序对非负整数数组进行排序。\n    对于相同数量的 1，则根据十进制值排序。\n\n    它必须像这样实现：\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) ==  [0, 1, 2, 3, 4]\n    \"\"\"", "def sort_array(arr):\n    \"\"\"\n    在这个Kata编程练习中，你需要根据二进制表示中1的数量对非负整数数组进行升序排序。\n    对于相同数量的1，按十进制值排序。\n\n    必须这样实现：\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]\n    \"\"\""]}
{"text": ["def select_words(s, n):\n    \"\"\"给定一个字符串 s 和一个自然数 n，你需要实现一个函数，\n    返回一个列表，其中包含字符串 s 中所有恰好包含 n 个辅音的单词，\n    按照这些单词在字符串 s 中出现的顺序。\n    如果字符串 s 为空，则函数应返回一个空列表。\n    注意：你可以假设输入字符串只包含字母和空格。\n    示例：\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\"", "def select_words(s, n):\n    \"\"\"给定一个字符串 s 和一个自然数 n，请编写一个函数，\n    需输出一个列表，其中包含字符串 s 中所有辅音个数为n的单词，\n    这些单词在字符串 s 中按先后顺序出现。\n    如果字符串 s 为空，则输出一个空列表。\n    注：假设输入字符串只包含字母和空格。\n    示例：\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\"", "def select_words(s, n):\n    \"\"\"给定一个字符串 s 和一个自然数 n，你需要实现一个函数，\n    返回一个列表，其中包含字符串 s 中所有恰好包含 n 个辅音的单词，\n    按照这些单词在字符串 s 中出现的顺序。\n    如果字符串 s 为空，则函数应返回一个空列表。\n    注意：你可以假设输入字符串只包含字母和空格。\n    示例：\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\""]}
{"text": ["def get_closest_vowel(word):\n    \"\"\"给定一个单词。你的任务是找到一个位于两个辅音之间的最接近的元音，\n    从单词的右侧开始（区分大小写）。\n    \n    开头和结尾的元音不算。如果没有找到符合\n    上述条件的元音，返回空字符串。\n\n    你可以假设给定的字符串只包含英文字母。\n\n    示例：\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\"", "def get_closest_vowel(word):\n    \"\"\"给定一个单词。你的任务是从该单词的右侧找到位于两个辅音之间的距离最近的元音，\n    （区分大小写）。\n    \n    开头和结尾的元音不算。如果没有找到符合上述条件的元音，返回空字符串。\n\n    你可以假设给定的字符串只包含英文字母。\n\n    示例：\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\"", "def get_closest_vowel(word):\n    \"\"\"给定一个单词。您的任务是找到单词右侧两个辅音之间最接近的元音（区分大小写）。\n\n    开头和结尾的元音不计算在内。如果未找到满足上述条件的元音，则返回空字符串。\n\n    您可以假设给定的字符串仅包含英文字母。\n\n    示例：\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\""]}
{"text": ["def match_parens(lst):\n    '''\n    给你一个包含两个字符串的列表，两个字符串都只包含开括号 '(' 或闭括号 ')'。\n    你的职责是检查是否可以按某种顺序连接这两个字符串，以确保生成的字符串是好的。\n    当且仅当 S 中的所有括号都匹配时，字符串 S 才被认为是好的。例如：字符串 '(())()' 是好的，而字符串 '())' 不是。\n    如果有办法生成好的字符串，则返回 'Yes'，否则返回 'No'。\n\n    示例：\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''", "def match_parens(lst):\n    '''\n    给定一个包含两个字符串的列表，两个字符串都只由左\n    括号 '(' 或右括号 ')' 组成。\n    你的任务是检查是否可以通过某种顺序连接这两个字符串，\n    使得结果字符串是好的。\n    当且仅当字符串 S 中的所有括号都是平衡的时，字符串 S \n    被认为是好的。例如：字符串 '(())()' 是好的，而字符串 \n    '())' 不是。\n    如果有办法构造一个好的字符串，返回 'Yes'，否则返回 'No'。\n\n    示例：\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''", "def match_parens(lst):\n    '''\n    给定一个包含两个字符串的列表，两个字符串都只由左括号 '(' 或右括号 ')' 组成。\n    你的任务是检查是否可以通过某种顺序连接这两个字符串，\n    使得结果字符串是好的。\n    当且仅当字符串 S 中的所有括号都是成对时，字符串 S 被认为是好的。\n    例如：字符串 '(())()' 是好的，而字符串 '())' 不是。\n    如果有办法构造一个好的字符串，返回 'Yes'，否则返回 'No'。\n\n    示例：\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''"]}
{"text": ["def maximum(arr, k):\n    \"\"\"\n    给定一个整数数组 arr 和一个正整数 k，返回一个长度为 k 的排序列表，\n    其中包含 arr 中最大的 k 个数字。\n\n    示例 1：\n\n        输入: arr = [-3, -4, 5], k = 3\n        输出: [-4, -3, 5]\n\n    示例 2：\n\n        输入: arr = [4, -4, 4], k = 2\n        输出: [4, 4]\n\n    示例 3：\n\n        输入: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n        输出: [2]\n\n    注意:\n        1. 数组的长度将在 [1, 1000] 的范围内。\n        2. 数组中的元素将在 [-1000, 1000] 的范围内。\n        3. 0 <= k <= len(arr)\n    \"\"\"", "def maximum(arr, k):\n    \"\"\"\n    给定一个整数数组arr和一个正整数k，返回一个长度为k的排序列表，\n    其中包含arr中最大的k个数字。\n\n    示例1:\n\n        Input: arr = [-3, -4, 5], k = 3\n        Output: [-4, -3, 5]\n\n    示例2:\n\n        Input: arr = [4, -4, 4], k = 2\n        Output: [4, 4]\n\n    示例3:\n\n        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n        Output: [2]\n\n    注意事项:\n        1. 数组的长度将在 [1, 1000] 的范围内。\n        2.  数组中的元素将在 [-1000, 1000] 的范围内。\n        3. 0 <= k <= len(arr)\n    \"\"\"", "def maximum(arr, k):\n    \"\"\"\n    给定一个整数数组 arr 和一个正整数 k，返回一个长度为 k 的排序列表，其中包含 arr 中的最大 k 个数字。\n\n    示例 1:\n\n    输入：arr = [-3, -4, 5], k = 3\n    输出：[-4, -3, 5]\n\n    示例 2:\n\n    输入：arr = [4, -4, 4], k = 2\n    输出：[4, 4]\n\n    示例 3:\n\n    输入：arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n    输出：[2]\n\n    注意：\n    1. 数组的长度将在 [1, 1000] 范围内。\n    2. 数组中的元素将在 [-1000, 1000] 范围内。\n    3. 0 <= k <= len(arr)\n    \"\"\""]}
{"text": ["def solution(lst):\n    \"\"\"给定一个非空的整数列表，返回所有位于偶数位置的奇数元素的总和。\n\n    示例\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==>0\n    \"\"\"", "def solution(lst):\n    \"\"\"给定一个非空整数列表，返回所有位于偶数位置的奇数元素的和。\n    \n\n    示例\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==>0\n    \"\"\"", "def solution(lst):\n    “”“给定一个非空整数列表，返回所有位于偶数位置的奇数元素的和。\n    \n    例子\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==>0\n    \"\"\""]}
{"text": ["def add_elements(arr, k):\n    \"\"\"\n    给定一个非空的整数数组 arr 和一个整数 k，返回 arr 的前 k 个元素中最多两位数的元素之和。\n\n    示例：\n\n    输入：arr = [111,21,3,4000,5,6,7,8,9], k = 4\n    输出：24 # 21 + 3 之和\n\n    约束：\n    1. 1 <= len(arr) <= 100\n    2. 1 <= k <= len(arr)\n    \"\"\"", "def add_elements(arr, k):\n    \"\"\"\n    给定一个非空整数数组 arr 和一个整数 k，返回\n    arr 的前 k 个元素中最多有两位数的元素的和。\n\n    示例：\n\n          Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n        Output: 24 # sum of 21 + 3\n\n    Constraints:\n        1. 1 <= len(arr) <= 100\n        2. 1 <= k <= len(arr)\n    \"\"\"", "def add_elements(arr, k):\n    \"\"\"\n    给定一个非空整数数组 arr 和一个整数 k，返回\n    arr 的前 k 个元素中最多有两位数的元素的和。\n\n    示例：\n\n          输入: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n          输出: 24 # 21 + 3 的和\n\n    约束条件:\n        1. 1 <= len(arr) <= 100\n        2. 1 <= k <= len(arr)\n    \"\"\""]}
{"text": ["def get_odd_collatz(n):\n    \"\"\"\n    给定一个正整数 n，返回一个排序后的列表，其中包含 collatz 序列中的奇数。\n\n    Collatz 猜想是数学中的一个猜想，涉及一个序列的定义如下：从任何正整数 n 开始。\n    然后每一项是从前一项得到的，规则如下：如果前一项是偶数，下一项是前一项的一半。\n    如果前一项是奇数，下一项是前一项的 3 倍加 1。猜想是无论 n 的值是多少，序列总会到达 1。\n\n    注意：\n    1. Collatz(1) 是 [1]。\n    2. 返回的列表按升序排序。\n\n    例如：\n    get_odd_collatz(5) returns [1, 5] # 5 的 collatz 序列是[5, 16, 8, 4, 2, 1], 因此奇数只有 1 和 5.\n    \"\"\"", "def get_odd_collatz(n):\n    \"\"\"\n    给定一个正整数 n，返回一个包含 collatz 序列中奇数的排序列表。\n\n    Collatz 猜想是数学中的一个猜想，它涉及一个定义如下的序列：从任何正整数 n 开始。然后从前一项获得每一项，如下所示：如果前一项为偶数，则下一项为前一项的一半。如果前一项是奇数，则下一项是前一项的 3 倍加 1。猜想是无论 n 是什么值，序列总会达到 1。\n\n    注意：\n    1. Collatz(1) 为 [1]。\n    2. 返回按升序排序的列表。\n\n    例如：\n    get_odd_collatz(5) 返回 [1, 5] # 5 的 collatz 序列为 [5, 16, 8, 4, 2, 1]，所以奇数只有 1 和 5.\n    “””", "def get_odd_collatz(n):\n    \"\"\"\n    给定一个正整数 n，返回一个排序后的列表，其中包含 collatz 序列中的奇数。\n\n    Collatz 猜想是数学中的一个猜想，涉及一个序列的定义\n    如下：从任何正整数 n 开始。然后每一项是从前一项\n    得到的，规则如下：如果前一项是偶数，下一项是\n    前一项的一半。如果前一项是奇数，下一项是前一项的 3 倍\n    加 1。猜想是无论 n 的值是多少，序列总会到达 1。\n\n    注意：\n        1. Collatz(1) 是 [1]。\n        2. 返回的列表按升序排序。\n\n    例如：\n    get_odd_collatz(5) 返回 [1, 5] # 5 的 collatz 序列是 [5, 16, 8, 4, 2, 1]，所以奇数只有 1 和 5。\n    \"\"\""]}
{"text": ["def valid_date(date):\n    \"\"\"你需要编写一个函数来验证给定的日期字符串，\n    如果日期有效则返回True，否则返回False。\n    如果满足以下所有规则，则日期有效：\n    1. 日期字符串不能为空。\n    2. 对于月份1,3,5,7,8,10,12，天数不少于1且不多于31天。对于月份4,6,9,11，天数不少于1且不多于30天。对于月份2，天数不少于1且不多于29天。\n    3. 月份不应小于1或大于12。\n    4. 日期格式应为：mm-dd-yyyy\n\n    例如：\n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n\n    valid_date('06/04/2020') => False\n    \"\"\"", "def valid_date(date):\n    \"\"\"您必须编写一个函数来验证给定的日期字符串，并且\n\n    如果日期有效则返回 True，否则返回 False。\n\n    如果满足以下所有规则，则日期有效：\n    1. 日期字符串不为空。\n    2. 对于 1、3、5、7、8、10、12 月份，天数不少于 1 天或高于 31 天。对于 4、6、9、11 月份，天数不少于 1 天或高于 30 天。对于 2 月份，天数不少于 1 天或高于 29 天。\n    3. 月份不应少于 1 或高于 12。\n    4. 日期应采用以下格式：mm-dd-yyyy\n\n    例如：\n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n\n    valid_date('06/04/2020') => False\n    \"\"\"", "def valid_date(date):\n    \"\"\"您必须编写一个函数来验证给定的日期字符串，并且\n    如果日期有效则返回 True，否则返回 False。\n    如果满足以下所有规则，则日期有效：\n    1. 日期字符串不为空。\n    2. 对于 1、3、5、7、8、10、12 月份，天数不少于 1 天或高于 31 天。对于 4、6、9、11 月份，天数不少于 1 天或高于 30 天。对于 2 月        \n    份，天数不少于 1 天或高于 29 天。\n    3. 月份不应少于 1 天或高于 12 天。\n    4. 日期应采用以下格式：mm-dd-yyyy\n\n    例如：\n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n    \n    valid_date('06/04/2020') => False\n    \"\"\""]}
{"text": ["def split_words(txt):\n    '''\n    给定一个单词字符串，返回按空格拆分的单词列表，如果文本中不存在空格，则应按逗号 ',' 拆分，如果不存在逗号，则应返回字母表中的奇数序号的小写字母的数量，ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n    示例\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3\n    '''", "def split_words(txt):\n    '''\n    给定一个单词字符串，返回按空格拆分的单词列表，如果文本中不存在空格，则应按逗号 ',' 拆分，如果不存在逗号，则应返回字母表中奇数顺序的小写字母的数量，ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n    示例\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3\n    '''", "def split_words(txt):\n    '''\n    给定一个单词字符串，返回一个按空格分割的单词列表，如果文本中不存在空格，\n    则应按逗号 ',' 分割，如果不存在逗号，则应返回字母表中奇数顺序的小写字母的数量，\n    ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n    示例\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3 \n    '''"]}
{"text": ["def is_sorted(lst):\n    '''\n    给定一个数字列表，返回它们是否按升序排序。如果列表中有超过1个相同的数字，返回False。假设没有负数，只有整数。\n\n    示例\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''", "def is_sorted(lst):\n    '''\n    给定一个数字列表，返回它们是否按升序排序。如果列表中有多个相同数字的重复项，则返回 False。假设没有负数，只有整数。\n\n    示例\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''", "def is_sorted(lst):\n    '''\n    给定一个数字列表，返回它们是否按升序排列。\n    如果列表中有超过1个相同数字的重复，返回False。\n    假设没有负数，并且只有整数。\n\n    示例\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''"]}
{"text": ["def intersection(interval1, interval2):\n    \"\"\"给定两个区间，\n    每个区间是一个整数对。例如，区间 = (start, end) = (1, 2)。\n    给定的区间是闭区间，这意味着区间 (start, end)\n    包括 start 和 end。\n    对于每个给定的区间，假设其 start 小于或等于其 end。\n    你的任务是确定这两个区间的交集长度是否是一个质数。\n    例如，区间 (1, 3) 和 (2, 4) 的交集是 (2, 3)，\n    其长度为 1，不是质数。\n    如果交集的长度是质数，返回 \"YES\"，\n    否则，返回 \"NO\"。\n    如果两个区间不相交，返回 \"NO\"。\n\n\n    [输入/输出] 示例:\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    \"\"\"", "def intersection(interval1, interval2):\n    \"\"\"给定两个区间，\n    每个区间是一个整数对。例如，区间 = (start, end) = (1, 2)。\n    给定的区间是闭区间，这意味着区间 (start, end)\n    包括起始点和结束点。\n    对于每个给定的区间，假设其起始点小于或等于结束点。\n    你的任务是确定这两个区间的交集的长度\n    是否是一个质数。\n    例如，区间 (1, 3)、(2, 4) 的交集是 (2, 3)\n    其长度是 1，1 不是质数。\n    如果交集的长度是质数，返回 \"YES\"，\n    否则，返回 \"NO\"。\n    如果两个区间没有交集，返回 \"NO\"。\n\n\n    [输入/输出] 示例：\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    \"\"\"", "def Intersection(interval1, interval2):\n    \"\"\"给定两个区间，\n    其中每个区间是一对整数。例如，区间 = (start, end) = (1, 2)。\n    给定的区间是封闭的，这意味着区间 (start, end)\n    包括 start 和 end。\n    对于每个给定的区间，假设其 start 小于或等于其 end。\n    您的任务是确定这两个区间的交集长度是否为素数。\n    例如，区间 (1, 3)、(2, 4) 的交集为 (2, 3)\n    其长度为 1，不是素数。\n    如果交集的长度是素数，则返回“YES”，\n    否则，返回“NO”。\n    如果两个区间不相交，则返回“NO”。\n\n    [输入/输出] 样本：\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    “””"]}
{"text": ["def prod_signs(arr):\n    \"\"\"\n    给定一个整数数组 arr，您需要返回\n    整数的绝对值之和，乘以所有数字符号的乘积，用 1、-1 或 0 表示。\n    注意：如果 arr 为空，则返回 None。\n\n    示例：\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\"", "def prod_signs(arr):\n    \"\"\"\n    你将得到一个整数数组 arr，你需要返回\n    数组中每个数字的绝对值乘以其符号的积，\n    符号由 1、-1 或 0 表示。\n    注意：如果 arr 为空，返回 None。\n\n    示例：\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\"", "def prod_signs(arr):\n    \"\"\"\n    给定一个整数数组 arr，你需要返回整数的绝对值之和，\n    和乘以每个数符号（用1、-1或0表示）的乘积。\n    注意：对于空数组返回 None。\n\n    示例：\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\""]}
{"text": ["def minPath(grid, k):\n    \"\"\"\n    给定一个具有 N 行和 N 列（N >= 2）的网格和一个正整数 k，\n    网格的每个单元格都包含一个值。范围 [1, N * N] 中的每个整数\n    只在网格的单元格上出现一次。\n\n    您必须在网格中找到长度为 k 的最小路径。您可以从\n    任何单元格开始，并且在每一步中，您可以移动到任何相邻单元格，\n    换句话说，您可以转到与当前单元格共享边缘的单元格。\n    请注意，长度为 k 的路径意味着访问恰好 k 个单元格（不一定是不同的）。\n    您不能离开网格。\n    如果在对 A 和 B 经过的单元格的值进行有序列表（我们将它们称为 lst_A 和 lst_B）后，lst_A 按字典顺序小于 lst_B，换句话说，存在一个整数 \n    索引 i，则认为路径 A（长度为 k）小于路径 B（长度为 k） (1 <= i <= k)\n    使得 lst_A[i] < lst_B[i] 并且对于任何 j (1 <= j < i)，我们有\n    lst_A[j] = lst_B[j]。\n    保证答案是唯一的。\n    返回最小路径经过的单元格上的值的有序列表。\n\n    示例：\n\n    输入：grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n    输出：[1, 2, 1]\n\n    输入：grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n    输出：[1]\n    \"\"\"", "def minPath(grid, k):\n    \"\"\"\n    给定一个有 N 行 N 列（N >= 2）和一个正整数 k 的网格、 \n    网格的每个单元格都包含一个值。在 [1, N * N] 范围内的每一个整数\n    都会在网格单元格中出现一次。\n\n    你必须找到网格中长度为 k 的最小路径。你可以\n    你可以从任何一个单元格开始，每一步都可以移动到任何一个相邻的单元格、\n    换句话说，你可以移动到与当前单元格共享一条边的单元格。\n    单元格。\n    请注意，一条长度为 k 的路径意味着要访问整整 k 个单元格（不一定是不同的）。\n    不一定完全相同）。\n    您不能离开网格。\n    如果出现以下情况，则认为长度为 k 的路径 A 小于长度为 k 的路径 B\n    将 A 和 B 经过的单元格上的值有序列出（我们称之为 l\n    让我们称它们为 lst_A 和 lst_B）后，lst_A 在词法上小于 lst_B，即 lst_A 小于 lst_B。\n    换句话说，存在一个整数索引 i（1 <= i <= k）\n    这样，lst_A[i] < lst_B[i]，并且对于任意 j（1 <= j < i），我们有\n    lst_A[j] = lst_B[j]。\n    保证答案是唯一的。\n    返回最小路径经过的单元格上的值的有序列表。\n\n    示例：\n\n        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n        Output: [1, 2, 1]\n\n        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n        Output: [1]\n    \"\"\"", "def minPath(grid, k):\n    \"\"\"\n    给定一个具有 N 行和 N 列（N >= 2）的网格和一个正整数 k，\n    网格的每个单元格包含一个值。范围 [1, N * N] 内的每个整数\n    在网格的单元格中出现一次。\n\n    你必须在网格中找到最小的路径，路径长度为 k。你可以从\n    任何单元格开始，在每一步中，你可以移动到任何相邻的\n    单元格，换句话说，你可以前往与当前单元格共享边的\n    单元格。\n    请注意，路径长度 k 意味着访问正好 k 个单元格（不一定\n    是不同的）。\n    你不能走出网格。\n    那么在按照 A 和 B 经过的单元格值的顺序列出\n    它们的值之后，（我们称之为 lst_A 和 lst_B），\n    lst_A 在字典序上小于 lst_B，换句话说，存在\n    一个整数索引 i（1 <= i <= k），使得\n    lst_A[i] < lst_B[i]，并且对于任何 \n    j（1 <= j < i），我们有\n    lst_A[j] = lst_B[j]。\n    保证答案是唯一的。\n    返回最小路径经过的单元格的值的有序列表。\n\n    示例：\n\n        输入: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n        输出: [1, 2, 1]\n\n        输入: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n        输出: [1]\n    \"\"\""]}
{"text": ["def tri(n):\n    \"\"\"每个人都知道斐波那契数列，数学家们在过去几个世纪里深入研究了它。\n    然而，人们不知道的是 Tribonacci 数列。\n    Tribonacci 数列由以下递归定义：\n    tri(1) = 3\n    tri(n) = 1 + n / 2，如果 n 是偶数。\n    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)，如果 n 是奇数。\n    例如：\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n           = 2 + 3 + 3 = 8 \n    给定一个非负整数 n，你需要返回 Tribonacci 数列的前 n + 1 个数字的列表。\n    示例：\n    tri(3) = [1, 3, 2, 8]\n    \"\"\"", "def tri(n):\n    \"\"\"每个人都知道斐波那契数列，在过去的几个世纪里，数学家们对它进行了深入研究。然而，人们不知道的是Tribonacci数列。Tribonacci数列由递归定义：\n    tri(1) = 3\n    tri(n) = 1 + n / 2，如果 n 为偶数。\n    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)，如果 n 为奇数。\n    例如：\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n    = 2 + 3 + 3 = 8\n    给定一个非负整数 n，你必须返回Tribonacci数列的前 n + 1 个数字的列表。\n    示例：\n    tri(3) = [1, 3, 2, 8]\n    “”", "def tri(n):\n    \"\"\"众所周知，斐波那契数列在过去几个世纪中被数学家深入研究。\n    然而，人们不知道的是三波那契数列。\n    三波那契数列由以下递推关系定义:\n    tri(1) = 3\n    tri(n) = 1 + n / 2, 如果 n 是偶数.\n    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), 如果 n 是奇数.\n    例如:\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n           = 2 + 3 + 3 = 8 \n    给定一个非负整数 n，你需要返回一个包含前 n + 1 个三波那契数列的列表.\n    示例:\n    tri(3) = [1, 3, 2, 8]\n    \"\"\""]}
{"text": ["def digits(n):\n    \"\"\"给定一个正整数 n，返回奇数位的乘积。\n    如果所有数字都是偶数，则返回 0。\n    例如：\n    digits(1) == 1\n    digits(4) == 0\n    digits(235) == 15\n    \"\"\"", "def digits(n):\n    “”\"给定一个正整数n，返回其奇数位的乘积。\n    如果所有数字都是偶数，则返回0。\n    例如:\n    digits(1)  == 1\n    digits(4)  == 0\n    digits(235) == 15\n    \"\"\"", "def digits(n):\n    \"\"\"给定一个正整数 n，返回奇数位的乘积。\n    如果所有位都是偶数，则返回 0。\n    例如：\n    digits(1)  == 1\n    digits(4)  == 0\n    digits(235) == 15\n    \"\"\""]}
{"text": ["def is_nested(string):\n    '''\n    创建一个函数，该函数以仅包含方括号的字符串作为输入。\n    ​​当且仅当存在有效的括号子序列时，该函数才应返回 True，其中至少有一个括号是嵌套的。\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''", "def is_nested(string):\n    '''\n    创建一个函数，该函数接受一个仅包含方括号的字符串作为输入。\n    该函数应当返回True当且仅当存在一个有效的括号子序列，\n    其中至少有一个括号在子序列中是嵌套的。\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''", "def is_nested(string):\n    '''\n    创建一个函数，该函数以仅包含方括号的字符串作为输入。\n    ​​当且仅当存在有效的括号子序列时，该函数才应返回 True，其中子序列中至少有一个括号是嵌套的。\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''"]}
{"text": ["def sum_squares(lst):\n    \"\"\"给定一个数字列表。\n    需要返回给定列表中平方数的和，\n    首先将列表中的每个元素向上取整。\n    示例：\n    对于 lst = [1,2,3] 输出应为 14\n    对于 lst = [1,4,9] 输出应为 98\n    对于 lst = [1,3,5,7] 输出应为 84\n    对于 lst = [1.4,4.2,0] 输出应为 29\n    对于 lst = [-2.4,1,1] 输出应为 6\n    \n\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"给定一个数字列表。\n    您需要返回给定列表中平方数的和，\n    首先将列表中的每个元素四舍五入到上整数（上限）。\n    示例：\n    对于 lst = [1,2,3] 输出应为 14\n    对于 lst = [1,4,9] 输出应为 98\n    对于 lst = [1,3,5,7] 输出应为 84\n    对于 lst = [1.4,4.2,0] 输出应为 29\n    对于 lst = [-2.4,1,1] 输出应为 6 \n    \n\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"您将获得一个数字列表。\n    您需要返回给定列表中数字的平方和，\n    首先将列表中的每个元素四舍五入到上限 int（Ceiling）。\n    示例：\n    对于 lst = [1,2,3]，输出应为 14\n    对于 lst = [1,4,9]，输出应为 98\n    对于 lst = [1,3,5,7]，输出应为 84\n    对于 lst = [1.4,4.2,0]，输出应为 29\n    对于 lst = [-2.4,1,1]，输出应为 6\n\n    \"\"\""]}
{"text": ["def check_if_last_char_is_a_letter(txt):\n    '''\n    创建一个函数，如果给定字符串的最后一个字符是字母字符且不是单词的一部分，则返回True，否则为False。\n    注意：“单词”是一组用空格分隔的字符。\n\n    示例：\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False \n    '''", "def check_if_last_char_is_a_letter(txt):\n    '''\n    创建一个函数，如果给定字符串的最后一个字符\n    是字母字符且不是单词的一部分，\n    则返回True，否则返回False。\n    注意：“单词”是由空格分隔的一组字符。\n\n    示例：\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False \n    '''", "def check_if_last_char_is_a_letter(txt):\n    '''\n    创建一个函数，如果给定字符串的最后一个字符是字母字符并且不是单词的一部分，则返回 True，否则返回 False。\n    注意：“单词”是一组用空格分隔的字符。\n\n    示例：\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False\n    '''"]}
{"text": ["def can_arrange(arr):\n    \"\"\"创建一个函数，返回元素的最大索引，该元素不大于或等于其前一个元素。如果不存在这样的元素，则返回 -1。给定的数组将不包含重复的值。\n\n    示例：\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\"", "def can_arrange(arr):\n    \"\"\"创建一个函数，返回一个元素的最大索引，该元素不大于或等于其前面的元素。\n    如果不存在这样的元素，则返回 -1。给定的数组不包含重复值。\n\n    示例:\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\"", "def can_arrange(arr):\n    \"\"\"创建一个函数，返回一个元素的最大索引，\n    该元素不大于或等于其前面的元素。如果\n    不存在这样的元素，则返回 -1。给定的数组不包含\n    重复值。\n\n    示例:\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\""]}
{"text": ["def largest_smallest_integers(lst):\n    '''\n    创建一个返回一个tuple（a, b）的函数，\n    其中‘a’是列表中最大的负整数，‘b’是列表中最小的正整数。\n    如果没有正负整数，\n    则返回None。\n\n    示例：\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''", "def largest_smallest_integers(lst):\n    '''\n    创建一个函数，返回一个元组 (a, b)，其中 'a' 是\n    负整数中最大的值，而 'b' 是\n    列表中正整数中最小的值。\n    如果列表中没有负整数或正整数，则将它们作为 None 返回。\n\n    示例：\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''", "def largest_smallest_integers(lst):\n    '''\n    创建一个返回元组 (a, b) 的函数，其中 “a ”是最大的负整数，“b ”是最小的正整数。\n    如果没有负整数或正整数，则返回 None。\n\n    示例：\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''"]}
{"text": ["def compare_one(a, b):\n    \"\"\"\n    创建一个函数，接受整数、浮点数或表示实数的字符串，\n    并返回较大的变量，保持其原有的变量类型。\n    如果值相等，则返回 None。\n    注意：如果实数表示为字符串，浮点可能是 . 或 ,\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\"", "def compare_one（a， b）：\n    \"\"\"\n    创建一个函数，该函数采用整数、浮点数或字符串表示\n    实数，并返回其给定变量类型中的较大变量。\n    如果值相等，则返回 None。\n    注意：如果实数表示为字符串，则浮点数可能是 。或，\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\"", "def compare_one(a, b):\n    \"\"\"\n    创建一个函数，传入整数、浮点数或代表实数的字符串，\n    返回值较大的变量，并保持其原有的变量类型。\n    如果值相等，则返回 None。\n    注意：如果实数表示为字符串，浮点可能是“.” 或 “,”\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\""]}
{"text": ["def is_equal_to_sum_even(n):\n    \"\"\"评估给定的数字 n 是否可以表示为恰好 4 个正偶数的和\n    示例\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\"", "def is_equal_to_sum_even(n):\n    \"\"\"评估给定数字 n 是否可以写成恰好 4 个正偶数的总和\n    示例\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\"", "def is_equal_to_sum_even(n):\n    \"\"\"评估给定的数n是否可以写成正好4个正偶数之和\n    示例\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\""]}
{"text": ["def special_factorial(n):\n    \"\"\"巴西阶乘定义为：\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    其中 n > 0\n\n    例如：\n    >>> special_factorial(4)\n    288\n\n    该函数将接收一个整数作为输入，并应返回该整数的特殊阶乘。\n    \"\"\"", "def special_factorial(n):\n    \"\"\"巴西阶乘的定义是：\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    其中 n > 0\n\n    例如：\n    >>> special_factorial(4)\n    288\n\n    函数将接收一个整数作为输入，并返回该整数的特殊\n    阶乘。\n    \"\"\"", "def special_factorial(n):\n    \"\"\"巴西阶乘定义为：\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    其中 n > 0\n\n    例如：\n    >>> special_factorial(4)\n    288\n\n    该函数将接收一个整数作为输入，并应返回该整数的\n    特殊阶乘。\n    \"\"\""]}
{"text": ["def fix_spaces(text):\n    \"\"\"\n    给定一个字符串 text，将其中的所有空格替换为下划线，\n    如果字符串中有超过2个连续空格，\n    则将所有连续空格替换为-\n    \n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example   3\") == \"_Example-3\"\n    \"\"\"", "def fix_spaces(text):\n    \"\"\"\n    给定一个字符串文本，将其中的所有空格替换为下划线，\n    如果字符串中有超过2个连续空格，\n    则将所有连续空格替换为-\n    \n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example   3\") == \"_Example-3\"\n    \"\"\"", "def fix_spaces(text):\n    \"\"\"\n    给定一个字符串 text，将其中的所有空格替换为下划线，\n    如果字符串中有超过 2 个连续的空格，\n    则将所有连续的空格替换为 -\n\n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example 3\") == \"_Example-3\"\n    \"\"\""]}
{"text": ["def file_name_check(file_name):\n    \"\"\"创建一个函数，该函数接受一个表示文件名的字符串，如果文件名有效，则返回\n    “是”，否则返回“否”。\n    当且仅当满足以下所有条件时，文件名才被视为有效：\n    - 文件名中的数字不应超过三位（'0'-'9'）。\n    - 文件名只包含一个点“.”\n    - 点之前的子字符串不应为空，并且以拉丁字母 ('a'-'z' 和 'A'-'Z') 中的字母开头。\n    - 点后的子字符串应为以下之一：['txt', 'exe', 'dll']\n    示例：\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No'（名称应以拉丁字母开头）\n    \"\"\"", "def file_name_check(file_name):\n    \"\"\"创建一个函数，该函数接受一个表示文件名的字符串，如果文件名有效，则返回\n    “Yes”，否则返回“No”。\n    当且仅当满足以下所有条件时，文件名才被视为有效：\n    - 文件名中的数字不应超过三位（'0'-'9'）。\n    - 文件名只包含一个点“。”\n    - 点之前的子字符串不应为空，并且以拉丁字母 ('a'-'z' 和 'A'-'Z') 中的字母开头。\n    - 点后的子字符串应为下列之一：['txt', 'exe', 'dll']\n    示例：\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No'（名称应以拉丁字母开头）\n    \"\"\"", "def file_name_check(file_name):\n    \"\"\"创建一个函数，接受一个表示文件名的字符串，并返回\n    'Yes' 如果文件名有效，若无效则返回 'No'。\n    文件名被认为有效，当且仅当满足以下所有\n    条件时：\n    - 文件名中不能有超过三个数字（'0'-'9'）。\n    - 文件名中必须恰好包含一个点 '.'。\n    - 点之前的子串不能为空，并且它必须以拉丁字母（'a'-'z' 和 'A'-'Z'）\n    开头。\n    - 点之后的子串应该是以下之一：['txt', 'exe', 'dll']。\n    示例：\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No' （文件名应该以拉丁字母开头）\n    \"\"\""]}
{"text": ["def sum_squares(lst):\n    \"\"\"\"\n    这个函数将接收一个整数列表。对于列表中的所有项，如果其索引是3的倍数，函数将对整数条目进行平方；\n    如果其索引是4的倍数且不是3的倍数，函数将对整数条目进行立方。对于索引不是3或4的倍数的列表元素，函数将不做改变。\n    然后函数将返回所有条目的和。\n    \n    示例：\n    对于 lst = [1,2,3] 输出应为 6\n    对于 lst = [] 输出应为 0\n    对于 lst = [-1,-5,2,-1,-5] 输出应为 -126\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"\"\n    这个函数将接受一个整数列表。对于列表中的所有项，如果索引是3的倍数，则将该项平方，\n    如果索引是4的倍数但不是3的倍数，则将该项立方。对于索引不是3或4的倍数的项，函数将不做改变。\n    然后，函数将返回所有项的和。\n    \n    示例：\n    对于 lst = [1,2,3] 输出应该是 6\n    对于 lst = [] 输出应该是 0\n    对于 lst = [-1,-5,2,-1,-5] 输出应该是 -126\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"\"\n    此函数将接收一个整数列表。对于列表中的所有条目，如果其索引是3的倍数，函数将对整数条目进行平方；\n    如果其索引是4的倍数且不是3的倍数，函数将对整数条目进行立方。函数不会改变索引不是3或4倍数的列表条目。\n    然后函数将返回所有条目的和。\n    \n    示例：\n    对于 lst = [1,2,3] 输出应为 6\n    对于 lst = []  输出应为 0\n    对于 lst = [-1,-5,2,-1,-5]  输出应为 -126\n    \"\"\""]}
{"text": ["def words_in_sentence(sentence):\n    \"\"\"\n    给定一个表示句子的字符串，\n    句子包含一些由空格分隔的单词，\n    你需要返回一个包含原句子中长度为质数的单词的字符串，\n    新字符串中单词的顺序应该与原句相同。\n\n    示例 1：\n        输入：sentence = \"This is a test\"\n        输出：\"is\"\n\n    示例 2：\n        输入：sentence = \"lets go for swimming\"\n        输出：\"go for\"\n\n    约束条件：\n        * 1 <= len(sentence) <= 100\n        * sentence 只包含字母\n    \"\"\"", "def words_in_sentence(sentence):\n    \"\"\"\n    给你一个表示句子的字符串，\n    该句子包含一些由空格分隔的单词，\n    你必须返回一个包含原始句子中的单词的字符串，\n    其长度为素数，\n    新字符串中单词的顺序应与原始字符串相同。\n\n    示例 1：\n    输入：sentence = \"This is a test\"\n    输出：\"is\"\n\n    示例 2：\n    输入：sentence = \"lets go for swimming\"\n    输出：\"go for\"\n\n    约束：\n    * 1 <= len(sentence) <= 100\n    * 句子仅包含字母\n    \"\"\"", "def words_in_sentence(sentence):\n    \"\"\"\n    给定一个表示句子的字符串，\n    句子包含一些用空格分隔的单词，\n    你需要返回一个字符串，其中包含原句中长度为质数的单词，\n    新字符串中单词的顺序应与原句相同。\n\n    示例 1:\n        输入: sentence = \"This is a test\"\n        输出: \"is\"\n\n    示例 2:\n        输入: sentence = \"lets go for swimming\"\n        输出: \"go for\"\n\n    约束条件:\n        * 1 <= len(sentence) <= 100\n        * 句子只包含字母\n    \"\"\""]}
{"text": ["def simplify(x, n):\n    \"\"\"你的任务是实现一个函数，用于简化表达式 x * n。\n    如果 x * n 计算结果为整数，函数返回 True，否则返回 False。\n    x 和 n 都是分数的字符串表示形式，格式如下：\n    <分子>/<分母>，其中分子和分母都是正整数。\n\n    你可以假设 x 和 n 是有效的分数，并且分母不为零。\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\"", "def simplify(x, n):\n    \"\"\"你的任务是实现一个函数，用于简化表达式 x * n。\n    如果 x * n 计算结果为整数，函数返回 True，否则返回 False。\n    x 和 n 都是分数的字符串表示形式，格式如下：\n    <分子>/<分母>，其中分子和分母都是正整数。\n\n    你可以假设 x 和 n 是有效的分数，并且分母不为零。\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\"", "def simplify((x, n):\n    \"\"\"您的任务是实现一个函数来简化表达式\n    x * n。如果x * n的计算结果为整数，则该函数返回 True，否则返回 False。x 和 n 都是分数的字符串表示，格式如下，\n    <numerator>/<denominator>，其中分子和分母都是正整数。\n\n    您可以假设 x 和 n 是有效分数，并且分母不为零。\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\""]}
{"text": ["def order_by_points(nums):\n    \"\"\"\n    编写一个函数，对给定的整数列表进行升序排序\n    根据整数各位数字之和。\n    注意：如果有多个项的数字之和相同，\n    则根据它们在原始列表中的索引进行排序。\n\n    例如：\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\"", "def order_by_points(nums):\n    \"\"\"\n    编写一个函数，根据给定的整数列表的数字总和按升序对它们进行排序。\n    注意：如果有多个项的数字总和相似，则根据它们在原始列表中的索引对它们进行排序。\n    例如：\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\"", "def order_by_points(nums):\n    \"\"\"\n    编写一个函数，根据整数各位数字之和对给定的整数列表进行升序排序。\n    注意：如果有几个项目的位数和相似，则根据它们在原始列表中的索引进行排序。\n\n    例如：\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\""]}
{"text": ["def specialFilter(nums):\n    \"\"\"编写一个函数，以数字数组作为输入并返回\n    数组中大于 10 的元素数，并且数字的第一位和最后一位都是奇数（1、3、5、7、9）。\n    例如：\n    specialFilter([15, -73, 14, -15]) => 1\n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\"", "def specialFilter(nums):\n    \"\"\"编写一个函数，以数字数组作为输入并返回\n    数组中大于 10 的元素数，并且数字的第一位和最后一位都是奇数（1、3、5、7、9）。\n    例如：\n    specialFilter([15, -73, 14, -15]) => 1\n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\"", "def specialFilter(nums):\n    \"\"\"编写一个函数，接受一个数字数组作为输入，并返回\n    数组中大于10且数字的首尾位都是奇数\n    （1, 3, 5, 7, 9）的元素数量。\n    例如：\n    specialFilter([15, -73, 14, -15]) => 1 \n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\""]}
{"text": ["def get_max_triples(n):\n    \"\"\"\n    给定一个正整数 n。您必须创建一个长度为 n 的整数数组 a。\n    对于每个 i（1 ≤ i ≤ n），a[i] 的值 = i * i - i + 1。\n    返回 a 的三元组 (a[i], a[j], a[k]) 的数量，其中 i < j < k，\n    并且 a[i] + a[j] + a[k] 是 3 的倍数。\n\n    示例：\n    输入：n = 5\n    输出：1\n    解释：\n    a = [1, 3, 7, 13, 21]\n    唯一有效的三元组是 (1, 7, 13)。\n    \"\"\"", "def get_max_triples(n):\n    \"\"\"\n    给定一个正整数n，你需要创建一个长度为n的整数数组a。\n        每个 i (1 ≤ i ≤ n), a[i]的值是 i * i - i + 1.\n        返回数组a中满足i < j < k且a[i] + a[j] + a[k]是3的倍数的三元组（a[i], a[j], a[k]）的数量。\n\n    示例：\n        Input: n = 5\n        Output: 1\n        Explanation: \n        a = [1, 3, 7, 13, 21]\n        唯一有效的三元组是 (1, 7, 13)。\n    \"\"\"", "def get_max_triples(n):\n    \"\"\"\n    给定一个正整数 n。您必须创建一个长度为 n 的整数数组 a。\n        对于每个 i（1 ≤ i ≤ n），a[i] 的值 = i * i - i + 1。\n        返回 a 的三元组 (a[i], a[j], a[k]) 的数量，其中 i < j < k，\n    并且 a[i] + a[j] + a[k] 是 3 的倍数。\n\n    示例：\n        Input: n = 5\n        Output: 1\n        Explanation: \n        a = [1, 3, 7, 13, 21]\n        The only valid triple is (1, 7, 13).\n    \"\"\""]}
{"text": ["def bf(planet1, planet2):\n    '''\n    我们的太阳系中有八个行星：离太阳最近的是水星，\n    接下来是金星，然后是地球，火星，木星，土星，\n    天王星，海王星。\n    编写一个函数，该函数接受两个行星名称作为字符串 planet1 和 planet2。\n    该函数应返回一个元组，其中包含所有轨道位于 planet1 和 planet2 之间的行星，\n    按照离太阳的距离排序。\n    如果 planet1 或 planet2 不是正确的行星名称，函数应返回一个空元组。\n    示例\n    bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n    bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n    bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n    '''", "def bf(planet1, planet2):\n    '''\n    我们的太阳系中有八个行星：离太阳最近的是水星，\n    接下来是金星，然后是地球，火星，木星，土星，\n    天王星，海王星。\n    编写一个函数，其planet1 和 planet2是两个行星的名称。\n    该函数应返回一个元组，其中包含所有轨道位于 planet1 和 planet2 之间的行星--\n    按照离太阳的距离排序。\n    如果 planet1 或 planet2 不是正确的行星名称，函数应返回一个空元组。\n    示例\n    bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n    bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n    bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n    '''", "def bf(planet1, planet2):\n    '''\n    我们的太阳系有八颗行星：离太阳\n    最近的是水星，接下来是金星，然后是地球、火星、木星、土星、\n    天王星、海王星。\n    编写一个函数，接受两个行星名称作为字符串planet1和planet2。\n     该函数应返回一个元组，包含位于\n    planet1和planet2轨道之间的所有行星，按离\n    太阳的远近排序。\n    如果planet1或planet2不是正确的行星名称，\n    则该函数应返回一个空元组。\n    示例\n    bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n    bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n    bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n    '''"]}
{"text": ["def sorted_list_sum(lst):\n    \"\"\"编写一个函数，接受一个字符串列表作为参数，\n    从中删除长度为奇数的字符串，\n    并返回按排序顺序排列的结果列表，\n    该列表始终是字符串列表，而不是数字数组，\n    并且它可能包含重复项。\n    列表的顺序应按每个单词的长度升序排列，并且您\n    应该返回按该规则排序的列表。\n    如果两个单词的长度相同，则按字母顺序对列表进行排序。\n    该函数应返回按排序顺序排列的字符串列表。\n    您可以假设所有单词的长度都相同。\n    例如：\n    sorted_list_sum([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    sorted_list_sum([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\"", "def sorted_list_sum(lst):\n    \"\"\"编写一个函数，接受一个字符串列表作为参数，\n    删除其中长度为奇数的字符串，\n    并返回排序后的结果列表，\n    该列表始终是字符串列表，而不是数字数组，\n    并且可能包含重复项。\n    列表的顺序应按每个单词的长度升序排列，\n    并且您应该按此规则返回排序后的列表。\n    如果两个单词长度相同，则按字母顺序排序。\n    该函数应返回按排序顺序排列的字符串列表。\n    您可以假设所有单词的长度相同。\n    例如：\n    assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\"", "def sorted_list_sum(lst):\n    \"\"\"编写一个函数，输入一个字符串列表作为参数，\n    删除其中长度为奇数的字符串，\n    并输出重新排序后的列表。\n    该列表为字符串列表，不能是数字数组，\n    并且可能包含重复项。\n    该列表需参考其单词长度，按升序排列，\n    并且您应该按此规则返回排序后的列表。\n    如果两个单词长度相同，则按字母顺序排列。\n    该函数需要输出按上述要求排列的字符串列表。\n    为简化起见，可假设所有单词的长度相同。\n    例如：\n    assert sorted_list_sum([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    assert sorted_list_sum([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\""]}
{"text": ["def x_or_y(n, x, y):\n    \"\"\"一个简单的程序，如果 n 是素数，则返回 x 的值，否则返回 y 的值。\n\n    示例：\n    for x_or_y(7, 34, 12) == 34\n    for x_or_y(15, 8, 5) == 5\n\n    \"\"\"", "def x_or_y(n, x, y):\n    \"\"\"一个简单的程序，如果 n 是素数，则返回 x 的值，否则返回 y 的值。\n\n    示例：\n    for x_or_y(7, 34, 12) == 34\n    for x_or_y(15, 8, 5) == 5\n    \n    \"\"\"", "def x_or_y(n, x, y):\n    \"\"\"一个简单的程序，如果 n 是质数，则返回 x 的值，\n    否则返回 y 的值。\n\n    示例：\n    对于 x_or_y(7, 34, 12) == 34\n    对于 x_or_y(15, 8, 5) == 5\n    \n    \"\"\""]}
{"text": ["def double_the_difference(lst):\n    '''\n    给定一个数字列表，返回列表中奇数的平方和。\n    忽略负数或非整数的数字。\n    \n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n   \n    如果输入列表为空，返回0。\n    '''", "def double_the_difference(lst):\n    '''\n    给定一个数字列表，返回列表中奇数的平方和。\n    忽略负数或非整数的数字。\n    \n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n   \n    如果输入列表为空，返回0。\n    '''", "def double_the_difference(lst):\n    '''\n    给定一个数字列表，返回列表中奇数数字的平方和。\n    的平方和。忽略负数或非整数。\n    \n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n   \n    如果输入列表为空，则返回 0。\n    '''"]}
{"text": ["def compare(game,guess):\n    \"\"\"我想我们都记得，当某个期待已久的事件结果终于揭晓时的那种感觉。\n    那一刻的感受和想法绝对值得记录下来并进行比较。\n    你的任务是确定一个人是否正确猜测了一些比赛的结果。\n    会给你两个长度相等的数组，分别是实际比分和猜测比分，其中每个索引表示一场比赛。\n    返回一个相同长度的数组，表示每个猜测的偏差程度。如果他们猜对了，\n    值为0；如果没有，值为猜测比分和实际比分之间的绝对差值。\n    \n    例子:\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    \"\"\"", "def compare(game,guess):\n    \"\"\"我想我们都记得，当某个期待已久的事件的结果终于为人所知时，那种感觉。那一刻的感受和想法绝对值得记录下来并进行比较。\n    您的任务是确定一个人是否正确猜出了多场比赛的结果。\n    您将获得两个长度相等的分数和猜测数组，其中每个索引表示一个匹配项。\n    返回一个长度相同的数组，表示每个猜测的偏差有多大。如果他们猜对了，则值为 0，如果猜错，则值为猜测和分数之间的绝对差。\n\n    示例：\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    “””", "def compare(game,guess):\n    \"\"\"我想我们都记得，当一个期待已久的事件结果\n    终于揭晓时的那种感觉。在那个时刻的感受和想法，\n    绝对值得记录下来并加以比较。\n    你的任务是确定一个人是否正确预测了一系列比赛的结果。\n    你会得到两个等长的数组，分别是比分和预测，其中每个索引对应一场比赛。\n    返回一个等长的数组，表示每次预测的误差有多大。如果预测正确，\n    值为 0，如果不正确，值为预测与实际比分之间的绝对差值。\n    \n    \n    例子:\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    \"\"\""]}
{"text": ["def Strongest_Extension(class_name, extensions):\n    \"\"\"给定一个类的名称（一个字符串）和一个扩展列表。\n    这些扩展用于加载附加类到该类。扩展的强度如下：设CAP为扩展名中大写字母的数量，\n    SM为扩展名中小写字母的数量，强度由分数CAP - SM给出。\n    你应该找到最强的扩展并返回一个字符串，格式为：ClassName.StrongestExtensionName。\n    如果有两个或多个扩展具有相同的强度，你应该选择列表中第一个出现的。\n    例如，如果给定类名为\"Slices\"和扩展列表：['SErviNGSliCes', 'Cheese', 'StuFfed']，\n    那么你应该返回'Slices.SErviNGSliCes'，因为'SErviNGSliCes'是最强的扩展\n    （其强度为-1）。\n    示例：\n    对于 Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n    \"\"\"", "def Strongest_Extension(class_name, extensions):\n    \"\"\"给定一个类的名称（一个字符串）和一个扩展列表。\n    这些扩展用于加载附加类到该类。扩展的强度如下：设CAP为扩展名中大写字母的数量，\n    SM为扩展名中小写字母的数量，强度由分数由CAP - SM计算得出。\n    你应该找到最强的扩展并返回一个字符串，格式为：ClassName.StrongestExtensionName。\n    如果有两个或多个扩展具有相同的强度，你应该选择列表中第一个出现的。\n    例如，如果给定类名为\"Slices\"和扩展列表：['SErviNGSliCes', 'Cheese', 'StuFfed']，\n    那么你应该返回'Slices.SErviNGSliCes'，因为'SErviNGSliCes'是最强的扩展\n    （其强度为-1）。.\n    示例:\n    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) 的结果应为 'my_class.AA'\n    \"\"\"", "def Strongest_Extension(class_name, extensions):\n    \"\"\"给定一个类的名称（一个字符串）和一个扩展列表。\n    这些扩展用于加载附加类到该类。扩展的\n    强度如下：设CAP为扩展名中大写字母的数量，\n    SM为扩展名中小写字母的数量，强度\n    由分数CAP - SM给出。\n    你应该找到最强的扩展并返回一个字符串，\n    格式为：ClassName.StrongestExtensionName。\n    如果有两个或多个扩展具有相同的强度，你应该\n    选择列表中第一个出现的。\n    例如，如果给定类名为\"Slices\"和\n    扩展列表：['SErviNGSliCes', 'Cheese', 'StuFfed']，那么你应该\n    返回 'Slices.SErviNGSliCes'，因为 'SErviNGSliCes' 是最强的扩展\n    （其强度为-1）。\n    示例：\n    对于 Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n    \"\"\""]}
{"text": ["def cycpattern_check(a , b):\n    \"\"\"给定两个单词。如果第二个单词或其任何旋转是第一个单词的子字符串，则需要返回True\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whassup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n\n    \"\"\"", "def cycpattern_check(a , b):\n    \"\"\"您有两个单词。如果第二个单词或其任何旋转是第一个单词的子字符串，则需要返回 True\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whas​​sup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n\n    \"\"\"", "def cycpattern_check(a , b):\n    \"\"\"给定两个单词。如果第二个单词或其任何旋转是第一个单词的子字符串，则需要返回True\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whassup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n\n    \"\"\""]}
{"text": ["def even_odd_count(num):\n    \"\"\"给定一个整数。返回一个元组，分别包含偶数和奇数位数的数量。\n\n     示例:\n        even_odd_count(-12) ==> (1, 1)\n        even_odd_count(123) ==> (1, 2)\n    \"\"\"", "def even_odd_count(num):\n    \"\"\"给定一个整数。返回一个分别具有偶数和奇数位数的元组。\n\n    示例：\n    even_odd_count(-12) ==> (1, 1)\n    even_odd_count(123) ==> (1, 2)\n    \"\"\"", "def even_odd_count(num):\n    \"\"\"给定一个整数。返回一个元组，分别包含偶数和奇数位数的数量。\n\n     示例:\n        even_odd_count(-12) ==> (1, 1)\n        even_odd_count(123) ==> (1, 2)\n    \"\"\""]}
{"text": ["def int_to_mini_roman(number):\n    \"\"\"\n    给定一个正整数，获取其对应的罗马数字字符串，\n    并以小写形式返回。\n    限制条件: 1 <= num <= 1000\n\n    示例:\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\"", "def int_to_mini_roman(number):\n    \"\"\"\n    给定一个正整数，获取其罗马数字等价字符串，\n    并以小写形式返回。\n    限制：1 <= num <= 1000\n\n    示例：\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\"", "def int_to_mini_roman(number):\n    \"\"\"\n    给定一个正整数，以字符串形式获取其罗马数字字符串\n    并以小写形式返回。\n    限制条件： 1 <= num <= 1000\n\n    示例：\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\""]}
{"text": ["def right_angle_triangle(a, b, c):\n    '''\n    给定一个三角形的三边长度。如果这三边构成一个直角三角形则返回True，否则返回False。\n    直角三角形是指其中一个角为直角或90度的三角形。\n    示例：\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''", "def right_angle_triangle(a, b, c):\n    '''\n    给出三角形三边的长度。如果三边形成直角三角形，则返回 True，否则返回 False。\n    直角三角形是其中一个角为直角或 90 度的三角形。\n    示例：\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''", "def right_angle_triangle(a, b, c):\n    '''\n    给定一个三角形的三边长度。如果这三边\n    构成一个直角三角形则返回True，否则返回False。\n    直角三角形是指其中一个角为直角或\n    90度的三角形。\n    示例：\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''"]}
{"text": ["def find_max(words):\n    \"\"\"编写一个接受字符串列表的函数。\n    该列表包含不同的单词。返回具有最大数量的独特字符的单词。如果多个字符串具有最大数量唯一字符，则返回按字典顺序排在最前的字符串。\n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"aaaaaaa\"\n    \"\"\"", "def find_max(words):\n    \"\"\"编写一个函数，接受一个字符串列表。\n    该列表包含不同的单词。返回具有最多唯一字符的单词。\n    如果多个字符串具有最多的唯一字符，则返回按字典顺序排列最靠前的那个。\n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\n    \"\"\"", "def find_max(words):\n    \"\"\"编写一个接受字符串列表的函数。\n    该列表包含不同的单词。返回具有最多唯一字符的字符串。\n    如果多个字符串具有最大数量唯一字符，则返回按字典顺序排列的第一个字符串。\n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\n    \"\"\""]}
{"text": ["def eat(number, need, remaining):\n    \"\"\"\n    你是一只饥饿的兔子，你已经吃了一定数量的胡萝卜，\n    但现在你需要吃更多的胡萝卜来完成一天的餐食。\n    你应该返回一个数组 [ 餐后吃掉的胡萝卜总数,\n                                    餐后剩余的胡萝卜数量 ]\n    如果剩余的胡萝卜不够，你将吃掉所有剩余的胡萝卜，但仍然会感到饥饿。\n    \n    示例:\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n    \n    变量:\n    @number : integer\n        你已经吃掉的胡萝卜数量。\n    @need : integer\n        你需要吃的胡萝卜数量。\n    @remaining : integer\n        库存中剩余的胡萝卜数量\n    \n    约束条件:\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    玩得开心 :)\n    \"\"\"", "def eat(number, need, remaining):\n    \"\"\"\n    你是一只饥饿的兔子，你已经吃了一定数量的胡萝卜，\n    但现在你需要吃更多的胡萝卜来保证一天的餐食。\n    你应该返回一个数组[饭后吃胡萝卜的总数，\n                                    餐后剩余的胡萝卜数量 ]\n    如果剩下的胡萝卜不够，你会吃掉所有剩下的胡萝卜，但仍然会饿。\n    \n    示例:\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n    \n    变量:\n    @number : integer\n        你已经吃掉的胡萝卜数量。\n    @need : integer\n        你需要吃的胡萝卜数量。\n    @remaining : integer\n        库存中剩余的胡萝卜数量。\n    \n    约束:\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    玩得开心 :)\n    \"\"\"", "def eat(number, need, remaining):\n    \"\"\"\n    你是一只饥饿的兔子，你已经吃了一定数量的胡萝卜，\n    但现在你需要吃更多的胡萝卜来完成一天的餐食。\n    你应该返回一个数组，其中包含 [ 餐后吃过的胡萝卜总数，\n    餐后剩下的胡萝卜数量 ]\n    如果剩余的胡萝卜不够，你会吃掉所有剩余的胡萝卜，但仍然会感到饥饿。\n\n    示例：\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n\n    变量：\n    @number ：integer\n    你已经吃过的胡萝卜数量。\n    @need ：integer\n    你需要吃的胡萝卜数量。\n    @remaining ：integer\n    库存中剩余的胡萝卜数量\n\n    限制：\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    玩得开心 :)\n    \"\"\""]}
{"text": ["def do_algebra(operator, operand):\n    \"\"\"\n    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，\n    第二个列表是一个整数列表。使用这两个给定的列表构建代数表达式并返回该表达式的计算结果。\n\n    基本代数运算：\n    加法 ( + ) \n    减法 ( - ) \n    乘法 ( * ) \n    整数除法 ( // ) \n    幂运算 ( ** ) \n\n    示例：\n    operator['+', '*', '-']\n    array = [2, 3, 4, 5]\n    result = 2 + 3 * 4 - 5\n    => result = 9\n\n    注意：\n        operator 列表的长度等于 operand 列表的长度减一。\n        operand 是一个非负整数的列表。\n        operator 列表至少有一个运算符，operand 列表至少有两个操作数。\n\n    \"\"\"", "def do_algebra(operator, operand):\n    \"\"\"\n    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，\n    第二个列表是一个整数列表。使用这两个给定的列表构建代数表\n    达式并返回该表达式的计算结果。\n\n    基本代数运算：\n    加法 ( + ) \n    减法 ( - ) \n    乘法 ( * ) \n    整数除法 ( // ) \n    幂运算 ( ** ) \n\n    示例：\n    operator['+', '*', '-']\n    array = [2, 3, 4, 5]\n    result = 2 + 3 * 4 - 5\n    => result = 9\n\n    注意：\n        operator 列表的长度等于 operand 列表的长度减一。\n        operand 是一个非负整数的列表。\n        operator 列表至少有一个运算符，operand 列表至少有两个操作数。\n\n    \"\"\"", "def do_algebra(operator, operand):\n    \"\"\"\n    给定两个列表 operator 和 operand。第一个列表包含基本代数运算，\n    第二个列表是一个整数列表。使用这两个给定的列表构建代数表达式并返回该表达式的计算结果。\n\n    基本代数运算:\n    加法 ( + ) \n    减法 ( - ) \n    乘法 ( * ) \n    整数除法 ( // ) \n    幂运算 ( ** ) \n\n    示例:\n    operator['+', '*', '-']\n    array = [2, 3, 4, 5]\n    result = 2 + 3 * 4 - 5\n    => result = 9\n\n    注意:\n        operator 列表的长度等于 operand 列表的长度减一。\n        operand 是一个非负整数的列表。\n        operator 列表至少有一个运算符，operand 列表至少有两个操作数。\n\n    \"\"\""]}
{"text": ["def solve(s):\n    \"\"\"给定一个字符串 s。\n    如果 s[i] 是字母，则将其大小写反转，从小写变为大写或反之，\n    否则保持不变。\n    如果字符串不包含字母，则反转字符串。\n    函数应返回结果字符串。\n    示例\n    solve(\"1234\") = \"4321\"\n    solve(\"ab\") = \"AB\"\n    solve(\"#a@C\") = \"#A@c\"\n    \"\"\"", "def solve(s):\n    \"\"\"给定一个字符串 s。\n    如果 s[i] 是字母，则将其大小写反转，从小写变为大写或反之， \n    否则保持不变。\n    如果字符串不包含字母，则反转字符串。\n    函数应返回结果字符串。\n    示例\n    solve(\"1234\") = \"4321\"\n    solve(\"ab\") = \"AB\"\n    solve(\"#a@C\") = \"#A@c\"\n    \"\"\"", "def resolve(s):\n    \"\"\"给定一个字符串 s。\n    如果 s[i] 是字母，则将其大小写从小写反转为大写或反之，\n    否则保持原样。\n    如果字符串不包含字母，则反转字符串。\n    该函数应返回结果字符串。\n    示例\n    resolve(\"1234\") = \"4321\"\n    resolve(\"ab\") = \"AB\"\n    resolve(\"#a@C\") = \"#A@c\"\n    \"\"\""]}
{"text": ["def string_to_md5(text):\n    \"\"\"\n    给定一个字符串 'text'，返回其 md5 哈希等效字符串。\n    如果 'text' 是一个空字符串，返回 None。\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n    \"\"\"", "def string_to_md5(text):\n    \"\"\"\n    给定一个字符串“text”，返回其 md5 哈希等效字符串。\n    如果“text”为空字符串，则返回 None。\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n    \"\"\"", "def string_to_md5(text):\n    \"\"\"\n    给定字符串 ’text‘，返回其md5哈希等价字符串。\n    如果 ‘text ’是空字符串，则返回None。\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n    \"\"\""]}
{"text": ["def generate_integers(a, b):\n    \"\"\"\n    给定两个正整数 a 和 b，返回 a 和 b 之间的偶数，按升序排列。\n\n    例如：\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\"", "def generate_integers(a, b):\n    \"\"\"\n    给定两个正整数 a 和 b，按升序返回 a和 b 之间的偶数。\n\n    例如：\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\"", "def generate_integers(a, b):\n    \"\"\"\n    给定两个正整数 a 和 b，按升序返回 a 和 b 之间的偶数数字。\n\n    例如：\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\""]}