Prompt:
问题描述：检查给定数字列表中，是否有任何两个数字之间的距离小于给定的阈值。
示例：
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
代码如下：
```python
from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:


Prompt:
问题描述：这个函数的输入是一个包含多组嵌套括号的字符串。你的目标是将这些组分离成独立的字符串，并返回这些字符串的列表。独立的组是平衡的（每个开括号都被正确地关闭），并且不在彼此之内嵌套。忽略输入字符串中的任何空格。
示例：
>>> separate_paren_groups('( ) (( )) (( )( ))')
['()', '(())', '(()())']
代码如下：
```python
from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:


Prompt:
问题描述：给定一个正浮点数，它可以被分解为：整数部分（小于给定数的最大整数）和小数（剩余部分总是小于1）。返回数字的小数部分。
示例：
>>> truncate_number(3.5)
0.5
代码如下：
```python
def truncate_number(number: float) -> float:


Prompt:
问题描述：你被给予一个银行账户的存款和取款操作列表，该账户开始时余额为零。你的任务是检测账户余额是否在任何时候下降到零以下，如果是，则函数应返回True。否则，它应返回False。
示例：
>>> below_zero([1, 2, 3])
False
>>> below_zero([1, 2, -4, 5])
True
代码如下：
```python
from typing import List

def below_zero(operations: List[int]) -> bool:


Prompt:
问题描述：对于给定的输入数字列表，计算这个数据集平均值周围的平均绝对偏差。平均绝对偏差是每个元素与中心点（本例中为平均值）之间的平均绝对差：MAD = average | x - x_mean |。
示例：
>>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
1.0
代码如下：
```python
from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:


Prompt:
问题描述：在输入列表 `numbers' 的每两个连续元素之间插入一个数字 'delimeter'。
示例：
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
代码如下：
```python
from typing import List

def intersperse(numbers, delimeter):


Prompt:
问题描述：这个函数的输入是一个字符串，表示由空格分隔的多组嵌套括号。对于每一组，输出括号的最深嵌套级别。例如，(()())的最大嵌套级别为两级，而((()))有三级。
例如：
>>> parse_nested_parens('(()()) ((())) () ((())()())')
[2, 3, 1, 3]
代码如下：
```python
from typing import List

def parse_nested_parens(paren_string):


Prompt:
问题描述：将输入的字符串列表过滤，仅保留包含给定子字符串的项。
示例：
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array']
代码如下：
```python
from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:


Prompt:
问题描述：对于给定的整数列表，返回一个元组，该元组由列表中所有整数的和和积组成。空列表的和应等于0，空列表的积应等于1。
示例：
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24)
代码如下：
```python
from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:


Prompt:
问题描述：从给定的整数列表中，生成一个序列，该序列在给定时刻显示到目前为止找到的滚动最大元素。
示例：
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
代码如下：
```python
from typing import List, Tuple

def rolling_max(numbers):


Prompt:
问题描述：找到以给定的字符串开头的最短回文。算法思想很简单：-找到给定字符串的最长回文后缀。—将回文后缀前的字符串反转，附加到给定字符串的末尾。
示例：
>>> make_palindrome('')
''
>>> make_palindrome('cat')
'catac'
>>> make_palindrome('cata')
'catac'
代码如下：
```python
def is_palindrome(string: str) -> bool:
    """ 检查给定的字符串是否是回文。 """
    return string == string[::-1]
def make_palindrome(string: str) -> str:
    """找到以给定的字符串开头的最短回文。算法思想很简单：-找到给定字符串的最长回文后缀。—将回文后缀前的字符串反转，附加到给定字符串的末尾。
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


Prompt:
问题描述：输入是仅由1和0组成的两个字符串a和b。对这些输入执行二进制异或操作，并以字符串形式返回结果。
例如，string_xor('010', '110')的结果为'100'。
代码如下：
```python
from typing import List

def string_xor(a: str, b: str) -> str:


Prompt:
问题描述：从字符串列表中，返回最长的一个。如果有多个字符串长度相同，则返回第一个。如果输入列表为空，则返回None。
示例：
>>> longest([])

>>> longest(['a', 'b', 'c'])
'a'
>>> longest(['a', 'bb', 'ccc'])
'ccc'
代码如下：
```python
from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:


Prompt:
问题描述：返回两个整数a和b的最大公约数
示例：
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
代码如下：
```python
def greatest_common_divisor(a: int, b: int) -> int:


Prompt:
问题描述：返回输入字符串的所有前缀，从最短到最长
示例：
>>> all_prefixes('abc')
['a', 'ab', 'abc']
代码如下：
```python
from typing import List

def all_prefixes(string: str) -> List[str]:


Prompt:
问题描述：返回一个字符串，其中包含从0开始到n（包括n）的空格分隔的数字。
示例：
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
代码如下：
```python
def string_sequence(n: int) -> str:


Prompt:
问题描述：给定一个字符串，找出它由多少个不同的字符（不区分大小写）组成
示例：
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
代码如下：
```python
def count_distinct_characters(string: str) -> int:


Prompt:
问题描述：这个函数的输入是一个以特殊ASCII格式表示的音符字符串。你的任务是解析这个字符串，并返回一个整数列表，对应于每个音符持续的拍数。这里是图例：
'o' - 全音符，持续四拍
'o|' - 半音符，持续两拍
'.|' - 四分音符，持续一拍
示例：
>>> parse_music('o o| .| o| o| .| .| .| .| o o')
[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
代码如下：
```python
from typing import List

def parse_music(music_string):


Prompt:
问题描述：找出给定子字符串在原始字符串中出现的次数。重叠的情况也计算在内。
示例：
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
代码如下：
```python
def how_many_times(string: str, substring: str) -> int:


Prompt:
问题描述：输入是一个由'zero'到'nine'的数字组成的以空格分隔的字符串。有效的选择是'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'和'nine'。返回从最小到最大排序的数字字符串。
示例：
>>> sort_numbers('three one five')
'one three five'
代码如下：
```python
from typing import List

def sort_numbers(numbers):


Prompt:
问题描述：从提供的数字列表（长度至少为两个）中选择并返回两个彼此最接近的数字，并按此顺序返回：（较小的数字，较大的数字）。
示例：
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
(2.0, 2.0)
代码如下：
```python
from typing import List, Tuple

def find_closest_elements(numbers):


Prompt:
问题描述：给定一个至少包含两个元素的数字列表，对该列表应用线性变换，使得最小的数字变为0，最大的数字变为1。
示例：
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0]
代码如下：
```python
from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:


Prompt:
问题描述：根据给定的Python值列表，仅筛选出整数
示例：
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
代码如下：
```python
from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:


Prompt:
问题描述：返回给定字符串的长度
示例：
>>> strlen('')
0
>>> strlen('abc')
3
代码如下：
```python
def strlen(string: str) -> int:


Prompt:
问题描述：对于给定的数n，找出小于n且能整除n的最大的数。
示例：
>>> largest_divisor(15)
5
代码如下：
```python
def largest_divisor(n: int) -> int:


Prompt:
问题描述：返回给定整数的质因数列表，从最小到最大的顺序排列。每个因数应按照其在分解中出现的次数列出。输入的数字应等于所有因数的乘积
示例：
>>> factorize(8)
[2, 2, 2]
>>> factorize(25)
[5, 5]
>>> factorize(70)
[2, 5, 7]
代码如下：
```python
from typing import List

def factorize(n: int) -> List[int]:


Prompt:
问题描述：从整数列表中删除所有出现次数超过一次的元素。保持剩余元素的顺序与输入时相同。
示例：
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
代码如下：
```python
from typing import List

def remove_duplicates(numbers):


Prompt:
问题描述：对于给定的字符串，将小写字符转换为大写，将大写字符转换为小写。
示例：
>>> flip_case('Hello')
'hELLO'
代码如下：
```python
def flip_case(string: str) -> str:


Prompt:
问题描述：将字符串列表连接成一个单独的字符串
示例：
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
代码如下：
```python
from typing import List

def concatenate(strings: List[str]) -> str:


Prompt:
问题描述：过滤一个字符串列表，只保留以给定前缀开头的字符串。
示例：
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
代码如下：
```python
from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:


Prompt:
问题描述：只返回列表中的正数。
示例：
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
代码如下：
```python
def get_positive(l: list):


Prompt:
问题描述：如果给定的数字是质数，则返回真，否则返回假。
示例：
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
代码如下：
```python
def is_prime(n):


Prompt:
问题描述：xs是多项式的系数。查找满足poly(x) = 0的x值。函数find_zero只返回一个零点，即使有多个零点。此外，函数find_zero只接受具有偶数个系数和最大非零系数的列表xs，因为这样可以保证有一个解。
示例：
>>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-0.5
>>> round(find_zero([-6, 11, -6, 1]), 2) # f(x) = (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
1.0
代码如下：
```python
import math

def poly(xs: list, x: float):
    """
    求解点x处系数为xs的多项式。
    返回xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n。
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
    """
    xs是多项式的系数。find_zero返回poly(x)= 0时的解。函数find_zero只返回一个零点，即使有多个零点。此外，函数find_zero只接受具有偶数个系数和最大非零系数的列表xs，因为这样可以保证有一个解。
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


Prompt:
问题描述：这个函数接收一个列表l，返回一个列表l'，满足以下条件：l'与l在不能被3整除的索引处完全相同，而在能被3整除的索引处的值等于l中对应索引的值，但是排好序。
示例：
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_third([5, 6, 3, 4, 8, 9, 2])
[2, 6, 3, 4, 8, 9, 5]
代码如下：
```python
def sort_third(l):


Prompt:
问题描述：返回列表中排序后的唯一元素。
示例：
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
代码如下：
```python
def unique(l):


Prompt:
问题描述：返回列表中的最大元素。
示例：
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
代码如下：
```python
def max_element(l: list):


Prompt:
问题描述：返回小于n的整数中，能够被11或13整除的数字中，数字7出现的次数。
示例：
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
代码如下：
```python
def fizz_buzz(n):


Prompt:
问题描述：这个函数接受一个列表l，并返回一个新的列表l'，使得l'与l在奇数索引处完全相同，而它在偶数索引处的值等于l的偶数索引处的值，但是已经排序。
示例：
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4]
代码如下：
```python
def sort_even(l):


Prompt:
问题描述：输入encode_cyclic函数编码的字符串，返回解码后的字符串。
代码如下：
```python
def encode_cyclic(s: str):
    """
    返回通过循环移动3个字符编码的字符串。
    """
    # 将字符串拆分为组，每个组的长度为3。
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 在每个组中循环元素，除非该组的元素少于3个。
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)
def decode_cyclic(s: str):
    """
    输入encode_cyclic函数编码的字符串，返回解码后的字符串。
    """


Prompt:
问题描述：prime_fib返回第n个既是斐波那契数又是质数的数字。
示例：
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
代码如下：
```python
def prime_fib(n):


Prompt:
问题描述："triples_sum_to_zero"接收一个整数列表作为输入。如果列表中有三个不同的元素相加等于零，它将返回True，否则返回False。
示例：
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True
>>> triples_sum_to_zero([1, 2, 3, 7])
False
>>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
True
>>> triples_sum_to_zero([1])
False
代码如下：
```python
def triples_sum_to_zero(l: list):


Prompt:
问题描述：想象一条完美的直线无限长的道路。n辆车从左向右行驶；同时，另外n辆车从右向左行驶。这两组车开始时彼此相距非常远。所有的车都以相同的速度移动。当一辆从左向右行驶的车撞到一辆从右向左行驶的车时，我们称之为碰撞。然而，这些车都无比坚固强大；因此，即使它们发生了碰撞，也会继续按照原来的轨迹行驶。这个函数输出这样的碰撞次数。
代码如下：
```python
def car_race_collision(n):


Prompt:
问题描述：返回一个元素增加1的列表。
示例：
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
代码如下：
```python
def incr_list(l: list):


Prompt:
问题描述："pairs_sum_to_zero"接收一个整数列表作为输入。如果列表中有两个不同的元素之和等于零，则返回True，否则返回False。
例如：
>>> pairs_sum_to_zero([1, 3, 5, 0])
返回 False
>>> pairs_sum_to_zero([1, 3, -2, 1])
返回 False
>>> pairs_sum_to_zero([1, 2, 3, 7])
返回 False
>>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
返回 True
>>> pairs_sum_to_zero([1])
返回 False
代码如下：
```python
def pairs_sum_to_zero(l):


Prompt:
问题描述：将输入数字x转换为基数。转换后返回字符串表示。基数小于10。
示例：
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
代码如下：
```python
def change_base(x: int, base: int):


Prompt:
问题描述：给定三角形的一边长和高，返回其面积。
示例：
>>> triangle_area(5, 3)
7.5
代码如下：
```python
def triangle_area(a, h):


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


Prompt:
问题描述：返回列表l中元素的中位数。
示例：
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
代码如下：
```python
def median(l: list):


Prompt:
问题描述：检查给定的字符串是否为回文
示例：
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
代码如下：
```python
def is_palindrome(text: str):


Prompt:
问题描述：返回 2^n modulo p 的值（注意数值处理）。
示例：
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
代码如下：
```python
def modp(n, p):


Prompt:
问题描述：输入encode_shift函数编码的字符串。返回解码的字符串。
代码如下：
```python
def encode_shift(s: str):
    """
    返回通过在字母表中将每个字符移动5位得到的编码字符串。
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
    """
    输入encode_shift函数编码的字符串。返回解码的字符串。
    """


Prompt:
问题描述：remove_vowels是一个函数，它接受一个字符串并返回一个没有元音字母的字符串。
示例：
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaBAA')
'B'
>>> remove_vowels('zbcd')
'zbcd'
代码如下：
```python
def remove_vowels(text):


Prompt:
问题描述：如果列表l中的所有数字都低于阈值t，则返回True。
示例：
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
代码如下：
```python
def below_threshold(l: list, t: int):


Prompt:
问题描述：将两个数字x和y相加
示例：
>>> add(2, 3)
5
>>> add(5, 7)
12
代码如下：
```python
def add(x: int, y: int):


Prompt:
问题描述：检查两个单词是否具有相同的字符。
示例：
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same_chars('abcd', 'dddddddabce')
False
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
False
代码如下：
```python
def same_chars(s0, s1):


Prompt:
问题描述：返回第n个斐波那契数。
示例：
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
代码如下：
```python
def fib(n: int):


Prompt:
问题描述："brackets"是一个由"<"和">"组成的字符串。如果每个开括号都有对应的闭括号，则返回True。
示例：
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing("><<>")
False
代码如下：
```python
def correct_bracketing(brackets: str):


Prompt:
问题描述：如果列表元素是单调递增或递减的，则返回True。
示例：
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
代码如下：
```python
def monotonic(l):


Prompt:
问题描述：返回两个列表中排序后的唯一公共元素。
示例：
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
代码如下：
```python
def common(l1: list, l2: list):


Prompt:
问题描述：返回n的最大质数因子。假设n>1且不是质数。
示例：
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
代码如下：
```python
def largest_prime_factor(n):


Prompt:
问题描述：sum_to_n是一个函数，用于求和从1到n的数字。
示例：
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
代码如下：
```python
def sum_to_n(n: int):


Prompt:
问题描述："brackets"是一个由"("和")"组成的字符串。如果每个开括号都有对应的闭括号，则返回True。
示例：
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(")(()")
False
代码如下：
```python
def correct_bracketing(brackets: str):


Prompt:
问题描述：xs代表多项式的系数。xs[0] + xs[1] * x + xs[2] * x^2 + ....以同样的形式返回这个多项式的导数。
示例：
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
代码如下：
```python
def derivative(xs):


Prompt:
问题描述：FibFib数列是一个类似于斐波那契数列的序列，其定义如下：
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
请编写一个函数，有效地计算出FibFib数列的第n个元素。
示例：
>>> fibfib(1)
0
>>> fibfib(5)
4
>>> fibfib(8)
24
代码如下：
```python
def fibfib(n):


Prompt:
问题描述：编写一个函数vowels_count，它接受一个表示单词的字符串作为输入，并返回该字符串中元音字母的数量。这里的元音字母是'a'、'e'、'i'、'o'、'u'。此外，当'y'位于单词的末尾时，也视为元音字母。
示例：
>>> vowels_count("abcde")
2
>>> vowels_count("ACEDY")
3
代码如下：
```python
def vowels_count(s):


Prompt:
问题描述：将整数x的数字进行循环移位，向右移动shift位，并将结果以字符串形式返回。如果shift > 数字的位数，则返回倒序的数字。
例如：
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
代码如下：
```python
def circular_shift(x, shift):


Prompt:
问题描述：编写一个函数，该函数接收一个字符串作为输入，并返回仅包含大写字符的ASCII码之和。
示例：
    digitSum("") => 0
    digitSum("abAB") => 131
    digitSum("abcCd") => 67
    digitSum("helloE") => 69
    digitSum("woArBld") => 131
    digitSum("aAaaaXa") => 153
代码如下：
```python
def digitSum(s):


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


Prompt:
问题描述："给定一个表示树枝的数组，该树枝由非负整数节点组成，你的任务是摘下其中一个节点并返回。应摘下具有最小偶数值的节点。如果发现多个具有相同最小偶数值的节点，则返回索引最小的节点。应以列表的形式返回摘下的节点，[ 最小值, 其索引 ]，如果没有偶数值或给定数组为空，则返回 []。
示例 1:
    输入: [4,2,3]
    输出: [2, 1]
    解释: 2 是最小的偶数值，且 2 的索引最小。
示例 2:
    输入: [1,2,3]
    输出: [2, 1]
    解释: 2 是最小的偶数值，且 2 的索引最小。
示例 3:
    输入: []
    输出: []
示例 4:
    输入: [5, 0, 3, 0, 4, 2]
    输出: [0, 1]
    解释: 0 是最小的值，但有两个零，所以我们选择第一个零，它的索引最小。
约束条件:
    * 节点的长度在 1 到 10000 之间
    * 节点的值大于等于 0"
代码如下：
```python
def pluck(arr):


Prompt:
问题描述：你得到了一个非空的正整数列表。返回大于零的最大整数，其频率大于或等于该整数本身的值。整数的频率是它在列表中出现的次数。如果不存在这样的值，返回-1。
示例：
search([4, 1, 2, 2, 3, 1]) == 2
search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
search([5, 5, 4, 4, 4]) == -1
代码如下：
```python
def search(lst):


Prompt:
问题描述：给定一个整数列表，按照奇特的顺序返回列表。这种奇特的排序方式是，你先从最小值开始，然后是剩余整数中的最大值，然后是最小值，依此类推。
示例：
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
strange_sort_list([]) == []
代码如下：
```python
def strange_sort_list(lst):


Prompt:
问题描述：给定三角形的三条边的长度。如果这三条边可以构成一个有效的三角形，则返回该三角形的面积，结果保留两位小数。否则返回-1。三个边能构成有效的三角形的条件是任何两边之和大于第三边。
示例：
triangle_area(3, 4, 5) == 6.00
triangle_area(1, 2, 10) == -1
代码如下：
```python
def triangle_area(a, b, c):


Prompt:
问题描述：编写一个函数，如果对象q能飞则返回True，否则返回False。对象q能飞的条件是它平衡（它是一个回文列表）并且其元素之和小于或等于最大可能重量w。
示例：
will_it_fly([1, 2], 5) ➞ False
# 1+2小于最大可能的重量，但它不平衡。
will_it_fly([3, 2, 3], 1) ➞ False
# 它是平衡的，但3+2+3大于最大可能的重量。
will_it_fly([3, 2, 3], 9) ➞ True
# 3+2+3小于最大可能的重量，并且它是平衡的。
will_it_fly([3], 5) ➞ True
# 3小于最大可能的重量，并且它是平衡的。
代码如下：
```python
def will_it_fly(q,w):


Prompt:
问题描述：给定一个整数数组arr，找出需要改变的最少元素数量以使数组成为回文数组。回文数组是指正向和反向读取都相同的数组。在一次更改中，你可以将一个元素更改为任何其他元素。
例如：
smallest_change([1,2,3,5,4,7,9,6]) == 4
smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
smallest_change([1, 2, 3, 2, 1]) == 0
代码如下：
```python
def smallest_change(arr):


Prompt:
问题描述：编写一个函数，该函数接受两个字符串列表，并返回总字符数少于另一个列表的所有字符串的列表。如果这两个列表的字符数相同，那么返回第一个列表。
示例：
total_match([], []) ➞ []
total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
代码如下：
```python
def total_match(lst1, lst2):


Prompt:
问题描述：编写一个函数，如果给定的数字是3个质数的乘积，则返回True，否则返回False。已知（a）小于100。
例如：
is_multiply_prime(30) == True
30 = 2 * 3 * 5
代码如下：
```python
def is_multiply_prime(a):


Prompt:
问题描述：你需要编写一个函数，如果数字x是n的简单幂则返回true，否则返回false。x是n的简单幂是指n的某个整数次幂等于x。
例如：
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_simple_power(3, 2) => false
is_simple_power(3, 1) => false
is_simple_power(5, 3) => false
代码如下：
```python
def is_simple_power(x, n):


Prompt:
问题描述：编写一个函数，该函数接收一个整数a，如果这个整数是某个整数的立方，则返回True。注意：你可以假设输入总是有效的。
示例：
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
iscube(180) ==> False
代码如下：
```python
def iscube(a):


Prompt:
问题描述：你需要编写一个函数，这个函数接收一个字符串形式的十六进制数，并计算其中是质数的十六进制数字的数量（质数是大于1的自然数，不能由两个较小的自然数的乘积得到）。十六进制的数字包括0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F。质数包括2, 3, 5, 7, 11, 13, 17等等。所以你需要确定以下数字的数量：2, 3, 5, 7, B（等于十进制的11）, D（等于十进制的13）。注意：你可以假设输入总是正确的或者是空字符串，并且符号A,B,C,D,E,F总是大写的。
例如：
对于 num = "AB"，输出应该是1。
对于 num = "1077E"，输出应该是2。
对于 num = "ABED1A33"，输出应该是4。
对于 num = "123456789ABCDEF0"，输出应该是6。
对于 num = "2020"，输出应该是2。
代码如下：
```python
def hex_key(num):


Prompt:
问题描述：你将会得到一个十进制形式的数字，你的任务是将它转换为二进制格式。该函数应返回一个字符串，每个字符代表一个二进制数。字符串中的每个字符将是'0'或'1'。字符串的开始和结束处将有额外的一对字符'db'。这些额外的字符是用来帮助格式化的。
示例：
decimal_to_binary(15)   # 返回 "db1111db"
decimal_to_binary(32)   # 返回 "db100000db"
代码如下：
```python
def decimal_to_binary(decimal):


Prompt:
问题描述：你被赋予一个字符串s。你的任务是检查这个字符串是否是"快乐的"。如果一个字符串的长度至少为3且每3个连续的字母都是不同的，那么这个字符串就是"快乐的"。
例如：
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => False
is_happy(adb) => True
is_happy(xyy) => False
代码如下：
```python
def is_happy(s):


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

示例：
grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
代码如下：
```python
def numerical_letter_grade(grades):


Prompt:
问题描述：编写一个函数，该函数接收一个字符串，并返回该字符串的长度是否为素数。如果是素数则返回True，否则返回False。
示例：
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
代码如下：
```python
def prime_length(string):


Prompt:
问题描述：给定一个正整数n，返回以1开始或结束的n位正整数的数量。
代码如下：
```python
def starts_one_ends(n):


Prompt:
问题描述：给定一个正整数N，以二进制形式返回N的各位数字的总和。
示例：
对于 N = 1000，数位之和为1，输出应为"1"。
对于 N = 150，数位之和为6，输出应为"110"。
对于 N = 147，数位之和为12，输出应为"1100"。
变量:
@N 整数
     约束条件: 0 ≤ N ≤ 10000。
输出:
 一个二进制数的字符串
代码如下：
```python
def solve(N):


Prompt:
问题描述：给定一个非空的整数列表 lst。加总位于奇数索引的偶数元素。
示例：
    add([4, 2, 6, 7]) ==> 2
代码如下：
```python
def add(lst):


Prompt:
问题描述：编写一个函数，该函数接收一个字符串并返回其有序版本。字符串的有序版本是指一个新的字符串，其中所有的单词（由空格分隔）都被替换成了新的单词，新单词中所有的字符都按照ASCII值的升序排列。注意：你应该保持句子中单词和空格的顺序。
例如：
anti_shuffle('Hi') 返回 'Hi'
anti_shuffle('hello') 返回 'ehllo'
anti_shuffle('Hello World!!!') 返回 'Hello !!!Wdlor'
代码如下：
```python
def anti_shuffle(s):


Prompt:
问题描述：你将获得一个二维数据，作为嵌套列表，这类似于矩阵，但与矩阵不同的是，每一行可能包含不同数量的列。给定列表 lst 和整数 x，找到列表中的整数 x，并返回元组列表 [(x1, y1), (x2, y2) ...]，每个元组都是一个坐标 - (行, 列)，从0开始。首先按行以升序排序坐标。同时，按列以降序排序行的坐标。
示例：
get_row([
  [1,2,3,4,5,6],
  [1,2,3,4,1,6],
  [1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
get_row([], 1) == []
get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
代码如下：
```python
def get_row(lst, x):


Prompt:
问题描述：给定一个非负整数数组，返回排序后的数组副本，如果数组的第一个值和最后一个值的和是奇数，则按升序排序数组，如果这个和是偶数，则按降序排序数组。
注意：
* 不要改变给定的数组。
示例：
* sort_array([]) => []
* sort_array([5]) => [5]
* sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
* sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
代码如下：
```python
def sort_array(array):


Prompt:
问题描述：创建一个函数encrypt，该函数读入一个字符串作为参数，返回一个通过字母表旋转加密得到的字符串。字母表应该以这样的方式旋转，即每个字母在字母表中向后移动2乘以2个位置。
例如：
encrypt('hi') 返回 'lm'
encrypt('asdfghjkl') 返回 'ewhjklnop'
encrypt('gf') 返回 'kj'
encrypt('et') 返回 'ix'
代码如下：
```python
def encrypt(s):


Prompt:
问题描述：你将得到一个整数列表。编写一个函数 next_smallest()，该函数返回列表中第二小的元素。如果没有这样的元素，则返回 None。
示例：
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest([1, 1]) == None
代码如下：
```python
def next_smallest(lst):


Prompt:
问题描述：给定一个由单词组成的字符串，你的任务是计算其中boredom的数量。 boredom指的是以"I"开头的句子。
句子由 '.', '?' 或者 '!'分隔。
例如：
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1
代码如下：
```python
def is_bored(S):


Prompt:
问题描述：创建一个接收三个数字的函数。如果其中一个数字等于另外两个数字的和，并且所有数字都是整数，则返回True。在任何其他情况下，返回False。
示例：
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, 1) ➞ True
any_int(3.6, -2.2, 2) ➞ False
代码如下：
```python
def any_int(x, y, z):


Prompt:
问题描述：编写一个函数，该函数接收一条消息，并以一种方式进行编码，即交换所有字母的大小写，并将消息中的所有元音替换为英文字母表中该元音后两位的字母。假设只有字母。
示例：
>>> encode('test')
'TGST'
>>> encode('This is a message')
'tHKS KS C MGSSCGG'
代码如下：
```python
def encode(message):


Prompt:
问题描述：你将获得一个整数列表。你需要找出其中最大的质数，并返回这个最大质数的各位数字之和。
示例：
对于 lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]，输出应为 10
对于 lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]，输出应为 25
对于 lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]，输出应为 13
对于 lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6]，输出应为 11
对于 lst = [0,81,12,3,1,21]，输出应为 3
对于 lst = [0,8,1,2,1,7]，输出应为 7
代码如下：
```python
def skjkasdkd(lst):


Prompt:
问题描述：给定一个字典，如果所有键都是小写字符串或所有键都是大写字符串，则返回True，否则返回False。如果给定的字典为空，则返回False。
示例：
check_dict_case({"a":"apple", "b":"banana"}) 应返回True。
check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) 应返回False。
check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) 应返回False。
check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) 应返回False。
check_dict_case({"STATE":"NC", "ZIP":"12345" }) 应返回True。
代码如下：
```python
def check_dict_case(dict):


Prompt:
问题描述：实现一个函数，该函数接收一个非负整数，并返回一个数组，数组中是小于n的前n个素数。
例如：
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1) => []
count_up_to(18) => [2,3,5,7,11,13,17]
代码如下：
```python
def count_up_to(n):


Prompt:
问题描述：完成一个函数，读入两个整数，并返回它们个位数乘积。假设输入始终有效。
示例：
multiply(148, 412) 应返回 16。
multiply(19, 28) 应返回 72。
multiply(2020, 1851) 应返回 0。
multiply(14,-15) 应返回 20。
代码如下：
```python
def multiply(a, b):


Prompt:
问题描述：给定一个字符串s，计算偶数索引上的大写元音字母的数量。
例如：
count_upper('aBCdEf') 返回 1
count_upper('abcdefg') 返回 0
count_upper('dBBE') 返回 0
代码如下：
```python
def count_upper(s):


Prompt:
问题描述：创建一个函数，该函数接收一个代表数字的字符串值，并返回最接近它的整数。如果该数字与两个整数等距离，那么向零的反方向取整。
示例：
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15
注意：
向零的反方向取整意味着，如果给定的数字与两个整数等距离，你应返回的是离零最远的那个。例如，closest_integer("14.5") 应返回 15，closest_integer("-14.5") 应返回 -15。
代码如下：
```python
def closest_integer(value):


Prompt:
问题描述：给定一个正整数n，你需要堆积n层的石头。
第一层有n块石头。
下一层石头的数量是：
    - 如果n是奇数，则为下一个奇数。
    - 如果n是偶数，则为下一个偶数。
返回一个列表，其中每个元素代表每一层的石头数量，索引i代表第（i+1）层。
示例：
>>> make_a_pile(3)
[3, 5, 7]
代码如下：
```python
def make_a_pile(n):


Prompt:
问题描述：你将获得一个由逗号或空格分隔的字符串。你的任务是将字符串分割成单词，并返回一个包含这些单词的数组。
例如：
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
代码如下：
```python
def words_string(s):


Prompt:
问题描述：这个函数接受两个正数x和y，并返回在[x, y]范围内（包括x和y）的最大偶数。如果该范围内没有符合条件的数字，那么函数应返回-1。
例如：
choose_num(12, 15) = 14
choose_num(13, 12) = -1
代码如下：
```python
def choose_num(x, y):


Prompt:
问题描述：你将得到两个正整数n和m，你的任务是计算从n到m（包括n和m）的整数的平均值。将答案四舍五入到最接近的整数，并将其转换为二进制。如果n大于m，返回-1。
示例：
rounded_avg(1, 5) => "0b11"
rounded_avg(7, 5) => -1
rounded_avg(10, 20) => "0b1111"
rounded_avg(20, 33) => "0b11010"
代码如下：
```python
def rounded_avg(n, m):


Prompt:
问题描述：给定一个正整数列表x。返回一个已排序的列表，该列表包含所有没有任何偶数位的元素。
注意：返回的列表应按递增顺序排序。
例如：
>>> unique_digits([15, 33, 1422, 1])
[1, 15, 33]
>>> unique_digits([152, 323, 1422, 10])
[]
代码如下：
```python
def unique_digits(x):


Prompt:
问题描述：给定一个整数数组，将其中1至9（包括1和9）的整数进行排序，然后反转结果数组，最后将每个数字替换为对应的名称，即"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"。
例如：
  arr = [2, 1, 1, 4, 5, 8, 2, 3]
    -> 排序 arr -> [1, 1, 2, 2, 3, 4, 5, 8]
    -> 反转 arr -> [8, 5, 4, 3, 2, 2, 1, 1]
  返回 ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
如果数组为空，则返回一个空数组：
  arr = []
  返回 []
如果数组中有任何异常数字，忽略它：
  arr = [1, -1 , 55]
    -> 排序 arr -> [-1, 1, 55]
    -> 反转 arr -> [55, 1, -1]
  返回 ['One']
代码如下：
```python
def by_length(arr):


Prompt:
问题描述：实现一个函数f，该函数接收n作为参数，并返回一个大小为n的列表，其中索引i处的元素值是i的阶乘（如果i是偶数）或者是从1到i的数字之和（如果i是奇数）。
i从1开始。i的阶乘是从1到i的数字的乘积（1 * 2 * ... * i）。
示例：
f(5) == [1, 2, 6, 24, 15]
代码如下：
```python
def f(n):


Prompt:
问题描述：给定一个正整数n，返回一个元组，该元组包含在范围(1, n)内（包括n）的偶数和奇数整数回文数的数量。
示例 1：
输入：3
输出：(1, 2)
解释：
整数回文数有1，2，3。其中一个是偶数，两个是奇数。
示例 2：
输入：12
输出：(4, 6)
解释：
整数回文数有1，2，3，4，5，6，7，8，9，11。其中四个是偶数，六个是奇数。
注意：
1. 1 <= n <= 10^3
2. 返回的元组分别表示偶数和奇数整数回文数的数量。
代码如下：
```python
def even_odd_palindrome(n):


Prompt:
问题描述：编写一个名为count_nums的函数，该函数接收一个整数数组，并返回其数字之和大于0的元素数量。如果一个数字是负数，那么它的第一个符号位将是负的：例如，-123的符号位是-1，2和3。
示例：
>>> count_nums([]) == 0
>>> count_nums([-1, 11, -11]) == 1
>>> count_nums([1, 1, 2]) == 3
代码如下：
```python
def count_nums(arr):


Prompt:
问题描述：我们有一个由N个整数arr[1]，arr[2]，...，arr[N]组成的数组'arr'。数组中的数字将被随机排序。你的任务是确定是否可以通过在给定数组上执行以下操作来得到一个按非递减顺序排序的数组：你可以执行任意次数的右移操作。一次右移操作意味着将数组的所有元素向右方向移动一位。数组的最后一个元素将被移动到数组的起始位置，即0号索引。如果能够通过执行上述操作获得排序数组，则返回True，否则返回False。如果给定的数组为空，则返回True。注意：给定列表的元素保证是唯一的。
例如：
move_one_ball([3, 4, 5, 1, 2])==>True
解释：通过执行2次右移操作，可以实现给定数组的非递减顺序。
move_one_ball([3, 5, 4, 1, 2])==>False
解释：对于给定的数组，无法通过执行任何数量的右移操作来获得非递减顺序。
代码如下：
```python
def move_one_ball(arr):


Prompt:
问题描述：在这个问题中，你需要实现一个函数，该函数接收两个数字列表，并确定是否可以通过它们之间的元素交换使lst1成为一个只包含偶数的列表。在lst1和lst2之间交换元素的数量没有限制。如果可以通过交换lst1和lst2的元素使得lst1的所有元素都变为偶数，则返回"YES"。否则，返回"NO"。
例如：
exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
假设输入的列表都不会为空。
代码如下：
```python
def exchange(lst1, lst2):


Prompt:
问题描述：给定一个表示空格分隔的小写字母的字符串，返回一个字典，该字典包含重复次数最多的字母和相应的计数。如果有多个字母出现次数相同，则返回它们全部。
示例：
histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
histogram('a b b a') == {'a': 2, 'b': 2}
histogram('a b c a b') == {'a': 2, 'b': 2}
histogram('b b b b a') == {'b': 4}
histogram('') == {}
代码如下：
```python
def histogram(test):


Prompt:
问题描述：我们有两个字符串s和c，你需要删除s中所有与c中任何字符相同的字符，然后检查结果字符串是否为回文。如果一个字符串正读和反读都一样，那么这个字符串就被称为回文。你应该返回一个元组，包含结果字符串和对检查的True/False。
示例：
对于 s = "abcde", c = "ae", 结果应为 ('bcd',False)
对于 s = "abcdef", c = "b"，结果应为 ('acdef',False)
对于 s = "abcdedcba", c = "ab", 结果应为 ('cdedc',True)
代码如下：
```python
def reverse_delete(s,c):


Prompt:
问题描述：给定一个由字符串组成的列表，其中每个字符串只包含数字，返回一个列表。输出中的每个元素应该是’the number of odd elements in the string i of the input.’，句子中所有的i都应该被替换为对应的输入字符串中奇数数字的数量。
示例：
>>> odd_count(['1234567'])
["the number of odd elements 4n the str4ng 4 of the 4nput."]
示例：
>>> odd_count(['3',"11111111"])
["the number of odd elements 1n the str1ng 1 of the 1nput.",
 "the number of odd elements 8n the str8ng 8 of the 8nput."]
代码如下：
```python
def odd_count(lst):


Prompt:
问题描述：给定一个整数数组 nums，找出任意非空子数组的最小和。
示例：
minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
minSubArraySum([-1, -2, -3]) == -6
代码如下：
```python
def minSubArraySum(nums):


Prompt:
问题描述：给定一个矩形的水井网格。每一行代表一个井，每一行中的1代表一单位的水。每个井都有一个对应的桶，可以用来从井中抽取水，而且所有的桶容量都相同。你的任务是使用这些桶来排空井中的水。输出你需要降低桶的次数。
示例:
>>> grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]，bucket_capacity : 1
6
>>> grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]，bucket_capacity : 2
5
>>> grid : [[0,0,0], [0,0,0]]，bucket_capacity : 5
0
约束:
    * 所有的井的长度是相同的。
    * 1 <= grid.length <= 10^2
    * 1 <= grid[:,1].length <= 10^2
    * grid[i][j] -> 0 | 1
    * 1 <= capacity <= 10
代码如下：
```python
def max_fill(grid, capacity):
    import math


Prompt:
问题描述：在这个Kata中，你需要根据二进制表示中的1的数量对一个非负整数数组进行升序排序。如果1的数量相同，那么就根据十进制值进行排序。
它应该像这样实现：
示例：
>>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
>>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
>>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
代码如下：
```python
def sort_array(arr):


Prompt:
问题描述：给定一个字符串s和一个自然数n，你的任务是实现一个函数，返回字符串s中所有恰好包含n个辅音字母的单词的列表，这些单词应按照它们在字符串s中出现的顺序排列。如果字符串s为空，则函数应返回一个空列表。注意：你可以假设输入字符串只包含字母和空格。
示例：
select_words("Mary had a little lamb", 4) ==> ["little"]
select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
select_words("simple white space", 2) ==> []
select_words("Hello world", 4) ==> ["world"]
select_words("Uncle sam", 3) ==> ["Uncle"]
代码如下：
```python
def select_words(s, n):


Prompt:
问题描述：你会得到一个单词。你的任务是从右侧开始，找到位于两个辅音之间的，最靠近右侧的元音（区分大小写）。词首和词尾的元音不计算在内。如果你没有找到符合上述条件的任何元音，请返回空字符串。你可以假设给定的字符串只包含英文字母。
示例：
get_closest_vowel("yogurt") ==> "u"
get_closest_vowel("FULL") ==> "U"
get_closest_vowel("quick") ==> ""
get_closest_vowel("ab") ==> ""
代码如下：
```python
def get_closest_vowel(word):


Prompt:
问题描述：你将得到一个包含两个字符串的列表，这两个字符串仅由开括号 '(' 或闭括号 ')' 组成。你的任务是检查是否有可能以某种顺序连接这两个字符串，使得结果字符串是好的。只有当字符串 S 中的所有括号都平衡时，才认为它是好的。例如：字符串 '(())()' 是好的，而字符串 '())' 则不是。如果有办法生成一个好的字符串，则返回 'Yes'，否则返回 'No'。
示例：
match_parens(['()(', ')']) == 'Yes'
match_parens([')', ')']) == 'No'
代码如下：
```python
def match_parens(lst):


Prompt:
问题描述：给定一个整数数组 arr 和一个正整数 k，返回一个长度为 k 的排序列表，其中包含 arr 中最大的 k 个数字。
示例 1：
输入：arr = [-3, -4, 5], k = 3
输出：[-4, -3, 5]
示例 2：
输入：arr = [4, -4, 4], k = 2
输出：[4, 4]
示例 3：
输入：arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
输出：[2]
注意：
1. 数组的长度将在 [1, 1000] 的范围内。
2. 数组中的元素将在 [-1000, 1000] 的范围内。
3. 0 <= k <= len(arr)
代码如下：
```python
def maximum(arr, k):


Prompt:
问题描述：给定一个非空的整数列表，返回所有在偶数位置的奇数元素之和。
示例：
solution([5, 8, 7, 1]) ==> 12
solution([3, 3, 3, 3, 3]) ==> 9
solution([30, 13, 24, 321]) ==>0
代码如下：
```python
def solution(lst):


Prompt:
问题描述：给定一个非空整数数组arr和一个整数k，返回arr的前k个元素中最多有两位数的元素之和。
示例：
输入：arr = [111,21,3,4000,5,6,7,8,9], k = 4
输出：24 # 21 + 3 的和
约束条件：
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr)
代码如下：
```python
def add_elements(arr, k):


Prompt:
问题描述：给定一个正整数n，返回一个排序列表，该列表包含了Collatz序列中的奇数。Collatz猜想是数学中的一个猜想，涉及到如下定义的序列：从任何一个正整数n开始。然后每个项都是根据前一个项得出的：如果前一个项是偶数，那么下一个项就是前一个项的一半。如果前一个项是奇数，那么下一个项就是前一个项的3倍加一。这个猜想是无论n的值是多少，这个序列最终总会达到1。
注意：
    1. Collatz(1) 是 [1]。
    2. 返回的列表按照递增顺序排序。
例如：
get_odd_collatz(5) 返回 [1, 5] # 5的Collatz序列是 [5, 16, 8, 4, 2, 1]，所以奇数只有1和5。
代码如下：
```python
def get_odd_collatz(n):


Prompt:
问题描述：你需要编写一个函数来验证给定的日期字符串，如果日期有效则返回True，否则返回False。日期是否有效取决于以下所有规则：
1. 日期字符串不能为空。
2. 对于月份为1,3,5,7,8,10,12的情况，天数不能少于1或超过31天。对于月份为4,6,9,11的情况，天数不能少于1或超过30天。对于2月，天数不能少于1或超过29天。
3. 月份不能少于1或超过12。
4. 日期应采用以下格式：mm-dd-yyyy
例如：
valid_date('03-11-2000') => True
valid_date('15-01-2012') => False
valid_date('04-0-2040') => False
valid_date('06-04-2020') => True
valid_date('06/04/2020') => False
代码如下：
```python
def valid_date(date):


Prompt:
问题描述：给定一个字符串，如果字符串中存在空格，就根据空格将其分割为单词列表。如果没有空格，但有逗号','，则根据逗号进行分割。如果既没有空格也没有逗号，那么你应该返回字母表中顺序为奇数的小写字母的数量，其中ord('a') = 0, ord('b') = 1, ... ord('z') = 25。
示例：
split_words("Hello world!") ➞ ["Hello", "world!"]
split_words("Hello,world!") ➞ ["Hello", "world!"]
split_words("abcdef") == 3
代码如下：
```python
def split_words(txt):


Prompt:
问题描述：给定一个数字列表，返回它们是否按升序排序。如果列表中有超过1个重复的相同数字，则返回False。假设没有负数，只有整数。
示例：
is_sorted([5]) ➞ True
is_sorted([1, 2, 3, 4, 5]) ➞ True
is_sorted([1, 3, 2, 4, 5]) ➞ False
is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
代码如下：
```python
def is_sorted(lst):


Prompt:
问题描述：给定两个区间，每个区间都是一对整数。
例如，区间 = (start, end) = (1, 2)。给定的区间是闭区间，意味着区间(start, end)包括开始值和结束值。对于每一个给定的区间，我们假设其开始值小于或等于其结束值。你的任务是确定这两个区间的交集长度是否为质数。例如，区间 (1, 3)，(2, 4) 的交集是 (2, 3)，其长度是1，不是质数。如果交集的长度是质数，返回 "YES"，否则，返回 "NO"。如果两个区间没有交集，也返回 "NO"。
[输入/输出] 示例：
intersection((1, 2), (2, 3)) ==> "NO"
intersection((-1, 1), (0, 4)) ==> "NO"
intersection((-3, -1), (-5, 5)) ==> "YES"
代码如下：
```python
def intersection(interval1, interval2):


Prompt:
问题描述：你需要处理一个整数数组arr，返回这些整数的绝对值之和乘以数组中每个数字的符号的乘积，符号由1，-1或0表示。注意：如果arr为空，则返回None。
示例：
>>> prod_signs([1, 2, 2, -4]) == -9
>>> prod_signs([0, 1]) == 0
>>> prod_signs([]) == None
代码如下：
```python
def prod_signs(arr):


Prompt:
问题描述：给定一个N行N列的网格（N >= 2）和一个正整数k，网格的每个单元格都包含一个值。在[1，N * N]的范围内的每个整数在网格的单元格上都只出现一次。你需要在网格中找到长度为k的最小路径。你可以从任何单元格开始，每一步都可以移动到任何相邻单元格，也就是说，你可以去与当前单元格共享边的单元格。请注意，长度为k的路径意味着访问恰好k个单元格（不必是不同的单元格）。你不能走出网格。如果路径A（长度为k）被认为小于路径B（长度为k），那么在制作路径A和B经过的单元格的值的有序列表（我们称之为lst_A和lst_B）后，如果lst_A在字典顺序上小于lst_B，也就是说，存在一个整数索引i（1 <= i <= k）使得lst_A[i] < lst_B[i]，并且对于任何j（1 <= j < i），我们有lst_A[j] = lst_B[j]。保证答案是唯一的。返回最小路径经过的单元格的值的有序列表。
示例：
输入：grid = [[1,2,3], [4,5,6], [7,8,9]], k = 3
输出：[1, 2, 1]
输入：grid = [[5,9,3], [4,1,6], [7,8,2]], k = 1
输出：[1]
代码如下：
```python
def minPath(grid, k):


Prompt:
问题描述：每个人都知道斐波那契数列，这是过去几个世纪以来数学家们深入研究的主题。然而，人们可能不了解的是Tribonacci数列。
Tribonacci数列由以下递归定义：
tri(1) = 3
如果n为偶数，tri(n) = 1 + n / 2。
如果n为奇数，tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)。
例如：
tri(2) = 1 + (2 / 2) = 2
tri(4) = 3
tri(3) = tri(2) + tri(1) + tri(4)
    = 2 + 3 + 3 = 8
给定一个非负整数n，你需要返回Tribonacci数列的前n + 1个数字的列表。
示例：
tri(3) = [1, 3, 2, 8]
代码如下：
```python
def tri(n):


Prompt:
问题描述：给定一个正整数n，返回其所有奇数位的乘积。如果所有数字都是偶数，则返回0。
例如：
digits(1)  == 1
digits(4)  == 0
digits(235) == 15
代码如下：
```python
def digits(n):


Prompt:
问题描述：创建一个函数，该函数接收一个只包含方括号的字符串作为输入。当且仅当存在一个有效的方括号子序列，并且子序列中至少有一个括号是嵌套的，函数应返回True。
示例：
is_nested('[[]]') ➞ True
is_nested('[]]]]]]][[[[[]') ➞ False
is_nested('[][]') ➞ False
is_nested('[]') ➞ False
is_nested('[[][]]') ➞ True
is_nested('[[]][[') ➞ True
代码如下：
```python
def is_nested(string):


Prompt:
问题描述：你需要处理一个数字列表。你需要返回列表中每个数值平方后的总和，但在这之前，你首先需要将列表中的每个元素向上取整（向上取最接近的整数）。
示例：
对于列表 lst = [1,2,3]，输出应为 14
对于列表 lst = [1,4,9]，输出应为 98
对于列表 lst = [1,3,5,7]，输出应为 84
对于列表 lst = [1.4,4.2,0]，输出应为 29
对于列表 lst = [-2.4,1,1]，输出应为 6
代码如下：
```python
def sum_squares(lst):


Prompt:
问题描述：创建一个函数，如果给定字符串的最后一个字符是字母并且不是单词的一部分，则返回True，否则返回False。注意："单词"是由空格分隔的一组字符。
示例：
check_if_last_char_is_a_letter("apple pie") ➞ False
check_if_last_char_is_a_letter("apple pi e") ➞ True
check_if_last_char_is_a_letter("apple pi e ") ➞ False
check_if_last_char_is_a_letter("") ➞ False
代码如下：
```python
def check_if_last_char_is_a_letter(txt):


Prompt:
问题描述：创建一个函数，该函数返回元素的最大索引，该元素不大于或等于其之前最相邻的元素。如果不存在这样的元素，则返回-1。给定的数组将不包含重复的值。
示例：
can_arrange([1,2,4,3,5]) = 3
can_arrange([1,2,3]) = -1
代码如下：
```python
def can_arrange(arr):


Prompt:
问题描述：创建一个函数，该函数返回一个元组(a, b)，其中 'a' 是列表中的最大负整数，'b' 是最小的正整数。如果列表中没有负整数或正整数，则返回 None。
示例：
largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
largest_smallest_integers([]) == (None, None)
largest_smallest_integers([0]) == (None, None)
代码如下：
```python
def largest_smallest_integers(lst):


Prompt:
问题描述：创建一个函数，该函数接收整数、浮点数或表示实数的字符串，并以其给定的变量类型返回较大的变量。如果值相等，则返回None。注意：如果实数被表示为字符串，那么浮点可能是'.'或','。
示例：
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3") ➞ "2,3"
compare_one("5,1", "6") ➞ "6"
compare_one("1", 1) ➞ None
代码如下：
```python
def compare_one(a, b):


Prompt:
问题描述：判断给定的数字n是否可以表示为正好4个正偶数的和。
示例：
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True
代码如下：
```python
def is_equal_to_sum_even(n):


Prompt:
问题描述：巴西阶乘定义如下：
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
其中 n > 0
例如：
>>> special_factorial(4)
288
这个函数会接收一个整数作为输入，然后返回这个整数的特殊阶乘。
代码如下：
```python
def special_factorial(n):


Prompt:
问题描述：给定一个字符串文本，将其中的所有空格替换为下划线，如果一个字符串有超过2个连续的空格，那么将所有连续的空格替换为'-'。
示例：
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example   3") == "_Example-3"
代码如下：
```python
def fix_spaces(text):


Prompt:
问题描述：创建一个函数，该函数接收表示文件名的字符串，如果文件名有效，返回'Yes'，否则返回'No'。
文件名被认为是有效的当且仅当满足以下所有条件：
- 文件名中不应超过三个数字('0'-'9')。
- 文件名中只包含一个点'.'。
- 点前的子字符串不应为空，并且以拉丁字母表的一个字母开头('a'-'z' 和 'A'-'Z')。
- 点后的子字符串应该是以下之一：['txt', 'exe', 'dll']
示例：
file_name_check("example.txt") # => 'Yes'
file_name_check("1example.dll") # => 'No' (名称应以拉丁字母开头)
代码如下：
```python
def file_name_check(file_name):


Prompt:
问题描述：这个函数将接收一个整数列表。对于列表中的所有条目，如果其索引是3的倍数，则该函数应将整数条目平方；如果其索引是4的倍数且不是3的倍数，则该函数应将整数条目立方。对于索引既非3的倍数也非4的倍数的条目，该函数不会改变它们。然后，函数应返回所有条目的总和。
示例：
对于 lst = [1,2,3]，输出应为 6
对于 lst = []，输出应为 0
对于 lst = [-1,-5,2,-1,-5]，输出应为 -126
代码如下：
```python
def sum_squares(lst):


Prompt:
问题描述：你将得到一个代表句子的字符串，这个句子包含一些由空格分隔的单词，你需要返回一个新的字符串，其中包含原始句子中长度为质数的单词，新字符串中的单词顺序应与原始句子相同。
示例 1：
输入：sentence = "This is a test"
输出："is"
示例 2：
输入：sentence = "lets go for swimming"
输出："go for"
约束条件：
* 1 <= len(sentence) <= 100
* 句子只包含字母
代码如下：
```python
def words_in_sentence(sentence):


Prompt:
问题描述：你的任务是实现一个函数，用于简化表达式 x * n。如果 x * n 的结果为整数，则函数返回True，否则返回False。其中，x 和 n 都是分数的字符串表示形式，格式为 <分子>/<分母>，分子和分母都是正整数。你可以假设 x 和 n 都是有效的分数，并且分母不为零。
例如：
simplify("1/5", "5/1") = True
simplify("1/6", "2/1") = False
simplify("7/10", "10/2") = False
代码如下：
```python
def simplify(x, n):


Prompt:
问题描述：编写一个函数，该函数根据给定整数列表中每个数字的各位数之和进行升序排序。注意：如果有多个项的各位数之和相同，则根据它们在原始列表中的索引进行排序。
例如：
>>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
>>> order_by_points([]) == []
代码如下：
```python
def order_by_points(nums):


Prompt:
问题描述：编写一个函数，该函数接收一个数字数组作为输入，并返回数组中大于10且数字的首尾位都是奇数（1、3、5、7、9）的元素数量。
例如：
specialFilter([15, -73, 14, -15]) => 1
specialFilter([33, -2, -3, 45, 21, 109]) => 2
代码如下：
```python
def specialFilter(nums):


Prompt:
问题描述：你得到了一个正整数n。你需要创建一个长度为n的整数数组a。对于每个i (1 ≤ i ≤ n)，数组a的值a[i] = i * i - i + 1。返回数组a中满足i < j < k，且a[i] + a[j] + a[k]是3的倍数的三元组(a[i], a[j], a[k])的数量。
示例：
    输入：n = 5
    输出：1
    解释：
    a = [1, 3, 7, 13, 21]
    唯一有效的三元组是(1, 7, 13)。
代码如下：
```python
def get_max_triples(n):


Prompt:
问题描述：这是一个关于我们太阳系的八大行星的问题：离太阳最近的是Mercury，然后是Venus，Earth，Mars，Jupiter，Saturn，Uranus，和Neptune。编写一个函数，该函数接受两个行星名称作为字符串planet1和planet2。 函数应返回一个包含所有位于planet1和planet2轨道之间的行星的元组，按照靠近太阳的顺序排序。 如果planet1或planet2不是正确的行星名称，函数应返回一个空元组。
示例：
bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
bf("Earth", "Mercury") ==> ("Venus")
bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
代码如下：
```python
def bf(planet1, planet2):


Prompt:
问题描述：编写一个函数，该函数接受一个字符串列表作为参数，删除其中长度为奇数的字符串，并以排序的方式返回结果列表，这个列表总是由字符串组成，而不是数字数组，并且可能包含重复项。列表应按每个单词的长度升序排列，并且应按此规则返回排序的列表。如果两个单词长度相同，按字母顺序排序列表。函数应返回一个按排序顺序的字符串列表。你可以假设所有单词的长度都是相同的。
例如：
assert list_sort(["aa", "a", "aaa"]) => ["aa"]
assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
代码如下：
```python
def sorted_list_sum(lst):


Prompt:
问题描述：一个简单的程序，如果n是一个质数，那么它应该返回x的值，否则应该返回y的值。
示例：
对于 x_or_y(7, 34, 12)，结果应为 34
对于 x_or_y(15, 8, 5)，结果应为 5
代码如下：
```python
def x_or_y(n, x, y):


Prompt:
问题描述：给定一个数字列表，返回列表中奇数的平方和。忽略负数或非整数。
示例：
double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
double_the_difference([-1, -2, 0]) == 0
double_the_difference([9, -2]) == 81
double_the_difference([0]) == 0
如果输入列表为空，返回0。
代码如下：
```python
def double_the_difference(lst):


Prompt:
问题描述：我想我们都记得那种当某个期待已久的事件的结果最终揭晓时的感觉。那一刻你的感受和想法绝对值得记录下来并进行比较。你的任务是确定一个人是否正确地猜测了一系列比赛的结果。你将得到两个长度相等的比分和猜测数组，其中每个索引表示一场比赛。返回一个长度相同的数组，表示每次猜测的偏差程度。如果他们猜对了，值就是0，如果没有，值就是猜测和比分之间的绝对差值。
示例：
compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
代码如下：
```python
def compare(game,guess):


Prompt:
问题描述：你将得到一个类的名称（一个字符串）和一组扩展名。这些扩展名是用于加载到类中的额外类。扩展的强度以如下方式确定：设CAP为扩展名中大写字母的数量，SM为扩展名中小写字母的数量，那么强度就由算式CAP-SM给出。你应该找到最强的扩展，并以这种格式返回一个字符串：ClassName.StrongestExtensionName。如果有两个或更多的扩展具有相同的强度，你应该选择列表中最早出现的那个。例如，如果你得到"Slices"作为类，以及一组扩展：['SErviNGSliCes', 'Cheese', 'StuFfed']，那么你应该返回'Slices.SErviNGSliCes'，因为'SErviNGSliCes'是最强的扩展（其强度为-1）。例如：对于Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'。
代码如下：
```python
def Strongest_Extension(class_name, extensions):


Prompt:
问题描述：你被给予两个单词。如果第二个单词或其任何旋转版本是第一个单词的子字符串，你需要返回True。
示例：
cycpattern_check("abcd","abd") => False
cycpattern_check("hello","ell") => True
cycpattern_check("whassup","psus") => False
cycpattern_check("abab","baa") => True
cycpattern_check("efef","eeff") => False
cycpattern_check("himenss","simen") => True
代码如下：
```python
def cycpattern_check(a , b):


Prompt:
问题描述：给定一个整数。返回一个元组，其中包含该整数中偶数和奇数数字的数量。
示例：
    even_odd_count(-12) ==> (1, 1)
    even_odd_count(123) ==> (1, 2)
代码如下：
```python
def even_odd_count(num):


Prompt:
问题描述：给定一个正整数，获取其对应的罗马数字字符串，并以小写形式返回。
限制条件：1 <= 数字 <= 1000
示例：
>>> int_to_mini_roman(19) == 'xix'
>>> int_to_mini_roman(152) == 'clii'
>>> int_to_mini_roman(426) == 'cdxxvi'
代码如下：
```python
def int_to_mini_roman(number):


Prompt:
问题描述：给定一个三角形的三条边的长度。如果这三条边构成一个直角三角形，返回True，否则返回False。直角三角形是一种有一个角为直角或90度的三角形。
示例：
right_angle_triangle(3, 4, 5) == True
right_angle_triangle(1, 2, 3) == False
代码如下：
```python
def right_angle_triangle(a, b, c):


Prompt:
问题描述：编写一个接受字符串列表的函数。列表包含不同的单词。返回具有最多唯一字符的单词。如果有多个字符串具有最大数量的唯一字符，按字典顺序返回第一个。
示例：
find_max(["name", "of", "string"]) == "string"
find_max(["name", "enam", "game"]) == "enam"
find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
代码如下：
```python
def find_max(words):


Prompt:
问题描述：你是一只饥饿的兔子，你已经吃了一定数量的胡萝卜，但现在你需要吃更多的胡萝卜来完成一天的饭量。你应该返回一个数组，包括[吃完饭后吃掉的胡萝卜总数，吃完饭后剩下的胡萝卜数量]。如果剩下的胡萝卜不够，你会吃掉所有剩下的胡萝卜，但仍然会觉得饿。
示例：
* eat(5, 6, 10) -> [11, 4]
* eat(4, 8, 9) -> [12, 1]
* eat(1, 10, 10) -> [11, 0]
* eat(2, 11, 5) -> [7, 0]
变量：
@number : 整数
你已经吃掉的胡萝卜数量。
@need : 整数
你需要吃的胡萝卜数量。
@remaining : 整数
库存中剩余的胡萝卜数量
约束：
* 0 <= number <= 1000
* 0 <= need <= 1000
* 0 <= remaining <= 1000
祝你玩得开心 :)
代码如下：
```python
def eat(number, need, remaining):


Prompt:
问题描述：给定两个列表operator和operand。第一个列表包含基本的代数运算，第二个列表是一组整数。使用这两个给定的列表来构建代数表达式，并返回这个表达式的计算结果。
基本的代数运算包括：
加法 ( + )
减法 ( - )
乘法 ( * )
整除 ( // )
指数运算 ( ** )
示例：
operator['+', '*', '-']
array = [2, 3, 4, 5]
result = 2 + 3 * 4 - 5
=> 结果 = 9
注意：
运算符列表的长度等于操作数列表的长度减一。
操作数是非负整数的列表。
运算符列表至少有一个运算符，操作数列表至少有两个操作数。
代码如下：
```python
def do_algebra(operator, operand):


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


Prompt:
问题描述：给定一个字符串'text'，返回其对应的md5 hash字符串。如果'text'是一个空字符串，则返回None。
示例：
>>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
代码如下：
```python
def string_to_md5(text):


Prompt:
问题描述：给定两个正整数a和b，返回a和b之间的偶数数字，按升序排列。
例如：
generate_integers(2, 8) => [2, 4, 6, 8]
generate_integers(8, 2) => [2, 4, 6, 8]
generate_integers(10, 14) => []
代码如下：
```python
def generate_integers(a, b):