from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Kiểm tra xem trong danh sách các số cho trước, có bất kỳ hai số nào gần nhau hơn
    ngưỡng đã cho hay không.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Kiểm tra xem trong danh sách số đã cho, có bất kỳ hai số nào gần nhau hơn
    ngưỡng đã cho không.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Kiểm tra xem trong danh sách số đã cho, có hai số nào gần nhau hơn ngưỡng đã cho hay không.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc lồng nhau. Mục tiêu là
    tách các nhóm này thành các chuỗi riêng lẻ và trả về danh sách đó.
    Các nhóm riêng lẻ được cân bằng (mỗi dấu ngoặc mở đều được đóng đúng cách) và không lồng vào nhau.
    Khoảng trắng trong chuỗi đầu vào được bỏ qua.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc đơn lồng nhau. Mục tiêu của bạn là
    tách các nhóm đó thành các chuỗi riêng biệt và trả về danh sách các nhóm đó.
    Các nhóm riêng biệt được cân bằng (mỗi dấu ngoặc mở được đóng đúng cách) và không được lồng vào nhau
    Bỏ qua bất kỳ khoảng trắng nào trong chuỗi đầu vào.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc đơn lồng nhau. Mục tiêu của bạn là
    tách các nhóm này thành các chuỗi riêng biệt và trả về danh sách các nhóm đó.
    Các nhóm tách biệt là cân bằng (mỗi dấu ngoặc mở đều có dấu ngoặc đóng tương ứng) và không lồng vào nhau.
    Bỏ qua bất kỳ khoảng trắng nào trong chuỗi đầu vào.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Cho một số thực dương, nó có thể được phân tách thành phần nguyên
    (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân (phần còn lại luôn nhỏ hơn 1).

    Trả về phần thập phân của số.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Với một số dấu phẩy động dương, nó có thể được phân tích thành
    và phần nguyên (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân
    (phần còn lại luôn nhỏ hơn 1).

    Trả về phần thập phân của số.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Cho một số thực dương, nó có thể được phân thành
    phần nguyên (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân
    (phần dư luôn nhỏ hơn 1).

    Trả về phần thập phân của số.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """Bạn được cho một danh sách các giao dịch gửi tiền và rút tiền từ tài khoản ngân hàng, bắt đầu với số dư bằng 0. Nhiệm vụ của bạn là phát hiện nếu tại bất kỳ thời điểm nào, số dư tài khoản giảm xuống dưới 0, và khi đó hàm nên trả về True. Nếu không, hàm nên trả về False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Bạn được cung cấp một danh sách các giao dịch gửi và rút tiền của một tài khoản ngân hàng bắt đầu với
    số dư bằng không. Nhiệm vụ của bạn là phát hiện xem tại bất kỳ thời điểm nào số dư của tài khoản giảm xuống dưới không và
    tại thời điểm đó hàm sẽ trả về True. Nếu không, nó sẽ trả về False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Bạn được cung cấp danh sách các hoạt động gửi và rút tiền từ một tài khoản ngân hàng bắt đầu với
    số dư là 0. Nhiệm vụ là phát hiện thời điểm số dư tài khoản giảm xuống dưới 0, và
    tại thời điểm đó, hàm phải trả về True. Nếu không, trả về False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Đối với danh sách số đầu vào đã cho, hãy tính Độ lệch tuyệt đối trung bình
    xung quanh giá trị trung bình của tập dữ liệu này.
    Độ lệch tuyệt đối trung bình là chênh lệch tuyệt đối trung bình giữa mỗi
    phần tử và một điểm trung tâm (trung bình trong trường hợp này là):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Đối với một danh sách các số đầu vào nhất định, hãy tính Độ lệch tuyệt đối trung bình
    xung quanh giá trị trung bình của tập dữ liệu này.
    Độ lệch tuyệt đối trung bình là sự khác biệt tuyệt đối trung bình giữa mỗi
    phần tử và một điểm trung tâm (trung bình trong trường hợp này):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Đối với một danh sách số đầu vào, tính Toán Độ lệch tuyệt đối trung bình
    quanh giá trị trung bình của tập dữ liệu này.
    Độ lệch tuyệt đối trung bình là giá trị trung bình của sự khác biệt tuyệt đối giữa mỗi
    phần tử và điểm trung tâm (trong trường hợp này là giá trị trung bình):
    MAD = trung bình | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Chèn một số 'delimeter' vào giữa mỗi hai phần tử liên tiếp trong danh sách đầu vào `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Chèn một số 'delimeter' giữa mỗi hai phần tử liên tiếp của danh sách đầu vào `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Chèn số 'delimeter' giữa hai phần tử liên tiếp trong danh sách đầu vào `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Đầu vào của hàm này là một chuỗi biểu diễn nhiều nhóm ngoặc lồng nhau được phân tách bằng dấu cách.
    Đối với mỗi nhóm, xuất ra mức độ lồng nhau sâu nhất của ngoặc.
    Ví dụ: (()()) có tối đa hai cấp độ lồng nhau và ((())) có ba cấp độ lồng nhau.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Đầu vào của hàm này là một chuỗi được biểu thị bằng nhiều nhóm cho các dấu ngoặc đơn lồng nhau được phân tách bằng dấu cách.
    Đối với mỗi nhóm, đầu ra là mức lồng nhau sâu nhất của các dấu ngoặc đơn.
    Ví dụ. (()()) có tối đa hai mức lồng nhau trong khi ((())) có ba mức.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Đầu vào của hàm này là một chuỗi đại diện cho nhiều nhóm dấu ngoặc đơn lồng nhau, các nhóm được phân cách bởi khoảng trắng.
    Với mỗi nhóm, trả về mức độ sâu nhất của dấu ngoặc đơn lồng nhau.
    Ví dụ: (()()) có tối đa hai mức độ lồng nhau, trong khi ((())) có ba mức độ.

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Lọc danh sách chuỗi đầu vào chỉ để lại các chuỗi chứa phần chuỗi con đã cho.
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Lọc danh sách chuỗi đầu vào chỉ cho những chuỗi chứa một chuỗi con đã cho.
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Lọc danh sách đầu vào của các chuỗi chỉ để lại các chuỗi chứa phần chuỗi con đã cho
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Cho một danh sách các số nguyên, trả về một tuple bao gồm tổng và tích của tất cả các số nguyên trong danh sách.
    Tổng của danh sách rỗng phải bằng 0 và tích của danh sách rỗng phải bằng 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """Dành cho một danh sách các số nguyên, trả về một tuple bao gồm tổng và tích của tất cả các số trong danh sách.
    Tổng của danh sách rỗng nên bằng 0 và tích của danh sách rỗng nên bằng 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Trả về một bộ giá trị gồm tổng và tích của tất cả các số nguyên trong danh sách đã cho.
    Tổng của danh sách rỗng phải bằng 0 và tích của danh sách rỗng phải bằng 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Từ danh sách các số nguyên đã cho, tạo danh sách giá trị lớn nhất tích lũy được tìm thấy cho đến thời điểm đã cho
    trong chuỗi.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Tạo danh sách cuộn của các phần tử lớn nhất được tìm thấy cho đến thời điểm hiện tại trong dãy số nguyên đã cho.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """
    Từ một danh sách các số nguyên cho trước, tạo ra một danh sách các giá trị tối đa tích lũy cho đến thời điểm hiện tại
    trong dãy.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Kiểm tra xem chuỗi có phải là palindrome không """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Tìm palindrome ngắn nhất bắt đầu bằng chuỗi đã cho.
    Ý tưởng thuật toán rất đơn giản:
    - Tìm hậu tố dài nhất của chuỗi được cung cấp là palindrome.
    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi đứng trước hậu tố palindrome.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Kiểm tra xem chuỗi đã cho có phải là chuỗi đối xứng  hay không """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Tìm chuỗi đối xứng ngắn nhất bắt đầu với chuỗi đã cho.
    Ý tưởng thuật toán rất đơn giản:
    - Tìm hậu tố dài nhất của chuỗi đã cho mà là một chuỗi đối xứng .
    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi trước hậu tố đối xứng đó.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Kiểm tra xem chuỗi đã cho có phải là palindrome không """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Tìm palindrome ngắn nhất bắt đầu bằng một chuỗi được cung cấp.
    Ý tưởng thuật toán rất đơn giản:
    - Tìm hậu tố dài nhất của chuỗi được cung cấp là palindrome.
    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi đứng trước hậu tố palindrome.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """
    Đầu vào là hai chuỗi a và b chỉ bao gồm các ký tự 1 và 0.
    Thực hiện phép XOR nhị phân trên hai chuỗi này và trả về kết quả cũng dưới dạng một chuỗi.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Đầu vào là hai chuỗi a and b chỉ bao gồm các số 1s and 0s.
    Thực hiện phép XOR nhị phân trên các đầu vào này và trả về kết quả dưới dạng chuỗi.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Đầu vào là hai chuỗi a và b chỉ bao gồm 1 và 0.
    Thực hiện XOR nhị phân trên các đầu vào này và trả về kết quả cũng dưới dạng chuỗi.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """Trong danh sách các chuỗi, trả về chuỗi dài nhất. Nếu có nhiều chuỗi có cùng độ dài, trả về chuỗi đầu tiên.
    Trả về None nếu danh sách đầu vào rỗng.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ "Từ danh sách các chuỗi, trả về chuỗi dài nhất. Nếu có nhiều chuỗi có độ dài bằng nhau,
    trả về chuỗi đầu tiên. Trả về None nếu danh sách đầu vào là rỗng.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Trong danh sách các chuỗi, trả về chuỗi dài nhất. Trả về chuỗi đầu tiên trong trường hợp có nhiều
    chuỗi có cùng độ dài. Trả về None trong trường hợp danh sách đầu vào trống.
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ Trả về ước chung lớn nhất của hai số nguyên a và b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Trả về danh sách tất cả các tiền tố từ ngắn nhất đến dài nhất của chuỗi đầu vào
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Trả về danh sách tất cả các tiền tố của chuỗi đầu vào từ ngắn nhất đến dài nhất
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Trả về một chuỗi chứa các số được phân cách bởi dấu cách, bắt đầu từ 0 đến n (bao gồm n).
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Trả về một chuỗi chứa các số phân cách bằng dấu cách bắt đầu từ 0 đến n bao gồm.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Trả về một chuỗi chứa các số phân cách bằng dấu cách bắt đầu từ 0 đến n.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Cho một chuỗi, tìm xem nó bao gồm bao nhiêu ký tự khác nhau (không phân biệt chữ hoa chữ thường).
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Cho một chuỗi, hãy tìm xem chuỗi đó bao gồm bao nhiêu ký tự riêng biệt (bất kể chữ hoa hay chữ thường)
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Cho một chuỗi, tìm ra số lượng ký tự khác nhau (không phân biệt chữ hoa hay chữ thường) mà chuỗi đó chứa
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Đầu vào của hàm này là một chuỗi đại diện cho các nốt nhạc theo định dạng ASCII đặc biệt.
    Nhiệm vụ của bạn là phân tích chuỗi này và trả về một danh sách các số nguyên tương ứng với số nhịp mà mỗi
    nốt nhạc kéo dài.

    Dưới đây là ký hiệu:
    'o' - nốt tròn, kéo dài bốn nhịp
    'o|' - nốt trắng, kéo dài hai nhịp
    '.|' - nốt đen, kéo dài một nhịp

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Đầu vào cho hàm này là một chuỗi biểu diễn các nốt nhạc theo định dạng ASCII đặc biệt.
    Nhiệm vụ của bạn là phân tích cú pháp chuỗi này và trả về danh sách các số nguyên tương ứng với số nhịp mà mỗi nốt
    không kéo dài.

    Sau đây là một chú giải:
    'o' - nốt tròn, kéo dài 4 nhịp
    'o|' - nốt trắng, kéo dài 2 nhịp
    '.|' - nốt đen, kéo dài 1 nhịp

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Đầu vào cho hàm này là một chuỗi biểu diễn các nốt nhạc theo định dạng ASCII đặc biệt.
    Nhiệm vụ của bạn là phân tích cú pháp chuỗi này và trả về danh sách các số nguyên tương ứng với số nhịp mà mỗi nốt không
    kéo dài.

    Sau đây là chú giải:
    'o' - nốt tròn, kéo dài 4 nhịp
    'o|' - nốt trắng, kéo dài 2 nhịp
    '.|' - nốt đen, kéo dài 1 nhịp

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


def how_many_times(string: str, substring: str) -> int:
    """ Tìm số lần một chuỗi con đã cho có thể được tìm thấy trong chuỗi gốc. Đếm các trường hợp chồng chéo.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Tìm số lần một chuỗi con nhất định có thể được tìm thấy trong chuỗi gốc. Đếm các trường hợp chồng chéo.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Tìm xem một chuỗi con xuất hiện bao nhiêu lần trong chuỗi gốc. Đếm cả trường hợp chồng chéo.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ Đầu vào là một chuỗi các số được phân cách bằng khoảng trắng từ 'zero' đến 'nine'.
    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.
    Trả về chuỗi với các số được sắp xếp từ nhỏ nhất đến lớn nhất.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Đầu vào là một chuỗi số được phân cách bằng dấu cách từ 'zero' đến 'nine'.
    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.
    Trả về chuỗi có các số được sắp xếp từ nhỏ nhất đến lớn nhất
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Đầu vào là một chuỗi các số được phân cách bằng dấu cách từ 'zero' đến 'nine'.
    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.
    Trả về chuỗi với các số được sắp xếp từ nhỏ đến lớn.
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Chọn hai số gần nhau nhất từ danh sách số đã cho (có độ dài ít nhất là hai)
    và trả về theo thứ tự số nhỏ, số lớn.
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Từ danh sách các số đã cho (có ít nhất hai phần tử), chọn và trả về hai số có khoảng cách gần nhất với nhau
    và trả về chúng theo thứ tự (số nhỏ hơn, số lớn hơn).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """Từ danh sách các số đã cho (có độ dài ít nhất là hai), chọn và trả về hai số gần nhau nhất và trả chúng theo thứ tự (số nhỏ hơn, số lớn hơn).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Cho danh sách các số (có ít nhất hai phần tử), áp dụng phép biến đổi tuyến tính cho danh sách đó,
    sao cho số nhỏ nhất sẽ trở thành 0 và số lớn nhất sẽ trở thành 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Cho danh sách các số (ít nhất có hai phần tử), áp dụng phép biến đổi tuyến tính cho danh sách đó,
    sao cho số nhỏ nhất sẽ trở thành 0 và số lớn nhất sẽ trở thành 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Lọc các số nguyên từ danh sách các giá trị Python đã cho
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Lọc danh sách đã cho của bất kỳ giá trị python nào chỉ dành cho số nguyên
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Lọc danh sách các giá trị python bất kỳ chỉ lấy các số nguyên
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Trả về độ dài của chuỗi đã cho
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """Cho một số n, tìm số lớn nhất nhỏ hơn n mà n chia hết cho số đó
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Cho số n, tìm số lớn nhất mà chia hết n, nhỏ hơn n.
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Với một số n cho trước, hãy tìm số lớn nhất chia hết cho n, nhỏ hơn n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Trả về danh sách các thừa số nguyên tố của số nguyên đã cho theo thứ tự từ nhỏ đến lớn.
    Mỗi thừa số phải được liệt kê theo số lần xuất hiện trong phép phân tích thừa số.
    Số đầu vào phải bằng tích của tất cả các thừa số.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Trả về danh sách các yếu tố nguyên tố của số nguyên đã cho theo thứ tự từ nhỏ nhất đến lớn nhất.
    Mỗi yếu tố sẽ được liệt kê số lần tương ứng với số lần nó xuất hiện trong phép phân tích.
    Số đầu vào phải bằng tích của tất cả các yếu tố.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Trả về danh sách các ước số nguyên tố của số nguyên đầu vào theo thứ tự từ nhỏ nhất đến lớn nhất.
    Mỗi yếu tố trong danh sách sẽ được liệt kê theo số lần xuất hiện trong phân tích thừa số.
    Số đầu vào phải bằng tích của tất cả các thừa số.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Từ một danh sách các số nguyên, loại bỏ tất cả các phần tử xuất hiện hơn một lần.
    Giữ nguyên thứ tự của các phần tử còn lại như trong danh sách đầu vào.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Từ danh sách các số nguyên, xóa tất cả các phần tử xuất hiện nhiều hơn một lần.
    Giữ nguyên thứ tự các phần tử như trong đầu vào.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Loại bỏ tất cả các phần tử xuất hiện nhiều hơn một lần trong danh sách số nguyên.
    Giữ nguyên thứ tự của các phần tử còn lại như trong đầu vào.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Đối với một chuỗi cho trước, chuyển đổi các ký tự chữ thường thành chữ hoa và ngược lại.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Đối với chuỗi đã cho, chuyển chữ thường thành chữ hoa và chữ hoa thành chữ thường.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Đối với một chuỗi nhất định, hãy đảo ngược các ký tự chữ thường thành chữ hoa và chữ hoa thành chữ thường.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Nối danh sách các chuỗi thành một chuỗi duy nhất
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Nối danh sách các chuỗi thành một chuỗi
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Lọc danh sách chuỗi đầu vào chỉ lấy những chuỗi bắt đầu bằng tiền tố đã cho.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """Lọc danh sách chuỗi đầu vào chỉ bao gồm các chuỗi bắt đầu bằng tiền tố đã cho.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Lọc danh sách chuỗi đầu vào chỉ để lại các chuỗi bắt đầu bằng tiền tố đã cho.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Trả về chỉ các số dương trong danh sách.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """Chỉ trả về các số dương trong danh sách.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """Chỉ trả về các số dương trong danh sách.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """Trả về true nếu một số cho trước là số nguyên tố, và false nếu không phải.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Trả về true nếu số được cho là số nguyên tố, nếu không thì trả về false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Trả về true nếu số đã cho là số nguyên tố, và false nếu không.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Tính giá trị của đa thức với các hệ số xs tại điểm x.
    trả về xs[0] + xs[1] * x + xs[2] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """  xs là các hệ số của một đa thức.
    find_zero tìm giá trị x sao cho poly(x) = 0.
    find_zero chỉ trả về một điểm x sao cho poly(x) = 0, dù đa thức có nhiều nghiệm.
    Thêm vào đó, find_zero chỉ nhận danh sách xs có số hệ số chẵn
    và hệ số lớn nhất khác 0 vì nó đảm bảo rằng sẽ có nghiệm.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Đánh giá đa thức với các hệ số xs tại điểm x.
    trả về 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 là các hệ số của một đa thức.
    find_zero tìm x sao cho poly(x) = 0.
    find_zero chỉ trả về một điểm x , ngay cả khi có nhiều điểm.
    Hơn nữa, find_zero chỉ nhận danh sách xs có số lượng hệ số chẵn
    và hệ số không bằng không lớn nhất vì nó đảm bảo
    có một nghiệm.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Đánh giá đa thức có hệ số xs tại điểm x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs là hệ số của đa thức.
    find_zero tìm x sao cho poly(x) = 0.
    find_zero chỉ trả về điểm không, ngay cả khi có nhiều điểm không.
    Hơn nữa, find_zero chỉ lấy danh sách xs có số hệ số chẵn
    và hệ số khác không lớn nhất vì nó đảm bảo
    một nghiệm.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Hàm này lấy một danh sách l và trả về một danh sách l' sao cho
    l' giống hệt l trong các chỉ số không chia hết cho ba, trong khi các giá trị của nó tại các chỉ số chia hết cho ba bằng với các giá trị của các chỉ số tương ứng của l, nhưng đã được sắp xếp.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Hàm này nhận vào một danh sách l và trả về một danh sách l' sao cho
    l' giống hệt l ở những chỉ số không chia hết cho ba, trong khi các giá trị ở những chỉ số chia hết cho ba sẽ
    bằng các giá trị của các chỉ số tương ứng trong l, nhưng được sắp xếp.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Hàm này lấy một danh sách l và trả về một danh sách l' sao cho
    l' giống hệt l trong các chỉ số không chia hết cho ba, trong khi các giá trị của nó tại các chỉ số chia hết cho ba bằng
    với các giá trị của các chỉ số tương ứng của l, nhưng được sắp xếp.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Trả về các phần tử duy nhất được sắp xếp trong một danh sách
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Trả về các phần tử duy nhất trong danh sách đã được sắp xếp
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Trả về các phần tử duy nhất đã được sắp xếp từ danh sách
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Trả về phần tử lớn nhất trong danh sách.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Trả về số lần chữ số 7 xuất hiện trong các số nguyên nhỏ hơn n và chia hết cho 11 hoặc 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Trả về số lần xuất hiện của chữ số 7 trong các số nguyên nhỏ hơn n và chia hết cho 11 hoặc 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Trả về số lần xuất hiện chữ số 7 trong các số nguyên nhỏ hơn n chia hết cho 11 hoặc 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Hàm này nhận một danh sách l và trả về một danh sách l' sao cho
    l' giống với l ở các chỉ số lẻ, trong khi các giá trị của nó ở các chỉ số chẵn
    bằng các giá trị ở chỉ số chẵn của l đã được sắp xếp.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Hàm này lấy một danh sách l và trả về một danh sách l' sao cho
    l' giống hệt l trong các chỉ số lẻ, trong khi các giá trị của nó ở các chỉ số chẵn bằng
    với các giá trị của các chỉ số chẵn của l, nhưng được sắp xếp.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Hàm này nhận một danh sách l và trả về danh sách l' sao cho
    l' giống l ở các chỉ số lẻ, trong khi các giá trị tại các chỉ số chẵn của l' sẽ
    bằng các giá trị của các chỉ số chẵn trong l nhưng đã được sắp xếp.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    trả về chuỗi đã mã hóa bằng cách xoay vòng các nhóm ba ký tự.
    """
    # Chia chuỗi thành các nhóm. Mỗi nhóm có độ dài là 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Xoay vòng các phần tử trong mỗi nhóm, trừ khi nhóm có ít hơn 3 phần tử.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Nhận chuỗi đã mã hóa bằng hàm encode_cyclic làm đầu vào. Trả về chuỗi đã giải mã.
    """

def encode_cyclic(s: str):
    """
    Trả về chuỗi đã mã hóa bằng cách xoay các nhóm ba ký tự.
    """
    # chia chuỗi thành các nhóm, mỗi nhóm có độ dài 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # xoay các phần tử trong mỗi nhóm, trừ khi nhóm có ít hơn 3 phần tử.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Nhận đầu vào là chuỗi được mã hóa bằng hàm encode_cyclic. Trả về chuỗi đã giải mã.
    """

def encode_cyclic(s: str):
    """
    trả về chuỗi được mã hóa bằng cách tuần hoàn các nhóm gồm ba ký tự.
    """
    # chia chuỗi thành các nhóm. Mỗi nhóm có độ dài 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # tuần hoàn các phần tử trong mỗi nhóm. Trừ khi nhóm có ít phần tử hơn 3
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    lấy chuỗi đầu vào được mã hóa bằng hàm encode_cyclic. Trả về chuỗi đã giải mã.
    """


def prime_fib(n: int):
    """
    prime_fib trả về số thứ n trong dãy Fibonacci mà cũng là số nguyên tố.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    Hàm prime_fib trả về số thứ n là số  Fibonacci và cũng là số nguyên tố.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """ >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib trả về số thứ n là số Fibonacci và cũng là số nguyên tố.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero nhận một danh sách các số nguyên làm đầu vào.
    Hàm trả về True nếu có ba phần tử khác nhau trong danh sách có tổng bằng không,
    và trả về False nếu không có.

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero nhận vào một danh sách các số nguyên.
    Hàm trả về True nếu có ba phần tử khác nhau trong danh sách có tổng bằng không,
    và False nếu không có.

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero lấy một danh sách các số nguyên làm đầu vào.
    trả về True nếu có ba phần tử riêng biệt trong danh sách
    có tổng bằng 0, và False nếu ngược lại.

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


def car_race_collision(n: int):
    """
    Hãy tưởng tượng một con đường là một đường thẳng dài vô hạn hoàn hảo.
    n chiếc xe ô tô đang lái từ trái sang phải; đồng thời, một nhóm n xe ô tô khác
    đang lái từ phải sang trái. Hai nhóm xe ban đầu cách nhau rất xa. Tất
    cả các xe đều di chuyển với cùng một tốc độ. Hai xe được cho là va chạm
    khi một xe đang di chuyển từ trái sang phải đâm vào một xe đang di chuyển từ phải sang trái.
    Tuy nhiên, các xe vô cùng chắc chắn và mạnh mẽ; do đó, chúng tiếp tục di chuyển
    theo quỹ đạo của chúng như thể chúng không va chạm.

    Hàm này đưa ra số lần va chạm như vậy.
    """

def car_race_collision(n: int):
    """
    Hãy tưởng tượng một con đường là một đường thẳng dài vô hạn hoàn hảo.
    n xe đang lái từ trái sang phải; đồng thời, một nhóm n xe khác
    đang lái từ phải sang trái. Hai nhóm xe ban đầu cách nhau rất xa. Tất cả các xe đều di chuyển với cùng một tốc độ. Hai xe được cho là va chạm
    khi một xe đang di chuyển từ trái sang phải đâm vào một xe đang di chuyển từ phải sang trái.
    Tuy nhiên, các xe vô cùng chắc chắn và mạnh mẽ; do đó, chúng tiếp tục di chuyển
    theo quỹ đạo của chúng như thể chúng không va chạm.

    Hàm này đưa ra số lần va chạm như vậy.
    """

def car_race_collision(n: int):
    """
    Hãy tưởng tượng con đường là một đường thẳng hoàn hảo kéo dài vô hạn.
    Có n chiếc ô tô đang lái từ trái sang phải; đồng thời, có n chiếc ô tô khác
    đang lái từ phải sang trái. Hai nhóm ô tô ban đầu cách nhau rất xa.
    Tất cả các ô tô đều di chuyển với cùng một tốc độ. Khi một chiếc ô tô di chuyển
    từ trái sang phải gặp một chiếc ô tô di chuyển từ phải sang trái, được gọi là va chạm.
    Tuy nhiên, các ô tô vô cùng bền bỉ và mạnh mẽ; kết quả là, chúng tiếp tục di chuyển
    theo quỹ đạo của mình như thể không có va chạm nào xảy ra.

    Hàm này sẽ xuất ra số lượng các va chạm như vậy.
    """


def incr_list(l: list):
    """Trả về danh sách với các phần tử được tăng thêm 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Trả về danh sách có các phần tử tăng thêm 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero nhận một danh sách các số nguyên làm đầu vào.
    Hàm trả về True nếu có hai phần tử khác nhau trong danh sách có tổng bằng không, và trả về False nếu không có.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero lấy một danh sách các số nguyên làm đầu vào.
    trả về True nếu có hai phần tử riêng biệt trong danh sách
    có tổng bằng 0, và False nếu không.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """Chuyển đổi cơ số của số đầu vào x sang cơ số mới.
    Trả về chuỗi biểu diễn số sau khi chuyển đổi.
    Các cơ số nhỏ hơn 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Đổi cơ số của số đầu vào x thành cơ số.
    trả về biểu diễn chuỗi sau khi chuyển đổi.
    các số cơ số nhỏ hơn 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Chuyển đổi cơ số của số đầu vào x sang cơ số mới.
    Trả về chuỗi biểu diễn số sau khi chuyển đổi.
    Các cơ số đều nhỏ hơn 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Cho chiều dài của một cạnh và chiều cao, trả về diện tích của tam giác.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Cho chiều dài một cạnh và chiều cao, trả về diện tích của tam giác.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Dãy số Fib4 tương tự như dãy số Fibonacci và được định nghĩa như sau:
    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).
    Viết một hàm để tính toán phần tử thứ n của dãy số Fib4 một cách hiệu quả. Không sử dụng đệ quy.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Dãy số Fib4 tương tự như dãy số Fibonacci và được định nghĩa như sau:
    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).
    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n của chuỗi số fib4. Không sử dụng đệ quy.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Dãy số Fib4 là một dãy số tương tự như dãy Fibbonacci, được định nghĩa như sau:
    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).
    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n trong dãy số fib4. Không sử dụng đệ quy.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Trả về trung vị của các phần tử trong danh sách l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Trả về giá trị trung vị của các phần tử trong danh sách l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Kiểm tra xem chuỗi cho trước có phải là một chuỗi đối xứng (palindrome) hay không.
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Kiểm tra xem chuỗi đã cho có phải là palindrome không
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Kiểm tra xem chuỗi đã cho có phải là chuỗi đối xứng không
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Trả về 2^n modulo p (lưu ý về số).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Trả về 2^n theo modulo p (chú ý đến các phép toán số học).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Trả về phần dư của 2^n chia cho p (chú ý đến số liệu).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    Trả về chuỗi mã hóa bằng cách dịch chuyển mỗi ký tự lên 5 bước trong bảng chữ cái.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Nhận vào chuỗi đã mã hóa bằng hàm encode_shift. Trả về chuỗi đã giải mã.
    """

def encode_shift(s: str):
    """
    trả về chuỗi được mã hóa bằng cách dịch chuyển mỗi ký tự 5 trong bảng chữ cái.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    lấy chuỗi đầu vào được mã hóa bằng hàm encode_shift. Trả về chuỗi đã giải mã.
    """

def encode_shift(s: str):
    """
    Trả về chuỗi đã được mã hóa bằng cách dịch chuyển mỗi ký tự trong bảng chữ cái 5 vị trí.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Nhận chuỗi đã được mã hóa bằng hàm encode_shift làm đầu vào và trả về chuỗi đã được giải mã.
    """


def remove_vowels(text):
    """
    remove_vowels là một hàm nhận vào một chuỗi và trả về chuỗi không có nguyên âm.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels là một hàm lấy chuỗi và trả về chuỗi không có nguyên âm.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Trả về True nếu tất cả các số trong danh sách l đều nhỏ hơn ngưỡng t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Trả về True nếu tất cả các số trong danh sách l đều thấp hơn ngưỡng t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Cộng hai số x và y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Kiểm tra xem hai từ có cùng ký tự không.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    Kiểm tra xem hai từ có chứa các ký tự giống nhau không.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    Kiểm tra xem hai từ có cùng ký tự hay không.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Trả về số Fibonacci thứ n.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets là một chuỗi gồm các ký tự "<" và ">".
    Trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.

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

def correct_bracketing(brackets: str):
    """ dấu ngoặc là một chuỗi "<" và ">".
    trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.

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

def correct_bracketing(brackets: str):
    """ brackets là một chuỗi bao gồm "<" và ">".
    Trả về True nếu tất cả các dấu ngoặc mở có dấu ngoặc đóng tương ứng.

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


def monotonic(l: list):
    """Trả về True nếu các phần tử trong danh sách là tăng dần hoặc giảm dần.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Trả về True nếu các phần tử trong danh sách tăng hoặc giảm theo kiểu đơn điệu.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Trả về True nếu các phần tử trong danh sách tăng hoặc giảm đều đặn.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Trả về các phần tử chung duy nhất và được sắp xếp cho hai danh sách.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]
    """

def common(l1: list, l2: list):
    """Trả về các phần tử chung duy nhất đã được sắp xếp cho hai danh sách.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Trả về các phần tử chung duy nhất đã được sắp xếp của hai danh sách.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Trả về ước số nguyên tố lớn nhất của n. Giả sử n > 1 và n không phải là một số nguyên tố.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Trả về ước số nguyên tố lớn nhất của n. Giả sử n > 1 và không phải là một số nguyên tố.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Trả về thừa số nguyên tố lớn nhất của n. Giả sử n > 1 và không phải là số nguyên tố.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n là một hàm tính tổng các số từ 1 đến n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n là hàm tính tổng các số từ 1 đến n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets là một chuỗi gồm các dấu ngoặc "(" và ")".
    Trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.

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

def correct_bracketing(brackets: str):
    """ brackets là một chuỗi của "(" and ")".
    Trả về True nếu các dấu ngoặc mở có dấu ngoặc đóng tương ứng.

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

def correct_bracketing(brackets: str):
    """ brackets là một chuỗi bao gồm "(" và ")".
    Nếu tất cả các dấu ngoặc mở có dấu ngoặc đóng tương ứng thì trả về True.

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


def derivative(xs: list):
    """ xs biểu diễn hệ số của đa thức.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Trả về đạo hàm của đa thức này dưới dạng tương tự.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs biểu thị hệ số của một đa thức.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Trả về đạo hàm của đa thức này ở cùng dạng.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs đại diện cho các hệ số của một đa thức.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    Trả về đạo hàm của đa thức này dưới cùng một dạng.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """Dãy số FibFib là một dãy số tương tự như dãy số Fibonacci, được định nghĩa như sau:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n của dãy số fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Chuỗi số FibFib là một chuỗi tương tự như chuỗi Fibbonacci được xác định như sau:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Hãy viết một hàm để tính hiệu quả phần tử thứ n của chuỗi số fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Chuỗi số FibFib là một chuỗi tương tự như chuỗi Fibbonacci được định nghĩa như sau:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Vui lòng viết một hàm để tính hiệu quả phần tử thứ n của chuỗi số fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Thêm nhiều trường hợp kiểm thử hơn.
"""

def vowels_count(s):
    """Viết hàm vowels_count nhận một chuỗi làm đầu vào và trả về số lượng
    nguyên âm trong chuỗi. Trong trường hợp này, nguyên âm là 'a', 'e', 'i', 'o', 'u'.
    Ở đây 'y' chỉ được coi là nguyên âm khi nó ở cuối từ cho trước.

    Ví dụ:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Thêm nhiều trường hợp kiểm tra hơn.
"""

def vowels_count(s):
    """Viết một hàm vowels_count lấy một chuỗi biểu diễn
    một từ làm đầu vào và trả về số nguyên âm trong chuỗi.
    Nguyên âm trong trường hợp này là 'a', 'e', 'i', 'o', 'u'. Ở đây, 'y' cũng là một
    nguyên âm, nhưng chỉ khi nó ở cuối từ đã cho.

    Ví dụ:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Thêm nhiều trường hợp kiểm tra.
"""

def vowels_count(s):
    """Viết một hàm vowels_count lấy một chuỗi có
    một từ làm đầu vào và trả về số nguyên âm trong chuỗi.
    Nguyên âm trong trường hợp này là 'a', 'e', 'i', 'o', 'u'. Ở đây, 'y' cũng là một
    nguyên âm, nhưng chỉ khi nó ở cuối từ đã cho.

    Ví dụ:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Dịch chuyển vòng các chữ số của số nguyên x sang phải một lượng bằng shift
    và trả về kết quả dưới dạng chuỗi.
    Nếu shift lớn hơn số chữ số, đảo ngược các chữ số và trả về.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Dịch chuyển tròn các chữ số của số nguyên x, dịch chuyển các chữ số sang phải bằng shift
    và trả về kết quả dưới dạng chuỗi.
    Nếu shift > số chữ số, trả về các chữ số bị đảo ngược.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Dịch chuyển vòng các chữ số của số nguyên x, dịch chuyển các chữ số sang phải theo số lượng shift
    và trả về kết quả dưới dạng một chuỗi.
    Nếu shift > số lượng chữ số, trả về các chữ số đảo ngược.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Nhiệm vụ
    Viết một hàm nhận một chuỗi làm đầu vào và trả về tổng mã ASCII của các ký tự in hoa.

    Ví dụ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Nhiệm vụ
    Viết một hàm lấy một chuỗi làm đầu vào và trả về tổng của chỉ các chữ cái in hoa'
    mã ASCII của các ký tự in hoa.
    Ví dụ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Nhiệm vụ
    Viết một hàm lấy một chuỗi làm đầu vào và chỉ trả về tổng của các ký tự in hoa'
    Mã ASCII.

    Ví dụ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s, n):
    """
    Trong bài toán này, bạn sẽ được cho một chuỗi đại diện cho số lượng táo và cam
    được phân phối trong một giỏ trái cây. Giỏ này chứa táo, cam và xoài.
    Dựa trên chuỗi đại diện cho tổng số lượng táo và cam và một số nguyên đại diện
    cho tổng số lượng trái cây trong giỏ, trả về số lượng trái xoài trong giỏ.
    Ví dụ:
    fruit_distribution("5 apples and 6 oranges", 19) -> 19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges", 3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges", 120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    Trong yêu cầu này, bạn sẽ được cho một chuỗi biểu diễn số lượng táo và cam
    được phân phối trong một giỏ trái cây, giỏ này chứa
    táo, cam và xoài. Cho chuỗi biểu thị tổng số
    quả cam và quả táo và một số nguyên biểu thị tổng số loại trái cây
    trong giỏ, trả về số lượng quả xoài trong giỏ.
    ví dụ:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    Trong bài toán này, bạn sẽ nhận được một chuỗi đại diện cho số lượng táo và cam
    được phân phối trong một giỏ trái cây. Giỏ này chứa táo, cam và xoài.
    Cho chuỗi đại diện cho tổng số lượng táo và cam và một số nguyên đại diện cho tổng số trái cây
    trong giỏ, hãy trả về số lượng trái xoài trong giỏ.
    ví dụ:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Cho một mảng đại diện cho nhánh của một cây có các nút là các số nguyên không âm,
    nhiệm vụ của bạn là chọn một trong các nút và trả về nó.
    Nút được chọn phải là nút có giá trị chẵn nhỏ nhất.
    Nếu có nhiều nút có giá trị chẵn nhỏ nhất giống nhau, hãy chọn nút có chỉ số nhỏ nhất.

    Nút được chọn sẽ được trả về dưới dạng danh sách, [giá trị nhỏ nhất, chỉ số của nó],
    Nếu không có giá trị chẵn nào hoặc mảng cho trước là rỗng, trả về [].

    Ví dụ 1:
        Input: [4,2,3]
        Output: [2, 1]
        Giải thích: 2 có giá trị chẵn nhỏ nhất, và 2 có chỉ số nhỏ nhất.

    Ví dụ 2:
        Input: [1,2,3]
        Output: [2, 1]
        Giải thích: 2 có giá trị chẵn nhỏ nhất, và 2 có chỉ số nhỏ nhất.

    Ví dụ 3:
        Input: []
        Output: []

    Ví dụ 4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        Giải thích: 0 là giá trị nhỏ nhất, nhưng có hai số 0,
                     vì vậy chúng ta sẽ chọn số 0 đầu tiên, có chỉ số nhỏ nhất.

    Ràng buộc:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Cho một mảng biểu diễn một nhánh của cây có các nút nguyên không âm
    nhiệm vụ của bạn là nhổ một trong các nút và trả nó lại.
    Nút được nhổ phải là nút có giá trị chẵn nhỏ nhất.
    Nếu tìm thấy nhiều nút có cùng giá trị chẵn nhỏ nhất, hãy trả về nút có chỉ số nhỏ nhất.

    Nút được nhổ phải được trả về trong một danh sách, [ smalest_value, chỉ số của nút đó],
    Nếu không có giá trị chẵn nào hoặc mảng đã cho trống, hãy trả về [].

    Ví dụ 1:
        Input: [4,2,3]
        Đầu ra: [2, 1]
        Giải thích: 2 có giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.

    Ví dụ 2:
        Đầu vào: [1,2,3]
        Đầu ra: [2, 1]
        Giải thích: 2 có giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.

    Ví dụ 3:
        Đầu vào: []
        Đầu ra: []

    Ví dụ 4:
        Đầu vào: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        Giải thích: 0 là giá trị nhỏ nhất, nhưng có hai số không,
                     vì vậy chúng ta sẽ chọn số không đầu tiên, có chỉ số nhỏ nhất.

    Giới hạn:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Với một mảng đại diện cho một nhánh của cây có các nút số nguyên không âm
    nhiệm vụ của bạn là nhổ một trong các nút và trả về nút đó.
    Nút được nhổ phải là nút có giá trị chẵn nhỏ nhất.
    Nếu tìm thấy nhiều nút có cùng giá trị chẵn nhỏ nhất, hãy trả về nút có chỉ số nhỏ nhất.

    Nút được nhổ phải được trả về trong một danh sách, [ smalest_value, its index ],
    Nếu không có giá trị chẵn nào hoặc mảng đã cho trống, hãy trả về [].

    Ví dụ 1:
        Đầu vào: [4,2,3]
        Đầu ra: [2, 1]
        Giải thích: 2 là giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.

    Ví dụ 2:
        Đầu vào: [1,2,3]
        Đầu ra: [2, 1]
        Giải thích: 2 là giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.

    Ví dụ 3:
        Đầu vào: []
        Đầu ra: []

    Ví dụ 4:
        Đầu vào: [5, 0, 3, 0, 4, 2]
        Đầu ra: [0, 1]
        Giải thích: 0 là giá trị nhỏ nhất nhưng có hai số 0
                     nên chọn số 0 đầu tiên. Đây là chỉ số nhỏ nhất.

    Điều kiện ràng buộc:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Bạn được cho một danh sách các số nguyên dương không rỗng. Hãy trả về số nguyên lớn nhất lớn hơn 0,
    và có tần suất xuất hiện lớn hơn hoặc bằng chính giá trị của nó.
    Tần suất của một số nguyên là số lần nó xuất hiện trong danh sách.
    Nếu không có giá trị nào như vậy, hãy trả về -1.
    Ví dụ:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Một danh sách không rỗng gồm các số nguyên dương được đưa ra. Trả về số nguyên lớn nhất mà lớn hơn 0
    và tần suất của nó lớn hơn hoặc bằng giá trị của chính nó. Tần suất của số nguyên là số lần xuất hiện trong danh sách.
    Nếu không tồn tại giá trị như vậy, trả về -1.
    Ví dụ:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Bạn được cho một danh sách không rỗng các số nguyên dương. Trả về số nguyên lớn nhất lớn hơn
    không và có tần suất lớn hơn hoặc bằng giá trị của chính số nguyên đó.
    Tần suất của một số nguyên là số lần nó xuất hiện trong danh sách.
    Nếu không tồn tại giá trị nào như vậy, hãy trả về -1.
    Ví dụ:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Cho danh sách các số nguyên, trả về danh sách theo thứ tự lạ.
    Sắp xếp lạ là khi bạn bắt đầu với giá trị nhỏ nhất,
    sau đó là giá trị lớn nhất trong các số còn lại, rồi tiếp tục với giá trị nhỏ nhất và cứ như vậy.

    Ví dụ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Cho một danh sách các số nguyên, trả về danh sách theo thứ tự kỳ lạ.
    Sắp xếp kỳ lạ là khi bạn bắt đầu với giá trị nhỏ nhất,
    sau đó là giá trị lớn nhất trong các số còn lại, rồi tiếp tục với giá trị nhỏ nhất và cứ thế.

    Ví dụ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Cho danh sách các số nguyên, trả về danh sách theo thứ tự lạ.
    Sắp xếp lạ là khi bạn bắt đầu với giá trị nhỏ nhất,
    sau đó là giá trị lớn nhất của các số nguyên còn lại, sau đó là giá trị nhỏ nhất, v.v.

    Ví dụ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Khi độ dài của ba cạnh của một tam giác được cho, nếu ba cạnh tạo thành một tam giác hợp lệ,
    trả về diện tích của tam giác được làm tròn đến hai chữ số thập phân.
    Nếu không, trả về -1.
    Để ba cạnh tạo thành một tam giác hợp lệ, tổng của hai cạnh phải lớn hơn cạnh thứ ba.
    Ví dụ:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Cho độ dài của ba cạnh của một tam giác. Trả về diện tích
    của tam giác làm tròn đến 2 chữ số thập phân nếu ba cạnh tạo thành một tam giác hợp lệ.
    Nếu không, trả về -1.
    Ba cạnh tạo thành một tam giác hợp lệ khi tổng của bất kỳ hai cạnh nào lớn hơn
    cạnh còn lại.
    Ví dụ:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Cho chiều dài của ba cạnh của một tam giác. Trả về diện tích của tam giác
    làm tròn đến 2 chữ số thập phân nếu ba cạnh tạo thành một tam giác hợp lệ.
    Nếu không, trả về -1.
    Ba cạnh tạo thành một tam giác hợp lệ khi tổng của hai cạnh bất kỳ lớn hơn
    cạnh còn lại.
    Ví dụ:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q, w):
    '''
    Viết một hàm trả về True nếu đối tượng q có thể bay, và False nếu ngược lại.
    Đối tượng q có thể bay nếu nó cân bằng (là một danh sách đối xứng) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng lượng tối đa w.

    Ví dụ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 nhỏ hơn trọng lượng tối đa, nhưng nó không cân bằng.

    will_it_fly([3, 2, 3], 1) ➞ False
    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng lượng tối đa.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 nhỏ hơn trọng lượng tối đa, và nó cân bằng.

    will_it_fly([3], 5) ➞ True
    # 3 nhỏ hơn trọng lượng tối đa, và nó cân bằng.
    '''

def will_it_fly(q,w):
    '''
    Viết một hàm trả về True nếu vật thể q sẽ bay, và False nếu không.
    Vật thể q sẽ bay nếu nó cân bằng (đó là một danh sách hồi văn) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng số tối đa có thể w.

    Ví dụ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 nhỏ hơn trọng lượng tối đa có thể, nhưng nó không cân bằng.

    will_it_fly([3, 2, 3], 1) ➞ False
    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng lượng tối đa có thể.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 nhỏ hơn trọng lượng tối đa có thể, và nó cân bằng.

    will_it_fly([3], 5) ➞ True
    # 3 nhỏ hơn trọng lượng tối đa có thể và nó cân bằng.
    '''

def will_it_fly(q,w):
    '''
    Viết một hàm trả về True nếu đối tượng q sẽ bay, và False nếu không.
    Đối tượng q sẽ bay nếu nó cân bằng (đó là một danh sách hồi văn) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng số tối đa có thể w.

    Ví dụ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 nhỏ hơn trọng số tối đa có thể, nhưng nó không cân bằng.

    will_it_fly([3, 2, 3], 1) ➞ False
    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng số tối đa có thể.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 nhỏ hơn trọng số tối đa có thể, và nó cân bằng.

    will_it_fly([3], 5) ➞ True
    # 3 nhỏ hơn trọng lượng tối đa có thể và nó cân bằng.
    '''


def smallest_change(arr):
    """
    Cho một mảng arr các số nguyên, tìm số lượng phần tử tối thiểu cần thay đổi để làm cho mảng trở thành mảng đối xứng.
    Một mảng đối xứng là một mảng có thể đọc giống nhau khi đọc từ trái sang phải và từ phải sang trái.
    Trong một lần thay đổi, bạn có thể thay đổi một phần tử thành bất kỳ phần tử nào khác.

    Ví dụ:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Cho một mảng arr gồm các số nguyên, hãy tìm số lượng phần tử tối thiểu
    cần phải thay đổi để tạo thành mảng palindromic. Mảng palindromic là một mảng
    được đọc ngược và xuôi giống nhau. Trong một lần thay đổi, bạn có thể thay đổi một phần tử thành bất kỳ phần tử nào khác.

    Ví dụ:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Cho một mảng số nguyên arr, tìm số lượng phần tử tối thiểu cần thay đổi  để biến mảng thành mảng đối xứng. Mảng đối xứng
    là mảng mà khi đọc từ trái sang phải hay phải sang trái đều giống nhau. Với một lần thay đổi, có thể thay đổi một phần tử
    thành phần tử khác.

    Ví dụ:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Viết một hàm nhận vào hai danh sách chuỗi và trả về danh sách có
    tổng số ký tự trong tất cả các chuỗi của danh sách nhỏ hơn danh sách còn lại.

    Nếu hai danh sách có số lượng ký tự bằng nhau, trả về danh sách đầu tiên.

    Ví dụ
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Viết một hàm chấp nhận hai danh sách chuỗi và trả về danh sách có tổng số ký tự trong tất cả các chuỗi của danh sách ít hơn danh sách còn lại.

    Nếu hai danh sách có tổng số ký tự bằng nhau, trả về danh sách đầu tiên.

    Ví dụ
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Viết một hàm chấp nhận hai danh sách chuỗi và trả về danh sách có
    tổng số ký tự trong tất cả các chuỗi của danh sách ít hơn danh sách kia.

    nếu hai danh sách có cùng số ký tự, hãy trả về danh sách đầu tiên.

    Ví dụ
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Viết một hàm trả về true nếu số đã cho là tích của 3 số nguyên tố, nếu không thì trả về false.
    Biết rằng (a) nhỏ hơn 100.
    Ví dụ:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Viết một hàm trả về true nếu số đã cho là phép nhân của 3 số nguyên tố
    và false nếu không.
    Biết rằng (a) nhỏ hơn 100.
    Ví dụ:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Viết một hàm trả về True nếu số đã cho là tích của 3 số nguyên tố và False nếu không phải.
    Biết rằng (a) nhỏ hơn 100.
    Ví dụ:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Nhiệm vụ của bạn là viết một hàm trả về true nếu số x là lũy thừa đơn giản của n,
    và false nếu không phải.
    x là lũy thừa đơn giản của n khi n**int=x.
    Ví dụ:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Nhiệm vụ của bạn là viết một hàm trả về true nếu một số x là lũy thừa
    đơn giản của n và trả về false trong các trường hợp khác.
    x là lũy thừa đơn giản của n nếu nk=x trong đó k là số nguyên
    Ví dụ:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Nhiệm vụ của bạn là viết một hàm trả về true nếu số x là lũy thừa đơn giản của n và false trong các trường hợp khác.
    x là lũy thừa đơn giản của n nếu n**int = x
    Ví dụ:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Viết một hàm nhận một số nguyên a và trả về True
    nếu số nguyên này là lập phương của một số nguyên nào đó.
    Lưu ý: bạn có thể giả sử rằng đầu vào luôn hợp lệ.
    Ví dụ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Nhập vào số nguyên a và viết hàm trả về liệu số nguyên này có phải là lũy thừa ba của một số nguyên nào đó hay không.
    Tham khảo: Có thể giả định rằng đầu vào luôn hợp lệ.
    Ví dụ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Viết một hàm lấy một số nguyên a và trả về True nếu số nguyên này là lập phương của một số nguyên nào đó.
    Lưu ý: Có thể giả định rằng đầu vào luôn hợp lệ.
    Ví dụ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """Bạn được giao nhiệm vụ viết một hàm nhận vào
    một số thập lục phân dưới dạng chuỗi và đếm số lượng
    chữ số thập lục phân là số nguyên tố (số nguyên tố là một số tự nhiên
    lớn hơn 1 và không phải là tích của hai số tự nhiên nhỏ hơn).
    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...
    Vì vậy bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7,
    B (= thập phân 11), D (= thập phân 13).
    Lưu ý: bạn có thể giả định rằng đầu vào luôn đúng hoặc là chuỗi rỗng,
    và các ký tự A, B, C, D, E, F luôn viết hoa.
    Ví dụ:
    Khi num = "AB", kết quả trả về sẽ là 1.
    Khi num = "1077E", kết quả trả về sẽ là 2.
    Khi num = "ABED1A33", kết quả trả về sẽ là 4.
    Khi num = "123456789ABCDEF0", kết quả trả về sẽ là 6.
    Khi num = "2020", kết quả trả về sẽ là 2.
    """

def hex_key(num):
    """Bạn được giao nhiệm vụ viết một hàm nhận
    một số thập lục phân dưới dạng chuỗi và đếm số chữ số thập lục phân
    là số nguyên tố (số nguyên tố hoặc số nguyên tố là số tự nhiên lớn hơn
    1 không phải là tích của hai số tự nhiên nhỏ hơn).
    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...
    Vì vậy, bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    Lưu ý: bạn có thể cho rằng đầu vào luôn là chuỗi đúng hoặc rỗng,
    và các ký hiệu A, B, C, D, E, F luôn viết hoa.
    Ví dụ:
    For num = "AB" the output should be 1.
    For num = "1077E" the output should be 2.
    For num = "ABED1A33" the output should be 4.
    For num = "123456789ABCDEF0" the output should be 6.
    For num = "2020" the output should be 2.
    """

def hex_key(num):
    """Bạn được giao nhiệm vụ viết một hàm nhận vào
    một số thập lục phân dưới dạng chuỗi và đếm số lượng
    chữ số thập lục phân là số nguyên tố (số nguyên tố là một số tự nhiên
    lớn hơn 1 không phải là tích của hai số tự nhiên nhỏ hơn).
    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...
    Vì vậy, bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7,
    B (=thập phân 11), D (=thập phân 13).
    Lưu ý: bạn có thể giả định đầu vào luôn đúng hoặc là chuỗi rỗng,
    và các ký tự A, B, C, D, E, F luôn ở dạng chữ hoa.
    Ví dụ:
    Với num = "AB" kết quả sẽ là 1.
    Với num = "1077E" kết quả sẽ là 2.
    Với num = "ABED1A33" kết quả sẽ là 4.
    Với num = "123456789ABCDEF0" kết quả sẽ là 6.
    Với num = "2020" kết quả sẽ là 2.
    """


def decimal_to_binary(decimal):
    """Bạn sẽ được cung cấp một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự biểu diễn một số nhị phân. Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.

    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.
    Các ký tự bổ sung ở đó để hỗ trợ định dạng.

    Ví dụ:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Bạn sẽ được cung cấp một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang
    định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự đại diện cho một số nhị phân.
    Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.

    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.
    Những ký tự bổ sung này có mục đích giúp định dạng.

    Ví dụ:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Cho một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang
    định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự biểu thị một số
    nhị phân. Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.

    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.
    Các ký tự bổ sung ở đó để hỗ trợ định dạng.

    Ví dụ:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """Bạn được cho một chuỗi s.
    Nhiệm vụ của bạn là kiểm tra xem chuỗi có phải là chuỗi "hạnh phúc" hay không.
    Một chuỗi được coi là "hạnh phúc" nếu độ dài của chuỗi ít nhất là 3 và 3 ký tự liên tiếp trong chuỗi là khác nhau
    Ví dụ:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Bạn được cho một chuỗi s.
    Nhiệm vụ của bạn là kiểm tra xem chuỗi đó có hạnh phúc hay không.
    Một chuỗi được coi là hạnh phúc nếu độ dài của nó ít nhất là 3 và cứ 3 chữ cái liên tiếp thì phải khác nhau
    Ví dụ:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Bạn được cung cấp một chuỗi s.
    Nhiệm vụ của bạn là kiểm tra xem chuỗi đó có hạnh phúc hay không.
    Một chuỗi được coi là hạnh phúc nếu độ dài của nó ít nhất là 3 và cứ 3 chữ cái liên tiếp thì phải khác nhau
    Ví dụ:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """ Đó là tuần học cuối cùng của học kỳ và giáo viên phải chấm điểm cho học sinh.
    Giáo viên đã tự tạo ra thuật toán chấm điểm của riêng mình.
    Vấn đề duy nhất là, cô ấy đã làm mất mã nguồn mà cô ấy đã dùng để chấm điểm.
    Cô ấy đã đưa cho bạn một danh sách các điểm GPA của một số học sinh và bạn phải viết
    một hàm có thể xuất ra danh sách các điểm chữ dựa trên bảng sau:
             GPA       |    Điểm chữ
              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
    Ví dụ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Đây là tuần học cuối cùng của học kỳ và giáo viên phải cho điểm
    cho học sinh. Giáo viên đã tạo ra một thuật toán riêng để chấm điểm.
    Vấn đề duy nhất là, cô ấy đã làm mất mã nguồn dùng để chấm điểm.
    Cô ấy đã đưa cho bạn một danh sách GPA của một số học sinh và bạn phải viết
    một hàm để trả về danh sách các điểm chữ theo bảng sau:
             GPA       |    Điểm chữ cái
              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

    Ví dụ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Đây là tuần cuối cùng của học kỳ và giáo viên phải cho điểm
    cho học sinh. Giáo viên đã tự tạo thuật toán chấm điểm của riêng mình.
    Vấn đề duy nhất là cô ấy đã làm mất mã cô ấy dùng để chấm điểm.
    Cô ấy đã đưa cho bạn danh sách GPA của một số học sinh và bạn phải viết
    một hàm có thể xuất ra danh sách các điểm chữ bằng cách sử dụng bảng sau:
             GPA       |    Điểm bằng chữ
              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

    Ví dụ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Viết một hàm nhận vào một chuỗi và trả về True nếu độ dài của chuỗi là một số nguyên tố,
    hoặc False nếu không phải.
    Ví dụ:
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Nhận một chuỗi và viết hàm trả về True nếu độ dài của chuỗi là số nguyên tố
    hoặc trả về False nếu không phải
    Ví dụ
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Viết một hàm nhận vào một chuỗi và trả về True nếu độ dài chuỗi
    là một số nguyên tố, hoặc False nếu không phải.
    Ví dụ
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Cho một số nguyên dương n, trả về số lượng các số nguyên dương n chữ số
    bắt đầu hoặc kết thúc bằng 1.
    """

def starts_one_ends(n):
    """
    Cho một số nguyên dương n, trả về số lượng các số nguyên dương có n chữ số
    bắt đầu hoặc kết thúc bằng 1.
    """

def starts_one_ends(n):
    """
    Cho một số nguyên dương n, trả về số lượng các số nguyên dương có n chữ số
    bắt đầu hoặc kết thúc bằng chữ số 1.
    """


def solve(N):
    """Cho một số nguyên dương N, trả về tổng các chữ số của nó dưới dạng nhị phân.

    Ví dụ:
        Với N = 1000, tổng các chữ số là 1 và kết quả trả về sẽ là "1".
        Với N = 150, tổng các chữ số là 6 và kết quả trả về sẽ là "110".
        Với N = 147, tổng các chữ số là 12 và kết quả trả về sẽ là "1100".

    Biến:
        @N: số nguyên
            Ràng buộc: 0 ≤ N ≤ 10000.
    Kết quả:
        Một chuỗi số nhị phân
    """

def solve(N):
    """Cho một số nguyên dương N, trả về tổng các chữ số của nó ở dạng nhị phân

    Ví dụ
        Khi N = 1000, tổng các chữ số là 1 và đầu ra phải là "1".
        Khi N = 150, tổng các chữ số là 6 và đầu ra phải là "110".
        Khi N = 147, tổng các chữ số là 12 và đầu ra phải là "1100".

    Biến:
        @N số nguyên
             Điều kiện ràng buộc: 0 ≤ N ≤ 10000.
    Đầu ra:
         Chuỗi nhị phân
    """

def solve(N):
    """Cho một số nguyên dương N, trả về tổng các chữ số của nó ở dạng nhị phân.

    Ví dụ
    Với N = 1000, tổng các chữ số sẽ là 1, đầu ra sẽ là "1".
    Với N = 150, tổng các chữ số sẽ là 6, đầu ra sẽ là "110".
    Với N = 147, tổng các chữ số sẽ là 12, đầu ra sẽ là "1100".

    Biến:
    @N số nguyên
    Ràng buộc: 0 ≤ N ≤ 10000.
    Đầu ra:
    một chuỗi số nhị phân
    """


def add(lst):
    """Cho một danh sách các số nguyên không rỗng lst. Tính tổng các phần tử chẵn nằm ở chỉ số lẻ.

    Ví dụ:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Cho một danh sách các số nguyên không rỗng, hãy cộng các phần tử chẵn có chỉ số lẻ.

    Ví dụ:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Cho một danh sách các số nguyên không rỗng lst. cộng các phần tử chẵn ở vị trí lẻ..

    Ví dụ:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Viết một hàm nhận một chuỗi và trả về phiên bản có thứ tự của chuỗi đó.
    Phiên bản có thứ tự của chuỗi là một chuỗi mà trong đó tất cả các từ (được phân cách bằng dấu cách)
    được thay thế bằng một từ mới, trong đó tất cả các ký tự được sắp xếp theo thứ tự tăng dần dựa trên giá trị ascii.
    Lưu ý: Bạn cần giữ nguyên thứ tự của các từ và khoảng trắng trong câu.

    Ví dụ:
    anti_shuffle('Hi') trả về 'Hi'
    anti_shuffle('hello') trả về 'ehllo'
    anti_shuffle('Hello World!!!') trả về 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Viết một hàm lấy một chuỗi và trả về phiên bản có thứ tự của chuỗi đó.
    Phiên bản có thứ tự của chuỗi là một chuỗi trong đó tất cả các từ (phân cách bằng dấu cách)
    được thay thế bằng một từ mới trong đó tất cả các ký tự được sắp xếp theo
    thứ tự tăng dần dựa trên giá trị ASCII.
    Lưu ý: Bạn nên giữ nguyên thứ tự của các từ và khoảng trắng trong câu.

    Ví dụ:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Nhận một chuỗi và trả về phiên bản đã sắp xếp của nó.
    Phiên bản đã sắp xếp của chuỗi là chuỗi mà tất cả các từ (phân tách bằng khoảng trắng)
    được thay thế bằng các ký tự sắp xếp theo thứ tự tăng dần theo giá trị ASCII.
    Lưu ý: Thứ tự của từ và khoảng trắng trong câu phải được giữ nguyên.

    Ví dụ:
    anti_shuffle('Hi') trả về 'Hi'.
    anti_shuffle('hello') trả về 'ehllo'.
    anti_shuffle('Hello World!!!') trả về 'Hello !!!Wdlor'.
    """


def get_row(lst, x):
    """
    Bạn được cung cấp dữ liệu hai chiều, dưới dạng danh sách lồng nhau,
    giống như một ma trận, tuy nhiên, không giống như ma trận,
    mỗi hàng có thể chứa số cột khác nhau.
    Cho lst và số nguyên x, tìm các số nguyên x trong danh sách,
    và trả về danh sách các tuple, [(x1, y1), (x2, y2) ...] sao cho
    mỗi tuple là một tọa độ - (hàng, cột), bắt đầu từ 0.
    Sắp xếp các tọa độ theo hàng theo thứ tự tăng dần.
    Ngoài ra, sắp xếp tọa độ trong hàng theo cột theo thứ tự giảm dần.

    Ví dụ:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Bạn được cung cấp dữ liệu 2 chiều, dưới dạng danh sách lồng nhau,
    tương tự như ma trận, tuy nhiên, khác với ma trận,
    mỗi hàng có thể chứa một số cột khác nhau.
    Cho lst và một số nguyên x, hãy tìm các số x trong danh sách,
    và trả về danh sách các cặp tọa độ, [(x1, y1), (x2, y2) ...] sao cho
    mỗi cặp tọa độ là (hàng, cột), bắt đầu từ 0.
    Sắp xếp tọa độ ban đầu theo hàng theo thứ tự tăng dần.
    Đồng thời, sắp xếp tọa độ của mỗi hàng theo cột theo thứ tự giảm dần.

    Ví dụ:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Bạn được cung cấp dữ liệu 2 chiều, dưới dạng danh sách lồng nhau,
    tương tự như ma trận, tuy nhiên, không giống như ma trận,
    mỗi hàng có thể chứa một số cột khác nhau.
    Cho lst và số nguyên x, hãy tìm các số nguyên x trong danh sách,
    và trả về danh sách các bộ, [(x1, y1), (x2, y2) ...] sao cho
    mỗi bộ là một tọa độ - (hàng, cột), bắt đầu bằng 0.
    Sắp xếp tọa độ ban đầu theo hàng theo thứ tự tăng dần.
    Ngoài ra, sắp xếp tọa độ của hàng theo cột theo thứ tự giảm dần.

    Ví dụ:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã cho sau khi sắp xếp,
    bạn sẽ sắp xếp mảng đã cho theo thứ tự tăng dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số lẻ,
    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số chẵn.

    Lưu ý:
    * không thay đổi mảng đã cho.

    Ví dụ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã cho sau khi sắp xếp,
    bạn sẽ sắp xếp mảng đã cho theo thứ tự tăng dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số lẻ,
    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số chẵn.

    Ghi chú:
    * không thay đổi mảng đã cho.

    Ví dụ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã được sắp xếp,
    bạn sẽ sắp xếp mảng theo thứ tự tăng dần nếu tổng (giá trị chỉ số đầu tiên, giá trị chỉ số cuối cùng) là số lẻ,
    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ số đầu tiên, giá trị chỉ số cuối cùng) là số chẵn.

    Lưu ý:
    * không thay đổi mảng cho trước.

    Ví dụ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """Tạo hàm encrypt nhận một chuỗi làm tham số và trả về
    chuỗi đã được mã hóa với bảng chữ cái được xoay vòng. Bảng chữ cái phải được
    xoay theo cách mà các chữ cái dịch chuyển xuống xuống hai lần hai vị trí.
    Ví dụ:
    encrypt('hi') trả về 'lm'.
    encrypt('asdfghjkl') trả về 'ewhjklnop'.
    encrypt('gf') trả về 'kj'.
    encrypt('et') trả về 'ix'.
    """

def encrypt(s):
    """Tạo một hàm encrypt nhận một chuỗi làm tham số và
    trả về chuỗi đã được mã hóa với bảng chữ cái được xoay vòng.
    Bảng chữ cái sẽ được xoay vòng theo cách mà các chữ cái
    dịch chuyển xuống hai lần số hai vị trí.
    Ví dụ:
    encrypt('hi') trả về 'lm'
    encrypt('asdfghjkl') trả về 'ewhjklnop'
    encrypt('gf') trả về 'kj'
    encrypt('et') trả về 'ix'
    """

def encrypt(s):
    """Tạo một hàm encrypt nhận một chuỗi làm đối số và
    trả về chuỗi được mã hóa với bảng chữ cái được xoay.
    Bảng chữ cái nên được xoay sao cho các chữ cái
    dịch chuyển xuống hai vị trí gấp đôi.
    Ví dụ:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """


def next_smallest(lst):
    """
    Bạn được cho một danh sách các số nguyên.
    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 trong danh sách.
    Trả về None nếu không có phần tử như vậy.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Bạn được cung cấp một danh sách các số nguyên.
    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 của danh sách.
    Trả về None nếu không có phần tử nào như vậy.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Bạn được cho một danh sách các số nguyên.
    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 của danh sách.
    Trả về None nếu không có phần tử nào như vậy.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    Bạn sẽ được cho một chuỗi các từ, và nhiệm vụ của bạn là đếm số lượng sự nhàm chán.
    Một sự nhàm chán là một câu bắt đầu bằng từ "I".
    Các câu được phân cách bởi dấu chấm ('.'), dấu hỏi ('?') hoặc dấu chấm than ('!').

    Ví dụ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Bạn sẽ được cung cấp một chuỗi từ và nhiệm vụ của bạn là đếm số lượng
    của sự nhàm chán. Sự nhàm chán là một câu bắt đầu bằng từ "I".
    Các câu được phân cách bằng dấu '.', '?' hoặc '!'.

    Ví dụ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Bạn sẽ được cho một chuỗi các từ, và nhiệm vụ của bạn là đếm số lượng sự buồn chán.
    Một sự buồn chán là một câu bắt đầu bằng từ "I".
    Các câu được phân tách bằng dấu chấm ('.'), dấu hỏi ('?') hoặc dấu chấm than ('!').

    Ví dụ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """