def any_int(x, y, z):
    '''
    Tạo một hàm nhận vào 3 số.
    Trả về True nếu một trong các số bằng tổng của hai số còn lại, và tất cả các số đều là số nguyên.
    Trả về False trong các trường hợp khác.

    Ví dụ
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Tạo một hàm lấy 3 số.
    Trả về true nếu một trong các số bằng tổng của hai số còn lại và tất cả các số đều là số nguyên.
    Trả về false trong mọi trường hợp khác.

    Ví dụ
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Tạo một hàm nhận vào 3 số.
    Trả về true nếu một trong các số bằng tổng của hai số còn lại và tất cả các số đều là số nguyên.
    Trả về false trong bất kỳ trường hợp nào khác.

    Ví dụ:
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Viết một hàm nhận vào một thông điệp và mã hóa theo cách
    mà nó đổi chữ hoa thành chữ thường và ngược lại, thay thế tất cả các nguyên âm
    trong thông điệp bằng chữ cái xuất hiện 2 vị trí sau nguyên âm đó trong bảng chữ cái tiếng Anh.
    Giả sử chỉ có các chữ cái.

    Ví dụ:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Nhận một thông điệp và thay đổi chữ hoa thành chữ thường và ngược lại,
    sau đó thay thế tất cả các nguyên âm trong thông điệp bằng chữ cái
    đứng sau 2 vị trí trong bảng chữ cái tiếng Anh.
    Giả sử chỉ có ký tự chữ cái.

    Ví dụ:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Viết một hàm lấy một thông điệp và đảo chữ hoa và chữ thường,
    sau đó thay thế tất cả các nguyên âm trong thông điệp bằng chữ cái
    xuất hiện ở 2 vị trí đầu so với nguyên âm đó trong bảng chữ cái.
    Giả sử chỉ có các chữ cái.

    Ví dụ:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Bạn được cho một danh sách các số nguyên.
    Bạn cần tìm giá trị số nguyên tố lớn nhất và trả về tổng các chữ số của nó.

    Ví dụ:
    Với lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3], kết quả trả về sẽ là 10
    Với lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1], kết quả trả về sẽ là 25
    Với lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3], kết quả trả về sẽ là 13
    Với lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6], kết quả trả về sẽ là 11
    Với lst = [0,81,12,3,1,21], kết quả trả về sẽ là 3
    Với lst = [0,8,1,2,1,7], kết quả trả về sẽ là 7
    """

def skjkasdkd(lst):
    """Cho một danh sách các số nguyên.
    Hãy tìm giá trị nguyên tố lớn nhất và trả về tổng các chữ số của nó.

    Ví dụ:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] thì đầu ra phải là 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] thì đầu ra phải là 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] thì đầu ra phải là 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] thì đầu ra phải là 11
    lst = [0,81,12,3,1,21] thì đầu ra phải là 3
    lst = [0,8,1,2,1,7] thì đầu ra phải là 7
    """

def skjkasdkd(lst):
    """Bạn được cung cấp một danh sách các số nguyên.
    Bạn cần tìm giá trị nguyên tố lớn nhất và trả về tổng các chữ số của nó.

    Ví dụ:
    Đối với lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] thì đầu ra phải là 10
    Đối với lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] thì đầu ra phải là 25
    Đối với lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] thì đầu ra phải là 13
    Đối với lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] đầu ra phải là 11
    Đối với lst = [0,81,12,3,1,21] đầu ra phải là 3
    Đối với lst = [0,8,1,2,1,7] đầu ra phải là 7
    """


def check_dict_case(dict):
    """
    Cho một từ điển, trả về True nếu tất cả các khóa đều là chuỗi chữ cái in thường
    hoặc tất cả các khóa đều là chuỗi chữ cái in hoa, nếu không trả về False.
    Hàm này nên trả về False nếu từ điển cho trước là rỗng.
    Ví dụ:
    check_dict_case({"a":"apple", "b":"banana"}) sẽ trả về True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) sẽ trả về False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) sẽ trả về False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) sẽ trả về False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) sẽ trả về True.
    """

def check_dict_case(dict):
    """
    Cho một từ điển, trả về True nếu tất cả các từ khoá là chuỗi viết thường
    hoặc tất cả các từ khoá là chuỗi viết hoa, nếu không thì trả về False.
    Hàm sẽ trả về False nếu từ điển đã cho là rỗng.
    Ví dụ:
    check_dict_case({"a":"apple", "b":"banana"}) should return True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
    """

def check_dict_case(dict):
    """
    Cho một từ điển, trả về True nếu tất cả các khóa đều là chuỗi và viết thường hoặc tất cả các khóa đều là chuỗi và viết hoa,
    nếu không thì trả về False.
    Hàm cần trả về False nếu từ điển được đưa vào là rỗng.
    Ví dụ:
    check_dict_case({"a":"apple", "b":"banana"}) phải trả về True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) phải trả về False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) phải trả về False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) phải trả về False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" })  phải trả về True.
    """


def count_up_to(n):
    """Triển khai một hàm nhận một số nguyên không âm và trả về một mảng gồm n số nguyên đầu tiên là số nguyên tố và nhỏ hơn n.
    Ví dụ:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Triển khai một hàm lấy một số nguyên không âm và trả về một mảng gồm các số nguyên tố đầu tiên nhỏ hơn n.
    ví dụ:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Thực hiện một hàm nhận một số nguyên không âm và trả về một mảng gồm các số nguyên tố đầu tiên nhỏ hơn n.
    Ví dụ:
    count_up_to(5) => [2, 3]
    count_up_to(11) => [2, 3, 5, 7]
    count_up_to(0) => []
    count_up_to(20) => [2, 3, 5, 7, 11, 13, 17, 19]
    count_up_to(1) => []
    count_up_to(18) => [2, 3, 5, 7, 11, 13, 17]
    """


def multiply(a, b):
    """Hoàn thành hàm nhận hai số nguyên và trả về
    tích của chữ số hàng đơn vị của chúng.
    Giả sử đầu vào luôn hợp lệ.
    Ví dụ:
    multiply(148, 412) sẽ trả về 16.
    multiply(19, 28) sẽ trả về 72.
    multiply(2020, 1851) sẽ trả về 0.
    multiply(14, -15) sẽ trả về 20.
    """

def multiply(a, b):
    """Hoàn thành hàm lấy hai số nguyên và trả về
    tích các chữ số hàng đơn vị của chúng.
    Giả sử đầu vào luôn hợp lệ.
    Ví dụ:
    multiply(148, 412) should return 16.
    multiply(19, 28) should return 72.
    multiply(2020, 1851) should return 0.
    multiply(14,-15) should return 20.
    """

def multiply(a, b):
    """Nhận hai số nguyên và hoàn thành hàm trả về tích của chữ số hàng đơn vị của chúng.
    Giả sử đầu vào luôn hợp lệ.
    Ví dụ:
    multiply(148, 412) nên trả về 16.
    multiply(19, 28) nên trả về 72.
    multiply(2020, 1851) nên trả về 0.
    multiply(14,-15) nên trả về 20.
    """


def count_upper(s):
    """
    Cho một chuỗi s, đếm số lượng nguyên âm viết hoa ở các chỉ số chẵn.

    Ví dụ:
    count_upper('aBCdEf') trả về 1
    count_upper('abcdefg') trả về 0
    count_upper('dBBE') trả về 0
    """

def count_upper(s):
    """
    Chuỗi s được cho, hãy đếm số lượng nguyên âm viết hoa ở vị trí chỉ số chẵn.

    Ví dụ:
    count_upper('aBCdEf') trả về 1
    count_upper('abcdefg') trả về 0
    count_upper('dBBE') trả về 0
    """

def count_upper(s):
    """
    Cho một chuỗi s, đếm số nguyên âm viết hoa trong các chỉ số chẵn.

    Ví dụ:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


def closest_integer(value):
    '''
    Tạo một hàm lấy một giá trị (chuỗi) biểu diễn một số
    và trả về số nguyên gần nhất với số đó. Nếu số đó cách đều
    hai số nguyên, hãy làm tròn ra xa khỏi không.

    Ví dụ
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Lưu ý:
    Làm tròn ra khỏi số không có nghĩa là nếu số đã cho cách đều
    hai số nguyên, số bạn nên trả về là số
    xa nhất so với số không. Ví dụ, closest_integer("14.5") sẽ
    trả về 15 và closest_integer("-14.5") sẽ trả về -15.
    '''

def closest_integer(value):
    '''
    Tạo một hàm lấy một giá trị (chuỗi) biểu diễn một số
    và trả về số nguyên gần nhất với số đó. Nếu số đó cách đều
    hai số nguyên, hãy làm tròn số đó ra khỏi số không.

    Ví dụ
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Lưu ý:
    Làm tròn ra khỏi số không có nghĩa là nếu số đã cho cách đều
    hai số nguyên, số bạn nên trả về là số
    xa nhất so với số không. Ví dụ closest_integer("14.5") sẽ
    trả về 15 và closest_integer("-14.5") sẽ trả về -15.
    '''

def closest_integer(value):
    '''
    Tạo một hàm nhận vào một giá trị (chuỗi) đại diện cho một số
    và trả về số nguyên gần nhất với nó. Nếu số đó cách đều
    giữa hai số nguyên, làm tròn nó ra xa 0.

    Ví dụ
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Lưu ý:
    Làm tròn ra xa 0 có nghĩa là nếu số đã cho cách đều
    giữa hai số nguyên, số bạn trả về sẽ là số xa 0 hơn. Ví dụ, closest_integer("14.5") sẽ
    trả về 15 và closest_integer("-14.5") sẽ trả về -15.
    '''


def make_a_pile(n):
    """
    Với một số nguyên dương n, bạn phải tạo một đống đá gồm n cấp.
    Cấp đầu tiên có n viên đá.
    Số lượng đá ở cấp tiếp theo là:
    - số lẻ tiếp theo nếu n lẻ.
    - số chẵn tiếp theo nếu n chẵn.
    Trả về số lượng đá ở mỗi cấp trong danh sách, trong đó phần tử ở chỉ mục
    i biểu thị số lượng đá ở cấp (i+1).

    Ví dụ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Với một số nguyên dương n, bạn phải tạo một đống đá gồm n cấp.
    Cấp đầu tiên có n viên đá.
    Số lượng đá ở cấp tiếp theo là:
    - số lẻ tiếp theo nếu n lẻ.
    - số chẵn tiếp theo nếu n chẵn.
    Trả về số lượng đá ở mỗi cấp độ trong danh sách, trong đó phần tử tại chỉ số i biểu thị số lượng đá ở cấp (i+1).

    Ví dụ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Với một số nguyên dương n, bạn phải tạo một đống đá gồm n mức độ.
    Mức độ đầu tiên có n viên đá.
    Số lượng đá ở mức độ tiếp theo là:
        - số lẻ tiếp theo nếu n lẻ.
        - số chẵn tiếp theo nếu n chẵn.
    Trả về số lượng đá ở mỗi cấp trong danh sách, trong đó phần tử ở chỉ mục
    i biểu thị số lượng đá ở mức độ (i+1).

    Ví dụ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Bạn sẽ nhận được một chuỗi các từ ngăn cách bằng dấu phẩy hoặc dấu cách. Nhiệm vụ của bạn là
    phân tách chuỗi thành các từ và trả về một mảng chứa các từ đó.

    Ví dụ:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Bạn sẽ được cung cấp một chuỗi các từ được phân cách bằng dấu phẩy hoặc dấu cách. Nhiệm vụ của bạn là
    chia chuỗi thành các từ và trả về một mảng các từ.

    Ví dụ:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Bạn sẽ nhận được một chuỗi các từ được phân cách bằng dấu phẩy hoặc dấu cách. Nhiệm vụ của bạn là
    tách chuỗi thành các từ và trả về một mảng chứa các từ.

    Ví dụ:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """Hàm này lấy hai số dương x và y và trả về
    số nguyên chẵn lớn nhất nằm trong phạm vi [x, y] bao gồm. Nếu
    không có số nào như vậy, thì hàm sẽ trả về -1.

    Ví dụ:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Hàm này nhận hai số dương x và y và trả về số nguyên chẵn lớn nhất nằm trong phạm vi [x, y].
    Nếu không có số như vậy, hàm phải trả về -1.

    Ví dụ:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Bạn được cung cấp hai số nguyên dương n và m, và nhiệm vụ của bạn là tính toán
    trung bình của các số nguyên từ n đến m (bao gồm n và m).
    Làm tròn câu trả lời đến số nguyên gần nhất và chuyển đổi thành nhị phân.
    Nếu n lớn hơn m, hãy trả về -1.
    Ví dụ:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Bạn được cung cấp hai số nguyên dương n và m, và nhiệm vụ của bạn là tính
    trung bình của các số nguyên từ n đến m (bao gồm n và m).
    Làm tròn câu trả lời đến số nguyên gần nhất và chuyển đổi thành nhị phân.
    Nếu n lớn hơn m, hãy trả về -1.
    Ví dụ:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Bạn được cho hai số nguyên dương n và m, và nhiệm vụ của bạn là tính toán
    trung bình của các số nguyên từ n đến m (bao gồm n và m).
    Làm tròn kết quả về số nguyên gần nhất và chuyển đổi kết quả đó thành hệ nhị phân.
    Nếu n lớn hơn m, trả về -1.
    Ví dụ:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Cho một danh sách các số nguyên dương x, trả về một danh sách đã được sắp xếp
    gồm tất cả các phần tử không chứa bất kỳ chữ số chẵn nào.

    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Cho một danh sách các số nguyên dương x. trả về một danh sách đã sắp xếp của tất cả các
    phần tử không có chữ số chẵn nào.

    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Cho một danh sách các số nguyên dương x, trả về một danh sách đã được sắp xếp
    gồm tất cả các phần tử không có chữ số chẵn.

    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Cho một mảng các số nguyên, sắp xếp các số nguyên nằm trong khoảng từ 1 đến 9 (bao gồm 1 và 9),
    đảo ngược mảng kết quả, sau đó thay thế mỗi chữ số bằng tên tương ứng của nó từ
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Ví dụ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Nếu mảng rỗng, trả về một mảng rỗng:
      arr = []
      return []

      Nếu mảng có bất kỳ số lạ nào, bỏ qua nó:
      arr = [1, -1 , 55]
            -> sắp xếp arr -> [-1, 1, 55]
            -> đảo ngược arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Cho một mảng các số nguyên, sắp xếp các số nguyên trong mảng có giá trị từ 1 đến 9 (bao gồm cả 1 và 9),
    đảo ngược mảng sau khi sắp xếp, sau đó thay thế mỗi chữ số bằng tên tương ứng của nó từ
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Ví dụ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      trả về ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Nếu mảng rỗng, trả về mảng rỗng:
      arr = []
      trả về []

      Nếu mảng có số lạ, bỏ qua nó:
      arr = [1, -1 , 55]
            -> sắp xếp arr -> [-1, 1, 55]
            -> đảo ngược arr -> [55, 1, -1]
      trả về = ['One']
    """

def by_length(arr):
    """
    Cho một mảng các số nguyên, hãy sắp xếp các số nguyên từ 1 đến 9,
    sau đó đảo ngược mảng kết quả và thay thế mỗi số bằng tên tương ứng "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Ví dụ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Nếu mảng rỗng, trả về mảng rỗng:
      arr = []
      return []

      Nếu có số lạ trong mảng, bỏ qua chúng:
      arr = [1, -1 , 55]
            -> sắp xếp arr -> [-1, 1, 55]
            -> đảo ngược arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Triển khai hàm f. Hàm này nhận n làm tham số và
    trả về một danh sách có kích thước n sao cho giá trị của phần tử tại chỉ số i là giai thừa của i nếu i là số chẵn,
    nếu không thì là tổng của các số từ 1 đến i.
    i bắt đầu từ 1.
    Giai thừa của i là tích của các số từ 1 đến i (1 * 2 * ... * i).
    Ví dụ:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Triển khai hàm f lấy n làm tham số,
    và trả về danh sách có kích thước n, sao cho giá trị của phần tử tại chỉ mục i là giai thừa của i nếu i chẵn
    hoặc tổng các số từ 1 đến i nếu không.
    i bắt đầu từ 1.
    giai thừa của i là phép nhân các số từ 1 đến i (1 * 2 * ... * i).
    Ví dụ:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """
    Thực hiện hàm f nhận vào n làm tham số,
    và trả về một danh sách có kích thước n, sao cho giá trị của phần tử tại chỉ số i là giai thừa của i nếu i là số chẵn
    hoặc là tổng các số từ 1 đến i nếu i là số lẻ.
    i bắt đầu từ 1.
    Giai thừa của i là phép nhân các số từ 1 đến i (1 * 2 * ... * i).
    Ví dụ:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Khi một số nguyên dương n được cho, trả về một bộ giá trị chứa số lượng số nguyên đối xứng chẵn và lẻ nằm trong phạm vi
    (1, n).

    Ví dụ 1:

        Đầu vào: 3
        Đầu ra: (1, 2)
        Giải thích:
        Các số nguyên đối xứng là 1, 2, 3. Trong đó có một số chẵn và hai số lẻ.

    Ví dụ 2:

        Đầu vào: 12
        Đầu ra: (4, 6)
        Giải thích:
        Các số nguyên đối xứng là 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Trong đó có bốn số chẵn và sáu số lẻ.

    Ghi chú:
        1. 1 <= n <= 10^3
        2. Bộ giá trị trả về chứa số lượng số nguyên đối xứng chẵn và lẻ tương ứng.
    """

def even_odd_palindrome(n):
    """
    Cho một số nguyên dương n, trả về một tuple có số lượng palindrome chẵn và lẻ
    nằm trong phạm vi (1, n), bao gồm.

    Ví dụ 1:

        Đầu vào: 3
        Đầu ra: (1, 2)
        Giải thích:
        Số palindrome nguyên là 1, 2, 3. một trong số chúng là số chẵn và hai trong số chúng là số lẻ.

    Ví dụ 2:

        Đầu vào: 12
        Đầu ra: (4, 6)
        Giải thích:
        Số palindrome nguyên là 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. bốn trong số chúng là số chẵn và 6 trong số chúng là số lẻ.

    Lưu ý:
        1. 1 <= n <= 10^3
        2. tuple trả về có số lượng palindrome nguyên chẵn và lẻ tương ứng.
    """

def even_odd_palindrome(n):
    """
    Cho một số nguyên dương n, trả về một tuple chứa số lượng số nguyên đối xứng chẵn và lẻ trong phạm vi (1, n), bao gồm cả n.

    Ví dụ 1:

        Đầu vào: 3
        Đầu ra: (1, 2)
        Giải thích:
        Các số nguyên đối xứng là 1, 2, 3. Một trong số chúng là số chẵn, và hai trong số chúng là số lẻ.

    Ví dụ 2:

        Đầu vào: 12
        Đầu ra: (4, 6)
        Giải thích:
        Các số nguyên đối xứng là 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Bốn trong số chúng là số chẵn, và 6 trong số chúng là số lẻ.

    Lưu ý:
        1. 1 <= n <= 10^3
        2. Tuple trả về chứa số lượng số nguyên đối xứng chẵn và lẻ tương ứng.
    """


def count_nums(arr):
    """
    Viết một hàm count_nums nhận một mảng các số nguyên và trả về
    số lượng phần tử có tổng các chữ số > 0.
    Nếu một số là số âm, thì chữ số có dấu đầu tiên sẽ là âm:
    ví dụ: -123 có các chữ số có dấu là -1, 2, và 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Viết một hàm count_nums nhận vào một mảng số nguyên và trả về số lượng phần tử có tổng các chữ số lớn hơn 0.
    Nếu số là số âm, chữ số đầu tiên có dấu sẽ là số âm:
    Ví dụ: -123 có chữ số có dấu là -1, 2, 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Viết hàm count_nums nhận vào một mảng các số nguyên và trả về số phần tử có tổng các chữ số > 0.
    Nếu một số âm thì chữ số có dấu đầu tiên của nó sẽ âm:
    Ví dụ. -123 có các chữ số có dấu -1, 2 và 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N].
    Các số trong mảng sẽ được sắp xếp ngẫu nhiên. Nhiệm vụ của bạn là xác định
    liệu có thể sắp xếp mảng theo thứ tự không giảm bằng cách thực hiện
    phép toán sau trên mảng đã cho:
        Bạn được phép thực hiện phép dịch chuyển phải bất kỳ số lần nào.

    Một phép dịch chuyển phải có nghĩa là dịch tất cả các phần tử trong mảng
    sang một vị trí sang phải. Phần tử cuối cùng của mảng sẽ được chuyển tới
    vị trí đầu tiên trong mảng, tức là chỉ số 0.

    Nếu có thể đạt được mảng đã sắp xếp theo thứ tự không giảm bằng cách
    thực hiện phép toán trên, trả về True, ngược lại trả về False.
    Nếu mảng đã cho là rỗng thì trả về True.

    Lưu ý: Mảng đã cho đảm bảo không có phần tử trùng lặp.

    Ví dụ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Giải thích: Bằng cách thực hiện 2 phép dịch chuyển phải, mảng có thể
                được sắp xếp theo thứ tự không giảm.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Giải thích: Không thể sắp xếp mảng theo thứ tự không giảm bằng bất kỳ
                phép dịch chuyển phải nào.

    """

def move_one_ball(arr):
    """Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N]. Các
    số trong mảng sẽ được sắp xếp ngẫu nhiên. Nhiệm vụ của bạn là xác định xem
    có thể sắp xếp một mảng theo thứ tự không giảm dần bằng cách thực hiện
    thao tác sau trên mảng đã cho hay không:
        Bạn được phép thực hiện thao tác dịch chuyển phải bất kỳ số lần nào.

    Một thao tác dịch chuyển phải có nghĩa là dịch chuyển tất cả các phần tử của mảng một
    vị trí theo hướng phải. Phần tử cuối cùng của mảng sẽ được di chuyển đến
    vị trí bắt đầu trong mảng tức là chỉ số thứ 0.

    Nếu có thể lấy được mảng đã sắp xếp bằng cách thực hiện thao tác trên
    thì trả về True nếu không thì trả về False.
    Nếu mảng đã cho trống thì trả về True.

    Lưu ý: Danh sách đã cho được đảm bảo có các phần tử duy nhất.

    Ví dụ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Giải thích: Bằng việc thực hiện 2 phép dịch chuyển phải, có thể đạt được thứ tự không giảm
                 cho mảng đã cho.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Giải thích: Không thể có được thứ tự không giảm cho
                mảng đã cho bằng cách thực hiện bất kỳ số lượng phép dịch chuyển phải nào.

    """

def move_one_ball(arr):
    """Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N].
    Các số trong mảng được sắp xếp ngẫu nhiên. Nhiệm vụ là kiểm tra xem có thể sắp xếp
    mảng theo thứ tự không giảm bằng cách thực hiện thao tác sau đây trên mảng đã cho hay không:
        Có thể thực hiện thao tác di chuyển sang phải bao nhiêu lần tùy ý.

    Thao tác di chuyển sang phải có nghĩa là di chuyển tất cả các phần tử của mảng sang phải
    một vị trí. Phần tử cuối cùng của mảng sẽ di chuyển đến vị trí bắt đầu của mảng, tức là chỉ số 0.

    Nếu có thể thực hiện thao tác trên để có được mảng đã sắp xếp, trả về True, nếu không thì trả về False.
    Nếu mảng đã cho rỗng, trả về True.

    Lưu ý: Danh sách đã cho được đảm bảo có các phần tử duy nhất.

    Ví dụ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Giải thích: Có thể đạt được thứ tự không giảm cho mảng đã cho bằng cách thực hiện thao tác di chuyển sang phải 2 lần.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Giải thích: Không thể đạt được thứ tự không giảm cho mảng đã cho bằng bất kỳ số lần di chuyển sang phải nào.

    """


def exchange(lst1, lst2):
    """Trong bài toán này, hãy triển khai một hàm lấy hai danh sách số,
    và xác định xem có thể thực hiện trao đổi các phần tử
    giữa chúng để biến lst1 thành danh sách chỉ gồm các số chẵn hay không.
    Không có giới hạn về số lượng phần tử được trao đổi giữa lst1 và lst2.
    Nếu có thể trao đổi các phần tử giữa lst1 và lst2 để biến
    tất cả các phần tử của lst1 thành số chẵn, hãy trả về "YES".
    Nếu không, hãy trả về "NO".
    Ví dụ:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Giả sử rằng các danh sách đầu vào không rỗng.
    """

def exchange(lst1, lst2):
    """Trong bài toán này, bạn sẽ triển khai một hàm nhận hai danh sách số,
    và xác định liệu có thể thực hiện một phép trao đổi phần tử giữa chúng để biến lst1 thành một danh sách chỉ chứa số chẵn hay không.
    Không có giới hạn về số lượng phần tử trao đổi giữa lst1 và lst2.
    Nếu có thể trao đổi các phần tử giữa lst1 và lst2 để làm cho tất cả các phần tử trong lst1 là số chẵn, trả về "YES".
    Nếu không, trả về "NO".
    Ví dụ:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Giả sử rằng các danh sách đầu vào sẽ không rỗng.
    """

def exchange(lst1, lst2):
    """Trong bài toán này, bạn sẽ triển khai một hàm lấy hai danh sách số,
    và xác định xem có thể thực hiện trao đổi các phần tử
    giữa chúng để biến lst1 thành danh sách chỉ gồm các số chẵn hay không.
    Không có giới hạn về số lượng phần tử được trao đổi giữa lst1 và lst2.
    Nếu có thể trao đổi các phần tử giữa lst1 và lst2 để biến
    tất cả các phần tử của lst1 thành số chẵn, hãy trả về "YES".
    Nếu không, hãy trả về "NO".
    Ví dụ:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Giả sử rằng các danh sách đầu vào sẽ không rỗng.
    """


def histogram(test):
    """Cho một chuỗi gồm các chữ cái viết thường, cách nhau bằng dấu cách, trả về một từ điển
    chứa các chữ cái có số lần xuất hiện nhiều nhất và số lần xuất hiện tương ứng.
    Nếu có nhiều chữ cái có số lần xuất hiện giống nhau, trả về tất cả những chữ cái đó.

    Ví dụ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Cho một chuỗi biểu diễn các chữ cái thường được phân cách bằng dấu cách, trả về một từ điển
    của chữ cái có số lần lặp lại nhiều nhất và chứa số lượng tương ứng.
    Nếu một số chữ cái có cùng lần xuất hiện, trả về tất cả chúng.

    Ví dụ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Cho một chuỗi các chữ cái thường được phân tách bằng khoảng trắng, trả về một từ điển của chữ cái có số lần lặp
    lại nhiều nhất và chứa số lượng tương ứng.
    Nếu một số chữ cái có cùng lần xuất hiện, trả về tất cả chúng.

    Ví dụ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Nhiệm vụ
    Chúng ta được cung cấp hai chuỗi s và c, bạn phải xóa tất cả các ký tự trong s bằng với bất kỳ ký tự nào trong c
    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi palindrome không.
    Một chuỗi được gọi là chuỗi palindrome nếu nó đọc ngược lại giống như đọc xuôi.
    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.
    Ví dụ
    Đối với s = "abcde", c = "ae", kết quả phải là ('bcd',False)
    Đối với s = "abcdef", c = "b" thì kết quả phải là ('acdef',False)
    Đối với s = "abcdedcba", c = "ab", kết quả phải là ('cdedc',True)
    """

def reverse_delete(s,c):
    """Nhiệm vụ
    Chúng ta được cung cấp hai chuỗi s và c, bạn phải xóa tất cả các ký tự trong s giống với bất kỳ ký tự nào trong c
    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi đối xứng không.
    Một chuỗi được gọi là chuỗi đối xứng nếu nó đọc ngược lại giống như đọc xuôi.
    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.
    Ví dụ
    Nếu s = "abcde", c = "ae", kết quả phải là ('bcd',False).
    Nếu s = "abcdef", c = "b", kết quả phải là ('acdef',False).
    Nếu s = "abcdedcba", c = "ab", kết quả phải là ('cdedc',True).
    """

def reverse_delete(s,c):
    """Nhiệm vụ
    Chúng ta được cung cấp hai chuỗi s và c, bạn phải xóa tất cả các ký tự trong s bằng với bất kỳ ký tự nào trong c
    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi palindrome không.
    Một chuỗi được gọi là chuỗi palindrome nếu nó đọc ngược lại giống như đọc xuôi.
    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.
    Ví dụ
    Đối với s = "abcde", c = "ae", kết quả phải là ('bcd',False)
    Đối với s = "abcdef", c = "b"  kết quả phải là ('acdef',False)
    Đối với s = "abcdedcba", c = "ab", kết quả phải là ('cdedc',True)
    """


def odd_count(lst):
    """Cho một danh sách các chuỗi, trong đó mỗi chuỗi chỉ bao gồm các chữ số, trả về một danh sách.
    Mỗi phần tử i của đầu ra phải là "số phần tử lẻ trong chuỗi i của đầu vào,"
    trong đó tất cả các i phải được thay thế bằng số chữ số lẻ trong chuỗi thứ i của đầu vào.

    >>> odd_count(['1234567'])
    ["Số phần tử lẻ trong chuỗi 1234567 là 4."]
    >>> odd_count(['3',"11111111"])
    ["Số phần tử lẻ trong chuỗi 3 là 1.",
     "Số phần tử lẻ trong chuỗi 11111111 là 8."]
    """

def odd_count(lst):
    """Cho một danh sách các chuỗi, trong đó mỗi chuỗi chỉ bao gồm các chữ số, trả về một danh sách.
    Mỗi phần tử i của đầu ra phải là "số lượng phần tử lẻ trong chuỗi i của đầu vào." trong đó tất cả các i sẽ được thay thế bằng số các chữ số lẻ trong chuỗi i của đầu vào.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
    "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Cho một danh sách các chuỗi, trong đó mỗi chuỗi chỉ bao gồm các chữ số, trả về một danh sách.
    Mỗi phần tử i của đầu ra phải là "số lượng phần tử lẻ trong chuỗi i của đầu vào." trong đó tất cả các i phải được thay thế bằng số lượng chữ số lẻ trong chuỗi thứ i của đầu vào.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
    "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """


def minSubArraySum(nums):
    """
    Cho một mảng số nguyên nums, tìm tổng nhỏ nhất của bất kỳ dãy con không rỗng nào trong nums.
    Ví dụ:
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Cho một mảng số nguyên nums, hãy tìm tổng nhỏ nhất của bất kỳ mảng con nums nào không rỗng.
    Ví dụ
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Cho một mảng các số nguyên nums, hãy tìm tổng nhỏ nhất của bất kỳ mảng con nào không rỗng
    của nums.
    Ví dụ
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Bạn được cung cấp một lưới giếng hình chữ nhật. Mỗi hàng đại diện cho một giếng duy nhất,
    và mỗi 1 trong một hàng đại diện cho một đơn vị nước duy nhất.
    Mỗi giếng có một xô tương ứng có thể được sử dụng để lấy nước từ đó,
    và tất cả các xô đều có cùng dung tích.
    Nhiệm vụ của bạn là sử dụng các xô để làm rỗng các giếng.
    Đầu ra là số lần bạn cần hạ thấp các xô.

    Ví dụ 1:
        Đầu vào:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Đầu ra: 6

    Ví dụ 2:
        Đầu vào:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Đầu ra: 5

    Ví dụ 3:
        Đầu vào:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Đầu ra: 0

    Giới hạn:
        * tất cả các giếng có chiều dài bằng nhau
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Một lưới hình chữ nhật của giếng được cung cấp. Mỗi hàng đại diện cho một giếng,
    và mỗi số 1 trong hàng đại diện cho một đơn vị nước.
    Mỗi giếng có một xô có thể được sử dụng để rút nước, và tất cả các xô đều có cùng dung lượng.
    Nhiệm vụ là làm trống giếng bằng cách sử dụng xô.
    Xuất số lần hạ xô.

    Ví dụ 1:
        Đầu vào:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Đầu ra: 6

    Ví dụ 2:
        Đầu vào:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Đầu ra: 5

    Ví dụ 3:
        Đầu vào:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Đầu ra: 0

    Điều kiện:
        * Độ dài của tất cả các giếng là như nhau
        * 1 <= grid.length <= 10^2
        * 1 <= grid[0].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Bạn được cho một lưới chữ nhật của các giếng nước. Mỗi hàng đại diện cho một giếng,
    và mỗi 1 trong một hàng đại diện cho một đơn vị nước.
    Mỗi giếng có một xô tương ứng có thể được sử dụng để rút nước khỏi giếng đó,
    và tất cả các xô đều có cùng dung tích.
    Nhiệm vụ của bạn là sử dụng các xô để làm rỗng các giếng.
    Kết quả trả về là số lần bạn cần hạ các xô.

    Ví dụ 1:
        Đầu vào:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Đầu ra: 6

    Ví dụ 2:
        Đầu vào:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Đầu ra: 5

     Ví dụ 3:
        Đầu vào:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Đầu ra: 0

     Điều kiện:
        * tất cả các giếng đều có chiều dài giống nhau
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    Trong bài toán này, bạn phải sắp xếp một mảng các số nguyên không âm theo
    số lượng bit 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.
    Đối với những số có cùng số lượng bit 1, sắp xếp theo giá trị thập phân.

    Phải triển khai như sau:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Trong Kata này, bạn phải sắp xếp một mảng các số nguyên không âm theo
    số lượng bit 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.
    Đối với số lượng các bit 1 tương tự, hãy sắp xếp dựa trên giá trị thập phân.

    Nó phải được triển khai như sau:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Trong Kata này, bạn phải sắp xếp một mảng các số nguyên không âm theo
    số lượng số 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.
    Đối với số lượng số 1 tương tự, hãy sắp xếp dựa trên giá trị thập phân.

    Nó phải được triển khai như thế này:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) ==  [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Với một chuỗi s và một số tự nhiên n, bạn được giao nhiệm vụ triển khai
    một hàm trả về danh sách tất cả các từ trong chuỗi s chứa chính xác
    n phụ âm, theo thứ tự các từ này xuất hiện trong chuỗi s.
    Nếu chuỗi s trống thì hàm sẽ trả về một danh sách trống.
    Lưu ý: bạn có thể cho rằng chuỗi đầu vào chỉ chứa các chữ cái và khoảng trắng.
    Ví dụ:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Cho một chuỗi s và số tự nhiên n, hãy thực hiện
    một hàm trả về danh sách tất cả các từ trong chuỗi s chứa chính xác
    n phụ âm, thứ tự các từ này xuất hiện trong chuỗi s.
    Nếu chuỗi s trống thì hàm sẽ trả về một danh sách trống.
    Lưu ý: bạn có thể giả sử chuỗi đầu vào chỉ chứa các chữ cái và dấu cách.
    Ví dụ:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Với một chuỗi s và một số tự nhiên n được cho, cần triển khai một hàm trả về
    danh sách tất cả các từ trong chuỗi s chứa chính xác n phụ âm,
    các từ này được trả về theo thứ tự xuất hiện trong chuỗi s.
    Nếu chuỗi s rỗng, hàm phải trả về danh sách rỗng.
    Lưu ý: Có thể giả định rằng chuỗi đầu vào chỉ chứa chữ cái và khoảng trắng.
    Ví dụ:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Bạn được đưa cho một từ. Nhiệm vụ của bạn là tìm nguyên âm gần nhất nằm giữa
    hai phụ âm từ bên phải của từ (phân biệt chữ hoa chữ thường).

    Nguyên âm ở đầu và cuối không được tính. Trả về chuỗi rỗng nếu bạn không
    tìm thấy bất kỳ nguyên âm nào đáp ứng điều kiện trên.

    Bạn có thể cho rằng chuỗi đã cho chỉ chứa chữ cái tiếng Anh.

    Ví dụ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Cho một từ. Nhiệm vụ của bạn là tìm nguyên âm gần nhất nằm giữa
    hai phụ âm từ bên phải của từ (phân biệt chữ hoa chữ thường).

    Nguyên âm ở đầu và cuối không được tính. Trả về chuỗi rỗng nếu bạn không
    tìm thấy bất kỳ nguyên âm nào đáp ứng điều kiện trên.

    Bạn có thể cho rằng chuỗi đã cho chỉ chứa chữ cái tiếng Anh.

    Ví dụ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Bạn được cho một từ. Nhiệm vụ của bạn là tìm nguyên âm gần nhất nằm giữa
    hai phụ âm từ phía bên phải của từ (chú ý đến chữ hoa và chữ thường).

    Nguyên âm ở đầu và cuối không được tính. Trả về chuỗi rỗng nếu bạn không tìm được
    nguyên âm nào thỏa mãn điều kiện trên.

    Bạn có thể giả sử rằng chuỗi đầu vào chỉ chứa các chữ cái tiếng Anh.

    Ví dụ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Bạn được cho một danh sách gồm hai chuỗi, cả hai chuỗi chỉ chứa dấu ngoặc mở '(' hoặc ngoặc đóng ')'.
    Nhiệm vụ của bạn là kiểm tra xem có thể nối hai chuỗi theo một thứ tự nào đó sao cho chuỗi kết quả sẽ là chuỗi hợp lệ hay không.
    Một chuỗi S được coi là hợp lệ nếu và chỉ nếu tất cả các dấu ngoặc trong S đều cân bằng. Ví dụ: chuỗi '(())()' là hợp lệ, trong khi chuỗi '())' thì không.
    Trả về 'Yes' nếu có cách để tạo ra một chuỗi hợp lệ, và trả về 'No' nếu không có.

    Ví dụ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Một danh sách gồm hai chuỗi được cung cấp. Hai chuỗi chỉ bao gồm dấu ngoặc mở '(' hoặc dấu ngoặc đóng ')'.
    Nhiệm vụ của bạn là kiểm tra xem có thể nối hai chuỗi theo bất kỳ thứ tự nào để tạo ra một chuỗi kết quả là chuỗi tốt hay không.
    Chuỗi S chỉ được coi là chuỗi tốt nếu tất cả các dấu ngoặc của S cân bằng. Ví dụ: chuỗi '(())()' là tốt, nhưng chuỗi '())' thì không tốt.
    Nếu có cách tạo ra chuỗi tốt, trả về 'Yes', nếu không thì trả về 'No'.

    Ví dụ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Bạn được cung cấp một danh sách gồm hai chuỗi, cả hai chuỗi đều chỉ bao gồm các dấu ngoặc đơn mở
    '(' hoặc dấu ngoặc đơn đóng ')'.
    Nhiệm vụ của bạn là kiểm tra xem có thể nối hai chuỗi theo
    một thứ tự nào đó không, rằng chuỗi kết quả sẽ tốt.
    Một chuỗi S được coi là tốt nếu và chỉ nếu tất cả các dấu ngoặc đơn trong S
    đều cân bằng. Ví dụ: chuỗi '(())()' là tốt, trong khi chuỗi
    '())' thì không.
    Trả về 'Yes' nếu có cách tạo một chuỗi tốt và trả về 'No' nếu không.

    Ví dụ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Cho một mảng arr các số nguyên và một số nguyên dương k, trả về một danh sách đã sắp xếp
    có độ dài k với k số lớn nhất trong arr.

    Ví dụ 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    Ví dụ 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    Ví dụ 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Lưu ý:
        1. Độ dài của mảng sẽ nằm trong phạm vi [1, 1000].
        2. Các phần tử trong mảng sẽ nằm trong phạm vi [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Cho một mảng số nguyên arr và một số nguyên dương k, trả về một danh sách đã sắp xếp
    có độ dài k được tạo thành từ tối đa k số trong arr.

    Ví dụ 1:

        Đầu vào: arr = [-3, -4, 5], k = 3
        Đầu ra: [-4, -3, 5]

    Ví dụ 2:

        Đầu vào: arr = [4, -4, 4], k = 2
        Đầu ra: [4, 4]

    Ví dụ 3:

        Đầu vào: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Đầu ra: [2]

    Ghi chú:
        1. Độ dài của mảng nằm trong phạm vi [1, 1000].
        2. Các phần tử của mảng nằm trong phạm vi [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Cho một mảng arr gồm các số nguyên và một số nguyên dương k, trả về một danh sách đã sắp xếp
    có độ dài k với k số lớn nhất trong arr.

    Ví dụ 1:

    Đầu vào: arr = [-3, -4, 5], k = 3
    Đầu ra: [-4, -3, 5]

    Ví dụ 2:

    Đầu vào: arr = [4, -4, 4], k = 2
    Đầu ra: [4, 4]

    Ví dụ 3:

    Đầu vào: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
    Đầu ra: [2]

    Lưu ý:
    1. Độ dài của mảng sẽ nằm trong phạm vi [1, 1000].
    2. Các phần tử trong mảng sẽ nằm trong phạm vi [-1000, 1000].
    3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Cho một danh sách không rỗng các số nguyên, trả về tổng của tất cả các phần tử lẻ ở các vị trí chẵn.

    Ví dụ:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==> 0
    """

def solution(lst):
    """Khi một danh sách không rỗng chứa các số nguyên được đưa ra, trả về tổng của tất cả các phần tử lẻ ở vị trí chẵn.

    Ví dụ
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Cho một danh sách các số nguyên không rỗng, trả về tổng của tất cả các phần tử lẻ ở vị trí chẵn.

    Ví dụ
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Cho một mảng không rỗng các số nguyên arr và một số nguyên k, trả về
    tổng các phần tử có tối đa hai chữ số từ k phần tử đầu tiên của mảng arr.

    Ví dụ:

        Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Đầu ra: 24 # tổng của 21 + 3

    Điều kiện:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Cho một mảng không rỗng gồm các số nguyên arr và một số nguyên k, trả về
    tổng các phần tử có nhiều nhất hai chữ số từ k phần tử đầu tiên của arr.

    Ví dụ:

    Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4
    Đầu ra: 24 # sum of 21 + 3

    Ràng buộc:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Cho một mảng arr không rỗng chứa các số nguyên và một số nguyên k,
    trả về tổng của các phần tử có tối đa hai chữ số trong k phần tử đầu tiên của arr.

    Ví dụ:

        Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Đầu ra: 24 # tổng của 21 + 3

    Điều kiện ràng buộc:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Cho một số nguyên dương n, trả về một danh sách đã được sắp xếp chứa các số lẻ trong dãy Collatz.

    Giả thuyết Collatz là một giả thuyết trong toán học liên quan đến một dãy số được định nghĩa
    như sau: bắt đầu với bất kỳ số nguyên dương n nào. Sau đó mỗi số hạng được lấy từ
    số hạng trước đó như sau: nếu số hạng trước là số chẵn, số hạng tiếp theo là một nửa của
    số hạng trước. Nếu số hạng trước là số lẻ, số hạng tiếp theo là 3 lần số hạng trước
    cộng 1. Giả thuyết này cho rằng dù n có giá trị gì đi chăng nữa, dãy số sẽ luôn đạt tới 1.

    Lưu ý:
        1. Collatz(1) là [1].
        2. Danh sách trả về được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    get_odd_collatz(5) trả về [1, 5] # Dãy Collatz của 5 là [5, 16, 8, 4, 2, 1], vì vậy các số lẻ chỉ có 1 và 5.
    """

def get_odd_collatz(n):
    """
    Cho một số nguyên dương n, trả về một danh sách được sắp xếp chứa các số lẻ trong dãy Collatz.

    Giả thuyết Collatz là một giả thuyết toán học liên quan đến một dãy số được định nghĩa như sau: Bắt đầu với bất kỳ số nguyên dương n
    nào. Sau đó, mỗi số hạng được lấy từ số hạng trước đó như sau: nếu số hạng trước đó là chẵn, số hạng tiếp theo là một nửa của số hạng
    trước đó. Nếu số hạng trước đó là lẻ, số hạng tiếp theo là số gấp ba lần số hạng trước đó cộng thêm 1. Giả thuyết cho rằng bất kể giá trị n
    là gì, dãy số sẽ luôn đạt đến 1.

    Lưu ý:
        1. Collatz(1) là [1].
        2. danh sách trả về được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    get_odd_collatz(5) trả về [1, 5] # Dãy Collatz cho 5 là [5, 16, 8, 4, 2, 1], vì vậy các số lẻ chỉ là 1 và 5.
    """

def get_odd_collatz(n):
    """
    Cho một số nguyên dương n, trả về một danh sách đã được sắp xếp chứa các số lẻ trong dãy Collatz.

    Giả thuyết Collatz là một giả thuyết trong toán học liên quan đến một dãy số được định nghĩa
    như sau: bắt đầu với bất kỳ số nguyên dương n nào. Sau đó, mỗi phần tử trong dãy số được tính từ
    phần tử trước đó như sau: nếu phần tử trước đó là số chẵn, phần tử tiếp theo là một nửa của phần tử trước đó.
    Nếu phần tử trước đó là số lẻ, phần tử tiếp theo là ba lần phần tử trước đó cộng 1. Giả thuyết này cho rằng bất kể giá trị
    của n là gì, dãy số sẽ luôn luôn đạt đến 1.

    Lưu ý:
        1. Collatz(1) là [1].
        2. danh sách trả về sẽ được sắp xếp theo thứ tự tăng dần.

    Ví dụ:
    get_odd_collatz(5) trả về [1, 5] # Dãy Collatz của 5 là [5, 16, 8, 4, 2, 1], vì vậy các số lẻ chỉ có 1 và 5.
    """


def valid_date(date):
    """Viết một hàm để kiểm tra chuỗi ngày đã cho và trả về True nếu ngày hợp lệ, ngược lại trả về False.
    Để ngày hợp lệ, tất cả các quy tắc sau phải được thỏa mãn:
    1. Chuỗi ngày không được rỗng.
    2. Đối với các tháng 1,3,5,7,8,10,12, số ngày không được nhỏ hơn 1 hoặc lớn hơn 31. Và đối với các tháng 4,6,9,11, số ngày không được nhỏ hơn 1 hoặc lớn hơn 30. Và đối với tháng 2, số ngày không được nhỏ hơn 1 hoặc lớn hơn 29.
    3. Các tháng không được nhỏ hơn 1 hoặc lớn hơn 12.
    4. Ngày phải có định dạng sau: mm-dd-yyyy

    Ví dụ:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Viết một hàm để kiểm tra chuỗi ngày đã cho và trả về True nếu ngày hợp lệ, ngược lại trả về False.
    Để ngày hợp lệ, tất cả các quy tắc sau phải được thỏa mãn:
    1. Chuỗi ngày không được rỗng.
    2. Đối với các tháng 1,3,5,7,8,10,12, số ngày không được nhỏ hơn 1 hoặc lớn hơn 31. Và đối với các tháng 4,6,9,11, số ngày không được nhỏ hơn 1 hoặc lớn hơn 30. Và đối với tháng 2, số ngày không được nhỏ hơn 1 hoặc lớn hơn 29.
    3. Tháng không được nhỏ hơn 1 hoặc lớn hơn 12.
    4. Ngày phải có định dạng sau: mm-dd-yyyy

    Ví dụ:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Bạn phải viết một hàm kiểm tra tính hợp lệ của một chuỗi ngày tháng đã cho và
    trả về True nếu ngày hợp lệ, ngược lại trả về False.
    Ngày là hợp lệ nếu tất cả các quy tắc sau được thỏa mãn:
    1. Chuỗi ngày tháng không được rỗng.
    2. Số ngày không ít hơn 1 hoặc không vượt quá 31 ngày đối với các tháng 1, 3, 5, 7, 8, 10, 12. Và số ngày không ít hơn 1 hoặc không vượt quá 30 ngày đối với các tháng 4, 6, 9, 11. Và số ngày không ít hơn 1 hoặc không vượt quá 29 ngày đối với tháng 2.
    3. Tháng không được ít hơn 1 hoặc vượt quá 12.
    4. Ngày phải theo định dạng: mm-dd-yyyy

    Ví dụ:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Cho một chuỗi các từ, trả về một danh sách các từ được tách ra theo khoảng trắng. Nếu không có khoảng trắng trong văn bản,
    bạn cần tách theo dấu phẩy ','; nếu không có dấu phẩy, bạn cần trả về số lượng chữ cái viết thường có thứ tự lẻ trong bảng chữ cái, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Ví dụ
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Cho một chuỗi từ, trả về danh sách các từ được chia theo khoảng trắng, nếu không có khoảng trắng nào trong văn bản, bạn
    hãy chia theo dấu phẩy ',' nếu không có dấu phẩy nào, bạn nên trả về số chữ cái thường có thứ tự lẻ trong
    bảng chữ cái, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Ví dụ
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Cho một chuỗi các từ, trả về danh sách các từ tách biệt bởi khoảng trắng, nếu trong văn bản không có khoảng trắng,
    bạn sẽ tách bằng dấu phẩy ',' nếu không có dấu phẩy thì bạn sẽ trả về số lượng các chữ cái thường có thứ tự lẻ trong
    bảng chữ cái, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Ví dụ:
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Được cho một danh sách các số, trả về liệu chúng có được sắp xếp theo thứ tự tăng dần hay không.
    Nếu danh sách có nhiều hơn 1 bản sao của cùng một số, trả về False. Giả sử không có số âm và chỉ có số nguyên.

    Ví dụ
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Cho một danh sách các số, trả về xem chúng có được sắp xếp theo thứ tự tăng dần hay không. Nếu danh sách có nhiều hơn 1 số trùng lặp của cùng một số, trả về False. Giả sử không có số âm và chỉ có số nguyên.

    Ví dụ
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Cho một danh sách các số, trả về kết quả xem chúng có được sắp xếp
    theo thứ tự tăng dần hay không. Nếu danh sách có hơn một bản sao của
    cùng một số, trả về False. Giả sử không có số âm và chỉ chứa số nguyên.

    Ví dụ
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Bạn được cho hai khoảng,
    trong đó mỗi khoảng là một cặp số nguyên. Ví dụ, khoảng = (bắt đầu, kết thúc) = (1, 2).
    Các khoảng đã cho là đóng, nghĩa là khoảng (bắt đầu, kết thúc)
    bao gồm cả bắt đầu và kết thúc.
    Đối với mỗi khoảng đã cho, giả sử rằng bắt đầu của nó nhỏ hơn hoặc bằng kết thúc của nó.
    Nhiệm vụ của bạn là xác định xem độ dài giao điểm của hai khoảng này
    có phải là số nguyên tố hay không.
    Ví dụ, giao điểm của các khoảng (1, 3), (2, 4) là (2, 3)
    có độ dài là 1, không phải là số nguyên tố.
    Nếu độ dài giao điểm là số nguyên tố, trả về "YES",
    nếu không, trả về "NO".
    Nếu hai khoảng không giao nhau, trả về "NO".

    [input/output] mẫu:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Bạn được cung cấp hai khoảng,
    trong đó mỗi khoảng là một cặp số nguyên. Ví dụ, interval = (start, end) = (1, 2).
    Các khoảng đã cho là đóng, nghĩa là khoảng(start, end)
    bao gồm cả bắt đầu và kết thúc.
    Đối với mỗi khoảng đã cho, giả sử rằng bắt đầu của nó nhỏ hơn hoặc bằng kết thúc của nó.
    Nhiệm vụ của bạn là xác định xem độ dài giao điểm của hai khoảng này
    có phải là số nguyên tố hay không.
    Ví dụ, giao điểm của các khoảng (1, 3), (2, 4) là (2, 3)
    có độ dài là 1, không phải là số nguyên tố.
    Nếu độ dài giao điểm là số nguyên tố, hãy trả về "YES",
    nếu không, hãy trả về "NO".
    Nếu hai khoảng không giao nhau, hãy trả về "NO".

    [đầu vào/đầu ra] mẫu:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Hai khoảng được cho,
    mỗi khoảng là một cặp số nguyên. Ví dụ, interval = (start, end) = (1, 2).
    Các khoảng cho trước là khoảng đóng, khoảng (start, end) bao gồm
    cả start và end.
    Với mỗi khoảng cho trước, giả sử rằng bắt đầu nhỏ hơn hoặc bằng kết thúc.
    Nhiệm vụ là xác định xem độ dài giao của hai khoảng có phải là số nguyên tố hay không.
    Ví dụ, giao của khoảng (1, 3), (2, 4) là (2, 3) và
    độ dài của nó là 1, không phải là số nguyên tố.
    Nếu độ dài giao là số nguyên tố, trả về "YES",
    nếu không, trả về "NO".
    Nếu hai khoảng không giao nhau, trả về "NO".

    [input/output] ví dụ:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Bạn được cho một mảng arr gồm các số nguyên và bạn cần trả về
    tổng các độ lớn của các số nguyên được nhân với tích của dấu của từng số trong mảng,
    dấu được biểu diễn bởi 1, -1 hoặc 0.
    Lưu ý: trả về None nếu arr là mảng rỗng.

    Ví dụ:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Cho mảng số nguyên arr, cần trả về tổng giá trị tuyệt đối của các số nguyên nhân với tích của các dấu của từng số. Dấu được biểu diễn bằng 1, -1 hoặc 0.
    Lưu ý: Trong trường hợp mảng rỗng, trả về None.

    Ví dụ:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Bạn được cho một mảng arr gồm các số nguyên và bạn cần trả về
    tổng các độ lớn của các số nguyên nhân với tích của tất cả các dấu hiệu
    của mỗi số trong mảng, được biểu thị bằng 1, -1 hoặc 0.
    Lưu ý: trả về None cho arr rỗng.

    Ví dụ:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Cho một lưới với N hàng và N cột (N >= 2) và một số nguyên dương k,
    mỗi ô trong lưới chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * N]
    (bao gồm cả 1 và N * N) xuất hiện chính xác một lần trong các ô của lưới.

    Bạn phải tìm đường đi ngắn nhất có độ dài k trong lưới. Bạn có thể bắt đầu
    từ bất kỳ ô nào, và ở mỗi bước bạn có thể di chuyển đến bất kỳ ô hàng xóm nào,
    nói cách khác, bạn có thể đi đến các ô có cạnh chung với ô hiện tại của bạn.
    Lưu ý rằng một đường đi có độ dài k có nghĩa là bạn phải thăm chính xác k ô (không nhất thiết là các ô khác nhau).
    Bạn KHÔNG ĐƯỢC đi ra ngoài lưới.
    Một đường đi A (có độ dài k) được coi là nhỏ hơn một đường đi B (có độ dài k) nếu
    sau khi tạo danh sách có thứ tự các giá trị trong các ô mà A và B đi qua (gọi chúng là lst_A và lst_B),
    lst_A là nhỏ hơn lst_B theo thứ tự từ điển, nói cách khác, có một chỉ số nguyên i (1 <= i <= k)
    sao cho lst_A[i] < lst_B[i] và với mọi j (1 <= j < i) chúng ta có lst_A[j] = lst_B[j].
    Đảm bảo rằng kết quả là duy nhất.
    Trả về một danh sách có thứ tự các giá trị trong các ô mà đường đi ngắn nhất đi qua.

    Ví dụ:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    Cho một bảng có N hàng và N cột (N >= 2) và một số nguyên dương k,
    mỗi ô của bảng chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * N]
    bao gồm xuất hiện đúng một lần trên các ô của bảng.

    Bạn phải tìm đường đi ngắn nhất có độ dài k trong bảng. Bạn có thể bắt
    đầu từ bất kỳ ô nào và trong mỗi bước, bạn có thể di chuyển đến bất kỳ ô lân cận nào,
    nói cách khác, bạn có thể đến các ô có chung cạnh với ô
    hiện tại.
    Lưu ý rằng đường đi có độ dài k có nghĩa là phải đi qua chính xác k ô (không
    nhất thiết phải khác biệt).
    Bạn KHÔNG THỂ ra khỏi bảng.
    Đường đi A (có độ dài k) được coi là nhỏ hơn đường đi B (có độ dài k) nếu
    sau khi tạo danh sách có thứ tự các giá trị trên các ô mà A và B đi qua
    (hãy gọi chúng là lst_A và lst_B), lst_A ít hơn lst_B về mặt từ điển, nói
    cách khác, tồn tại một chỉ số nguyên i (1 <= i <= k)
    sao cho lst_A[i] < lst_B[i] và với bất kỳ j nào (1 <= j < i) thì ta có
    lst_A[j] = lst_B[j].
    Đảm bảo rằng câu trả lời là duy nhất.
    Trả về danh sách có thứ tự các giá trị trên các ô mà đường dẫn tối thiểu đi qua.

    Ví dụ:

        Đầu vào: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Đầu ra: [1, 2, 1]

        Đầu vào: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Đầu ra: [1]
    """

def minPath(grid, k):
    """
    Cho một lưới với N hàng và N cột (N >= 2) và một số nguyên dương k,
    mỗi ô trong lưới chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * N]
    xuất hiện chính xác một lần trong các ô của lưới.

    Bạn cần tìm đường đi có độ dài k tối thiểu trong lưới. Bạn có thể bắt đầu
    từ bất kỳ ô nào, và mỗi bước bạn có thể di chuyển đến bất kỳ ô nào bên cạnh,
    nghĩa là bạn có thể đi đến các ô chia sẻ một cạnh với ô hiện tại của bạn.
    Lưu ý rằng một đường đi có độ dài k có nghĩa là viếng thăm chính xác k ô (không
    nhất thiết là các ô khác nhau).
    Bạn KHÔNG THỂ ra ngoài lưới.

    Một đường đi A (có độ dài k) được coi là nhỏ hơn một đường đi B (có độ dài k)
    nếu sau khi sắp xếp các danh sách giá trị của các ô mà A và B đi qua (gọi là
    lst_A và lst_B), lst_A nhỏ hơn lst_B theo thứ tự từ điển, tức là tồn tại
    một chỉ số nguyên i (1 <= i <= k) sao cho lst_A[i] < lst_B[i] và với mọi
    chỉ số j (1 <= j < i) chúng ta có lst_A[j] = lst_B[j].
    Đảm bảo rằng kết quả là duy nhất.
    Trả về một danh sách có thứ tự các giá trị trên các ô mà đường đi tối thiểu đi qua.

    Ví dụ:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """


def tri(n):
    """Mọi người đều biết về dãy số Fibonacci và nó đã được các nhà toán học nghiên cứu sâu trong nhiều thế kỷ qua.
    Tuy nhiên, điều mà mọi người ít biết đến là dãy số Tribonacci.
    Dãy số Tribonacci được định nghĩa bằng công thức truy hồi sau:
    tri(1) = 3
    tri(n) = 1 + n / 2, khi n là số chẵn.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), khi n là số lẻ.

    Ví dụ:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Bạn được cho một số nguyên không âm n, và bạn cần trả về một danh sách chứa các số của dãy Tribonacci từ tri(0) đến tri(n).

    Ví dụ:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Mọi người đều biết dãy số Fibonacci, nó đã được các nhà toán học nghiên cứu sâu sắc trong
    vài thế kỷ trở lại đây. Tuy nhiên, điều mà mọi người không biết là dãy số Tribonacci.
    Dãy số Tribonacci được xác định bằng phép lặp lại:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n is even.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
    Ví dụ:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Cho một số nguyên không âm n, hãy trả về danh sách gồm
    số n + 1 đầu tiên của dãy số Tribonacci.
    Ví dụ:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Mọi người đều biết đến dãy số Fibonacci, dãy số này đã được các nhà toán học nghiên cứu sâu trong
    vài thế kỷ qua. Tuy nhiên, ít người biết đến dãy số Tribonacci.
    Dãy số Tribonacci được định nghĩa bởi công thức đệ quy:
    tri(1) = 3
    tri(n) = 1 + n / 2, nếu n là số chẵn.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), nếu n là số lẻ.
    Ví dụ:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Bạn được cho một số nguyên không âm n, và yêu cầu trả về một danh sách các số trong dãy Tribonacci đầu tiên
    có chỉ số từ 0 đến n.
    Ví dụ:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Cho một số nguyên dương n, trả về tích của các chữ số lẻ.
    Trả về 0 nếu tất cả các chữ số đều là chẵn.
    Ví dụ:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Cho một số nguyên dương n, trả về tích của các chữ số lẻ.
    Trả về 0 nếu tất cả các chữ số đều chẵn.
    Ví dụ:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Cho một số nguyên dương n, trả về tích của các chữ số lẻ.
    Trả về 0 nếu tất cả các chữ số đều là số chẵn.
    Ví dụ:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Tạo một hàm nhận vào một chuỗi chỉ chứa dấu ngoặc vuông.
    Hàm này sẽ trả về True nếu và chỉ nếu có một chuỗi con hợp lệ của dấu ngoặc
    trong đó ít nhất một dấu ngoặc là lồng nhau.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Tạo một hàm lấy một chuỗi làm đầu vào chỉ chứa dấu ngoặc vuông.
    Hàm này sẽ trả về True nếu và chỉ nếu có một chuỗi con hợp lệ của dấu ngoặc vuông
    trong đó có ít nhất một dấu ngoặc trong chuỗi con được lồng vào nhau.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Tạo một hàm nhận vào một chuỗi chỉ chứa các dấu ngoặc vuông.
    Hàm này sẽ trả về True nếu và chỉ nếu có một chuỗi con hợp lệ của các dấu ngoặc
    mà trong đó ít nhất một dấu ngoặc được lồng nhau.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """Bạn được cung cấp một danh sách các số.
    Bạn cần trả về tổng của các số bình phương trong danh sách đã cho,
    sau khi làm tròn từng phần tử trong danh sách lên số nguyên gần nhất (Làm tròn lên - Ceiling).
    Ví dụ:
    Với lst = [1,2,3] kết quả trả về sẽ là 14
    Với lst = [1,4,9] kết quả trả về sẽ là 98
    Với lst = [1,3,5,7] kết quả trả về sẽ là 84
    Với lst = [1.4,4.2,0] kết quả trả về sẽ là 29
    Với lst = [-2.4,1,1] kết quả trả về sẽ là 6

    """

def sum_squares(lst):
    """Một danh sách các số được đưa ra.
    Bạn cần trả về tổng của các số sau khi làm tròn cận trên từng phần tử trong danh sách thành số nguyên và bình phương chúng.
    Ví dụ:
    lst = [1,2,3] thì đầu ra phải là 14.
    lst = [1,4,9] thì đầu ra phải là 98.
    lst = [1,3,5,7] thì đầu ra phải là 84.
    lst = [1.4,4.2,0] thì đầu ra phải là 29.
    lst = [-2.4,1,1] thì đầu ra phải là 6.

    """

def sum_squares(lst):
    """Cho một danh sách các số.
    Bạn cần trả về tổng của bình phương các số trong danh sách đã cho,
    làm tròn từng phần tử trong danh sách đã cho đến upper int(Ceiling) trước.
    Ví dụ:
    lst = [1,2,3] thì đầu ra phải là 14
    lst = [1,4,9] thì đầu ra phải là 98
    lst = [1,3,5,7] thì đầu ra phải là 84
    lst = [1.4,4.2,0] thì đầu ra phải là 29
    lst = [-2.4,1,1] thì đầu ra phải là 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Tạo một hàm trả về True nếu ký tự cuối cùng của chuỗi đã cho là một chữ cái
    và không phải là một phần của từ.
    Nếu không, trả về False.
    Lưu ý: "từ" là nhóm ký tự được phân tách bằng khoảng trắng.

    Ví dụ:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Tạo một hàm trả về True nếu ký tự cuối cùng
    của một chuỗi đã cho là ký tự chữ cái và không phải là
    một phần của một từ, và False nếu không.
    Lưu ý: "từ" là một nhóm ký tự được phân tách bằng dấu cách.

    Ví dụ:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Tạo một hàm trả về True nếu ký tự cuối cùng
    của chuỗi đầu vào là một ký tự chữ cái và không
    thuộc một từ, và trả về False nếu không phải.
    Lưu ý: "từ" là một nhóm các ký tự được ngăn cách bằng dấu cách.

    Ví dụ:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Tạo một hàm trả về chỉ số lớn nhất của một phần tử mà
    không lớn hơn hoặc bằng phần tử ngay trước đó. Nếu
    không có phần tử nào như vậy, trả về -1. Mảng đã cho sẽ không chứa
    các giá trị trùng lặp.

    Ví dụ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Tạo một hàm trả về chỉ số lớn nhất của một phần tử mà không lớn hơn hoặc bằng phần tử ngay trước nó.
    Nếu không có phần tử nào như vậy, trả về -1. Mảng đầu vào sẽ không chứa giá trị trùng lặp.

    Ví dụ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Tạo một hàm trả về chỉ số lớn nhất của phần tử không lớn hơn hoặc bằng phần tử ngay trước nó
    trong mảng đã cho. Nếu không tồn tại phần tử như vậy, trả về -1.
    Mảng đã cho không chứa các giá trị trùng lặp.

    Ví dụ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Tạo một hàm trả về một tuple (a, b), trong đó 'a' là
    số nguyên âm lớn nhất và 'b' là số nguyên dương nhỏ nhất trong một danh sách.
    Nếu không có số nguyên âm hoặc số nguyên dương nào, hãy trả về chúng là None.

    Ví dụ:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Tạo một hàm trả về một bộ đôi (a, b), trong đó 'a' là
    số nguyên âm lớn nhất, và 'b' là số nguyên dương nhỏ nhất
    trong danh sách.
    Nếu không có số nguyên âm hoặc số nguyên dương, trả về None cho chúng.

    Ví dụ:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Tạo một hàm nhận vào các số nguyên, số thực hoặc chuỗi đại diện
    cho các số thực, và trả về biến lớn hơn trong kiểu biến đã cho.
    Trả về None nếu các giá trị bằng nhau.
    Lưu ý: Nếu một số thực được biểu diễn dưới dạng chuỗi, dấu phẩy hoặc dấu chấm có thể được sử dụng làm dấu thập phân.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Tạo một hàm nhận vào các số nguyên, số thực hoặc chuỗi đại diện
    cho các số thực, và trả về giá trị lớn hơn trong loại biến đã cho.
    Trả về None nếu các giá trị bằng nhau.
    Lưu ý: Nếu một số thực được biểu diễn dưới dạng chuỗi, dấu thập phân có thể là . hoặc ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Tạo một hàm lấy số nguyên, số thực hoặc chuỗi biểu thị
    số thực và trả về biến lớn hơn trong kiểu biến đã cho.
    Trả về None nếu các giá trị bằng nhau.
    Lưu ý: Nếu một số thực được biểu thị dưới dạng chuỗi, dấu phẩy động có thể là . hoặc ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Đánh giá xem số đã cho n có thể được viết dưới dạng tổng của chính xác 4 số chẵn dương hay không.
    Ví dụ:
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Đánh giá xem số n đã cho có thể được biểu diễn chính xác bằng tổng của 4 số chẵn dương hay không
    Ví dụ
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Đánh giá xem số n đã cho có thể được viết thành tổng của đúng 4 số chẵn dương hay không
    Example
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Giai thừa Brazil được định nghĩa như sau:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    trong đó n > 0

    Ví dụ:
    >>> special_factorial(4)
    288

    Hàm sẽ nhận một số nguyên làm đầu vào và trả về giai thừa đặc biệt
    của số nguyên này.
    """

def special_factorial(n):
    """Giai thừa Brazil được định nghĩa là:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    trong đó n > 0

    Ví dụ:
    >>> special_factorial(4)
    288

    Hàm sẽ nhận một số nguyên làm đầu vào và sẽ trả về giai thừa
    đặc biệt của số nguyên này.
    """

def special_factorial(n):
    """Giai thừa Brazil được định nghĩa như sau:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    với n > 0

    Ví dụ:
    >>> special_factorial(4)
    288

    Hàm này nhận một số nguyên làm đầu vào và phải trả về giai thừa đặc biệt của số nguyên này.
    """


def fix_spaces(text):
    """
    Cho một chuỗi văn bản, thay thế tất cả các khoảng trắng trong đó bằng dấu gạch dưới,
    và nếu một chuỗi có nhiều hơn 2 khoảng trắng liên tiếp,
    thì thay thế tất cả các khoảng trắng liên tiếp bằng -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Cho một chuỗi văn bản, thay thế tất cả các khoảng trắng bằng dấu gạch dưới,
    và nếu chuỗi có hơn 2 khoảng trắng liên tiếp,
    thì thay thế tất cả các khoảng trắng liên tiếp bằng dấu gạch nối.

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Cho một chuỗi văn bản, thay thế tất cả các khoảng trắng trong nó bằng dấu gạch dưới,
    và nếu chuỗi có hơn 2 khoảng trắng liên tiếp.
    thì thay thế tất cả các khoảng trắng liên tiếp bằng dấu gạch ngang.

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """Tạo một hàm nhận vào tên một tệp dưới dạng chuỗi và trả về
    'Yes' nếu tên tệp hợp lệ, và trả về 'No' nếu không hợp lệ.
    Tên tệp được coi là hợp lệ nếu và chỉ nếu tất cả các điều kiện sau đều được thỏa mãn:
    - Tên tệp không được chứa quá ba chữ số ('0'-'9').
    - Tên tệp chứa đúng một dấu chấm '.'.
    - Phần chuỗi trước dấu chấm không được rỗng và phải bắt đầu bằng một chữ cái từ bảng chữ cái Latinh ('a'-'z' và 'A'-'Z').
    - Phần chuỗi sau dấu chấm phải là một trong các từ sau: ['txt', 'exe', 'dll']
    Ví dụ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (tên phải bắt đầu bằng một chữ cái Latinh)
    """

def file_name_check(file_name):
    """Tạo một hàm lấy một chuỗi biểu diễn tên tệp và trả về
    'Yes' nếu tên tệp hợp lệ và trả về 'No' nếu không.
    Tên tệp được coi là hợp lệ nếu và chỉ nếu tất cả các điều kiện sau đây
    được đáp ứng:
    - Không được có quá ba chữ số ('0'-'9') trong tên tệp.
    - Tên tệp chỉ chứa đúng một dấu chấm '.'
    - Chuỗi con trước dấu chấm không được để trống và bắt đầu bằng một chữ cái từ
    chữ cái latinh ('a'-'z' và 'A'-'Z').
    - Chuỗi con sau dấu chấm phải là một trong những chuỗi sau: ['txt', 'exe', 'dll']
    Ví dụ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (tên phải bắt đầu bằng một chữ cái latinh)
    """

def file_name_check(file_name):
    """Nhận tên tệp dưới dạng chuỗi và tạo một hàm trả về 'Yes' nếu tên tệp hợp lệ, nếu không thì trả về 'No'.
    Tên tệp chỉ được coi là hợp lệ khi tất cả các điều kiện sau được thỏa mãn:
    - Tên tệp không được có nhiều hơn ba chữ số ('0'-'9').
    - Tên tệp phải chứa chính xác một dấu chấm '.'.
    - Phần chuỗi con trước dấu chấm không được rỗng và phải bắt đầu bằng chữ cái Latin ('a'-'z' và 'A'-'Z').
    - Phần chuỗi con sau dấu chấm phải là một trong các giá trị sau: ['txt', 'exe', 'dll']
    Ví dụ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (Tên phải bắt đầu bằng chữ cái Latin)
    """


def sum_squares(lst):
    """"
    Hàm này sẽ nhận một danh sách các số nguyên. Đối với tất cả các phần tử trong danh sách, hàm sẽ bình phương phần tử nếu chỉ số của phần tử là bội số của 3,
    và sẽ lập phương phần tử nếu chỉ số của phần tử là bội số của 4 nhưng không phải bội số của 3. Hàm sẽ không thay đổi các phần tử trong danh sách có chỉ số
    không phải là bội số của 3 hoặc 4. Sau đó, hàm sẽ trả về tổng của tất cả các phần tử.

    Ví dụ:
    Với lst = [1,2,3]  thì đầu ra phải là 6
    Với lst = [] thì đầu ra phải là 0
    Với lst = [-1,-5,2,-1,-5]  thì đầu ra phải là -126
    """

def sum_squares(lst):
    """"
    Hàm này sẽ lấy một danh sách các số nguyên. Đối với tất cả các mục trong danh sách, hàm sẽ bình phương mục số nguyên nếu chỉ số của nó là
    bội số của 3 và sẽ lập phương mục số nguyên nếu chỉ số của nó là bội số của 4 chứ không phải bội số của 3. Hàm sẽ không
    thay đổi các mục trong danh sách có chỉ số không phải là bội số của 3 hoặc 4. Sau đó, hàm sẽ trả về tổng của tất cả các mục.
    Ví dụ:
    For lst = [1,2,3] the output should be 6
    For lst = []  the output should be 0
    For lst = [-1,-5,2,-1,-5]  the output should be -126
    """

def sum_squares(lst):
    """"
    Hàm này sẽ lấy một danh sách các số nguyên. Đối với tất cả các mục trong danh sách, hàm sẽ bình phương mục số nguyên nếu chỉ số của nó là bội số của 3 và sẽ lập phương mục số nguyên nếu chỉ số của nó là bội số của 4 chứ không phải bội số của 3. Hàm sẽ không thay đổi các mục trong danh sách có chỉ số không phải là bội số của 3 hoặc 4. Sau đó, hàm sẽ trả về tổng của tất cả các mục.

    Ví dụ:
    Đối với lst = [1,2,3], đầu ra phải là 6
    Đối với lst = [], đầu ra phải là 0
    Đối với lst = [-1,-5,2,-1,-5], đầu ra phải là -126
    """


def words_in_sentence(sentence):
    """
    Cho một chuỗi chữ biểu thị một câu, câu này chứa một số từ được phân cách bằng dấu cách và bạn phải trả
    về một chuỗi chứa các từ trong câu gốc, có độ dài là số nguyên tố, thứ tự của các từ trong chuỗi mới phải giống với
    chuỗi gốc.

    Ví dụ 1:
        Đầu vào: sentence = "This is a test"
        Đầu ra: "is"

    Ví dụ 2:
        Đầu vào: sentence = "lets go for swimming"
        Đầu ra: "go for"

    Điều kiện ràng buộc:
        * 1 <= len(sentence) <= 100
        * sentence chỉ bao gồm các chữ cái
    """

def words_in_sentence(sentence):
    """
    Bạn được cho một chuỗi đại diện cho một câu,
    câu chứa một số từ được phân cách bằng dấu cách,
    và bạn phải trả về một chuỗi chứa các từ trong câu gốc,
    có độ dài là số nguyên tố,
    thứ tự của các từ trong chuỗi mới phải giống với chuỗi gốc.

    Ví dụ 1:
        Đầu vào: sentence = "This is a test"
        Đầu ra: "is"

    Ví dụ 2:
        Đầu vào: sentence = "lets go for swimming"
        Đầu ra: "go for"

    Giới hạn:
        * 1 <= len(sentence) <= 100
        * câu chỉ chứa các chữ cái
    """

def words_in_sentence(sentence):
    """
    Bạn được cung cấp một chuỗi biểu diễn một câu,
    câu này chứa một số từ được phân cách bằng dấu cách,
    và bạn phải trả về một chuỗi chứa các từ trong câu gốc,
    có độ dài là số nguyên tố,
    thứ tự các từ trong chuỗi mới phải giống với chuỗi ban đầu.

    Ví dụ 1:
        Đầu vào: sentence = "This is a test"
        Đầu ra: "is"

    Ví dụ 2:
        Đầu vào: sentence = "lets go for swimming"
        Đầu ra: "go for"

    Ràng buộc:
        * 1 <= len(sentence) <= 100
        * sentence chỉ chứa các chữ cái.
    """


def simplify(x, n):
    """Công việc của bạn là triển khai một hàm để đơn giản hóa biểu thức x * n.
    Hàm trả về True nếu x * n được đánh giá là một số nguyên, nếu không thì trả về False.
    x và n đều là biểu diễn chuỗi của phân số, có định dạng như sau:
    <tử số>/<mẫu số> trong đó tử số và mẫu số đều là số nguyên dương.

    Có thể giả định rằng x và n là các phân số hợp lệ và mẫu số không bằng 0.

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

def simplify(x, n):
    """"Nhiệm vụ của bạn là triển khai một hàm để đơn giản hóa biểu thức
    x * n. Hàm trả về True nếu x * n tính ra một số nguyên và False nếu không.
    Cả x và n đều là chuỗi đại diện cho một phân số, có định dạng là
    <tử số>/<mẫu số> trong đó cả tử số và mẫu số đều là số nguyên dương.

    Bạn có thể giả sử rằng x và n đều là phân số hợp lệ, và không có mẫu số bằng 0.

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

def simplify(x, n):
    """Nhiệm vụ của bạn là triển khai một hàm sẽ đơn giản hóa biểu thức
    x * n. Hàm trả về True nếu x * n tính ra một số nguyên và False
    nếu không. Cả x và n đều là chuỗi đại diện cho một phân số, với định dạng sau:
    <tử số>/<mẫu số> trong đó cả tử số và mẫu số đều là các số nguyên dương.

    Bạn có thể giả định rằng x và n là các phân số hợp lệ và không có mẫu số bằng 0.

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


def order_by_points(nums):
    """
    Viết một hàm sắp xếp danh sách các số nguyên đã cho
    theo thứ tự tăng dần theo tổng các chữ số của chúng.
    Lưu ý: nếu có một số mục có tổng các chữ số tương tự nhau,
    hãy sắp xếp chúng dựa trên chỉ số của chúng trong danh sách gốc.

    Ví dụ:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Viết một hàm sắp xếp danh sách các số nguyên đã cho theo thứ tự tăng dần
    dựa trên tổng các chữ số của chúng.
    Lưu ý: nếu có nhiều phần tử có tổng chữ số giống nhau,
    hãy sắp xếp chúng theo chỉ số của chúng trong danh sách ban đầu.

    Ví dụ:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Viết một hàm nhận vào một mảng các số và trả về số lượng các phần tử trong mảng
    mà lớn hơn 10 và cả chữ số đầu và chữ số cuối của số đó đều là số lẻ (1, 3, 5, 7, 9).
    Ví dụ:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Viết một hàm nhận vào một mảng số và trả về
    số lượng phần tử trong mảng thỏa mãn hai điều kiện là lớn hơn 10 và cả
    chữ số đầu tiên và chữ số cuối cùng của số đó đều là số lẻ (1, 3, 5, 7, 9).
    Ví dụ:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Viết một hàm lấy một mảng số làm đầu vào và trả về
    số phần tử trong mảng lớn hơn 10 và cả
    chữ số đầu tiên và chữ số cuối cùng của một số đều là số lẻ (1, 3, 5, 7, 9).
    Ví dụ:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Bạn được cung cấp một số nguyên dương n. Bạn phải tạo một mảng số nguyên a có độ dài n.
    Với mỗi i (1 ≤ i ≤ n), giá trị của a[i] = i * i - i + 1.
    Trả về số bộ ba (a[i], a[j], a[k]) của a trong đó i < j < k,
    và a[i] + a[j] + a[k] là bội số của 3.

    Ví dụ:
    Đầu vào: n = 5
    Đầu ra: 1
    Giải thích:
    a = [1, 3, 7, 13, 21]
    Bộ ba hợp lệ duy nhất là (1, 7, 13).
    """

def get_max_triples(n):
    """
    Bạn được cho một số nguyên dương n. Bạn phải tạo một mảng số nguyên a có độ dài n.
        Đối với mỗi i (1 ≤ i ≤ n), giá trị của a[i] = i * i - i + 1.
        Trả về số lượng bộ ba (a[i], a[j], a[k]) của a sao cho i < j < k,
    và a[i] + a[j] + a[k] là bội của 3.

    Ví dụ:
        Input: n = 5
        Output: 1
        Giải thích:
        a = [1, 3, 7, 13, 21]
        Bộ ba hợp lệ duy nhất là (1, 7, 13).
    """

def get_max_triples(n):
    """
    Cho một số nguyên dương n. Cần tạo một mảng số nguyên a có độ dài n.
        Với mỗi i (1 ≤ i ≤ n), giá trị của a[i] là i * i - i + 1.
        Trả về số lượng bộ ba (a[i], a[j], a[k]) trong a với i < j < k.
        Và a[i] + a[j] + a[k] là bội số của 3.

    Ví dụ:
        Đầu vào: n = 5
        Đầu ra: 1
        Giải thích:
        a = [1, 3, 7, 13, 21]
        Bộ ba hợp lệ duy nhất là (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Hệ mặt trời có tám hành tinh: gần mặt trời nhất là Sao Thủy,
    tiếp theo là Sao Kim, Trái Đất, Sao Hỏa, Sao Mộc, Sao Thổ, Sao Thiên Vương, Sao Hải Vương.
    Viết một hàm nhận tên của hai hành tinh dưới dạng chuỗi: planet1 và planet2.
    Hàm phải trả về một tuple chứa tất cả các hành tinh nằm giữa quỹ đạo của planet1 và planet2,
    được sắp xếp theo thứ tự gần mặt trời nhất.
    Nếu planet1 hoặc planet2 không phải là tên hành tinh hợp lệ, trả về một tuple rỗng.
    Ví dụ
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Có tám hành tinh trong hệ mặt trời của chúng ta: gần Mặt trời nhất
    là Sao Thủy, tiếp theo là Sao Kim, sau đó là Trái Đất, Sao Hỏa, Sao Mộc, Sao Thổ,
    Sao Thiên Vương, Sao Hải Vương.
    Viết một hàm lấy hai tên hành tinh dưới dạng chuỗi planet1 và planet2.
    Hàm này sẽ trả về một bộ chứa tất cả các hành tinh có quỹ đạo
    nằm giữa quỹ đạo của planet1 và quỹ đạo của planet2, được sắp xếp theo
    khoảng cách đến Mặt trời.
    Hàm này sẽ trả về một bộ rỗng nếu planet1 hoặc planet2
    không phải là tên hành tinh chính xác.
    Ví dụ
    bf("Sao Mộc", "Sao Hải Vương") ==> ("Sao Thổ", "Sao Thiên Vương")
    bf("Trái Đất", "Sao Thủy") ==> ("Sao Kim")
    bf("Sao Thủy", "Sao Thiên Vương") ==> ("Sao Kim", "Trái Đất", "Sao Hỏa", "Sao Mộc", "Sao Thổ")
    '''

def bf(planet1, planet2):
    '''
    Hệ mặt trời của chúng ta có tám hành tinh: hành tinh gần Mặt Trời nhất
    là Sao Thủy, tiếp theo là Sao Kim, rồi đến Trái Đất, Sao Hỏa, Sao Mộc, Sao Thổ,
    Sao Thiên Vương, và Sao Hải Vương.
    Viết một hàm nhận vào hai tên hành tinh dưới dạng chuỗi planet1 và planet2.
    Hàm này sẽ trả về một tuple chứa tất cả các hành tinh có quỹ đạo nằm giữa
    quỹ đạo của planet1 và quỹ đạo của planet2, được sắp xếp theo độ gần Mặt Trời.
    Hàm sẽ trả về một tuple rỗng nếu planet1 hoặc planet2 không phải là tên hành tinh hợp lệ.
    Ví dụ:
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Viết một hàm nhận một danh sách các chuỗi làm tham số,
    xóa các chuỗi có độ dài lẻ,
    và trả về danh sách kết quả theo thứ tự đã sắp xếp,
    Danh sách luôn là danh sách các chuỗi và không phải là một mảng các số
    và nó có thể chứa các bản sao.
    Thứ tự của danh sách phải tăng dần theo độ dài của mỗi từ và
    phải trả về danh sách được sắp xếp theo quy tắc đó.
    Nếu độ dài của hai từ bằng nhau, hãy sắp xếp danh sách theo thứ tự bảng chữ cái.
    Hàm phải trả về danh sách các chuỗi theo thứ tự đã sắp xếp.
    Giả định rằng các từ có cùng độ dài sẽ được sắp xếp theo thứ tự bảng chữ cái.
    Ví dụ:
    assert sorted_list_sum(["aa", "a", "aaa"]) => ["aa"]
    assert sorted_list_sum(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Viết một hàm chấp nhận một danh sách các chuỗi làm tham số,
    xóa các chuỗi có độ dài lẻ khỏi nó,
    và trả về danh sách kết quả với thứ tự đã sắp xếp,
    Danh sách luôn là danh sách các chuỗi và không bao giờ là một mảng các số,
    và nó có thể chứa các bản sao.
    Thứ tự của danh sách phải tăng dần theo độ dài của mỗi từ và bạn
    phải trả về danh sách được sắp xếp theo quy tắc đó.
    Nếu hai từ có cùng độ dài, hãy sắp xếp danh sách theo thứ tự bảng chữ cái.
    Hàm phải trả về danh sách các chuỗi theo thứ tự đã sắp xếp.
    Bạn có thể cho rằng tất cả các từ sẽ có cùng độ dài.
    Ví dụ:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Viết một hàm nhận một danh sách các chuỗi làm tham số,
    xóa các chuỗi có độ dài lẻ khỏi danh sách,
    và trả về danh sách kết quả đã được sắp xếp,
    Danh sách luôn là danh sách các chuỗi  không phải là mảng số,
    và có thể chứa các phần tử trùng lặp.
    Thứ tự của danh sách nên được sắp xếp tăng dần theo độ dài của từng từ, và bạn
    cần trả về danh sách đã sắp xếp theo quy tắc đó.
    Nếu hai từ có độ dài bằng nhau, hãy sắp xếp danh sách theo thứ tự bảng chữ cái.
    Hàm phải trả về một danh sách các chuỗi theo thứ tự đã sắp xếp.
    Có thể giả định rằng độ dài của tất cả các từ là như nhau.
    Ví dụ:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Một chương trình đơn giản, sẽ trả về giá trị của x nếu n là
    một số nguyên tố và sẽ trả về giá trị của y nếu không phải.

    Ví dụ:
    cho x_or_y(7, 34, 12) == 34
    cho x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Một chương trình đơn giản, trả về giá trị của x nếu n là số nguyên tố,
    và trả về giá trị của y nếu không phải số nguyên tố.

    Ví dụ:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Một chương trình đơn giản sẽ trả về giá trị của x nếu n là số nguyên tố và sẽ trả về giá trị của y nếu ngược lại.

    Ví dụ:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Cho một danh sách các số, trả về tổng bình phương của các số lẻ trong danh sách.
    Bỏ qua các số âm hoặc không phải là số nguyên.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Nếu danh sách đầu vào rỗng, trả về 0.
    '''

def double_the_difference(lst):
    '''
    Trả về tổng bình phương của các số lẻ trong danh sách số đã cho.
    Bỏ qua các số âm hoặc không phải số nguyên.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Nếu danh sách đầu vào trống, trả về 0.
    '''

def double_the_difference(lst):
    '''
    Cho một danh sách các số, trả về tổng bình phương của các số
    trong danh sách là số lẻ. Bỏ qua các số âm hoặc không phải là số nguyên.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Nếu danh sách đầu vào rỗng, trả về 0.
    '''


def compare(game, guess):
    """Tôi nghĩ chúng ta đều nhớ cảm giác khi kết quả của một sự kiện dài chờ đợi cuối cùng cũng được biết.
    Những cảm xúc và suy nghĩ bạn có vào khoảnh khắc đó chắc chắn rất đáng để ghi lại và so sánh.
    Nhiệm vụ của bạn là xác định xem một người có đoán đúng kết quả của một số trận đấu không.
    Bạn được cung cấp hai mảng điểm số và dự đoán có cùng độ dài, trong đó mỗi chỉ số cho thấy một trận đấu.
    Trả về một mảng có độ dài tương tự chỉ ra sự sai lệch giữa mỗi dự đoán và kết quả.
    Nếu họ đoán đúng, giá trị là 0, nếu không, giá trị là hiệu số tuyệt đối giữa dự đoán và điểm số.

    ví dụ:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Tôi nghĩ tất cả chúng ta đều nhớ cảm giác đó khi kết quả của một sự kiện được mong đợi từ lâu cuối cùng cũng được biết. Những cảm xúc và suy nghĩ mà bạn có vào thời điểm đó chắc chắn đáng để ghi lại và so sánh.
    Nhiệm vụ của bạn là xác định xem một người có đoán đúng kết quả của các trận đấu hay không.
    Bạn được cung cấp hai mảng điểm và dự đoán có độ dài bằng nhau, trong đó mỗi phần tử trong mảng đại diện cho một trận đấu.
    Trả về một mảng có cùng độ dài biểu thị mức độ sai lệch của mỗi dự đoán. Nếu họ đoán đúng,
    giá trị là 0 và nếu không, giá trị là sự khác biệt tuyệt đối giữa dự đoán và điểm số.

    ví dụ:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Tôi nghĩ tất cả chúng ta đều nhớ cảm xúc khi kết quả của một sự kiện được mong đợi từ lâu
    cuối cùng cũng đến. Những cảm xúc và suy nghĩ của bạn tại thời điểm đó
    chắc chắn đáng để ghi lại và so sánh.
    Nhiệm vụ của bạn là xác định xem một người có dự đoán đúng kết quả của một số trận đấu hay không.
    Cho hai mảng điểm và dự đoán có độ dài bằng nhau, trong đó mỗi chỉ số hiển thị một trận đấu.
    Trả về một mảng có cùng độ dài biểu thị khoảng cách giữa mỗi dự đoán. Nếu họ đoán đúng,
    giá trị là 0 và nếu không, giá trị là sự khác biệt tuyệt đối giữa dự đoán và điểm số.

    Ví dụ:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """Bạn sẽ được cung cấp tên của một lớp (một chuỗi) và danh sách các phần mở rộng.
    Các phần mở rộng sẽ được sử dụng để tải các lớp bổ sung vào lớp.
    Độ mạnh của phần mở rộng như sau: Giả sử CAP là số chữ cái viết hoa
    trong tên phần mở rộng và giả sử SM là số chữ cái viết thường
    trong tên phần mở rộng, độ mạnh được biểu thị bằng phân số CAP - SM.
    Bạn sẽ tìm phần mở rộng mạnh nhất và trả về một chuỗi theo
    định dạng này: ClassName.StrongestExtensionName.
    Nếu có hai hoặc nhiều phần mở rộng có cùng độ mạnh, bạn sẽ
    chọn phần mở rộng đứng đầu trong danh sách.
    Ví dụ: nếu bạn được cung cấp "Slices" làm lớp và danh sách các
    phần mở rộng: ['SErviNGSliCes', 'Cheese', 'StuFfed'] thì bạn sẽ
    trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất
    (sức mạnh của nó là -1).
    Ví dụ:
    đối với Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Bạn sẽ nhận được tên của một lớp (dưới dạng chuỗi) và một danh sách các phần mở rộng.
    Các phần mở rộng này sẽ được sử dụng để tải thêm các lớp vào lớp.
    Độ mạnh của phần mở rộng được tính như sau: Giả sử CAP là số lượng chữ cái viết hoa
    trong tên của phần mở rộng, và SM là số lượng chữ cái viết thường trong tên của phần mở rộng,
    độ mạnh được tính bằng công thức CAP - SM.
    Bạn cần tìm phần mở rộng mạnh nhất và trả về chuỗi theo định dạng:
    ClassName.StrongestExtensionName.
    Nếu có hai hoặc nhiều phần mở rộng có độ mạnh giống nhau, bạn nên chọn phần mở rộng xuất hiện đầu tiên trong danh sách.
    Ví dụ, nếu bạn được cho "Slices" là lớp và danh sách các phần mở rộng:
    ['SErviNGSliCes', 'Cheese', 'StuFfed'], thì bạn nên trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất
    (độ mạnh của nó là -1).
    Ví dụ:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Bạn sẽ được cho tên của một lớp (một chuỗi) và danh sách các phần mở rộng.
    Các phần mở rộng sẽ được sử dụng để tải các lớp bổ sung vào lớp. Độ
    mạnh của phần mở rộng như sau: Giả sử CAP là số chữ cái viết hoa
    trong tên phần mở rộng và giả sử SM là số chữ cái viết thường
    trong tên phần mở rộng, độ mạnh được biểu thị bằng phân số CAP -SM.
    Bạn sẽ tìm phần mở rộng mạnh nhất và trả về một chuỗi theo
    định dạng này: ClassName.StrongestExtensionName.
    Nếu có hai hoặc nhiều phần mở rộng có cùng độ mạnh, hãy
    chọn phần mở rộng đứng đầu trong danh sách.
    Ví dụ: nếu bạn được cho "Slices" làm lớp và danh sách các
    phần mở rộng: ['SErviNGSliCes', 'Cheese', 'StuFfed'] thì bạn sẽ
    trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất.
    (độ mạnh của nó là-1).
    Ví dụ:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a, b):
    """Bạn được cho 2 từ. Bạn cần trả về True nếu từ thứ hai hoặc bất kỳ sự xoay vòng nào của nó là một chuỗi con trong từ đầu tiên.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True
    """

def cycpattern_check(a , b):
    """Cho hai từ. Nếu từ thứ hai hoặc một trong những cụm con xoay vòng của nó là một phần của từ thứ nhất, thì phải trả về True.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Bạn được cho 2 từ. Bạn cần trả về True nếu từ thứ hai hoặc bất kỳ vòng quay nào của nó là chuỗi con trong từ đầu tiên
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Khi một số nguyên được đưa ra, trả về một bộ chứa số lượng chữ số chẵn và lẻ tương ứng.

     Ví dụ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Cho một số nguyên. trả trả về một tuple chứa số chữ số chẵn và lẻ tương ứng.

     Ví dụ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Cho một số nguyên, trả về một bộ chứa số lượng chữ số chẵn và lẻ tương ứng.

     Ví dụ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """