{"text": ["from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" Kiểm tra xem trong danh sách các số cho trước, có bất kỳ hai số nào gần nhau hơn \n    ngưỡng đã cho hay không.\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\"", "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" Kiểm tra xem trong danh sách số đã cho, có bất kỳ hai số nào gần nhau hơn\n    ngưỡng đã cho không.\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\"", "from typing import List\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" Kiểm tra xem trong danh sách số đã cho, có hai số nào gần nhau hơn ngưỡng đã cho hay không.\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc lồng nhau. Mục tiêu là\n    tách các nhóm này thành các chuỗi riêng lẻ và trả về danh sách đó.\n    Các nhóm riêng lẻ được cân bằng (mỗi dấu ngoặc mở đều được đóng đúng cách) và không lồng vào nhau.\n    Khoảng trắng trong chuỗi đầu vào được bỏ qua.\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\"", "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc đơn lồng nhau. Mục tiêu của bạn là\n    tách các nhóm đó thành các chuỗi riêng biệt và trả về danh sách các nhóm đó.\n    Các nhóm riêng biệt được cân bằng (mỗi dấu ngoặc mở được đóng đúng cách) và không được lồng vào nhau\n    Bỏ qua bất kỳ khoảng trắng nào trong chuỗi đầu vào.\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\"", "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\"Đầu vào của hàm này là một chuỗi chứa nhiều nhóm dấu ngoặc đơn lồng nhau. Mục tiêu của bạn là \n    tách các nhóm này thành các chuỗi riêng biệt và trả về danh sách các nhóm đó.\n    Các nhóm tách biệt là cân bằng (mỗi dấu ngoặc mở đều có dấu ngoặc đóng tương ứng) và không lồng vào nhau.\n    Bỏ qua bất kỳ khoảng trắng nào trong chuỗi đầu vào.\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\""]}
{"text": ["def truncate_number(number: float) -> float:\n    \"\"\" Cho một số thực dương, nó có thể được phân tách thành phần nguyên \n    (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân (phần còn lại luôn nhỏ hơn 1).\n\n    Trả về phần thập phân của số.\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\"", "def truncate_number(number: float) -> float:\n    \"\"\" Với một số dấu phẩy động dương, nó có thể được phân tích thành\n    và phần nguyên (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân\n    (phần còn lại luôn nhỏ hơn 1).\n\n    Trả về phần thập phân của số.\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\"", "def truncate_number(number: float) -> float:\n    \"\"\" Cho một số thực dương, nó có thể được phân thành\n    phần nguyên (số nguyên lớn nhất nhỏ hơn số đã cho) và phần thập phân\n    (phần dư luôn nhỏ hơn 1).\n\n    Trả về phần thập phân của số.\n    >>> truncate_number(3.5)\n    0.5\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\"Bạn được cho một danh sách các giao dịch gửi tiền và rút tiền từ tài khoản ngân hàng, bắt đầu với số dư bằng 0. Nhiệm vụ của bạn là phát hiện nếu tại bất kỳ thời điểm nào, số dư tài khoản giảm xuống dưới 0, và khi đó hàm nên trả về True. Nếu không, hàm nên trả về False.\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\"", "from typing import List\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\" Bạn được cung cấp một danh sách các giao dịch gửi và rút tiền của một tài khoản ngân hàng bắt đầu với\n    số dư bằng không. Nhiệm vụ của bạn là phát hiện xem tại bất kỳ thời điểm nào số dư của tài khoản giảm xuống dưới không và\n    tại thời điểm đó hàm sẽ trả về True. Nếu không, nó sẽ trả về False.\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\"", "from typing import List\n\ndef below_zero(operations: List[int]) -> bool:\n    \"\"\" Bạn được cung cấp danh sách các hoạt động gửi và rút tiền từ một tài khoản ngân hàng bắt đầu với \n    số dư là 0. Nhiệm vụ là phát hiện thời điểm số dư tài khoản giảm xuống dưới 0, và\n    tại thời điểm đó, hàm phải trả về True. Nếu không, trả về False.\n    >>> below_zero([1, 2, 3])\n    False\n    >>> below_zero([1, 2, -4, 5])\n    True\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" Đối với danh sách số đầu vào đã cho, hãy tính Độ lệch tuyệt đối trung bình\n    xung quanh giá trị trung bình của tập dữ liệu này.\n    Độ lệch tuyệt đối trung bình là chênh lệch tuyệt đối trung bình giữa mỗi\n    phần tử và một điểm trung tâm (trung bình trong trường hợp này là):\n    MAD = average | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\"", "from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" Đối với một danh sách các số đầu vào nhất định, hãy tính Độ lệch tuyệt đối trung bình\n    xung quanh giá trị trung bình của tập dữ liệu này.\n    Độ lệch tuyệt đối trung bình là sự khác biệt tuyệt đối trung bình giữa mỗi\n    phần tử và một điểm trung tâm (trung bình trong trường hợp này):\n    MAD = average | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\"", "from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n    \"\"\" Đối với một danh sách số đầu vào, tính Toán Độ lệch tuyệt đối trung bình\n    quanh giá trị trung bình của tập dữ liệu này.\n    Độ lệch tuyệt đối trung bình là giá trị trung bình của sự khác biệt tuyệt đối giữa mỗi\n    phần tử và điểm trung tâm (trong trường hợp này là giá trị trung bình):\n    MAD = trung bình | x - x_mean |\n    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n    1.0\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" Chèn một số 'delimeter' vào giữa mỗi hai phần tử liên tiếp trong danh sách đầu vào `numbers'\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\"", "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" Chèn một số 'delimeter' giữa mỗi hai phần tử liên tiếp của danh sách đầu vào `numbers'\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\"", "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n    \"\"\" Chèn số 'delimeter' giữa hai phần tử liên tiếp trong danh sách đầu vào `numbers'\n    >>> intersperse([], 4)\n    []\n    >>> intersperse([1, 2, 3], 4)\n    [1, 4, 2, 4, 3]\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" Đầu vào của hàm này là một chuỗi biểu diễn nhiều nhóm ngoặc lồng nhau được phân tách bằng dấu cách.\n    Đối với mỗi nhóm, xuất ra mức độ lồng nhau sâu nhất của ngoặc.\n    Ví dụ: (()()) có tối đa hai cấp độ lồng nhau và ((())) có ba cấp độ lồng nhau.\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\"", "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" Đầu vào của hàm này là một chuỗi được biểu thị bằng nhiều nhóm cho các dấu ngoặc đơn lồng nhau được phân tách bằng dấu cách.\n    Đối với mỗi nhóm, đầu ra là mức lồng nhau sâu nhất của các dấu ngoặc đơn.\n    Ví dụ. (()()) có tối đa hai mức lồng nhau trong khi ((())) có ba mức.\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\"", "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n    \"\"\" Đầu vào của hàm này là một chuỗi đại diện cho nhiều nhóm dấu ngoặc đơn lồng nhau, các nhóm được phân cách bởi khoảng trắng.\n    Với mỗi nhóm, trả về mức độ sâu nhất của dấu ngoặc đơn lồng nhau.\n    Ví dụ: (()()) có tối đa hai mức độ lồng nhau, trong khi ((())) có ba mức độ.\n\n    >>> parse_nested_parens('(()()) ((())) () ((())()())')\n    [2, 3, 1, 3]\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" Lọc danh sách chuỗi đầu vào chỉ để lại các chuỗi chứa phần chuỗi con đã cho.\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" Lọc danh sách chuỗi đầu vào chỉ cho những chuỗi chứa một chuỗi con đã cho.\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n    \"\"\" Lọc danh sách đầu vào của các chuỗi chỉ để lại các chuỗi chứa phần chuỗi con đã cho\n    >>> filter_by_substring([], 'a')\n    []\n    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n    ['abc', 'bacd', 'array']\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\" Cho một danh sách các số nguyên, trả về một tuple bao gồm tổng và tích của tất cả các số nguyên trong danh sách.\n    Tổng của danh sách rỗng phải bằng 0 và tích của danh sách rỗng phải bằng 1.\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\"Dành cho một danh sách các số nguyên, trả về một tuple bao gồm tổng và tích của tất cả các số trong danh sách.\n    Tổng của danh sách rỗng nên bằng 0 và tích của danh sách rỗng nên bằng 1.\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n    \"\"\" Trả về một bộ giá trị gồm tổng và tích của tất cả các số nguyên trong danh sách đã cho.\n    Tổng của danh sách rỗng phải bằng 0 và tích của danh sách rỗng phải bằng 1.\n    >>> sum_product([])\n    (0, 1)\n    >>> sum_product([1, 2, 3, 4])\n    (10, 24)\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" Từ danh sách các số nguyên đã cho, tạo danh sách giá trị lớn nhất tích lũy được tìm thấy cho đến thời điểm đã cho\n    trong chuỗi.\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\"", "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" Tạo danh sách cuộn của các phần tử lớn nhất được tìm thấy cho đến thời điểm hiện tại trong dãy số nguyên đã cho.\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\"", "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n    \"\"\" \n    Từ một danh sách các số nguyên cho trước, tạo ra một danh sách các giá trị tối đa tích lũy cho đến thời điểm hiện tại \n    trong dãy.\n    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n    [1, 2, 3, 3, 3, 4, 4]\n    \"\"\""]}
{"text": ["def is_palindrome(string: str) -> bool:\n    \"\"\" Kiểm tra xem chuỗi có phải là palindrome không \"\"\"\n    return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n    \"\"\" Tìm palindrome ngắn nhất bắt đầu bằng chuỗi đã cho.\n    Ý tưởng thuật toán rất đơn giản:\n    - Tìm hậu tố dài nhất của chuỗi được cung cấp là palindrome.\n    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi đứng trước hậu tố palindrome.\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\"", "def is_palindrome(string: str) -> bool:\n    \"\"\" Kiểm tra xem chuỗi đã cho có phải là chuỗi đối xứng  hay không \"\"\"\n    return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n    \"\"\" Tìm chuỗi đối xứng ngắn nhất bắt đầu với chuỗi đã cho.\n    Ý tưởng thuật toán rất đơn giản:\n    - Tìm hậu tố dài nhất của chuỗi đã cho mà là một chuỗi đối xứng .\n    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi trước hậu tố đối xứng đó.\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\"", "def is_palindrome(string: str) -> bool:\n    \"\"\" Kiểm tra xem chuỗi đã cho có phải là palindrome không \"\"\"\n    return string == string[::-1]\n\ndef make_palindrome(string: str) -> str:\n    \"\"\" Tìm palindrome ngắn nhất bắt đầu bằng một chuỗi được cung cấp.\n    Ý tưởng thuật toán rất đơn giản:\n    - Tìm hậu tố dài nhất của chuỗi được cung cấp là palindrome.\n    - Thêm vào cuối chuỗi đảo ngược của tiền tố chuỗi đứng trước hậu tố palindrome.\n    >>> make_palindrome('')\n    ''\n    >>> make_palindrome('cat')\n    'catac'\n    >>> make_palindrome('cata')\n    'catac'\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\" \n    Đầu vào là hai chuỗi a và b chỉ bao gồm các ký tự 1 và 0.\n    Thực hiện phép XOR nhị phân trên hai chuỗi này và trả về kết quả cũng dưới dạng một chuỗi. \n    >>> string_xor('010', '110')\n    '100'\n    \"\"\"", "from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\" Đầu vào là hai chuỗi a and b chỉ bao gồm các số 1s and 0s.\n    Thực hiện phép XOR nhị phân trên các đầu vào này và trả về kết quả dưới dạng chuỗi.\n    >>> string_xor('010', '110')\n    '100'\n    \"\"\"", "from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n    \"\"\" Đầu vào là hai chuỗi a và b chỉ bao gồm 1 và 0.\n    Thực hiện XOR nhị phân trên các đầu vào này và trả về kết quả cũng dưới dạng chuỗi.\n    >>> string_xor('010', '110')\n    '100'\n    \"\"\""]}
{"text": ["from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\"Trong danh sách các chuỗi, trả về chuỗi dài nhất. Nếu có nhiều chuỗi có cùng độ dài, trả về chuỗi đầu tiên. \n    Trả về None nếu danh sách đầu vào rỗng.\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\"", "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\" \"Từ danh sách các chuỗi, trả về chuỗi dài nhất. Nếu có nhiều chuỗi có độ dài bằng nhau, \n    trả về chuỗi đầu tiên. Trả về None nếu danh sách đầu vào là rỗng.\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\"", "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n    \"\"\" Trong danh sách các chuỗi, trả về chuỗi dài nhất. Trả về chuỗi đầu tiên trong trường hợp có nhiều\n    chuỗi có cùng độ dài. Trả về None trong trường hợp danh sách đầu vào trống.\n    >>> longest([])\n\n    >>> longest(['a', 'b', 'c'])\n    'a'\n    >>> longest(['a', 'bb', 'ccc'])\n    'ccc'\n    \"\"\""]}
{"text": ["def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" Trả về ước chung lớn nhất của hai số nguyên a và b\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\"", "def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" Trả về ước chung lớn nhất của hai số nguyên a và b\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\"", "def greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\" Trả về ước chung lớn nhất của hai số nguyên a và b\n    >>> greatest_common_divisor(3, 5)\n    1\n    >>> greatest_common_divisor(25, 15)\n    5\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" Trả về danh sách tất cả các tiền tố từ ngắn nhất đến dài nhất của chuỗi đầu vào\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\"", "from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" Trả về danh sách tất cả các tiền tố của chuỗi đầu vào từ ngắn nhất đến dài nhất\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\"", "from typing import List\n\ndef all_prefixes(string: str) -> List[str]:\n    \"\"\" Trả về danh sách tất cả các tiền tố từ ngắn nhất đến dài nhất của chuỗi đầu vào\n    >>> all_prefixes('abc')\n    ['a', 'ab', 'abc']\n    \"\"\""]}
{"text": ["def string_sequence(n: int) -> str:\n    \"\"\" Trả về một chuỗi chứa các số được phân cách bởi dấu cách, bắt đầu từ 0 đến n (bao gồm n).\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\"", "def string_sequence(n: int) -> str:\n    \"\"\" Trả về một chuỗi chứa các số phân cách bằng dấu cách bắt đầu từ 0 đến n bao gồm.\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\"", "def string_sequence(n: int) -> str:\n    \"\"\" Trả về một chuỗi chứa các số phân cách bằng dấu cách bắt đầu từ 0 đến n.\n    >>> string_sequence(0)\n    '0'\n    >>> string_sequence(5)\n    '0 1 2 3 4 5'\n    \"\"\""]}
{"text": ["def count_distinct_characters(string: str) -> int:\n    \"\"\" Cho một chuỗi, tìm xem nó bao gồm bao nhiêu ký tự khác nhau (không phân biệt chữ hoa chữ thường).\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\"", "def count_distinct_characters(string: str) -> int:\n    \"\"\" Cho một chuỗi, hãy tìm xem chuỗi đó bao gồm bao nhiêu ký tự riêng biệt (bất kể chữ hoa hay chữ thường)\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\"", "def count_distinct_characters(string: str) -> int:\n    \"\"\" Cho một chuỗi, tìm ra số lượng ký tự khác nhau (không phân biệt chữ hoa hay chữ thường) mà chuỗi đó chứa\n    >>> count_distinct_characters('xyzXYZ')\n    3\n    >>> count_distinct_characters('Jerry')\n    4\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" Đầu vào của hàm này là một chuỗi đại diện cho các nốt nhạc theo định dạng ASCII đặc biệt.\n    Nhiệm vụ của bạn là phân tích chuỗi này và trả về một danh sách các số nguyên tương ứng với số nhịp mà mỗi\n    nốt nhạc kéo dài.\n\n    Dưới đây là ký hiệu:\n    'o' - nốt tròn, kéo dài bốn nhịp\n    'o|' - nốt trắng, kéo dài hai nhịp\n    '.|' - nốt đen, kéo dài một nhịp\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\"", "from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" Đầu vào cho hàm này là một chuỗi biểu diễn các nốt nhạc theo định dạng ASCII đặc biệt.\n    Nhiệm vụ của bạn là phân tích cú pháp chuỗi này và trả về danh sách các số nguyên tương ứng với số nhịp mà mỗi nốt\n    không kéo dài.\n\n    Sau đây là một chú giải:\n    'o' - nốt tròn, kéo dài 4 nhịp\n    'o|' - nốt trắng, kéo dài 2 nhịp\n    '.|' - nốt đen, kéo dài 1 nhịp\n\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\"", "from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n    \"\"\" Đầu vào cho hàm này là một chuỗi biểu diễn các nốt nhạc theo định dạng ASCII đặc biệt.\n    Nhiệm vụ của bạn là phân tích cú pháp chuỗi này và trả về danh sách các số nguyên tương ứng với số nhịp mà mỗi nốt không \n    kéo dài.\n\n    Sau đây là chú giải:\n    'o' - nốt tròn, kéo dài 4 nhịp\n    'o|' - nốt trắng, kéo dài 2 nhịp\n    '.|' - nốt đen, kéo dài 1 nhịp\n\n    >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n    \"\"\""]}
{"text": ["def how_many_times(string: str, substring: str) -> int:\n    \"\"\" Tìm số lần một chuỗi con đã cho có thể được tìm thấy trong chuỗi gốc. Đếm các trường hợp chồng chéo.\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\"", "def how_many_times(string: str, substring: str) -> int:\n    \"\"\" Tìm số lần một chuỗi con nhất định có thể được tìm thấy trong chuỗi gốc. Đếm các trường hợp chồng chéo.\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\"", "def how_many_times(string: str, substring: str) -> int:\n    \"\"\" Tìm xem một chuỗi con xuất hiện bao nhiêu lần trong chuỗi gốc. Đếm cả trường hợp chồng chéo.\n    >>> how_many_times('', 'a')\n    0\n    >>> how_many_times('aaa', 'a')\n    3\n    >>> how_many_times('aaaa', 'aa')\n    3\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" Đầu vào là một chuỗi các số được phân cách bằng khoảng trắng từ 'zero' đến 'nine'.\n    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.\n    Trả về chuỗi với các số được sắp xếp từ nhỏ nhất đến lớn nhất.\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\"", "from typing import List\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" Đầu vào là một chuỗi số được phân cách bằng dấu cách từ 'zero' đến 'nine'.\n    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.\n    Trả về chuỗi có các số được sắp xếp từ nhỏ nhất đến lớn nhất\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\"", "from typing import List\n\n\ndef sort_numbers(numbers: str) -> str:\n    \"\"\" Đầu vào là một chuỗi các số được phân cách bằng dấu cách từ 'zero' đến 'nine'.\n    Các lựa chọn hợp lệ là 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' và 'nine'.\n    Trả về chuỗi với các số được sắp xếp từ nhỏ đến lớn.\n    >>> sort_numbers('three one five')\n    'one three five'\n    \"\"\""]}
{"text": ["from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\" Chọn hai số gần nhau nhất từ danh sách số đã cho (có độ dài ít nhất là hai)\n    và trả về theo thứ tự số nhỏ, số lớn.\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n    (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n    (2.0, 2.0)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\" Từ danh sách các số đã cho (có ít nhất hai phần tử), chọn và trả về hai số có khoảng cách gần nhất với nhau \n    và trả về chúng theo thứ tự (số nhỏ hơn, số lớn hơn).\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n    (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n    (2.0, 2.0)\n    \"\"\"", "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n    \"\"\"Từ danh sách các số đã cho (có độ dài ít nhất là hai), chọn và trả về hai số gần nhau nhất và trả chúng theo thứ tự (số nhỏ hơn, số lớn hơn).\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n    (2.0, 2.2)\n    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n    (2.0, 2.0)\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    \"\"\" Cho danh sách các số (có ít nhất hai phần tử), áp dụng phép biến đổi tuyến tính cho danh sách đó,\n    sao cho số nhỏ nhất sẽ trở thành 0 và số lớn nhất sẽ trở thành 1\n    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\"", "from typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    \"\"\" Cho danh sách các số (có ít nhất hai phần tử), áp dụng phép biến đổi tuyến tính cho danh sách đó,\n    sao cho số nhỏ nhất sẽ trở thành 0 và số lớn nhất sẽ trở thành 1\n    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\"", "from typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n    \"\"\" Cho danh sách các số (ít nhất có hai phần tử), áp dụng phép biến đổi tuyến tính cho danh sách đó,\n    sao cho số nhỏ nhất sẽ trở thành 0 và số lớn nhất sẽ trở thành 1\n    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n    [0.0, 0.25, 0.5, 0.75, 1.0]\n    \"\"\""]}
{"text": ["from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n    \"\"\" Lọc các số nguyên từ danh sách các giá trị Python đã cho\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    \"\"\"", "from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n    \"\"\" Lọc danh sách đã cho của bất kỳ giá trị python nào chỉ dành cho số nguyên\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    \"\"\"", "from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n    \"\"\" Lọc danh sách các giá trị python bất kỳ chỉ lấy các số nguyên\n    >>> filter_integers(['a', 3.14, 5])\n    [5]\n    >>> filter_integers([1, 2, 3, 'abc', {}, []])\n    [1, 2, 3]\n    \"\"\""]}
{"text": ["def strlen(string: str) -> int:\n    \"\"\" Trả về độ dài của chuỗi đã cho\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\"", "def strlen(string: str) -> int:\n    \"\"\" Trả về độ dài của chuỗi đã cho\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\"", "def strlen(string: str) -> int:\n    \"\"\" Trả về độ dài của chuỗi đã cho\n    >>> strlen('')\n    0\n    >>> strlen('abc')\n    3\n    \"\"\""]}
{"text": ["def largest_divisor(n: int) -> int:\n    \"\"\"Cho một số n, tìm số lớn nhất nhỏ hơn n mà n chia hết cho số đó\n    >>> largest_divisor(15)\n    5\n    \"\"\"", "def largest_divisor(n: int) -> int:\n    \"\"\" Cho số n, tìm số lớn nhất mà chia hết n, nhỏ hơn n.\n    >>> largest_divisor(15)\n    5\n    \"\"\"", "def largest_divisor(n: int) -> int:\n    \"\"\" Với một số n cho trước, hãy tìm số lớn nhất chia hết cho n, nhỏ hơn n\n    >>> largest_divisor(15)\n    5\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" Trả về danh sách các thừa số nguyên tố của số nguyên đã cho theo thứ tự từ nhỏ đến lớn.\n    Mỗi thừa số phải được liệt kê theo số lần xuất hiện trong phép phân tích thừa số.\n    Số đầu vào phải bằng tích của tất cả các thừa số.\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\"", "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" Trả về danh sách các yếu tố nguyên tố của số nguyên đã cho theo thứ tự từ nhỏ nhất đến lớn nhất.\n    Mỗi yếu tố sẽ được liệt kê số lần tương ứng với số lần nó xuất hiện trong phép phân tích.\n    Số đầu vào phải bằng tích của tất cả các yếu tố.\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\"", "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n    \"\"\" Trả về danh sách các ước số nguyên tố của số nguyên đầu vào theo thứ tự từ nhỏ nhất đến lớn nhất.\n    Mỗi yếu tố trong danh sách sẽ được liệt kê theo số lần xuất hiện trong phân tích thừa số.\n    Số đầu vào phải bằng tích của tất cả các thừa số.\n    >>> factorize(8)\n    [2, 2, 2]\n    >>> factorize(25)\n    [5, 5]\n    >>> factorize(70)\n    [2, 5, 7]\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" Từ một danh sách các số nguyên, loại bỏ tất cả các phần tử xuất hiện hơn một lần.\n    Giữ nguyên thứ tự của các phần tử còn lại như trong danh sách đầu vào.\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\"", "from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" Từ danh sách các số nguyên, xóa tất cả các phần tử xuất hiện nhiều hơn một lần.\n    Giữ nguyên thứ tự các phần tử như trong đầu vào.\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\"", "from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n    \"\"\" Loại bỏ tất cả các phần tử xuất hiện nhiều hơn một lần trong danh sách số nguyên.\n    Giữ nguyên thứ tự của các phần tử còn lại như trong đầu vào.\n    >>> remove_duplicates([1, 2, 3, 2, 4])\n    [1, 3, 4]\n    \"\"\""]}
{"text": ["def flip_case(string: str) -> str:\n    \"\"\" Đối với một chuỗi cho trước, chuyển đổi các ký tự chữ thường thành chữ hoa và ngược lại.\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\"", "def flip_case(string: str) -> str:\n    \"\"\" Đối với chuỗi đã cho, chuyển chữ thường thành chữ hoa và chữ hoa thành chữ thường.\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\"", "def flip_case(string: str) -> str:\n    \"\"\" Đối với một chuỗi nhất định, hãy đảo ngược các ký tự chữ thường thành chữ hoa và chữ hoa thành chữ thường.\n    >>> flip_case('Hello')\n    'hELLO'\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" Nối danh sách các chuỗi thành một chuỗi duy nhất\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\"", "from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" Nối danh sách các chuỗi thành một chuỗi duy nhất\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\"", "from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n    \"\"\" Nối danh sách các chuỗi thành một chuỗi\n    >>> concatenate([])\n    ''\n    >>> concatenate(['a', 'b', 'c'])\n    'abc'\n    \"\"\""]}
{"text": ["from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\" Lọc danh sách chuỗi đầu vào chỉ lấy những chuỗi bắt đầu bằng tiền tố đã cho.\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\"Lọc danh sách chuỗi đầu vào chỉ bao gồm các chuỗi bắt đầu bằng tiền tố đã cho.\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\"", "from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n    \"\"\" Lọc danh sách chuỗi đầu vào chỉ để lại các chuỗi bắt đầu bằng tiền tố đã cho.\n    >>> filter_by_prefix([], 'a')\n    []\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n    ['abc', 'array']\n    \"\"\""]}
{"text": ["def get_positive(l: list):\n    \"\"\"Trả về chỉ các số dương trong danh sách.\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\"", "def get_positive(l: list):\n    \"\"\"Chỉ trả về các số dương trong danh sách.\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\"", "def get_positive(l: list):\n    \"\"\"Chỉ trả về các số dương trong danh sách.\n    >>> get_positive([-1, 2, -4, 5, 6])\n    [2, 5, 6]\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    [5, 3, 2, 3, 9, 123, 1]\n    \"\"\""]}
{"text": ["def is_prime(n):\n    \"\"\"Trả về true nếu một số cho trước là số nguyên tố, và false nếu không phải.\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\"", "def is_prime(n):\n    \"\"\"Trả về true nếu số được cho là số nguyên tố, nếu không thì trả về false.\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\"", "def is_prime(n):\n    \"\"\"Trả về true nếu số đã cho là số nguyên tố, và false nếu không.\n    >>> is_prime(6)\n    False\n    >>> is_prime(101)\n    True\n    >>> is_prime(11)\n    True\n    >>> is_prime(13441)\n    True\n    >>> is_prime(61)\n    True\n    >>> is_prime(4)\n    False\n    >>> is_prime(1)\n    False\n    \"\"\""]}
{"text": ["import math\n\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    Tính giá trị của đa thức với các hệ số xs tại điểm x.\n    trả về xs[0] + xs[1] * x + xs[2] * x^2 + .... xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n    \"\"\"  xs là các hệ số của một đa thức.\n    find_zero tìm giá trị x sao cho poly(x) = 0.\n    find_zero chỉ trả về một điểm x sao cho poly(x) = 0, dù đa thức có nhiều nghiệm.\n    Thêm vào đó, find_zero chỉ nhận danh sách xs có số hệ số chẵn\n    và hệ số lớn nhất khác 0 vì nó đảm bảo rằng sẽ có nghiệm.\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\"", "import math\n\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    Đánh giá đa thức với các hệ số xs tại điểm x.\n    trả về xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n    \"\"\" xs là các hệ số của một đa thức.\n    find_zero tìm x sao cho poly(x) = 0.\n    find_zero chỉ trả về một điểm x , ngay cả khi có nhiều điểm.\n    Hơn nữa, find_zero chỉ nhận danh sách xs có số lượng hệ số chẵn\n    và hệ số không bằng không lớn nhất vì nó đảm bảo\n    có một nghiệm.\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\"", "import math\n\ndef poly(xs: list, x: float):\n    \"\"\"\n    Đánh giá đa thức có hệ số xs tại điểm x.\n    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n    \"\"\"\n    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\ndef find_zero(xs: list):\n    \"\"\" xs là hệ số của đa thức.\n    find_zero tìm x sao cho poly(x) = 0.\n    find_zero chỉ trả về điểm không, ngay cả khi có nhiều điểm không.\n    Hơn nữa, find_zero chỉ lấy danh sách xs có số hệ số chẵn\n    và hệ số khác không lớn nhất vì nó đảm bảo\n    một nghiệm.\n    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n    -0.5\n    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n    1.0\n    \"\"\""]}
{"text": ["def sort_third(l: list):\n    \"\"\"Hàm này lấy một danh sách l và trả về một danh sách l' sao cho\n    l' giống hệt l trong các chỉ số không chia hết cho ba, trong khi các giá trị của nó tại các chỉ số chia hết cho ba bằng với các giá trị của các chỉ số tương ứng của l, nhưng đã được sắp xếp.\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\"", "def sort_third(l: list):\n    \"\"\"Hàm này nhận vào một danh sách l và trả về một danh sách l' sao cho\n    l' giống hệt l ở những chỉ số không chia hết cho ba, trong khi các giá trị ở những chỉ số chia hết cho ba sẽ \n    bằng các giá trị của các chỉ số tương ứng trong l, nhưng được sắp xếp.\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\"", "def sort_third(l: list):\n    \"\"\"Hàm này lấy một danh sách l và trả về một danh sách l' sao cho\n    l' giống hệt l trong các chỉ số không chia hết cho ba, trong khi các giá trị của nó tại các chỉ số chia hết cho ba bằng\n    với các giá trị của các chỉ số tương ứng của l, nhưng được sắp xếp.\n    >>> sort_third([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n    [2, 6, 3, 4, 8, 9, 5]\n    \"\"\""]}
{"text": ["def unique(l: list):\n    \"\"\"Trả về các phần tử duy nhất được sắp xếp trong một danh sách\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\"", "def unique(l: list):\n    \"\"\"Trả về các phần tử duy nhất trong danh sách đã được sắp xếp\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\"", "def unique(l: list):\n    \"\"\"Trả về các phần tử duy nhất đã được sắp xếp từ danh sách\n    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [0, 2, 3, 5, 9, 123]\n    \"\"\""]}
{"text": ["def max_element(l: list):\n    \"\"\"Trả về phần tử lớn nhất trong danh sách.\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\"", "def max_element(l: list):\n    \"\"\"Trả về phần tử lớn nhất trong danh sách.\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\"", "def max_element(l: list):\n    \"\"\"Trả về phần tử lớn nhất trong danh sách.\n    >>> max_element([1, 2, 3])\n    3\n    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n    123\n    \"\"\""]}
{"text": ["def fizz_buzz(n: int):\n    \"\"\"Trả về số lần chữ số 7 xuất hiện trong các số nguyên nhỏ hơn n và chia hết cho 11 hoặc 13.\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\"", "def fizz_buzz(n: int):\n    \"\"\"Trả về số lần xuất hiện của chữ số 7 trong các số nguyên nhỏ hơn n và chia hết cho 11 hoặc 13.\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\"", "def fizz_buzz(n: int):\n    \"\"\"Trả về số lần xuất hiện chữ số 7 trong các số nguyên nhỏ hơn n chia hết cho 11 hoặc 13.\n    >>> fizz_buzz(50)\n    0\n    >>> fizz_buzz(78)\n    2\n    >>> fizz_buzz(79)\n    3\n    \"\"\""]}
{"text": ["def sort_even(l: list):\n    \"\"\"Hàm này nhận một danh sách l và trả về một danh sách l' sao cho\n    l' giống với l ở các chỉ số lẻ, trong khi các giá trị của nó ở các chỉ số chẵn\n    bằng các giá trị ở chỉ số chẵn của l đã được sắp xếp.\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\"", "def sort_even(l: list):\n    \"\"\"Hàm này lấy một danh sách l và trả về một danh sách l' sao cho\n    l' giống hệt l trong các chỉ số lẻ, trong khi các giá trị của nó ở các chỉ số chẵn bằng\n    với các giá trị của các chỉ số chẵn của l, nhưng được sắp xếp.\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\"", "def sort_even(l: list):\n    \"\"\"Hàm này nhận một danh sách l và trả về danh sách l' sao cho\n    l' giống l ở các chỉ số lẻ, trong khi các giá trị tại các chỉ số chẵn của l' sẽ\n    bằng các giá trị của các chỉ số chẵn trong l nhưng đã được sắp xếp.\n    >>> sort_even([1, 2, 3])\n    [1, 2, 3]\n    >>> sort_even([5, 6, 3, 4])\n    [3, 6, 5, 4]\n    \"\"\""]}
{"text": ["def encode_cyclic(s: str):\n    \"\"\"\n    trả về chuỗi đã mã hóa bằng cách xoay vòng các nhóm ba ký tự.\n    \"\"\"\n    # Chia chuỗi thành các nhóm. Mỗi nhóm có độ dài là 3.\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # Xoay vòng các phần tử trong mỗi nhóm, trừ khi nhóm có ít hơn 3 phần tử.\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    Nhận chuỗi đã mã hóa bằng hàm encode_cyclic làm đầu vào. Trả về chuỗi đã giải mã.\n    \"\"\"", "def encode_cyclic(s: str):\n    \"\"\"\n    Trả về chuỗi đã mã hóa bằng cách xoay các nhóm ba ký tự.\n    \"\"\"\n    # chia chuỗi thành các nhóm, mỗi nhóm có độ dài 3.\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # xoay các phần tử trong mỗi nhóm, trừ khi nhóm có ít hơn 3 phần tử.\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    Nhận đầu vào là chuỗi được mã hóa bằng hàm encode_cyclic. Trả về chuỗi đã giải mã.\n    \"\"\"", "def encode_cyclic(s: str):\n    \"\"\"\n    trả về chuỗi được mã hóa bằng cách tuần hoàn các nhóm gồm ba ký tự.\n    \"\"\"\n    # chia chuỗi thành các nhóm. Mỗi nhóm có độ dài 3.\n    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n    # tuần hoàn các phần tử trong mỗi nhóm. Trừ khi nhóm có ít phần tử hơn 3\n    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n    return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n    \"\"\"\n    lấy chuỗi đầu vào được mã hóa bằng hàm encode_cyclic. Trả về chuỗi đã giải mã.\n    \"\"\""]}
{"text": ["def prime_fib(n: int):\n    \"\"\"\n    prime_fib trả về số thứ n trong dãy Fibonacci mà cũng là số nguyên tố.\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\"", "def prime_fib(n: int):\n    \"\"\"\n    Hàm prime_fib trả về số thứ n là số  Fibonacci và cũng là số nguyên tố.\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\" >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\"", "def prime_fib(n: int):\n    \"\"\"\n    prime_fib trả về số thứ n là số Fibonacci và cũng là số nguyên tố.\n    >>> prime_fib(1)\n    2\n    >>> prime_fib(2)\n    3\n    >>> prime_fib(3)\n    5\n    >>> prime_fib(4)\n    13\n    >>> prime_fib(5)\n    89\n    \"\"\""]}
{"text": ["def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero nhận một danh sách các số nguyên làm đầu vào.\n    Hàm trả về True nếu có ba phần tử khác nhau trong danh sách có tổng bằng không,\n    và trả về False nếu không có.\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\"", "def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero nhận vào một danh sách các số nguyên.\n    Hàm trả về True nếu có ba phần tử khác nhau trong danh sách có tổng bằng không,\n    và False nếu không có.\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\"", "def triples_sum_to_zero(l: list):\n    \"\"\"\n    triples_sum_to_zero lấy một danh sách các số nguyên làm đầu vào.\n    trả về True nếu có ba phần tử riêng biệt trong danh sách\n    có tổng bằng 0, và False nếu ngược lại.\n\n    >>> triples_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> triples_sum_to_zero([1, 3, -2, 1])\n    True\n    >>> triples_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n    True\n    >>> triples_sum_to_zero([1])\n    False\n    \"\"\""]}
{"text": ["def car_race_collision(n: int):\n    \"\"\"\n    Hãy tưởng tượng một con đường là một đường thẳng dài vô hạn hoàn hảo.\n    n chiếc xe ô tô đang lái từ trái sang phải; đồng thời, một nhóm n xe ô tô khác\n    đang lái từ phải sang trái. Hai nhóm xe ban đầu cách nhau rất xa. Tất\n    cả các xe đều di chuyển với cùng một tốc độ. Hai xe được cho là va chạm\n    khi một xe đang di chuyển từ trái sang phải đâm vào một xe đang di chuyển từ phải sang trái.\n    Tuy nhiên, các xe vô cùng chắc chắn và mạnh mẽ; do đó, chúng tiếp tục di chuyển\n    theo quỹ đạo của chúng như thể chúng không va chạm.\n\n    Hàm này đưa ra số lần va chạm như vậy.\n    \"\"\"", "def car_race_collision(n: int):\n    \"\"\"\n    Hãy tưởng tượng một con đường là một đường thẳng dài vô hạn hoàn hảo.\n    n xe đang lái từ trái sang phải; đồng thời, một nhóm n xe khác\n    đang lái từ phải sang trái. Hai nhóm xe ban đầu cách nhau rất xa. Tất cả các xe đều di chuyển với cùng một tốc độ. Hai xe được cho là va chạm\n    khi một xe đang di chuyển từ trái sang phải đâm vào một xe đang di chuyển từ phải sang trái.\n    Tuy nhiên, các xe vô cùng chắc chắn và mạnh mẽ; do đó, chúng tiếp tục di chuyển\n    theo quỹ đạo của chúng như thể chúng không va chạm.\n\n    Hàm này đưa ra số lần va chạm như vậy.\n    \"\"\"", "def car_race_collision(n: int):\n    \"\"\"\n    Hãy tưởng tượng con đường là một đường thẳng hoàn hảo kéo dài vô hạn.\n    Có n chiếc ô tô đang lái từ trái sang phải; đồng thời, có n chiếc ô tô khác\n    đang lái từ phải sang trái. Hai nhóm ô tô ban đầu cách nhau rất xa.\n    Tất cả các ô tô đều di chuyển với cùng một tốc độ. Khi một chiếc ô tô di chuyển\n    từ trái sang phải gặp một chiếc ô tô di chuyển từ phải sang trái, được gọi là va chạm.\n    Tuy nhiên, các ô tô vô cùng bền bỉ và mạnh mẽ; kết quả là, chúng tiếp tục di chuyển\n    theo quỹ đạo của mình như thể không có va chạm nào xảy ra.\n\n    Hàm này sẽ xuất ra số lượng các va chạm như vậy.\n    \"\"\""]}
{"text": ["def incr_list(l: list):\n    \"\"\"Trả về danh sách với các phần tử được tăng thêm 1.\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\"", "def incr_list(l: list):\n    \"\"\"Trả về danh sách có các phần tử tăng thêm 1.\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\"", "def incr_list(l: list):\n    \"\"\"Trả về danh sách với các phần tử được tăng thêm 1.\n    >>> incr_list([1, 2, 3])\n    [2, 3, 4]\n    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n    [6, 4, 6, 3, 4, 4, 10, 1, 124]\n    \"\"\""]}
{"text": ["def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero nhận một danh sách các số nguyên làm đầu vào.\n    Hàm trả về True nếu có hai phần tử khác nhau trong danh sách có tổng bằng không, và trả về False nếu không có.\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\"", "def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero lấy một danh sách các số nguyên làm đầu vào.\n    trả về True nếu có hai phần tử riêng biệt trong danh sách\n    có tổng bằng 0, và False nếu không.\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\"", "def pairs_sum_to_zero(l):\n    \"\"\"\n    pairs_sum_to_zero lấy một danh sách các số nguyên làm đầu vào.\n    trả về True nếu có hai phần tử riêng biệt trong danh sách\n    có tổng bằng 0, và False nếu không.\n    >>> pairs_sum_to_zero([1, 3, 5, 0])\n    False\n    >>> pairs_sum_to_zero([1, 3, -2, 1])\n    False\n    >>> pairs_sum_to_zero([1, 2, 3, 7])\n    False\n    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n    True\n    >>> pairs_sum_to_zero([1])\n    False\n    \"\"\""]}
{"text": ["def change_base(x: int, base: int):\n    \"\"\"Chuyển đổi cơ số của số đầu vào x sang cơ số mới.\n    Trả về chuỗi biểu diễn số sau khi chuyển đổi.\n    Các cơ số nhỏ hơn 10.\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\"", "def change_base(x: int, base: int):\n    \"\"\"Đổi cơ số của số đầu vào x thành cơ số.\n    trả về biểu diễn chuỗi sau khi chuyển đổi.\n    các số cơ số nhỏ hơn 10.\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\"", "def change_base(x: int, base: int):\n    \"\"\"Chuyển đổi cơ số của số đầu vào x sang cơ số mới.\n    Trả về chuỗi biểu diễn số sau khi chuyển đổi.\n    Các cơ số đều nhỏ hơn 10.\n    >>> change_base(8, 3)\n    '22'\n    >>> change_base(8, 2)\n    '1000'\n    >>> change_base(7, 2)\n    '111'\n    \"\"\""]}
{"text": ["def triangle_area(a, h):\n    \"\"\"Cho chiều dài của một cạnh và chiều cao, trả về diện tích của tam giác.\n    >>> triangle_area(5, 3)\n    7.5\n    \"\"\"", "def triangle_area(a, h):\n    \"\"\"Cho chiều dài một cạnh và chiều cao, trả về diện tích của tam giác.\n    >>> triangle_area(5, 3)\n    7.5\n    \"\"\"", "def triangle_area(a, h):\n    \"\"\"Cho chiều dài của một cạnh và chiều cao, trả về diện tích của tam giác.\n    >>> triangle_area(5, 3)\n    7.5\n    \"\"\""]}
{"text": ["def fib4(n: int):\n    \"\"\"Dãy số Fib4 tương tự như dãy số Fibonacci và được định nghĩa như sau:\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n    Viết một hàm để tính toán phần tử thứ n của dãy số Fib4 một cách hiệu quả. Không sử dụng đệ quy.\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\"", "def fib4(n: int):\n    \"\"\"Dãy số Fib4 tương tự như dãy số Fibonacci và được định nghĩa như sau:\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n của chuỗi số fib4. Không sử dụng đệ quy.\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\"", "def fib4(n: int):\n    \"\"\"Dãy số Fib4 là một dãy số tương tự như dãy Fibbonacci, được định nghĩa như sau:\n    fib4(0) -> 0\n    fib4(1) -> 0\n    fib4(2) -> 2\n    fib4(3) -> 0\n    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n trong dãy số fib4. Không sử dụng đệ quy.\n    >>> fib4(5)\n    4\n    >>> fib4(6)\n    8\n    >>> fib4(7)\n    14\n    \"\"\""]}
{"text": ["def median(l: list):\n    \"\"\"Trả về trung vị của các phần tử trong danh sách l.\n    >>> median([3, 1, 2, 4, 5])\n    3\n    >>> median([-10, 4, 6, 1000, 10, 20])\n    15.0\n    \"\"\"", "def median(l: list):\n    \"\"\"Trả về giá trị trung vị của các phần tử trong danh sách l.\n    >>> median([3, 1, 2, 4, 5])\n    3\n    >>> median([-10, 4, 6, 1000, 10, 20])\n    15.0\n    \"\"\"", "def median(l: list):\n    \"\"\"Trả về giá trị trung vị của các phần tử trong danh sách l.\n    >>> median([3, 1, 2, 4, 5])\n    3\n    >>> median([-10, 4, 6, 1000, 10, 20])\n    15.0\n    \"\"\""]}
{"text": ["def is_palindrome(text: str):\n    \"\"\"\n    Kiểm tra xem chuỗi cho trước có phải là một chuỗi đối xứng (palindrome) hay không.\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\"", "def is_palindrome(text: str):\n    \"\"\"\n    Kiểm tra xem chuỗi đã cho có phải là palindrome không\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\"", "def is_palindrome(text: str):\n    \"\"\"\n    Kiểm tra xem chuỗi đã cho có phải là chuỗi đối xứng không\n    >>> is_palindrome('')\n    True\n    >>> is_palindrome('aba')\n    True\n    >>> is_palindrome('aaaaa')\n    True\n    >>> is_palindrome('zbcd')\n    False\n    \"\"\""]}
{"text": ["def modp(n: int, p: int):\n    \"\"\"Trả về 2^n modulo p (lưu ý về số).\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    \"\"\"", "def modp(n: int, p: int):\n    \"\"\"Trả về 2^n theo modulo p (chú ý đến các phép toán số học).\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    \"\"\"", "def modp(n: int, p: int):\n    \"\"\"Trả về phần dư của 2^n chia cho p (chú ý đến số liệu).\n    >>> modp(3, 5)\n    3\n    >>> modp(1101, 101)\n    2\n    >>> modp(0, 101)\n    1\n    >>> modp(3, 11)\n    8\n    >>> modp(100, 101)\n    1\n    \"\"\""]}
{"text": ["def encode_shift(s: str):\n    \"\"\"\n    Trả về chuỗi mã hóa bằng cách dịch chuyển mỗi ký tự lên 5 bước trong bảng chữ cái.\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    Nhận vào chuỗi đã mã hóa bằng hàm encode_shift. Trả về chuỗi đã giải mã.\n    \"\"\"", "def encode_shift(s: str):\n    \"\"\"\n    trả về chuỗi được mã hóa bằng cách dịch chuyển mỗi ký tự 5 trong bảng chữ cái.\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    lấy chuỗi đầu vào được mã hóa bằng hàm encode_shift. Trả về chuỗi đã giải mã.\n    \"\"\"", "def encode_shift(s: str):\n    \"\"\"\n    Trả về chuỗi đã được mã hóa bằng cách dịch chuyển mỗi ký tự trong bảng chữ cái 5 vị trí.\n    \"\"\"\n    return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n    \"\"\"\n    Nhận chuỗi đã được mã hóa bằng hàm encode_shift làm đầu vào và trả về chuỗi đã được giải mã.\n    \"\"\""]}
{"text": ["def remove_vowels(text):\n    \"\"\"\n    remove_vowels là một hàm nhận vào một chuỗi và trả về chuỗi không có nguyên âm.\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\"", "def remove_vowels(text):\n    \"\"\"\n    remove_vowels là một hàm lấy chuỗi và trả về chuỗi không có nguyên âm.\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\"", "def remove_vowels(text):\n    \"\"\"\n    remove_vowels là một hàm lấy chuỗi và trả về chuỗi không có nguyên âm.\n    >>> remove_vowels('')\n    ''\n    >>> remove_vowels(\"abcdef\\nghijklm\")\n    'bcdf\\nghjklm'\n    >>> remove_vowels('abcdef')\n    'bcdf'\n    >>> remove_vowels('aaaaa')\n    ''\n    >>> remove_vowels('aaBAA')\n    'B'\n    >>> remove_vowels('zbcd')\n    'zbcd'\n    \"\"\""]}
{"text": ["def below_threshold(l: list, t: int):\n    \"\"\"Trả về True nếu tất cả các số trong danh sách l đều nhỏ hơn ngưỡng t.\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\"", "def below_threshold(l: list, t: int):\n    \"\"\"Trả về True nếu tất cả các số trong danh sách l đều thấp hơn ngưỡng t.\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\"", "def below_threshold(l: list, t: int):\n    \"\"\"Trả về True nếu tất cả các số trong danh sách l đều thấp hơn ngưỡng t.\n    >>> below_threshold([1, 2, 4, 10], 100)\n    True\n    >>> below_threshold([1, 20, 4, 10], 5)\n    False\n    \"\"\""]}
{"text": ["def add(x: int, y: int):\n    \"\"\"Cộng hai số x và y\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\"", "def add(x: int, y: int):\n    \"\"\"Cộng hai số x và y\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\"", "def add(x: int, y: int):\n    \"\"\"Cộng hai số x và y\n    >>> add(2, 3)\n    5\n    >>> add(5, 7)\n    12\n    \"\"\""]}
{"text": ["def same_chars(s0: str, s1: str):\n    \"\"\"\n    Kiểm tra xem hai từ có cùng ký tự không.\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\"", "def same_chars(s0: str, s1: str):\n    \"\"\"\n    Kiểm tra xem hai từ có chứa các ký tự giống nhau không.\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\"", "def same_chars(s0: str, s1: str):\n    \"\"\"\n    Kiểm tra xem hai từ có cùng ký tự hay không.\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n    True\n    >>> same_chars('abcd', 'dddddddabc')\n    True\n    >>> same_chars('dddddddabc', 'abcd')\n    True\n    >>> same_chars('eabcd', 'dddddddabc')\n    False\n    >>> same_chars('abcd', 'dddddddabce')\n    False\n    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n    False\n    \"\"\""]}
{"text": ["def fib(n: int):\n    \"\"\"Trả về số Fibonacci thứ n.\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\"", "def fib(n: int):\n    \"\"\"Trả về số Fibonacci thứ n.\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\"", "def fib(n: int):\n    \"\"\"Trả về số Fibonacci thứ n.\n    >>> fib(10)\n    55\n    >>> fib(1)\n    1\n    >>> fib(8)\n    21\n    \"\"\""]}
{"text": ["def correct_bracketing(brackets: str):\n    \"\"\" brackets là một chuỗi gồm các ký tự \"<\" và \">\".\n    Trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.\n\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" dấu ngoặc là một chuỗi \"<\" và \">\".\n    trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.\n\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" brackets là một chuỗi bao gồm \"<\" và \">\".\n    Trả về True nếu tất cả các dấu ngoặc mở có dấu ngoặc đóng tương ứng.\n\n    >>> correct_bracketing(\"<\")\n    False\n    >>> correct_bracketing(\"<>\")\n    True\n    >>> correct_bracketing(\"<<><>>\")\n    True\n    >>> correct_bracketing(\"><<>\")\n    False\n    \"\"\""]}
{"text": ["def monotonic(l: list):\n    \"\"\"Trả về True nếu các phần tử trong danh sách là tăng dần hoặc giảm dần.\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\"", "def monotonic(l: list):\n    \"\"\"Trả về True nếu các phần tử trong danh sách tăng hoặc giảm theo kiểu đơn điệu.\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\"", "def monotonic(l: list):\n    \"\"\"Trả về True nếu các phần tử trong danh sách tăng hoặc giảm đều đặn.\n    >>> monotonic([1, 2, 4, 20])\n    True\n    >>> monotonic([1, 20, 4, 10])\n    False\n    >>> monotonic([4, 1, 0, -10])\n    True\n    \"\"\""]}
{"text": ["def common(l1: list, l2: list):\n    \"\"\"Trả về các phần tử chung duy nhất và được sắp xếp cho hai danh sách.\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n    \"\"\"", "def common(l1: list, l2: list):\n    \"\"\"Trả về các phần tử chung duy nhất đã được sắp xếp cho hai danh sách.\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n\n    \"\"\"", "def common(l1: list, l2: list):\n    \"\"\"Trả về các phần tử chung duy nhất đã được sắp xếp của hai danh sách.\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n    [1, 5, 653]\n    >>> common([5, 3, 2, 8], [3, 2])\n    [2, 3]\n\n    \"\"\""]}
{"text": ["def largest_prime_factor(n: int):\n    \"\"\"Trả về ước số nguyên tố lớn nhất của n. Giả sử n > 1 và n không phải là một số nguyên tố.\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\"", "def largest_prime_factor(n: int):\n    \"\"\"Trả về ước số nguyên tố lớn nhất của n. Giả sử n > 1 và không phải là một số nguyên tố.\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\"", "def largest_prime_factor(n: int):\n    \"\"\"Trả về thừa số nguyên tố lớn nhất của n. Giả sử n > 1 và không phải là số nguyên tố.\n    >>> largest_prime_factor(13195)\n    29\n    >>> largest_prime_factor(2048)\n    2\n    \"\"\""]}
{"text": ["def sum_to_n(n: int):\n    \"\"\"sum_to_n là một hàm tính tổng các số từ 1 đến n.\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\"", "def sum_to_n(n: int):\n    \"\"\"sum_to_n là hàm tính tổng các số từ 1 đến n.\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\"", "def sum_to_n(n: int):\n    \"\"\"sum_to_n là một hàm tính tổng các số từ 1 đến n.\n    >>> sum_to_n(30)\n    465\n    >>> sum_to_n(100)\n    5050\n    >>> sum_to_n(5)\n    15\n    >>> sum_to_n(10)\n    55\n    >>> sum_to_n(1)\n    1\n    \"\"\""]}
{"text": ["def correct_bracketing(brackets: str):\n    \"\"\" brackets là một chuỗi gồm các dấu ngoặc \"(\" và \")\".\n    Trả về True nếu mỗi dấu ngoặc mở có một dấu ngoặc đóng tương ứng.\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" brackets là một chuỗi của \"(\" and \")\".\n    Trả về True nếu các dấu ngoặc mở có dấu ngoặc đóng tương ứng.\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\"", "def correct_bracketing(brackets: str):\n    \"\"\" brackets là một chuỗi bao gồm \"(\" và \")\".\n    Nếu tất cả các dấu ngoặc mở có dấu ngoặc đóng tương ứng thì trả về True.\n\n    >>> correct_bracketing(\"(\")\n    False\n    >>> correct_bracketing(\"()\")\n    True\n    >>> correct_bracketing(\"(()())\")\n    True\n    >>> correct_bracketing(\")(()\")\n    False\n    \"\"\""]}
{"text": ["def derivative(xs: list):\n    \"\"\" xs biểu diễn hệ số của đa thức.\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n     Trả về đạo hàm của đa thức này dưới dạng tương tự.\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\"", "def derivative(xs: list):\n    \"\"\" xs biểu thị hệ số của một đa thức.\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n     Trả về đạo hàm của đa thức này ở cùng dạng.\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\"", "def derivative(xs: list):\n    \"\"\" xs đại diện cho các hệ số của một đa thức.\n    xs[0] + xs[1] * x + xs[2] * x^2 + ....\n    Trả về đạo hàm của đa thức này dưới cùng một dạng.\n    >>> derivative([3, 1, 2, 4, 5])\n    [1, 4, 12, 20]\n    >>> derivative([1, 2, 3])\n    [2, 6]\n    \"\"\""]}
{"text": ["def fibfib(n: int):\n    \"\"\"Dãy số FibFib là một dãy số tương tự như dãy số Fibonacci, được định nghĩa như sau:\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n    Vui lòng viết một hàm để tính toán hiệu quả phần tử thứ n của dãy số fibfib.\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\"", "def fibfib(n: int):\n    \"\"\"Chuỗi số FibFib là một chuỗi tương tự như chuỗi Fibbonacci được xác định như sau:\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n    Hãy viết một hàm để tính hiệu quả phần tử thứ n của chuỗi số fibfib.\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\"", "def fibfib(n: int):\n    \"\"\"Chuỗi số FibFib là một chuỗi tương tự như chuỗi Fibbonacci được định nghĩa như sau:\n    fibfib(0) == 0\n    fibfib(1) == 0\n    fibfib(2) == 1\n    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n    Vui lòng viết một hàm để tính hiệu quả phần tử thứ n của chuỗi số fibfib.\n    >>> fibfib(1)\n    0\n    >>> fibfib(5)\n    4\n    >>> fibfib(8)\n    24\n    \"\"\""]}
{"text": ["FIX = \"\"\"\nThêm nhiều trường hợp kiểm thử hơn.\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"Viết hàm vowels_count nhận một chuỗi làm đầu vào và trả về số lượng\n    nguyên âm trong chuỗi. Trong trường hợp này, nguyên âm là 'a', 'e', 'i', 'o', 'u'.\n    Ở đây 'y' chỉ được coi là nguyên âm khi nó ở cuối từ cho trước.\n\n    Ví dụ:\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\"", "FIX = \"\"\"\nThêm nhiều trường hợp kiểm tra hơn.\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"Viết một hàm vowels_count lấy một chuỗi biểu diễn\n    một từ làm đầu vào và trả về số nguyên âm trong chuỗi.\n    Nguyên âm trong trường hợp này là 'a', 'e', ​​'i', 'o', 'u'. Ở đây, 'y' cũng là một\n    nguyên âm, nhưng chỉ khi nó ở cuối từ đã cho.\n\n    Ví dụ:\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\"", "FIX = \"\"\"\nThêm nhiều trường hợp kiểm tra.\n\"\"\"\n\ndef vowels_count(s):\n    \"\"\"Viết một hàm vowels_count lấy một chuỗi có\n    một từ làm đầu vào và trả về số nguyên âm trong chuỗi.\n    Nguyên âm trong trường hợp này là 'a', 'e', ​​'i', 'o', 'u'. Ở đây, 'y' cũng là một\n    nguyên âm, nhưng chỉ khi nó ở cuối từ đã cho.\n\n    Ví dụ:\n    >>> vowels_count(\"abcde\")\n    2\n    >>> vowels_count(\"ACEDY\")\n    3\n    \"\"\""]}
{"text": ["def circular_shift(x, shift):\n    \"\"\"Dịch chuyển vòng các chữ số của số nguyên x sang phải một lượng bằng shift\n    và trả về kết quả dưới dạng chuỗi.\n    Nếu shift lớn hơn số chữ số, đảo ngược các chữ số và trả về.\n    >>> circular_shift(12, 1)\n    \"21\"\n    >>> circular_shift(12, 2)\n    \"12\"\n    \"\"\"", "def circular_shift(x, shift):\n    \"\"\"Dịch chuyển tròn các chữ số của số nguyên x, dịch chuyển các chữ số sang phải bằng shift\n    và trả về kết quả dưới dạng chuỗi.\n    Nếu shift > số chữ số, trả về các chữ số bị đảo ngược.\n    >>> circular_shift(12, 1)\n    \"21\"\n    >>> circular_shift(12, 2)\n    \"12\"\n    \"\"\"", "def circular_shift(x, shift):\n    \"\"\"Dịch chuyển vòng các chữ số của số nguyên x, dịch chuyển các chữ số sang phải theo số lượng shift\n    và trả về kết quả dưới dạng một chuỗi.\n    Nếu shift > số lượng chữ số, trả về các chữ số đảo ngược.\n    >>> circular_shift(12, 1)\n    \"21\"\n    >>> circular_shift(12, 2)\n    \"12\"\n    \"\"\""]}
{"text": ["def digitSum(s):\n    \"\"\"Nhiệm vụ\n    Viết một hàm nhận một chuỗi làm đầu vào và trả về tổng mã ASCII của các ký tự in hoa.\n\n    Ví dụ:\n        digitSum(\"\") => 0\n        digitSum(\"abAB\") => 131\n        digitSum(\"abcCd\") => 67\n        digitSum(\"helloE\") => 69\n        digitSum(\"woArBld\") => 131\n        digitSum(\"aAaaaXa\") => 153\n    \"\"\"", "def digitSum(s):\n    \"\"\"Nhiệm vụ\n    Viết một hàm lấy một chuỗi làm đầu vào và trả về tổng của chỉ các chữ cái in hoa'\n    mã ASCII của các ký tự in hoa.\n    Ví dụ:\n        digitSum(\"\") => 0\n        digitSum(\"abAB\") => 131\n        digitSum(\"abcCd\") => 67\n        digitSum(\"helloE\") => 69\n        digitSum(\"woArBld\") => 131\n        digitSum(\"aAaaaXa\") => 153\n    \"\"\"", "def digitSum(s):\n    \"\"\"Nhiệm vụ\n    Viết một hàm lấy một chuỗi làm đầu vào và chỉ trả về tổng của các ký tự in hoa'\n    Mã ASCII.\n\n    Ví dụ:\n        digitSum(\"\") => 0\n        digitSum(\"abAB\") => 131\n        digitSum(\"abcCd\") => 67\n        digitSum(\"helloE\") => 69\n        digitSum(\"woArBld\") => 131\n        digitSum(\"aAaaaXa\") => 153\n    \"\"\""]}
{"text": ["def fruit_distribution(s, n):\n    \"\"\"\n    Trong bài toán này, bạn sẽ được cho một chuỗi đại diện cho số lượng táo và cam\n    được phân phối trong một giỏ trái cây. Giỏ này chứa táo, cam và xoài. \n    Dựa trên chuỗi đại diện cho tổng số lượng táo và cam và một số nguyên đại diện \n    cho tổng số lượng trái cây trong giỏ, trả về số lượng trái xoài trong giỏ.\n    Ví dụ:\n    fruit_distribution(\"5 apples and 6 oranges\", 19) -> 19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\", 3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\", 120) -> 120 - 100 - 1 = 19\n    \"\"\"", "def fruit_distribution(s,n):\n    \"\"\"\n    Trong yêu cầu này, bạn sẽ được cho một chuỗi biểu diễn số lượng táo và cam\n    được phân phối trong một giỏ trái cây, giỏ này chứa \n    táo, cam và xoài. Cho chuỗi biểu thị tổng số\n    quả cam và quả táo và một số nguyên biểu thị tổng số loại trái cây \n    trong giỏ, trả về số lượng quả xoài trong giỏ.\n    ví dụ:\n    fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n    \"\"\"", "def fruit_distribution(s,n):\n    \"\"\"\n    Trong bài toán này, bạn sẽ nhận được một chuỗi đại diện cho số lượng táo và cam\n    được phân phối trong một giỏ trái cây. Giỏ này chứa táo, cam và xoài. \n    Cho chuỗi đại diện cho tổng số lượng táo và cam và một số nguyên đại diện cho tổng số trái cây \n    trong giỏ, hãy trả về số lượng trái xoài trong giỏ.\n    ví dụ:\n    fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n    fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n    fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n    fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n    \"\"\""]}
{"text": ["def pluck(arr):\n    \"\"\"\n    \"Cho một mảng đại diện cho nhánh của một cây có các nút là các số nguyên không âm,\n    nhiệm vụ của bạn là chọn một trong các nút và trả về nó.\n    Nút được chọn phải là nút có giá trị chẵn nhỏ nhất.\n    Nếu có nhiều nút có giá trị chẵn nhỏ nhất giống nhau, hãy chọn nút có chỉ số nhỏ nhất.\n\n    Nút được chọn sẽ được trả về dưới dạng danh sách, [giá trị nhỏ nhất, chỉ số của nó],\n    Nếu không có giá trị chẵn nào hoặc mảng cho trước là rỗng, trả về [].\n\n    Ví dụ 1:\n        Input: [4,2,3]\n        Output: [2, 1]\n        Giải thích: 2 có giá trị chẵn nhỏ nhất, và 2 có chỉ số nhỏ nhất.\n\n    Ví dụ 2:\n        Input: [1,2,3]\n        Output: [2, 1]\n        Giải thích: 2 có giá trị chẵn nhỏ nhất, và 2 có chỉ số nhỏ nhất.\n\n    Ví dụ 3:\n        Input: []\n        Output: []\n\n    Ví dụ 4:\n        Input: [5, 0, 3, 0, 4, 2]\n        Output: [0, 1]\n        Giải thích: 0 là giá trị nhỏ nhất, nhưng có hai số 0,\n                     vì vậy chúng ta sẽ chọn số 0 đầu tiên, có chỉ số nhỏ nhất.\n\n    Ràng buộc:\n        * 1 <= nodes.length <= 10000\n        * 0 <= node.value\n    \"\"\"", "def pluck(arr):\n    \"\"\"\n    \"Cho một mảng biểu diễn một nhánh của cây có các nút nguyên không âm\n    nhiệm vụ của bạn là nhổ một trong các nút và trả nó lại.\n    Nút được nhổ phải là nút có giá trị chẵn nhỏ nhất.\n    Nếu tìm thấy nhiều nút có cùng giá trị chẵn nhỏ nhất, hãy trả về nút có chỉ số nhỏ nhất.\n\n    Nút được nhổ phải được trả về trong một danh sách, [ smalest_value, chỉ số của nút đó],\n    Nếu không có giá trị chẵn nào hoặc mảng đã cho trống, hãy trả về [].\n\n    Ví dụ 1:\n        Input: [4,2,3]\n        Đầu ra: [2, 1]\n        Giải thích: 2 có giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.\n\n    Ví dụ 2:\n        Đầu vào: [1,2,3]\n        Đầu ra: [2, 1]\n        Giải thích: 2 có giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất. \n\n    Ví dụ 3:\n        Đầu vào: []\n        Đầu ra: []\n    \n    Ví dụ 4:\n        Đầu vào: [5, 0, 3, 0, 4, 2]\n        Output: [0, 1]\n        Giải thích: 0 là giá trị nhỏ nhất, nhưng có hai số không,\n                     vì vậy chúng ta sẽ chọn số không đầu tiên, có chỉ số nhỏ nhất.\n\n    Giới hạn:\n        * 1 <= nodes.length <= 10000\n        * 0 <= node.value\n    \"\"\"", "def pluck(arr):\n    \"\"\"\n    \"Với một mảng đại diện cho một nhánh của cây có các nút số nguyên không âm\n    nhiệm vụ của bạn là nhổ một trong các nút và trả về nút đó.\n    Nút được nhổ phải là nút có giá trị chẵn nhỏ nhất.\n    Nếu tìm thấy nhiều nút có cùng giá trị chẵn nhỏ nhất, hãy trả về nút có chỉ số nhỏ nhất.\n\n    Nút được nhổ phải được trả về trong một danh sách, [ smalest_value, its index ],\n    Nếu không có giá trị chẵn nào hoặc mảng đã cho trống, hãy trả về [].\n\n    Ví dụ 1:\n        Đầu vào: [4,2,3]\n        Đầu ra: [2, 1]\n        Giải thích: 2 là giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.\n\n    Ví dụ 2:\n        Đầu vào: [1,2,3]\n        Đầu ra: [2, 1]\n        Giải thích: 2 là giá trị chẵn nhỏ nhất và 2 có chỉ số nhỏ nhất.\n\n    Ví dụ 3:\n        Đầu vào: []\n        Đầu ra: []\n    \n    Ví dụ 4:\n        Đầu vào: [5, 0, 3, 0, 4, 2]\n        Đầu ra: [0, 1]\n        Giải thích: 0 là giá trị nhỏ nhất nhưng có hai số 0\n                     nên chọn số 0 đầu tiên. Đây là chỉ số nhỏ nhất.\n\n    Điều kiện ràng buộc:\n        * 1 <= nodes.length <= 10000\n        * 0 <= node.value\n    \"\"\""]}
{"text": ["def search(lst):\n    '''\n    Bạn được cho một danh sách các số nguyên dương không rỗng. Hãy trả về số nguyên lớn nhất lớn hơn 0, \n    và có tần suất xuất hiện lớn hơn hoặc bằng chính giá trị của nó. \n    Tần suất của một số nguyên là số lần nó xuất hiện trong danh sách.\n    Nếu không có giá trị nào như vậy, hãy trả về -1.\n    Ví dụ:\n        search([4, 1, 2, 2, 3, 1]) == 2\n        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n        search([5, 5, 4, 4, 4]) == -1\n    '''", "def search(lst):\n    '''\n    Một danh sách không rỗng gồm các số nguyên dương được đưa ra. Trả về số nguyên lớn nhất mà lớn hơn 0 \n    và tần suất của nó lớn hơn hoặc bằng giá trị của chính nó. Tần suất của số nguyên là số lần xuất hiện trong danh sách.\n    Nếu không tồn tại giá trị như vậy, trả về -1.\n    Ví dụ:\n        search([4, 1, 2, 2, 3, 1]) == 2\n        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n        search([5, 5, 4, 4, 4]) == -1\n    '''", "def search(lst):\n    '''\n    Bạn được cho một danh sách không rỗng các số nguyên dương. Trả về số nguyên lớn nhất lớn hơn\n    không và có tần suất lớn hơn hoặc bằng giá trị của chính số nguyên đó.\n    Tần suất của một số nguyên là số lần nó xuất hiện trong danh sách. \n    Nếu không tồn tại giá trị nào như vậy, hãy trả về -1.\n    Ví dụ:\n        search([4, 1, 2, 2, 3, 1]) == 2\n        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n        search([5, 5, 4, 4, 4]) == -1\n    '''"]}
{"text": ["def strange_sort_list(lst):\n    '''\n    Cho danh sách các số nguyên, trả về danh sách theo thứ tự lạ.\n    Sắp xếp lạ là khi bạn bắt đầu với giá trị nhỏ nhất,\n    sau đó là giá trị lớn nhất trong các số còn lại, rồi tiếp tục với giá trị nhỏ nhất và cứ như vậy.\n\n    Ví dụ:\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''", "def strange_sort_list(lst):\n    '''\n    Cho một danh sách các số nguyên, trả về danh sách theo thứ tự kỳ lạ.\n    Sắp xếp kỳ lạ là khi bạn bắt đầu với giá trị nhỏ nhất,\n    sau đó là giá trị lớn nhất trong các số còn lại, rồi tiếp tục với giá trị nhỏ nhất và cứ thế.\n\n    Ví dụ:\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''", "def strange_sort_list(lst):\n    '''\n    Cho danh sách các số nguyên, trả về danh sách theo thứ tự lạ.\n    Sắp xếp lạ là khi bạn bắt đầu với giá trị nhỏ nhất,\n    sau đó là giá trị lớn nhất của các số nguyên còn lại, sau đó là giá trị nhỏ nhất, v.v.\n\n    Ví dụ:\n    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n    strange_sort_list([]) == []\n    '''"]}
{"text": ["def triangle_area(a, b, c):\n    '''\n    Khi độ dài của ba cạnh của một tam giác được cho, nếu ba cạnh tạo thành một tam giác hợp lệ,\n    trả về diện tích của tam giác được làm tròn đến hai chữ số thập phân.\n    Nếu không, trả về -1.\n    Để ba cạnh tạo thành một tam giác hợp lệ, tổng của hai cạnh phải lớn hơn cạnh thứ ba.\n    Ví dụ:\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''", "def triangle_area(a, b, c):\n    '''\n    Cho độ dài của ba cạnh của một tam giác. Trả về diện tích\n    của tam giác làm tròn đến 2 chữ số thập phân nếu ba cạnh tạo thành một tam giác hợp lệ.\n    Nếu không, trả về -1.\n    Ba cạnh tạo thành một tam giác hợp lệ khi tổng của bất kỳ hai cạnh nào lớn hơn\n    cạnh còn lại.\n    Ví dụ:\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''", "def triangle_area(a, b, c):\n    '''\n    Cho chiều dài của ba cạnh của một tam giác. Trả về diện tích của tam giác\n    làm tròn đến 2 chữ số thập phân nếu ba cạnh tạo thành một tam giác hợp lệ.\n    Nếu không, trả về -1.\n    Ba cạnh tạo thành một tam giác hợp lệ khi tổng của hai cạnh bất kỳ lớn hơn \n    cạnh còn lại.\n    Ví dụ:\n    triangle_area(3, 4, 5) == 6.00\n    triangle_area(1, 2, 10) == -1\n    '''"]}
{"text": ["def will_it_fly(q, w):\n    '''\n    Viết một hàm trả về True nếu đối tượng q có thể bay, và False nếu ngược lại.\n    Đối tượng q có thể bay nếu nó cân bằng (là một danh sách đối xứng) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng lượng tối đa w.\n\n    Ví dụ:\n    will_it_fly([1, 2], 5) ➞ False \n    # 1+2 nhỏ hơn trọng lượng tối đa, nhưng nó không cân bằng.\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng lượng tối đa.\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 nhỏ hơn trọng lượng tối đa, và nó cân bằng.\n\n    will_it_fly([3], 5) ➞ True\n    # 3 nhỏ hơn trọng lượng tối đa, và nó cân bằng.\n    '''", "def will_it_fly(q,w):\n    '''\n    Viết một hàm trả về True nếu vật thể q sẽ bay, và False nếu không.\n    Vật thể q sẽ bay nếu nó cân bằng (đó là một danh sách hồi văn) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng số tối đa có thể w.\n\n    Ví dụ:\n    will_it_fly([1, 2], 5) ➞ False \n    # 1+2 nhỏ hơn trọng lượng tối đa có thể, nhưng nó không cân bằng.\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng lượng tối đa có thể.\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 nhỏ hơn trọng lượng tối đa có thể, và nó cân bằng.\n\n    will_it_fly([3], 5) ➞ True\n    # 3 nhỏ hơn trọng lượng tối đa có thể và nó cân bằng.\n    '''", "def will_it_fly(q,w):\n    '''\n    Viết một hàm trả về True nếu đối tượng q sẽ bay, và False nếu không.\n    Đối tượng q sẽ bay nếu nó cân bằng (đó là một danh sách hồi văn) và tổng các phần tử của nó nhỏ hơn hoặc bằng trọng số tối đa có thể w.\n\n    Ví dụ:\n    will_it_fly([1, 2], 5) ➞ False\n    # 1+2 nhỏ hơn trọng số tối đa có thể, nhưng nó không cân bằng.\n\n    will_it_fly([3, 2, 3], 1) ➞ False\n    # nó cân bằng, nhưng 3+2+3 lớn hơn trọng số tối đa có thể.\n\n    will_it_fly([3, 2, 3], 9) ➞ True\n    # 3+2+3 nhỏ hơn trọng số tối đa có thể, và nó cân bằng.\n\n    will_it_fly([3], 5) ➞ True\n    # 3 nhỏ hơn trọng lượng tối đa có thể và nó cân bằng.\n    '''"]}
{"text": ["def smallest_change(arr):\n    \"\"\"\n    Cho một mảng arr các số nguyên, tìm số lượng phần tử tối thiểu cần thay đổi để làm cho mảng trở thành mảng đối xứng.\n    Một mảng đối xứng là một mảng có thể đọc giống nhau khi đọc từ trái sang phải và từ phải sang trái.\n    Trong một lần thay đổi, bạn có thể thay đổi một phần tử thành bất kỳ phần tử nào khác.\n\n    Ví dụ:\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\"", "def smallest_change(arr):\n    \"\"\"\n    Cho một mảng arr gồm các số nguyên, hãy tìm số lượng phần tử tối thiểu\n    cần phải thay đổi để tạo thành mảng palindromic. Mảng palindromic là một mảng\n    được đọc ngược và xuôi giống nhau. Trong một lần thay đổi, bạn có thể thay đổi một phần tử thành bất kỳ phần tử nào khác.\n\n    Ví dụ:\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\"", "def smallest_change(arr):\n    \"\"\"\n    Cho một mảng số nguyên arr, tìm số lượng phần tử tối thiểu cần thay đổi  để biến mảng thành mảng đối xứng. Mảng đối xứng \n    là mảng mà khi đọc từ trái sang phải hay phải sang trái đều giống nhau. Với một lần thay đổi, có thể thay đổi một phần tử \n    thành phần tử khác.\n\n    Ví dụ:\n    smallest_change([1,2,3,5,4,7,9,6]) == 4\n    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n    smallest_change([1, 2, 3, 2, 1]) == 0\n    \"\"\""]}
{"text": ["def total_match(lst1, lst2):\n    '''\n    Viết một hàm nhận vào hai danh sách chuỗi và trả về danh sách có\n    tổng số ký tự trong tất cả các chuỗi của danh sách nhỏ hơn danh sách còn lại.\n\n    Nếu hai danh sách có số lượng ký tự bằng nhau, trả về danh sách đầu tiên.\n\n    Ví dụ\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''", "def total_match(lst1, lst2):\n    '''\n    Viết một hàm chấp nhận hai danh sách chuỗi và trả về danh sách có tổng số ký tự trong tất cả các chuỗi của danh sách ít hơn danh sách còn lại.\n\n    Nếu hai danh sách có tổng số ký tự bằng nhau, trả về danh sách đầu tiên.\n\n    Ví dụ\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''", "def total_match(lst1, lst2):\n    '''\n    Viết một hàm chấp nhận hai danh sách chuỗi và trả về danh sách có\n    tổng số ký tự trong tất cả các chuỗi của danh sách ít hơn danh sách kia.\n\n    nếu hai danh sách có cùng số ký tự, hãy trả về danh sách đầu tiên.\n\n    Ví dụ\n    total_match([], []) ➞ []\n    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']\n    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']\n    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']\n    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']\n    '''"]}
{"text": ["def is_multiply_prime(a):\n    \"\"\"Viết một hàm trả về true nếu số đã cho là tích của 3 số nguyên tố, nếu không thì trả về false.\n    Biết rằng (a) nhỏ hơn 100.\n    Ví dụ:\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\"", "def is_multiply_prime(a):\n    \"\"\"Viết một hàm trả về true nếu số đã cho là phép nhân của 3 số nguyên tố\n    và false nếu không.\n    Biết rằng (a) nhỏ hơn 100.\n    Ví dụ:\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\"", "def is_multiply_prime(a):\n    \"\"\"Viết một hàm trả về True nếu số đã cho là tích của 3 số nguyên tố và False nếu không phải.\n    Biết rằng (a) nhỏ hơn 100.\n    Ví dụ:\n    is_multiply_prime(30) == True\n    30 = 2 * 3 * 5\n    \"\"\""]}
{"text": ["def is_simple_power(x, n):\n    \"\"\"Nhiệm vụ của bạn là viết một hàm trả về true nếu số x là lũy thừa đơn giản của n,\n    và false nếu không phải.\n    x là lũy thừa đơn giản của n khi n**int=x.\n    Ví dụ:\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\"", "def is_simple_power(x, n):\n    \"\"\"Nhiệm vụ của bạn là viết một hàm trả về true nếu một số x là lũy thừa\n    đơn giản của n và trả về false trong các trường hợp khác.\n    x là lũy thừa đơn giản của n nếu nk=x trong đó k là số nguyên\n    Ví dụ:\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\"", "def is_simple_power(x, n):\n    \"\"\"Nhiệm vụ của bạn là viết một hàm trả về true nếu số x là lũy thừa đơn giản của n và false trong các trường hợp khác.\n    x là lũy thừa đơn giản của n nếu n**int = x\n    Ví dụ:\n    is_simple_power(1, 4) => true\n    is_simple_power(2, 2) => true\n    is_simple_power(8, 2) => true\n    is_simple_power(3, 2) => false\n    is_simple_power(3, 1) => false\n    is_simple_power(5, 3) => false\n    \"\"\""]}
{"text": ["def iscube(a):\n    '''\n    Viết một hàm nhận một số nguyên a và trả về True \n    nếu số nguyên này là lập phương của một số nguyên nào đó.\n    Lưu ý: bạn có thể giả sử rằng đầu vào luôn hợp lệ.\n    Ví dụ:\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''", "def iscube(a):\n    '''\n    Nhập vào số nguyên a và viết hàm trả về liệu số nguyên này có phải là lũy thừa ba của một số nguyên nào đó hay không.\n    Tham khảo: Có thể giả định rằng đầu vào luôn hợp lệ.\n    Ví dụ:\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''", "def iscube(a):\n    '''\n    Viết một hàm lấy một số nguyên a và trả về True nếu số nguyên này là lập phương của một số nguyên nào đó.\n    Lưu ý: Có thể giả định rằng đầu vào luôn hợp lệ.\n    Ví dụ:\n    iscube(1) ==> True\n    iscube(2) ==> False\n    iscube(-1) ==> True\n    iscube(64) ==> True\n    iscube(0) ==> True\n    iscube(180) ==> False\n    '''"]}
{"text": ["def hex_key(num):\n    \"\"\"Bạn được giao nhiệm vụ viết một hàm nhận vào\n    một số thập lục phân dưới dạng chuỗi và đếm số lượng\n    chữ số thập lục phân là số nguyên tố (số nguyên tố là một số tự nhiên\n    lớn hơn 1 và không phải là tích của hai số tự nhiên nhỏ hơn).\n    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...\n    Vì vậy bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7, \n    B (= thập phân 11), D (= thập phân 13).\n    Lưu ý: bạn có thể giả định rằng đầu vào luôn đúng hoặc là chuỗi rỗng,\n    và các ký tự A, B, C, D, E, F luôn viết hoa.\n    Ví dụ:\n    Khi num = \"AB\", kết quả trả về sẽ là 1.\n    Khi num = \"1077E\", kết quả trả về sẽ là 2.\n    Khi num = \"ABED1A33\", kết quả trả về sẽ là 4.\n    Khi num = \"123456789ABCDEF0\", kết quả trả về sẽ là 6.\n    Khi num = \"2020\", kết quả trả về sẽ là 2.\n    \"\"\"", "def hex_key(num):\n    \"\"\"Bạn được giao nhiệm vụ viết một hàm nhận\n    một số thập lục phân dưới dạng chuỗi và đếm số chữ số thập lục phân\n    là số nguyên tố (số nguyên tố hoặc số nguyên tố là số tự nhiên lớn hơn\n    1 không phải là tích của hai số tự nhiên nhỏ hơn).\n    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...\n    Vì vậy, bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7,\n    B (=decimal 11), D (=decimal 13).\n    Lưu ý: bạn có thể cho rằng đầu vào luôn là chuỗi đúng hoặc rỗng,\n    và các ký hiệu A, B, C, D, E, F luôn viết hoa.\n    Ví dụ:\n    For num = \"AB\" the output should be 1.\n    For num = \"1077E\" the output should be 2.\n    For num = \"ABED1A33\" the output should be 4.\n    For num = \"123456789ABCDEF0\" the output should be 6.\n    For num = \"2020\" the output should be 2.\n    \"\"\"", "def hex_key(num):\n    \"\"\"Bạn được giao nhiệm vụ viết một hàm nhận vào\n    một số thập lục phân dưới dạng chuỗi và đếm số lượng\n    chữ số thập lục phân là số nguyên tố (số nguyên tố là một số tự nhiên\n    lớn hơn 1 không phải là tích của hai số tự nhiên nhỏ hơn).\n    Các chữ số thập lục phân là 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n    Các số nguyên tố là 2, 3, 5, 7, 11, 13, 17,...\n    Vì vậy, bạn phải xác định số lượng các chữ số sau: 2, 3, 5, 7, \n    B (=thập phân 11), D (=thập phân 13).\n    Lưu ý: bạn có thể giả định đầu vào luôn đúng hoặc là chuỗi rỗng, \n    và các ký tự A, B, C, D, E, F luôn ở dạng chữ hoa.\n    Ví dụ:\n    Với num = \"AB\" kết quả sẽ là 1.\n    Với num = \"1077E\" kết quả sẽ là 2.\n    Với num = \"ABED1A33\" kết quả sẽ là 4.\n    Với num = \"123456789ABCDEF0\" kết quả sẽ là 6.\n    Với num = \"2020\" kết quả sẽ là 2.\n    \"\"\""]}
{"text": ["def decimal_to_binary(decimal):\n    \"\"\"Bạn sẽ được cung cấp một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự biểu diễn một số nhị phân. Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.\n\n    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.\n    Các ký tự bổ sung ở đó để hỗ trợ định dạng.\n\n    Ví dụ:\n    decimal_to_binary(15)   # returns \"db1111db\"\n    decimal_to_binary(32)   # returns \"db100000db\"\n    \"\"\"", "def decimal_to_binary(decimal):\n    \"\"\"Bạn sẽ được cung cấp một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang \n    định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự đại diện cho một số nhị phân. \n    Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.\n\n    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.\n    Những ký tự bổ sung này có mục đích giúp định dạng.\n\n    Ví dụ:\n    decimal_to_binary(15)   # returns \"db1111db\"\n    decimal_to_binary(32)   # returns \"db100000db\"\n    \"\"\"", "def decimal_to_binary(decimal):\n    \"\"\"Cho một số ở dạng thập phân và nhiệm vụ của bạn là chuyển đổi nó sang \n    định dạng nhị phân. Hàm sẽ trả về một chuỗi, trong đó mỗi ký tự biểu thị một số\n    nhị phân. Mỗi ký tự trong chuỗi sẽ là '0' hoặc '1'.\n\n    Sẽ có thêm một vài ký tự 'db' ở đầu và cuối chuỗi.\n    Các ký tự bổ sung ở đó để hỗ trợ định dạng.\n\n    Ví dụ:\n    decimal_to_binary(15)   # returns \"db1111db\"\n    decimal_to_binary(32)   # returns \"db100000db\"\n    \"\"\""]}
{"text": ["def is_happy(s):\n    \"\"\"Bạn được cho một chuỗi s.\n    Nhiệm vụ của bạn là kiểm tra xem chuỗi có phải là chuỗi \"hạnh phúc\" hay không.\n    Một chuỗi được coi là \"hạnh phúc\" nếu độ dài của chuỗi ít nhất là 3 và 3 ký tự liên tiếp trong chuỗi là khác nhau\n    Ví dụ:\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\"", "def is_happy(s):\n    \"\"\"Bạn được cho một chuỗi s.\n    Nhiệm vụ của bạn là kiểm tra xem chuỗi đó có hạnh phúc hay không.\n    Một chuỗi được coi là hạnh phúc nếu độ dài của nó ít nhất là 3 và cứ 3 chữ cái liên tiếp thì phải khác nhau\n    Ví dụ:\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\"", "def is_happy(s):\n    \"\"\"Bạn được cung cấp một chuỗi s.\n    Nhiệm vụ của bạn là kiểm tra xem chuỗi đó có hạnh phúc hay không.\n    Một chuỗi được coi là hạnh phúc nếu độ dài của nó ít nhất là 3 và cứ 3 chữ cái liên tiếp thì phải khác nhau\n    Ví dụ:\n    is_happy(a) => False\n    is_happy(aa) => False\n    is_happy(abcd) => True\n    is_happy(aabb) => False\n    is_happy(adb) => True\n    is_happy(xyy) => False\n    \"\"\""]}
{"text": ["def numerical_letter_grade(grades):\n    \"\"\" Đó là tuần học cuối cùng của học kỳ và giáo viên phải chấm điểm cho học sinh.\n    Giáo viên đã tự tạo ra thuật toán chấm điểm của riêng mình.\n    Vấn đề duy nhất là, cô ấy đã làm mất mã nguồn mà cô ấy đã dùng để chấm điểm.\n    Cô ấy đã đưa cho bạn một danh sách các điểm GPA của một số học sinh và bạn phải viết \n    một hàm có thể xuất ra danh sách các điểm chữ dựa trên bảng sau:\n             GPA       |    Điểm chữ\n              4.0                A+\n            > 3.7                A\n            > 3.3                A-\n            > 3.0                B+\n            > 2.7                B\n            > 2.3                B-\n            > 2.0                C+\n            > 1.7                C\n            > 1.3                C-\n            > 1.0                D+\n            > 0.7                D\n            > 0.0                D-\n              0.0                E\n    Ví dụ:\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\"", "def numerical_letter_grade(grades):\n    \"\"\"Đây là tuần học cuối cùng của học kỳ và giáo viên phải cho điểm\n    cho học sinh. Giáo viên đã tạo ra một thuật toán riêng để chấm điểm.\n    Vấn đề duy nhất là, cô ấy đã làm mất mã nguồn dùng để chấm điểm.\n    Cô ấy đã đưa cho bạn một danh sách GPA của một số học sinh và bạn phải viết \n    một hàm để trả về danh sách các điểm chữ theo bảng sau:\n             GPA       |    Điểm chữ cái\n              4.0                A+\n            > 3.7                A \n            > 3.3                A- \n            > 3.0                B+\n            > 2.7                B \n            > 2.3                B-\n            > 2.0                C+\n            > 1.7                C\n            > 1.3                C-\n            > 1.0                D+ \n            > 0.7                D \n            > 0.0                D-\n              0.0                E\n    \n\n    Ví dụ:\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\"", "def numerical_letter_grade(grades):\n    \"\"\"Đây là tuần cuối cùng của học kỳ và giáo viên phải cho điểm \n    cho học sinh. Giáo viên đã tự tạo thuật toán chấm điểm của riêng mình.\n    Vấn đề duy nhất là cô ấy đã làm mất mã cô ấy dùng để chấm điểm.\n    Cô ấy đã đưa cho bạn danh sách GPA của một số học sinh và bạn phải viết\n    một hàm có thể xuất ra danh sách các điểm chữ bằng cách sử dụng bảng sau:\n             GPA       |    Điểm bằng chữ\n              4.0                A+\n            > 3.7                A \n            > 3.3                A- \n            > 3.0                B+\n            > 2.7                B \n            > 2.3                B-\n            > 2.0                C+\n            > 1.7                C\n            > 1.3                C-\n            > 1.0                D+ \n            > 0.7                D \n            > 0.0                D-\n              0.0                E\n    \n\n    Ví dụ:\n    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n    \"\"\""]}
{"text": ["def prime_length(string):\n    \"\"\"Viết một hàm nhận vào một chuỗi và trả về True nếu độ dài của chuỗi là một số nguyên tố, \n    hoặc False nếu không phải.\n    Ví dụ:\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\"", "def prime_length(string):\n    \"\"\"Nhận một chuỗi và viết hàm trả về True nếu độ dài của chuỗi là số nguyên tố\n    hoặc trả về False nếu không phải\n    Ví dụ\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\"", "def prime_length(string):\n    \"\"\"Viết một hàm nhận vào một chuỗi và trả về True nếu độ dài chuỗi\n    là một số nguyên tố, hoặc False nếu không phải.\n    Ví dụ\n    prime_length('Hello') == True\n    prime_length('abcdcba') == True\n    prime_length('kittens') == True\n    prime_length('orange') == False\n    \"\"\""]}
{"text": ["def starts_one_ends(n):\n    \"\"\"\n    Cho một số nguyên dương n, trả về số lượng các số nguyên dương n chữ số\n    bắt đầu hoặc kết thúc bằng 1.\n    \"\"\"", "def starts_one_ends(n):\n    \"\"\"\n    Cho một số nguyên dương n, trả về số lượng các số nguyên dương có n chữ số\n    bắt đầu hoặc kết thúc bằng 1.\n    \"\"\"", "def starts_one_ends(n):\n    \"\"\"\n    Cho một số nguyên dương n, trả về số lượng các số nguyên dương có n chữ số\n    bắt đầu hoặc kết thúc bằng chữ số 1.\n    \"\"\""]}
{"text": ["def solve(N):\n    \"\"\"Cho một số nguyên dương N, trả về tổng các chữ số của nó dưới dạng nhị phân.\n\n    Ví dụ:\n        Với N = 1000, tổng các chữ số là 1 và kết quả trả về sẽ là \"1\".\n        Với N = 150, tổng các chữ số là 6 và kết quả trả về sẽ là \"110\".\n        Với N = 147, tổng các chữ số là 12 và kết quả trả về sẽ là \"1100\".\n    \n    Biến:\n        @N: số nguyên\n            Ràng buộc: 0 ≤ N ≤ 10000.\n    Kết quả:\n        Một chuỗi số nhị phân\n    \"\"\"", "def solve(N):\n    \"\"\"Cho một số nguyên dương N, trả về tổng các chữ số của nó ở dạng nhị phân\n    \n    Ví dụ\n        Khi N = 1000, tổng các chữ số là 1 và đầu ra phải là \"1\".\n        Khi N = 150, tổng các chữ số là 6 và đầu ra phải là \"110\".\n        Khi N = 147, tổng các chữ số là 12 và đầu ra phải là \"1100\".\n    \n    Biến:\n        @N số nguyên\n             Điều kiện ràng buộc: 0 ≤ N ≤ 10000.\n    Đầu ra:\n         Chuỗi nhị phân\n    \"\"\"", "def solve(N):\n    \"\"\"Cho một số nguyên dương N, trả về tổng các chữ số của nó ở dạng nhị phân.\n\n    Ví dụ\n    Với N = 1000, tổng các chữ số sẽ là 1, đầu ra sẽ là \"1\".\n    Với N = 150, tổng các chữ số sẽ là 6, đầu ra sẽ là \"110\".\n    Với N = 147, tổng các chữ số sẽ là 12, đầu ra sẽ là \"1100\".\n\n    Biến:\n    @N số nguyên\n    Ràng buộc: 0 ≤ N ≤ 10000.\n    Đầu ra:\n    một chuỗi số nhị phân\n    \"\"\""]}
{"text": ["def add(lst):\n    \"\"\"Cho một danh sách các số nguyên không rỗng lst. Tính tổng các phần tử chẵn nằm ở chỉ số lẻ.\n\n\n    Ví dụ:\n        add([4, 2, 6, 7]) ==> 2 \n    \"\"\"", "def add(lst):\n    \"\"\"Cho một danh sách các số nguyên không rỗng, hãy cộng các phần tử chẵn có chỉ số lẻ.\n\n\n    Ví dụ:\n        add([4, 2, 6, 7]) ==> 2 \n    \"\"\"", "def add(lst):\n    \"\"\"Cho một danh sách các số nguyên không rỗng lst. cộng các phần tử chẵn ở vị trí lẻ..\n\n\n    Ví dụ:\n        add([4, 2, 6, 7]) ==> 2 \n    \"\"\""]}
{"text": ["def anti_shuffle(s):\n    \"\"\"\n    Viết một hàm nhận một chuỗi và trả về phiên bản có thứ tự của chuỗi đó.\n    Phiên bản có thứ tự của chuỗi là một chuỗi mà trong đó tất cả các từ (được phân cách bằng dấu cách)\n    được thay thế bằng một từ mới, trong đó tất cả các ký tự được sắp xếp theo thứ tự tăng dần dựa trên giá trị ascii.\n    Lưu ý: Bạn cần giữ nguyên thứ tự của các từ và khoảng trắng trong câu.\n\n    Ví dụ:\n    anti_shuffle('Hi') trả về 'Hi'\n    anti_shuffle('hello') trả về 'ehllo'\n    anti_shuffle('Hello World!!!') trả về 'Hello !!!Wdlor'\n    \"\"\"", "def anti_shuffle(s):\n    \"\"\"\n    Viết một hàm lấy một chuỗi và trả về phiên bản có thứ tự của chuỗi đó.\n    Phiên bản có thứ tự của chuỗi là một chuỗi trong đó tất cả các từ (phân cách bằng dấu cách)\n    được thay thế bằng một từ mới trong đó tất cả các ký tự được sắp xếp theo\n    thứ tự tăng dần dựa trên giá trị ASCII.\n    Lưu ý: Bạn nên giữ nguyên thứ tự của các từ và khoảng trắng trong câu.\n\n    Ví dụ:\n    anti_shuffle('Hi') returns 'Hi'\n    anti_shuffle('hello') returns 'ehllo'\n    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\n    \"\"\"", "def anti_shuffle(s):\n    \"\"\"\n    Nhận một chuỗi và trả về phiên bản đã sắp xếp của nó.\n    Phiên bản đã sắp xếp của chuỗi là chuỗi mà tất cả các từ (phân tách bằng khoảng trắng)\n    được thay thế bằng các ký tự sắp xếp theo thứ tự tăng dần theo giá trị ASCII.\n    Lưu ý: Thứ tự của từ và khoảng trắng trong câu phải được giữ nguyên.\n\n    Ví dụ:\n    anti_shuffle('Hi') trả về 'Hi'.\n    anti_shuffle('hello') trả về 'ehllo'.\n    anti_shuffle('Hello World!!!') trả về 'Hello !!!Wdlor'.\n    \"\"\""]}
{"text": ["def get_row(lst, x):\n    \"\"\"\n    Bạn được cung cấp dữ liệu hai chiều, dưới dạng danh sách lồng nhau,\n    giống như một ma trận, tuy nhiên, không giống như ma trận,\n    mỗi hàng có thể chứa số cột khác nhau.\n    Cho lst và số nguyên x, tìm các số nguyên x trong danh sách,\n    và trả về danh sách các tuple, [(x1, y1), (x2, y2) ...] sao cho\n    mỗi tuple là một tọa độ - (hàng, cột), bắt đầu từ 0.\n    Sắp xếp các tọa độ theo hàng theo thứ tự tăng dần.\n    Ngoài ra, sắp xếp tọa độ trong hàng theo cột theo thứ tự giảm dần.\n\n    Ví dụ:\n    get_row([ \n      [1,2,3,4,5,6],\n      [1,2,3,4,1,6],\n      [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\"", "def get_row(lst, x):\n    \"\"\"\n    Bạn được cung cấp dữ liệu 2 chiều, dưới dạng danh sách lồng nhau,\n    tương tự như ma trận, tuy nhiên, khác với ma trận,\n    mỗi hàng có thể chứa một số cột khác nhau.\n    Cho lst và một số nguyên x, hãy tìm các số x trong danh sách,\n    và trả về danh sách các cặp tọa độ, [(x1, y1), (x2, y2) ...] sao cho\n    mỗi cặp tọa độ là (hàng, cột), bắt đầu từ 0.\n    Sắp xếp tọa độ ban đầu theo hàng theo thứ tự tăng dần.\n    Đồng thời, sắp xếp tọa độ của mỗi hàng theo cột theo thứ tự giảm dần.\n    \n    Ví dụ:\n    get_row([\n      [1,2,3,4,5,6],\n      [1,2,3,4,1,6],\n      [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\"", "def get_row(lst, x):\n    \"\"\"\n    Bạn được cung cấp dữ liệu 2 chiều, dưới dạng danh sách lồng nhau,\n    tương tự như ma trận, tuy nhiên, không giống như ma trận,\n    mỗi hàng có thể chứa một số cột khác nhau.\n    Cho lst và số nguyên x, hãy tìm các số nguyên x trong danh sách,\n    và trả về danh sách các bộ, [(x1, y1), (x2, y2) ...] sao cho\n    mỗi bộ là một tọa độ - (hàng, cột), bắt đầu bằng 0.\n    Sắp xếp tọa độ ban đầu theo hàng theo thứ tự tăng dần.\n    Ngoài ra, sắp xếp tọa độ của hàng theo cột theo thứ tự giảm dần.\n    \n    Ví dụ:\n    get_row([\n      [1,2,3,4,5,6],\n      [1,2,3,4,1,6],\n      [1,2,3,4,5,1]\n    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n    get_row([], 1) == []\n    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n    \"\"\""]}
{"text": ["def sort_array(array):\n    \"\"\"\n    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã cho sau khi sắp xếp,\n    bạn sẽ sắp xếp mảng đã cho theo thứ tự tăng dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số lẻ,\n    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số chẵn.\n\n    Lưu ý:\n    * không thay đổi mảng đã cho.\n\n    Ví dụ:\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\"", "def sort_array(array):\n    \"\"\"\n    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã cho sau khi sắp xếp,\n    bạn sẽ sắp xếp mảng đã cho theo thứ tự tăng dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số lẻ,\n    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ mục đầu tiên, giá trị chỉ mục cuối cùng) là số chẵn.\n\n    Ghi chú:\n    * không thay đổi mảng đã cho.\n\n    Ví dụ:\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\"", "def sort_array(array):\n    \"\"\"\n    Cho một mảng các số nguyên không âm, trả về một bản sao của mảng đã được sắp xếp,\n    bạn sẽ sắp xếp mảng theo thứ tự tăng dần nếu tổng (giá trị chỉ số đầu tiên, giá trị chỉ số cuối cùng) là số lẻ,\n    hoặc sắp xếp theo thứ tự giảm dần nếu tổng (giá trị chỉ số đầu tiên, giá trị chỉ số cuối cùng) là số chẵn.\n\n    Lưu ý:\n    * không thay đổi mảng cho trước.\n\n    Ví dụ:\n    * sort_array([]) => []\n    * sort_array([5]) => [5]\n    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n    \"\"\""]}
{"text": ["def encrypt(s):\n    \"\"\"Tạo hàm encrypt nhận một chuỗi làm tham số và trả về\n    chuỗi đã được mã hóa với bảng chữ cái được xoay vòng. Bảng chữ cái phải được\n    xoay theo cách mà các chữ cái dịch chuyển xuống xuống hai lần hai vị trí.\n    Ví dụ:\n    encrypt('hi') trả về 'lm'.\n    encrypt('asdfghjkl') trả về 'ewhjklnop'.\n    encrypt('gf') trả về 'kj'.\n    encrypt('et') trả về 'ix'.\n    \"\"\"", "def encrypt(s):\n    \"\"\"Tạo một hàm encrypt nhận một chuỗi làm tham số và\n    trả về chuỗi đã được mã hóa với bảng chữ cái được xoay vòng.\n    Bảng chữ cái sẽ được xoay vòng theo cách mà các chữ cái \n    dịch chuyển xuống hai lần số hai vị trí.\n    Ví dụ:\n    encrypt('hi') trả về 'lm'\n    encrypt('asdfghjkl') trả về 'ewhjklnop'\n    encrypt('gf') trả về 'kj'\n    encrypt('et') trả về 'ix'\n    \"\"\"", "def encrypt(s):\n    \"\"\"Tạo một hàm encrypt nhận một chuỗi làm đối số và\n    trả về chuỗi được mã hóa với bảng chữ cái được xoay.\n    Bảng chữ cái nên được xoay sao cho các chữ cái\n    dịch chuyển xuống hai vị trí gấp đôi.\n    Ví dụ:\n    encrypt('hi') returns 'lm'\n    encrypt('asdfghjkl') returns 'ewhjklnop'\n    encrypt('gf') returns 'kj'\n    encrypt('et') returns 'ix'\n    \"\"\""]}
{"text": ["def next_smallest(lst):\n    \"\"\"\n    Bạn được cho một danh sách các số nguyên.\n    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 trong danh sách.\n    Trả về None nếu không có phần tử như vậy.\n\n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\"", "def next_smallest(lst):\n    \"\"\"\n    Bạn được cung cấp một danh sách các số nguyên.\n    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 của danh sách.\n    Trả về None nếu không có phần tử nào như vậy.\n\n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\"", "def next_smallest(lst):\n    \"\"\"\n    Bạn được cho một danh sách các số nguyên.\n    Viết một hàm next_smallest() trả về phần tử nhỏ thứ 2 của danh sách.\n    Trả về None nếu không có phần tử nào như vậy.\n    \n    next_smallest([1, 2, 3, 4, 5]) == 2\n    next_smallest([5, 1, 4, 3, 2]) == 2\n    next_smallest([]) == None\n    next_smallest([1, 1]) == None\n    \"\"\""]}
{"text": ["def is_bored(S):\n    \"\"\"\n    Bạn sẽ được cho một chuỗi các từ, và nhiệm vụ của bạn là đếm số lượng sự nhàm chán.\n    Một sự nhàm chán là một câu bắt đầu bằng từ \"I\".\n    Các câu được phân cách bởi dấu chấm ('.'), dấu hỏi ('?') hoặc dấu chấm than ('!').\n   \n    Ví dụ:\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\"", "def is_bored(S):\n    \"\"\"\n    Bạn sẽ được cung cấp một chuỗi từ và nhiệm vụ của bạn là đếm số lượng\n    của sự nhàm chán. Sự nhàm chán là một câu bắt đầu bằng từ \"I\".\n    Các câu được phân cách bằng dấu '.', '?' hoặc '!'.\n\n    Ví dụ:\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\"", "def is_bored(S):\n    \"\"\"\n    Bạn sẽ được cho một chuỗi các từ, và nhiệm vụ của bạn là đếm số lượng sự buồn chán. \n    Một sự buồn chán là một câu bắt đầu bằng từ \"I\".\n    Các câu được phân tách bằng dấu chấm ('.'), dấu hỏi ('?') hoặc dấu chấm than ('!').\n\n    Ví dụ:\n    >>> is_bored(\"Hello world\")\n    0\n    >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n    1\n    \"\"\""]}
{"text": ["def any_int(x, y, z):\n    '''\n    Tạo một hàm nhận vào 3 số.\n    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.\n    Trả về False trong các trường hợp khác.\n    \n    Ví dụ\n    any_int(5, 2, 7) ➞ True\n    \n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n    \n    any_int(3.6, -2.2, 2) ➞ False\n  \n\n    \n    '''", "def any_int(x, y, z):\n    '''\n    Tạo một hàm lấy 3 số.\n    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.\n    Trả về false trong mọi trường hợp khác.\n\n    Ví dụ\n    any_int(5, 2, 7) ➞ True\n\n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n\n    any_int(3.6, -2.2, 2) ➞ False\n\n    '''", "def any_int(x, y, z):\n    '''\n    Tạo một hàm nhận vào 3 số.\n    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.\n    Trả về false trong bất kỳ trường hợp nào khác.\n\n    Ví dụ:\n    any_int(5, 2, 7) ➞ True\n    \n    any_int(3, 2, 2) ➞ False\n\n    any_int(3, -2, 1) ➞ True\n    \n    any_int(3.6, -2.2, 2) ➞ False\n  \n\n    \n    '''"]}
{"text": ["def encode(message):\n    \"\"\"\n    Viết một hàm nhận vào một thông điệp và mã hóa theo cách \n    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 \n    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. \n    Giả sử chỉ có các chữ cái.\n\n    Ví dụ:\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\"", "def encode(message):\n    \"\"\"\n    Nhận một thông điệp và thay đổi chữ hoa thành chữ thường và ngược lại,\n    sau đó thay thế tất cả các nguyên âm trong thông điệp bằng chữ cái \n    đứng sau 2 vị trí trong bảng chữ cái tiếng Anh.\n    Giả sử chỉ có ký tự chữ cái.\n\n    Ví dụ:\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\"", "def encode(message):\n    \"\"\"\n    Viết một hàm lấy một thông điệp và đảo chữ hoa và chữ thường,\n    sau đó thay thế tất cả các nguyên âm trong thông điệp bằng chữ cái\n    xuất hiện ở 2 vị trí đầu so với nguyên âm đó trong bảng chữ cái.\n    Giả sử chỉ có các chữ cái.\n    \n    Ví dụ:\n    >>> encode('test')\n    'TGST'\n    >>> encode('This is a message')\n    'tHKS KS C MGSSCGG'\n    \"\"\""]}
{"text": ["def skjkasdkd(lst):\n    \"\"\"Bạn được cho một danh sách các số nguyên.\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ó.\n\n    Ví dụ:\n    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\n    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\n    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\n    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\n    Với lst = [0,81,12,3,1,21], kết quả trả về sẽ là 3\n    Với lst = [0,8,1,2,1,7], kết quả trả về sẽ là 7\n    \"\"\"", "def skjkasdkd(lst):\n    \"\"\"Cho một danh sách các số nguyên.\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ó.\n\n    Ví dụ:\n    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\n    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\n    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] thì đầu ra phải là 13\n    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] thì đầu ra phải là 11\n    lst = [0,81,12,3,1,21] thì đầu ra phải là 3\n    lst = [0,8,1,2,1,7] thì đầu ra phải là 7\n    \"\"\"", "def skjkasdkd(lst):\n    \"\"\"Bạn được cung cấp một danh sách các số nguyên.\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ó.\n\n    Ví dụ:\n    Đố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\n    Đố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\n    Đố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\n    Đối với lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] đầu ra phải là 11\n    Đối với lst = [0,81,12,3,1,21] đầu ra phải là 3\n    Đối với lst = [0,8,1,2,1,7] đầu ra phải là 7\n    \"\"\""]}
{"text": ["def check_dict_case(dict):\n    \"\"\"\n    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 \n    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.\n    Hàm này nên trả về False nếu từ điển cho trước là rỗng.\n    Ví dụ:\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) sẽ trả về True.\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) sẽ trả về False.\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) sẽ trả về False.\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) sẽ trả về False.\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) sẽ trả về True.\n    \"\"\"", "def check_dict_case(dict):\n    \"\"\"\n    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 \n    hoặc tất cả các từ khoá là chuỗi viết hoa, nếu không thì trả về False.\n    Hàm sẽ trả về False nếu từ điển đã cho là rỗng.\n    Ví dụ:\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) should return True.\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) should return False.\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) should return False.\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) should return False.\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) should return True.\n    \"\"\"", "def check_dict_case(dict):\n    \"\"\"\n    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    nếu không thì trả về False.\n    Hàm cần trả về False nếu từ điển được đưa vào là rỗng.\n    Ví dụ:\n    check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) phải trả về True.\n    check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) phải trả về False.\n    check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) phải trả về False.\n    check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) phải trả về False.\n    check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" })  phải trả về True.\n    \"\"\""]}
{"text": ["def count_up_to(n):\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.\n    Ví dụ:\n    count_up_to(5) => [2,3]\n    count_up_to(11) => [2,3,5,7]\n    count_up_to(0) => []\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\n    count_up_to(1) => []\n    count_up_to(18) => [2,3,5,7,11,13,17]\n    \"\"\"", "def count_up_to(n):\n    \"\"\"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.\n    ví dụ:\n    count_up_to(5) => [2,3]\n    count_up_to(11) => [2,3,5,7]\n    count_up_to(0) => []\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\n    count_up_to(1) => []\n    count_up_to(18) => [2,3,5,7,11,13,17]\n    \"\"\"", "def count_up_to(n):\n    \"\"\"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.\n    Ví dụ:\n    count_up_to(5) => [2, 3]\n    count_up_to(11) => [2, 3, 5, 7]\n    count_up_to(0) => []\n    count_up_to(20) => [2, 3, 5, 7, 11, 13, 17, 19]\n    count_up_to(1) => []\n    count_up_to(18) => [2, 3, 5, 7, 11, 13, 17]\n    \"\"\""]}
{"text": ["def multiply(a, b):\n    \"\"\"Hoàn thành hàm nhận hai số nguyên và trả về\n    tích của chữ số hàng đơn vị của chúng.\n    Giả sử đầu vào luôn hợp lệ.\n    Ví dụ:\n    multiply(148, 412) sẽ trả về 16.\n    multiply(19, 28) sẽ trả về 72.\n    multiply(2020, 1851) sẽ trả về 0.\n    multiply(14, -15) sẽ trả về 20.\n    \"\"\"", "def multiply(a, b):\n    \"\"\"Hoàn thành hàm lấy hai số nguyên và trả về\n    tích các chữ số hàng đơn vị của chúng.\n    Giả sử đầu vào luôn hợp lệ.\n    Ví dụ:\n    multiply(148, 412) should return 16.\n    multiply(19, 28) should return 72.\n    multiply(2020, 1851) should return 0.\n    multiply(14,-15) should return 20.\n    \"\"\"", "def multiply(a, b):\n    \"\"\"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 chúng.\n    Giả sử đầu vào luôn hợp lệ.\n    Ví dụ:\n    multiply(148, 412) nên trả về 16.\n    multiply(19, 28) nên trả về 72.\n    multiply(2020, 1851) nên trả về 0.\n    multiply(14,-15) nên trả về 20.\n    \"\"\""]}
{"text": ["def count_upper(s):\n    \"\"\"\n    Cho một chuỗi s, đếm số lượng nguyên âm viết hoa ở các chỉ số chẵn.\n    \n    Ví dụ:\n    count_upper('aBCdEf') trả về 1\n    count_upper('abcdefg') trả về 0\n    count_upper('dBBE') trả về 0\n    \"\"\"", "def count_upper(s):\n    \"\"\"\n    Chuỗi s được cho, hãy đếm số lượng nguyên âm viết hoa ở vị trí chỉ số chẵn.\n    \n    Ví dụ:\n    count_upper('aBCdEf') trả về 1\n    count_upper('abcdefg') trả về 0\n    count_upper('dBBE') trả về 0\n    \"\"\"", "def count_upper(s):\n    \"\"\"\n    Cho một chuỗi s, đếm số nguyên âm viết hoa trong các chỉ số chẵn.\n\n    Ví dụ:\n    count_upper('aBCdEf') returns 1\n    count_upper('abcdefg') returns 0\n    count_upper('dBBE') returns 0\n    \"\"\""]}
{"text": ["def closest_integer(value):\n    '''\n    Tạo một hàm lấy một giá trị (chuỗi) biểu diễn một số\n    và trả về số nguyên gần nhất với số đó. Nếu số đó cách đều\n    hai số nguyên, hãy làm tròn ra xa khỏi không.\n\n    Ví dụ\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    Lưu ý:\n    Làm tròn ra khỏi số không có nghĩa là nếu số đã cho cách đều\n    hai số nguyên, số bạn nên trả về là số\n    xa nhất so với số không. Ví dụ, closest_integer(\"14.5\") sẽ\n    trả về 15 và closest_integer(\"-14.5\") sẽ trả về -15.\n    '''", "def closest_integer(value):\n    '''\n    Tạo một hàm lấy một giá trị (chuỗi) biểu diễn một số\n    và trả về số nguyên gần nhất với số đó. Nếu số đó cách đều\n    hai số nguyên, hãy làm tròn số đó ra khỏi số không.\n\n    Ví dụ\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    Lưu ý:\n    Làm tròn ra khỏi số không có nghĩa là nếu số đã cho cách đều\n    hai số nguyên, số bạn nên trả về là số\n    xa nhất so với số không. Ví dụ closest_integer(\"14.5\") sẽ\n    trả về 15 và closest_integer(\"-14.5\") sẽ trả về -15.\n    '''", "def closest_integer(value):\n    '''\n    Tạo một hàm nhận vào một giá trị (chuỗi) đại diện cho một số\n    và trả về số nguyên gần nhất với nó. Nếu số đó cách đều\n    giữa hai số nguyên, làm tròn nó ra xa 0.\n\n    Ví dụ\n    >>> closest_integer(\"10\")\n    10\n    >>> closest_integer(\"15.3\")\n    15\n\n    Lưu ý:\n    Làm tròn ra xa 0 có nghĩa là nếu số đã cho cách đều\n    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ẽ\n    trả về 15 và closest_integer(\"-14.5\") sẽ trả về -15.\n    '''"]}
{"text": ["def make_a_pile(n):\n    \"\"\"\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.\n    Cấp đầu tiên có n viên đá.\n    Số lượng đá ở cấp tiếp theo là:\n    - số lẻ tiếp theo nếu n lẻ.\n    - số chẵn tiếp theo nếu n chẵn.\n    Trả về số lượng đá ở mỗi cấp trong danh sách, trong đó phần tử ở chỉ mục\n    i biểu thị số lượng đá ở cấp (i+1).\n\n    Ví dụ:\n    >>> make_a_pile(3)\n    [3, 5, 7]\n    \"\"\"", "def make_a_pile(n):\n    \"\"\"\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.\n    Cấp đầu tiên có n viên đá.\n    Số lượng đá ở cấp tiếp theo là:\n    - số lẻ tiếp theo nếu n lẻ.\n    - số chẵn tiếp theo nếu n chẵn.\n    Trả về số lượng đá ở mỗi cấp độ trong danh sách, trong đó phần tử tại chỉ số i biểu thị số lượng đá ở cấp (i+1).\n\n    Ví dụ:\n    >>> make_a_pile(3)\n    [3, 5, 7]\n    \"\"\"", "def make_a_pile(n):\n    \"\"\"\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 độ.\n    Mức độ đầu tiên có n viên đá.\n    Số lượng đá ở mức độ tiếp theo là:\n        - số lẻ tiếp theo nếu n lẻ.\n        - số chẵn tiếp theo nếu n chẵn.\n    Trả về số lượng đá ở mỗi cấp trong danh sách, trong đó phần tử ở chỉ mục\n    i biểu thị số lượng đá ở mức độ (i+1).\n\n    Ví dụ:\n    >>> make_a_pile(3)\n    [3, 5, 7]\n    \"\"\""]}
{"text": ["def words_string(s):\n    \"\"\"\n    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à\n    phân tách chuỗi thành các từ và trả về một mảng chứa các từ đó.\n    \n    Ví dụ:\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\"", "def words_string(s):\n    \"\"\"\n    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à\n    chia chuỗi thành các từ và trả về một mảng các từ.\n    \n    Ví dụ:\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\"", "def words_string(s):\n    \"\"\"\n    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à\n    tách chuỗi thành các từ và trả về một mảng chứa các từ.\n\n    Ví dụ:\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n    \"\"\""]}
{"text": ["def choose_num(x, y):\n    \"\"\"Hàm này lấy hai số dương x và y và trả về\n    số nguyên chẵn lớn nhất nằm trong phạm vi [x, y] bao gồm. Nếu\n    không có số nào như vậy, thì hàm sẽ trả về -1.\n\n    Ví dụ:\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\"", "def choose_num(x, y):\n    \"\"\"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    Nếu không có số như vậy, hàm phải trả về -1.\n\n    Ví dụ:\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\"", "def choose_num(x, y):\n    \"\"\"Hàm này lấy hai số dương x và y và trả về\n    số nguyên chẵn lớn nhất nằm trong phạm vi [x, y] bao gồm. Nếu\n    không có số nào như vậy, thì hàm sẽ trả về -1.\n\n    Ví dụ:\n    choose_num(12, 15) = 14\n    choose_num(13, 12) = -1\n    \"\"\""]}
{"text": ["def rounded_avg(n, m):\n    \"\"\"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\n    trung bình của các số nguyên từ n đến m (bao gồm n và m).\n    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    Nếu n lớn hơn m, hãy trả về -1.\n    Ví dụ:\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\"", "def rounded_avg(n, m):\n    \"\"\"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\n    trung bình của các số nguyên từ n đến m (bao gồm n và m).\n    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    Nếu n lớn hơn m, hãy trả về -1.\n    Ví dụ:\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\"", "def rounded_avg(n, m):\n    \"\"\"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\n    trung bình của các số nguyên từ n đến m (bao gồm n và m).\n    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    Nếu n lớn hơn m, trả về -1.\n    Ví dụ:\n    rounded_avg(1, 5) => \"0b11\"\n    rounded_avg(7, 5) => -1\n    rounded_avg(10, 20) => \"0b1111\"\n    rounded_avg(20, 33) => \"0b11010\"\n    \"\"\""]}
{"text": ["def unique_digits(x):\n    \"\"\"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\n    gồm tất cả các phần tử không chứa bất kỳ chữ số chẵn nào.\n\n    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.\n    \n    Ví dụ:\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\"", "def unique_digits(x):\n    \"\"\"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\n    phần tử không có chữ số chẵn nào.\n\n    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.\n    \n    Ví dụ:\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\"", "def unique_digits(x):\n    \"\"\"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 \n    gồm tất cả các phần tử không có chữ số chẵn.\n\n    Lưu ý: Danh sách trả về phải được sắp xếp theo thứ tự tăng dần.\n    \n    Ví dụ:\n    >>> unique_digits([15, 33, 1422, 1])\n    [1, 15, 33]\n    >>> unique_digits([152, 323, 1422, 10])\n    []\n    \"\"\""]}
{"text": ["def by_length(arr):\n    \"\"\"\n    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),\n    đả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ừ\n    \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n    Ví dụ:\n      arr = [2, 1, 1, 4, 5, 8, 2, 3]   \n            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n      return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n    \n      Nếu mảng rỗng, trả về một mảng rỗng:\n      arr = []\n      return []\n    \n      Nếu mảng có bất kỳ số lạ nào, bỏ qua nó:\n      arr = [1, -1 , 55] \n            -> sắp xếp arr -> [-1, 1, 55]\n            -> đảo ngược arr -> [55, 1, -1]\n      return = ['One']\n    \"\"\"", "def by_length(arr):\n    \"\"\"\n    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),\n    đả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ừ\n    \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n    Ví dụ:\n      arr = [2, 1, 1, 4, 5, 8, 2, 3]   \n            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n      trả về [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n    \n      Nếu mảng rỗng, trả về mảng rỗng:\n      arr = []\n      trả về []\n    \n      Nếu mảng có số lạ, bỏ qua nó:\n      arr = [1, -1 , 55] \n            -> sắp xếp arr -> [-1, 1, 55]\n            -> đảo ngược arr -> [55, 1, -1]\n      trả về = ['One']\n    \"\"\"", "def by_length(arr):\n    \"\"\"\n    Cho một mảng các số nguyên, hãy sắp xếp các số nguyên từ 1 đến 9,\n    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\".\n\n    Ví dụ:\n      arr = [2, 1, 1, 4, 5, 8, 2, 3]   \n            -> sắp xếp arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n            -> đảo ngược arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n      return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n    \n      Nếu mảng rỗng, trả về mảng rỗng:\n      arr = []\n      return []\n    \n      Nếu có số lạ trong mảng, bỏ qua chúng:\n      arr = [1, -1 , 55] \n            -> sắp xếp arr -> [-1, 1, 55]\n            -> đảo ngược arr -> [55, 1, -1]\n      return = ['One']\n    \"\"\""]}
{"text": ["def f(n):\n    \"\"\" Triển khai hàm f. Hàm này nhận n làm tham số và\n    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    nếu không thì là tổng của các số từ 1 đến i.\n    i bắt đầu từ 1.\n    Giai thừa của i là tích của các số từ 1 đến i (1 * 2 * ... * i).\n    Ví dụ:\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\"", "def f(n):\n    \"\"\" Triển khai hàm f lấy n làm tham số,\n    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\n    hoặc tổng các số từ 1 đến i nếu không.\n    i bắt đầu từ 1.\n    giai thừa của i là phép nhân các số từ 1 đến i (1 * 2 * ... * i).\n    Ví dụ:\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\"", "def f(n):\n    \"\"\" \n    Thực hiện hàm f nhận vào n làm tham số, \n    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    hoặc là tổng các số từ 1 đến i nếu i là số lẻ.\n    i bắt đầu từ 1.\n    Giai thừa của i là phép nhân các số từ 1 đến i (1 * 2 * ... * i).\n    Ví dụ:\n    f(5) == [1, 2, 6, 24, 15]\n    \"\"\""]}
{"text": ["def even_odd_palindrome(n):\n    \"\"\"\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 \n    (1, n).\n\n    Ví dụ 1:\n\n        Đầu vào: 3\n        Đầu ra: (1, 2)\n        Giải thích:\n        Các số nguyên đối xứng là 1, 2, 3. Trong đó có một số chẵn và hai số lẻ.\n\n    Ví dụ 2:\n\n        Đầu vào: 12\n        Đầu ra: (4, 6)\n        Giải thích:\n        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ẻ.\n\n    Ghi chú:\n        1. 1 <= n <= 10^3\n        2. Bộ giá trị trả về chứa số lượng số nguyên đối xứng chẵn và lẻ tương ứng.\n    \"\"\"", "def even_odd_palindrome(n):\n    \"\"\"\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    nằm trong phạm vi (1, n), bao gồm.\n\n    Ví dụ 1:\n\n        Đầu vào: 3\n        Đầu ra: (1, 2)\n        Giải thích:\n        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ẻ.\n\n    Ví dụ 2:\n\n        Đầu vào: 12\n        Đầu ra: (4, 6)\n        Giải thích:\n        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ẻ.\n\n    Lưu ý:\n        1. 1 <= n <= 10^3\n        2. tuple trả về có số lượng palindrome nguyên chẵn và lẻ tương ứng.\n    \"\"\"", "def even_odd_palindrome(n):\n    \"\"\"\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.\n\n    Ví dụ 1:\n\n        Đầu vào: 3\n        Đầu ra: (1, 2)\n        Giải thích:\n        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ẻ.\n\n    Ví dụ 2:\n\n        Đầu vào: 12\n        Đầu ra: (4, 6)\n        Giải thích:\n        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ẻ.\n\n    Lưu ý:\n        1. 1 <= n <= 10^3\n        2. Tuple trả về chứa số lượng số nguyên đối xứng chẵn và lẻ tương ứng.\n    \"\"\""]}
{"text": ["def count_nums(arr):\n    \"\"\"\n    Viết một hàm count_nums nhận một mảng các số nguyên và trả về\n    số lượng phần tử có tổng các chữ số > 0.\n    Nếu một số là số âm, thì chữ số có dấu đầu tiên sẽ là âm:\n    ví dụ: -123 có các chữ số có dấu là -1, 2, và 3.\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\"", "def count_nums(arr):\n    \"\"\"\n    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    Nếu số là số âm, chữ số đầu tiên có dấu sẽ là số âm:\n    Ví dụ: -123 có chữ số có dấu là -1, 2, 3.\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\"", "def count_nums(arr):\n    \"\"\"\n    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    Nếu một số âm thì chữ số có dấu đầu tiên của nó sẽ âm:\n    Ví dụ. -123 có các chữ số có dấu -1, 2 và 3.\n    >>> count_nums([]) == 0\n    >>> count_nums([-1, 11, -11]) == 1\n    >>> count_nums([1, 1, 2]) == 3\n    \"\"\""]}
{"text": ["def move_one_ball(arr):\n    \"\"\"Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N].\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\n    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 \n    phép toán sau trên mảng đã cho:\n        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.\n    \n    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\n    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\n    vị trí đầu tiên trong mảng, tức là chỉ số 0. \n\n    Nếu có thể đạt được mảng đã sắp xếp theo thứ tự không giảm bằng cách\n    thực hiện phép toán trên, trả về True, ngược lại trả về False.\n    Nếu mảng đã cho là rỗng thì trả về True.\n\n    Lưu ý: Mảng đã cho đảm bảo không có phần tử trùng lặp.\n\n    Ví dụ:\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    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ể\n                được sắp xếp theo thứ tự không giảm.\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    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ỳ\n                phép dịch chuyển phải nào.\n                \n    \"\"\"", "def move_one_ball(arr):\n    \"\"\"Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N]. Các\n    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\n    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\n    thao tác sau trên mảng đã cho hay không:\n        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.\n    \n    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\n    vị trí theo hướng phải. Phần tử cuối cùng của mảng sẽ được di chuyển đến\n    vị trí bắt đầu trong mảng tức là chỉ số thứ 0.\n\n    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\n    thì trả về True nếu không thì trả về False.\n    Nếu mảng đã cho trống thì trả về True.\n\n    Lưu ý: Danh sách đã cho được đảm bảo có các phần tử duy nhất.\n\n    Ví dụ:\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    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\n                 cho mảng đã cho.\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    Giải thích: Không thể có được thứ tự không giảm cho\n                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.\n                \n    \"\"\"", "def move_one_ball(arr):\n    \"\"\"Chúng ta có một mảng 'arr' gồm N số nguyên arr[1], arr[2], ..., arr[N].\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\n    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:\n        Có thể thực hiện thao tác di chuyển sang phải bao nhiêu lần tùy ý.\n    \n    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\n    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\n    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    Nếu mảng đã cho rỗng, trả về True.\n\n    Lưu ý: Danh sách đã cho được đảm bảo có các phần tử duy nhất.\n\n    Ví dụ:\n    \n    move_one_ball([3, 4, 5, 1, 2])==>True\n    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.\n    move_one_ball([3, 5, 4, 1, 2])==>False\n    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.\n                \n    \"\"\""]}
{"text": ["def exchange(lst1, lst2):\n    \"\"\"Trong bài toán này, hãy triển khai một hàm lấy hai danh sách số, \n    và xác định xem có thể thực hiện trao đổi các phần tử\n    giữa chúng để biến lst1 thành danh sách chỉ gồm các số chẵn hay không.\n    Không có giới hạn về số lượng phần tử được trao đổi giữa lst1 và lst2.\n    Nếu có thể trao đổi các phần tử giữa lst1 và lst2 để biến\n    tất cả các phần tử của lst1 thành số chẵn, hãy trả về \"YES\".\n    Nếu không, hãy trả về \"NO\".\n    Ví dụ:\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n    Giả sử rằng các danh sách đầu vào không rỗng.\n    \"\"\"", "def exchange(lst1, lst2):\n    \"\"\"Trong bài toán này, bạn sẽ triển khai một hàm nhận hai danh sách số,\n    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.\n    Không có giới hạn về số lượng phần tử trao đổi giữa lst1 và lst2.\n    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    Nếu không, trả về \"NO\".\n    Ví dụ:\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n    Giả sử rằng các danh sách đầu vào sẽ không rỗng.\n    \"\"\"", "def exchange(lst1, lst2):\n    \"\"\"Trong bài toán này, bạn sẽ triển khai một hàm lấy hai danh sách số,\n    và xác định xem có thể thực hiện trao đổi các phần tử\n    giữa chúng để biến lst1 thành danh sách chỉ gồm các số chẵn hay không.\n    Không có giới hạn về số lượng phần tử được trao đổi giữa lst1 và lst2.\n    Nếu có thể trao đổi các phần tử giữa lst1 và lst2 để biến\n    tất cả các phần tử của lst1 thành số chẵn, hãy trả về \"YES\".\n    Nếu không, hãy trả về \"NO\".\n    Ví dụ:\n    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n    Giả sử rằng các danh sách đầu vào sẽ không rỗng.\n    \"\"\""]}
{"text": ["def histogram(test):\n    \"\"\"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\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    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 đó.\n    \n    Ví dụ:\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\"", "def histogram(test):\n    \"\"\"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\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    Nếu một số chữ cái có cùng lần xuất hiện, trả về tất cả chúng.\n\n    Ví dụ:\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\"", "def histogram(test):\n    \"\"\"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 \n    lại nhiều nhất và chứa số lượng tương ứng.\n    Nếu một số chữ cái có cùng lần xuất hiện, trả về tất cả chúng.\n\n    Ví dụ:\n    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n    histogram('a b b a') == {'a': 2, 'b': 2}\n    histogram('a b c a b') == {'a': 2, 'b': 2}\n    histogram('b b b b a') == {'b': 4}\n    histogram('') == {}\n\n    \"\"\""]}
{"text": ["def reverse_delete(s,c):\n    \"\"\"Nhiệm vụ\n    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\n    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi palindrome không.\n    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.\n    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.\n    Ví dụ\n    Đối với s = \"abcde\", c = \"ae\", kết quả phải là ('bcd',False)\n    Đối với s = \"abcdef\", c = \"b\" thì kết quả phải là ('acdef',False)\n    Đối với s = \"abcdedcba\", c = \"ab\", kết quả phải là ('cdedc',True)\n    \"\"\"", "def reverse_delete(s,c):\n    \"\"\"Nhiệm vụ\n    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\n    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi đối xứng không.\n    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.\n    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.\n    Ví dụ\n    Nếu s = \"abcde\", c = \"ae\", kết quả phải là ('bcd',False).\n    Nếu s = \"abcdef\", c = \"b\", kết quả phải là ('acdef',False).\n    Nếu s = \"abcdedcba\", c = \"ab\", kết quả phải là ('cdedc',True).\n    \"\"\"", "def reverse_delete(s,c):\n    \"\"\"Nhiệm vụ\n    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\n    sau đó kiểm tra xem chuỗi kết quả có phải là chuỗi palindrome không.\n    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.\n    Bạn phải trả về một bộ chứa chuỗi kết quả và True/False để kiểm tra.\n    Ví dụ\n    Đối với s = \"abcde\", c = \"ae\", kết quả phải là ('bcd',False)\n    Đối với s = \"abcdef\", c = \"b\"  kết quả phải là ('acdef',False)\n    Đối với s = \"abcdedcba\", c = \"ab\", kết quả phải là ('cdedc',True)\n    \"\"\""]}
{"text": ["def odd_count(lst):\n    \"\"\"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.\n    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,\" \n    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.\n\n    >>> odd_count(['1234567'])\n    [\"Số phần tử lẻ trong chuỗi 1234567 là 4.\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"Số phần tử lẻ trong chuỗi 3 là 1.\",\n     \"Số phần tử lẻ trong chuỗi 11111111 là 8.\"]\n    \"\"\"", "def odd_count(lst):\n    \"\"\"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.\n    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 sẽ được thay thế bằng số các chữ số lẻ trong chuỗi i của đầu vào.\n\n    >>> odd_count(['1234567'])\n    [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n    \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n    \"\"\"", "def odd_count(lst):\n    \"\"\"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.\n    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.\n\n    >>> odd_count(['1234567'])\n    [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n    >>> odd_count(['3',\"11111111\"])\n    [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n    \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n    \"\"\""]}
{"text": ["def minSubArraySum(nums):\n    \"\"\"\n    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.\n    Ví dụ:\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\"", "def minSubArraySum(nums):\n    \"\"\"\n    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.\n    Ví dụ\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\"", "def minSubArraySum(nums):\n    \"\"\"\n    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\n    của nums.\n    Ví dụ\n    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n    minSubArraySum([-1, -2, -3]) == -6\n    \"\"\""]}
{"text": ["import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    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,\n    và mỗi 1 trong một hàng đại diện cho một đơn vị nước duy nhất.\n    Mỗi giếng có một xô tương ứng có thể được sử dụng để lấy nước từ đó,\n    và tất cả các xô đều có cùng dung tích.\n    Nhiệm vụ của bạn là sử dụng các xô để làm rỗng các giếng.\n    Đầu ra là số lần bạn cần hạ thấp các xô.\n\n    Ví dụ 1:\n        Đầu vào: \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        Đầu ra: 6\n\n    Ví dụ 2:\n        Đầu vào: \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        Đầu ra: 5\n    \n    Ví dụ 3:\n        Đầu vào: \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        Đầu ra: 0\n\n    Giới hạn:\n        * tất cả các giếng có chiều dài bằng nhau\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[:,1].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\"", "import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    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,\n    và mỗi số 1 trong hàng đại diện cho một đơn vị nước.\n    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.\n    Nhiệm vụ là làm trống giếng bằng cách sử dụng xô.\n    Xuất số lần hạ xô.\n\n    Ví dụ 1:\n        Đầu vào: \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        Đầu ra: 6\n\n    Ví dụ 2:\n        Đầu vào: \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        Đầu ra: 5\n    \n    Ví dụ 3:\n        Đầu vào: \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        Đầu ra: 0\n\n    Điều kiện:\n        * Độ dài của tất cả các giếng là như nhau\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[0].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\"", "import math\n\ndef max_fill(grid, capacity):\n    \"\"\"\n    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,\n    và mỗi 1 trong một hàng đại diện cho một đơn vị nước.\n    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 đó, \n    và tất cả các xô đều có cùng dung tích.\n    Nhiệm vụ của bạn là sử dụng các xô để làm rỗng các giếng.\n    Kết quả trả về là số lần bạn cần hạ các xô.\n\n    Ví dụ 1:\n        Đầu vào: \n            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n            bucket_capacity : 1\n        Đầu ra: 6\n\n    Ví dụ 2:\n        Đầu vào: \n            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n            bucket_capacity : 2\n        Đầu ra: 5\n    \n     Ví dụ 3:\n        Đầu vào: \n            grid : [[0,0,0], [0,0,0]]\n            bucket_capacity : 5\n        Đầu ra: 0\n\n     Điều kiện:\n        * tất cả các giếng đều có chiều dài giống nhau\n        * 1 <= grid.length <= 10^2\n        * 1 <= grid[:,1].length <= 10^2\n        * grid[i][j] -> 0 | 1\n        * 1 <= capacity <= 10\n    \"\"\""]}
{"text": ["def sort_array(arr):\n    \"\"\"\n    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\n    số lượng bit 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.\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.\n\n    Phải triển khai như sau:\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]\n    \"\"\"", "def sort_array(arr):\n    \"\"\"\n    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\n    số lượng bit 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.\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\n    Nó phải được triển khai như sau:\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]\n    \"\"\"", "def sort_array(arr):\n    \"\"\"\n    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\n    số lượng số 1 trong biểu diễn nhị phân của chúng theo thứ tự tăng dần.\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\n    Nó phải được triển khai như thế này:\n    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n    >>> sort_array([1, 0, 2, 3, 4]) ==  [0, 1, 2, 3, 4]\n    \"\"\""]}
{"text": ["def select_words(s, n):\n    \"\"\"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\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    n phụ âm, theo thứ tự các từ này xuất hiện trong chuỗi s.\n    Nếu chuỗi s trống thì hàm sẽ trả về một danh sách trống.\n    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.\n    Ví dụ:\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\"", "def select_words(s, n):\n    \"\"\"Cho một chuỗi s và số tự nhiên n, hãy thực hiện\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    n phụ âm, thứ tự các từ này xuất hiện trong chuỗi s.\n    Nếu chuỗi s trống thì hàm sẽ trả về một danh sách trống.\n    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.\n    Ví dụ:\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\"", "def select_words(s, n):\n    \"\"\"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ề \n    danh sách tất cả các từ trong chuỗi s chứa chính xác n phụ âm, \n    các từ này được trả về theo thứ tự xuất hiện trong chuỗi s.\n    Nếu chuỗi s rỗng, hàm phải trả về danh sách rỗng.\n    Lưu ý: Có thể giả định rằng chuỗi đầu vào chỉ chứa chữ cái và khoảng trắng.\n    Ví dụ:\n    select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n    select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n    select_words(\"simple white space\", 2) ==> []\n    select_words(\"Hello world\", 4) ==> [\"world\"]\n    select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n    \"\"\""]}
{"text": ["def get_closest_vowel(word):\n    \"\"\"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\n    hai phụ âm từ bên phải của từ (phân biệt chữ hoa chữ thường).\n\n    Nguyên âm ở đầu và cuối không được tính. Trả về chuỗi rỗng nếu bạn không\n    tìm thấy bất kỳ nguyên âm nào đáp ứng điều kiện trên.\n\n    Bạn có thể cho rằng chuỗi đã cho chỉ chứa chữ cái tiếng Anh.\n\n    Ví dụ:\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\"", "def get_closest_vowel(word):\n    \"\"\"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\n    hai phụ âm từ bên phải của từ (phân biệt chữ hoa chữ thường).\n    \n    Nguyên âm ở đầu và cuối không được tính. Trả về chuỗi rỗng nếu bạn không\n    tìm thấy bất kỳ nguyên âm nào đáp ứng điều kiện trên. \n\n    Bạn có thể cho rằng chuỗi đã cho chỉ chứa chữ cái tiếng Anh.\n\n    Ví dụ:\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\"", "def get_closest_vowel(word):\n    \"\"\"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\n    hai phụ âm từ phía bên phải của từ (chú ý đến chữ hoa và chữ thường).\n\n    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\n    nguyên âm nào thỏa mãn điều kiện trên.\n\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.\n\n    Ví dụ:\n    get_closest_vowel(\"yogurt\") ==> \"u\"\n    get_closest_vowel(\"FULL\") ==> \"U\"\n    get_closest_vowel(\"quick\") ==> \"\"\n    get_closest_vowel(\"ab\") ==> \"\"\n    \"\"\""]}
{"text": ["def match_parens(lst):\n    '''\n    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 ')'.\n    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.\n    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.\n    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ó.\n\n    Ví dụ:\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''", "def match_parens(lst):\n    '''\n    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 ')'.\n    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.\n    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    Nếu có cách tạo ra chuỗi tốt, trả về 'Yes', nếu không thì trả về 'No'.\n\n    Ví dụ:\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''", "def match_parens(lst):\n    '''\n    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ở\n    '(' hoặc dấu ngoặc đơn đóng ')'.\n    Nhiệm vụ của bạn là kiểm tra xem có thể nối hai chuỗi theo\n    một thứ tự nào đó không, rằng chuỗi kết quả sẽ tốt.\n    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\n    đều cân bằng. Ví dụ: chuỗi '(())()' là tốt, trong khi chuỗi\n    '())' thì không.\n    Trả về 'Yes' nếu có cách tạo một chuỗi tốt và trả về 'No' nếu không.\n\n    Ví dụ:\n    match_parens(['()(', ')']) == 'Yes'\n    match_parens([')', ')']) == 'No'\n    '''"]}
{"text": ["def maximum(arr, k):\n    \"\"\"\n    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 \n    có độ dài k với k số lớn nhất trong arr.\n\n    Ví dụ 1:\n\n        Input: arr = [-3, -4, 5], k = 3\n        Output: [-4, -3, 5]\n\n    Ví dụ 2:\n\n        Input: arr = [4, -4, 4], k = 2\n        Output: [4, 4]\n\n    Ví dụ 3:\n\n        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n        Output: [2]\n\n    Lưu ý:\n        1. Độ dài của mảng sẽ nằm trong phạm vi [1, 1000].\n        2. Các phần tử trong mảng sẽ nằm trong phạm vi [-1000, 1000].\n        3. 0 <= k <= len(arr)\n    \"\"\"", "def maximum(arr, k):\n    \"\"\"\n    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 \n    có độ dài k được tạo thành từ tối đa k số trong arr.\n\n    Ví dụ 1:\n\n        Đầu vào: arr = [-3, -4, 5], k = 3\n        Đầu ra: [-4, -3, 5]\n\n    Ví dụ 2:\n\n        Đầu vào: arr = [4, -4, 4], k = 2\n        Đầu ra: [4, 4]\n\n    Ví dụ 3:\n\n        Đầu vào: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n        Đầu ra: [2]\n\n    Ghi chú:\n        1. Độ dài của mảng nằm trong phạm vi [1, 1000].\n        2. Các phần tử của mảng nằm trong phạm vi [-1000, 1000].\n        3. 0 <= k <= len(arr)\n    \"\"\"", "def maximum(arr, k):\n    \"\"\"\n    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\n    có độ dài k với k số lớn nhất trong arr.\n\n    Ví dụ 1:\n\n    Đầu vào: arr = [-3, -4, 5], k = 3\n    Đầu ra: [-4, -3, 5]\n\n    Ví dụ 2:\n\n    Đầu vào: arr = [4, -4, 4], k = 2\n    Đầu ra: [4, 4]\n\n    Ví dụ 3:\n\n    Đầu vào: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n    Đầu ra: [2]\n\n    Lưu ý:\n    1. Độ dài của mảng sẽ nằm trong phạm vi [1, 1000].\n    2. Các phần tử trong mảng sẽ nằm trong phạm vi [-1000, 1000].\n    3. 0 <= k <= len(arr)\n    \"\"\""]}
{"text": ["def solution(lst):\n    \"\"\"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.\n    \n\n    Ví dụ:\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==> 0\n    \"\"\"", "def solution(lst):\n    \"\"\"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.\n    \n\n    Ví dụ\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==>0\n    \"\"\"", "def solution(lst):\n    \"\"\"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.\n    \n\n    Ví dụ\n    solution([5, 8, 7, 1]) ==> 12\n    solution([3, 3, 3, 3, 3]) ==> 9\n    solution([30, 13, 24, 321]) ==>0\n    \"\"\""]}
{"text": ["def add_elements(arr, k):\n    \"\"\"\n    Cho một mảng không rỗng các số nguyên arr và một số nguyên k, trả về\n    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.\n\n    Ví dụ:\n\n        Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n        Đầu ra: 24 # tổng của 21 + 3\n\n    Điều kiện:\n        1. 1 <= len(arr) <= 100\n        2. 1 <= k <= len(arr)\n    \"\"\"", "def add_elements(arr, k):\n    \"\"\"\n    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ề\n    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.\n\n    Ví dụ:\n\n    Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n    Đầu ra: 24 # sum of 21 + 3\n\n    Ràng buộc:\n        1. 1 <= len(arr) <= 100\n        2. 1 <= k <= len(arr)\n    \"\"\"", "def add_elements(arr, k):\n    \"\"\"\n    Cho một mảng arr không rỗng chứa các số nguyên và một số nguyên k,\n    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.\n\n    Ví dụ:\n\n        Đầu vào: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n        Đầu ra: 24 # tổng của 21 + 3\n\n    Điều kiện ràng buộc:\n        1. 1 <= len(arr) <= 100\n        2. 1 <= k <= len(arr)\n    \"\"\""]}
{"text": ["def get_odd_collatz(n):\n    \"\"\"\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.\n\n    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\n    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ừ \n    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 \n    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\n    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.\n\n    Lưu ý:\n        1. Collatz(1) là [1].\n        2. Danh sách trả về được sắp xếp theo thứ tự tăng dần.\n\n    Ví dụ:\n    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.\n    \"\"\"", "def get_odd_collatz(n):\n    \"\"\"\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. \n\n    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    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 \n    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 \n    là gì, dãy số sẽ luôn đạt đến 1.\n\n    Lưu ý: \n        1. Collatz(1) là [1].\n        2. danh sách trả về được sắp xếp theo thứ tự tăng dần. \n\n    Ví dụ:\n    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.\n    \"\"\"", "def get_odd_collatz(n):\n    \"\"\"\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.\n\n    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\n    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ừ\n    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    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ị \n    của n là gì, dãy số sẽ luôn luôn đạt đến 1.\n\n    Lưu ý: \n        1. Collatz(1) là [1].\n        2. danh sách trả về sẽ được sắp xếp theo thứ tự tăng dần.\n\n    Ví dụ:\n    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.\n    \"\"\""]}
{"text": ["def valid_date(date):\n    \"\"\"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.\n    Để ngày hợp lệ, tất cả các quy tắc sau phải được thỏa mãn:\n    1. Chuỗi ngày không được rỗng.\n    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.\n    3. Các tháng không được nhỏ hơn 1 hoặc lớn hơn 12.\n    4. Ngày phải có định dạng sau: mm-dd-yyyy\n\n    Ví dụ: \n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n\n    valid_date('06/04/2020') => False\n    \"\"\"", "def valid_date(date):\n    \"\"\"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.\n    Để ngày hợp lệ, tất cả các quy tắc sau phải được thỏa mãn:\n    1. Chuỗi ngày không được rỗng.\n    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.\n    3. Tháng không được nhỏ hơn 1 hoặc lớn hơn 12.\n    4. Ngày phải có định dạng sau: mm-dd-yyyy\n\n    Ví dụ: \n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n\n    valid_date('06/04/2020') => False\n    \"\"\"", "def valid_date(date):\n    \"\"\"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à\n    trả về True nếu ngày hợp lệ, ngược lại trả về False.\n    Ngày là hợp lệ nếu tất cả các quy tắc sau được thỏa mãn:\n    1. Chuỗi ngày tháng không được rỗng.\n    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.\n    3. Tháng không được ít hơn 1 hoặc vượt quá 12.\n    4. Ngày phải theo định dạng: mm-dd-yyyy\n\n    Ví dụ: \n    valid_date('03-11-2000') => True\n\n    valid_date('15-01-2012') => False\n\n    valid_date('04-0-2040') => False\n\n    valid_date('06-04-2020') => True\n\n    valid_date('06/04/2020') => False\n    \"\"\""]}
{"text": ["def split_words(txt):\n    '''\n    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,\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\n    Ví dụ\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3 \n    '''", "def split_words(txt):\n    '''\n    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\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\n    bảng chữ cái, ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n    Ví dụ\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3 \n    '''", "def split_words(txt):\n    '''\n    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,\n    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\n    bảng chữ cái, ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n    Ví dụ:\n    split_words(\"Hello world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"Hello,world!\") ➞ [\"Hello\", \"world!\"]\n    split_words(\"abcdef\") == 3 \n    '''"]}
{"text": ["def is_sorted(lst):\n    '''\n    Đượ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    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.\n\n    Ví dụ\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''", "def is_sorted(lst):\n    '''\n    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.\n\n    Ví dụ\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''", "def is_sorted(lst):\n    '''\n    Cho một danh sách các số, trả về kết quả xem chúng có được sắp xếp\n    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\n    cùng một số, trả về False. Giả sử không có số âm và chỉ chứa số nguyên.\n\n    Ví dụ\n    is_sorted([5]) ➞ True\n    is_sorted([1, 2, 3, 4, 5]) ➞ True\n    is_sorted([1, 3, 2, 4, 5]) ➞ False\n    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True\n    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True\n    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False\n    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True\n    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False\n    '''"]}
{"text": ["def intersection(interval1, interval2):\n    \"\"\"Bạn được cho hai khoảng,\n    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).\n    Các khoảng đã cho là đóng, nghĩa là khoảng (bắt đầu, kết thúc)\n    bao gồm cả bắt đầu và kết thúc.\n    Đố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ó.\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\n    có phải là số nguyên tố hay không.\n    Ví dụ, giao điểm của các khoảng (1, 3), (2, 4) là (2, 3)\n    có độ dài là 1, không phải là số nguyên tố.\n    Nếu độ dài giao điểm là số nguyên tố, trả về \"YES\",\n    nếu không, trả về \"NO\".\n    Nếu hai khoảng không giao nhau, trả về \"NO\".\n\n\n    [input/output] mẫu:\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    \"\"\"", "def intersection(interval1, interval2):\n    \"\"\"Bạn được cung cấp hai khoảng,\n    trong đó mỗi khoảng là một cặp số nguyên. Ví dụ, interval = (start, end) = (1, 2).\n    Các khoảng đã cho là đóng, nghĩa là khoảng(start, end)\n    bao gồm cả bắt đầu và kết thúc.\n    Đố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ó.\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\n    có phải là số nguyên tố hay không.\n    Ví dụ, giao điểm của các khoảng (1, 3), (2, 4) là (2, 3)\n    có độ dài là 1, không phải là số nguyên tố.\n    Nếu độ dài giao điểm là số nguyên tố, hãy trả về \"YES\",\n    nếu không, hãy trả về \"NO\".\n    Nếu hai khoảng không giao nhau, hãy trả về \"NO\".\n\n    [đầu vào/đầu ra] mẫu:\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    \"\"\"", "def intersection(interval1, interval2):\n    \"\"\"Hai khoảng được cho,\n    mỗi khoảng là một cặp số nguyên. Ví dụ, interval = (start, end) = (1, 2).\n    Các khoảng cho trước là khoảng đóng, khoảng (start, end) bao gồm\n    cả start và end.\n    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.\n    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.\n    Ví dụ, giao của khoảng (1, 3), (2, 4) là (2, 3) và\n    độ dài của nó là 1, không phải là số nguyên tố.\n    Nếu độ dài giao là số nguyên tố, trả về \"YES\",\n    nếu không, trả về \"NO\".\n    Nếu hai khoảng không giao nhau, trả về \"NO\".\n\n\n    [input/output] ví dụ:\n    intersection((1, 2), (2, 3)) ==> \"NO\"\n    intersection((-1, 1), (0, 4)) ==> \"NO\"\n    intersection((-3, -1), (-5, 5)) ==> \"YES\"\n    \"\"\""]}
{"text": ["def prod_signs(arr):\n    \"\"\"\n    Bạn được cho một mảng arr gồm các số nguyên và bạn cần trả về\n    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,\n    dấu được biểu diễn bởi 1, -1 hoặc 0.\n    Lưu ý: trả về None nếu arr là mảng rỗng.\n\n    Ví dụ:\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\"", "def prod_signs(arr):\n    \"\"\"\n    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.\n    Lưu ý: Trong trường hợp mảng rỗng, trả về None.\n\n    Ví dụ:\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\"", "def prod_signs(arr):\n    \"\"\"\n    Bạn được cho một mảng arr gồm các số nguyên và bạn cần trả về\n    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\n    của mỗi số trong mảng, được biểu thị bằng 1, -1 hoặc 0.\n    Lưu ý: trả về None cho arr rỗng.\n\n    Ví dụ:\n    >>> prod_signs([1, 2, 2, -4]) == -9\n    >>> prod_signs([0, 1]) == 0\n    >>> prod_signs([]) == None\n    \"\"\""]}
{"text": ["def minPath(grid, k):\n    \"\"\"\n    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, \n    mỗi ô trong lưới chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * 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.\n\n    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\n    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    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.\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).\n    Bạn KHÔNG ĐƯỢC đi ra ngoài lưới.\n    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\n    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),\n    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)\n    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].\n    Đảm bảo rằng kết quả là duy nhất.\n    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.\n\n    Ví dụ:\n\n        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n        Output: [1, 2, 1]\n\n        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n        Output: [1]\n    \"\"\"", "def minPath(grid, k):\n    \"\"\"\n    Cho một bảng có N hàng và N cột (N >= 2) và một số nguyên dương k, \n    mỗi ô của bảng chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * N]\n    bao gồm xuất hiện đúng một lần trên các ô của bảng.\n\n    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\n    đầ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    nói cách khác, bạn có thể đến các ô có chung cạnh với ô\n    hiện tại.\n    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\n    nhất thiết phải khác biệt).\n    Bạn KHÔNG THỂ ra khỏi bảng.\n    Đường đi A (có độ dài k) được coi là nhỏ hơn đường đi B (có độ dài k) nếu\n    sau khi tạo danh sách có thứ tự các giá trị trên các ô mà A và B đi qua\n    (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\n    cách khác, tồn tại một chỉ số nguyên i (1 <= i <= k)\n    sao cho lst_A[i] < lst_B[i] và với bất kỳ j nào (1 <= j < i) thì ta có\n    lst_A[j] = lst_B[j].\n    Đảm bảo rằng câu trả lời là duy nhất.\n    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.\n\n    Ví dụ:\n\n        Đầu vào: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n        Đầu ra: [1, 2, 1]\n\n        Đầu vào: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n        Đầu ra: [1]\n    \"\"\"", "def minPath(grid, k):\n    \"\"\"\n    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, \n    mỗi ô trong lưới chứa một giá trị. Mỗi số nguyên trong phạm vi [1, N * N] \n    xuất hiện chính xác một lần trong các ô của lưới.\n\n    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 \n    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, \n    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.\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 \n    nhất thiết là các ô khác nhau).\n    Bạn KHÔNG THỂ ra ngoài lưới.\n\n    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    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à \n    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 \n    một chỉ số nguyên i (1 <= i <= k) sao cho lst_A[i] < lst_B[i] và với mọi \n    chỉ số j (1 <= j < i) chúng ta có lst_A[j] = lst_B[j].\n    Đảm bảo rằng kết quả là duy nhất.\n    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.\n\n    Ví dụ:\n\n        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n        Output: [1, 2, 1]\n\n        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n        Output: [1]\n    \"\"\""]}
{"text": ["def tri(n):\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.\n    Tuy nhiên, điều mà mọi người ít biết đến là dãy số Tribonacci.\n    Dãy số Tribonacci được định nghĩa bằng công thức truy hồi sau:\n    tri(1) = 3\n    tri(n) = 1 + n / 2, khi n là số chẵn.\n    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), khi n là số lẻ.\n    \n    Ví dụ:\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n           = 2 + 3 + 3 = 8 \n    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).\n\n    Ví dụ:\n    tri(3) = [1, 3, 2, 8]\n    \"\"\"", "def tri(n):\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\n    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.\n    Dãy số Tribonacci được xác định bằng phép lặp lại:\n    tri(1) = 3\n    tri(n) = 1 + n / 2, if n is even.\n    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.\n    Ví dụ:\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n           = 2 + 3 + 3 = 8 \n    Cho một số nguyên không âm n, hãy trả về danh sách gồm \n    số n + 1 đầu tiên của dãy số Tribonacci.\n    Ví dụ:\n    tri(3) = [1, 3, 2, 8]\n    \"\"\"", "def tri(n):\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 \n    vài thế kỷ qua. Tuy nhiên, ít người biết đến dãy số Tribonacci.\n    Dãy số Tribonacci được định nghĩa bởi công thức đệ quy:\n    tri(1) = 3\n    tri(n) = 1 + n / 2, nếu n là số chẵn.\n    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), nếu n là số lẻ.\n    Ví dụ:\n    tri(2) = 1 + (2 / 2) = 2\n    tri(4) = 3\n    tri(3) = tri(2) + tri(1) + tri(4)\n           = 2 + 3 + 3 = 8\n    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\n    có chỉ số từ 0 đến n.\n    Ví dụ:\n    tri(3) = [1, 3, 2, 8]\n    \"\"\""]}
{"text": ["def digits(n):\n    \"\"\"Cho một số nguyên dương n, trả về tích của các chữ số lẻ.\n    Trả về 0 nếu tất cả các chữ số đều là chẵn.\n    Ví dụ:\n    digits(1)  == 1\n    digits(4)  == 0\n    digits(235) == 15\n    \"\"\"", "def digits(n):\n    \"\"\"Cho một số nguyên dương n, trả về tích của các chữ số lẻ.\n    Trả về 0 nếu tất cả các chữ số đều chẵn.\n    Ví dụ:\n    digits(1)  == 1\n    digits(4)  == 0\n    digits(235) == 15\n    \"\"\"", "def digits(n):\n    \"\"\"Cho một số nguyên dương n, trả về tích của các chữ số lẻ.\n    Trả về 0 nếu tất cả các chữ số đều là số chẵn.\n    Ví dụ:\n    digits(1)  == 1\n    digits(4)  == 0\n    digits(235) == 15\n    \"\"\""]}
{"text": ["def is_nested(string):\n    '''\n    Tạo một hàm nhận vào một chuỗi chỉ chứa dấu ngoặc vuông.\n    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 \n    trong đó ít nhất một dấu ngoặc là lồng nhau.\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''", "def is_nested(string):\n    '''\n    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.\n    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\n    trong đó có ít nhất một dấu ngoặc trong chuỗi con được lồng vào nhau.\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''", "def is_nested(string):\n    '''\n    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.\n    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 \n    mà trong đó ít nhất một dấu ngoặc được lồng nhau.\n\n    is_nested('[[]]') ➞ True\n    is_nested('[]]]]]]][[[[[]') ➞ False\n    is_nested('[][]') ➞ False\n    is_nested('[]') ➞ False\n    is_nested('[[][]]') ➞ True\n    is_nested('[[]][[') ➞ True\n    '''"]}
{"text": ["def sum_squares(lst):\n    \"\"\"Bạn được cung cấp một danh sách các số.\n    Bạn cần trả về tổng của các số bình phương trong danh sách đã cho,\n    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).\n    Ví dụ:\n    Với lst = [1,2,3] kết quả trả về sẽ là 14\n    Với lst = [1,4,9] kết quả trả về sẽ là 98\n    Với lst = [1,3,5,7] kết quả trả về sẽ là 84\n    Với lst = [1.4,4.2,0] kết quả trả về sẽ là 29\n    Với lst = [-2.4,1,1] kết quả trả về sẽ là 6\n    \n\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"Một danh sách các số được đưa ra.\n    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.\n    Ví dụ:\n    lst = [1,2,3] thì đầu ra phải là 14.\n    lst = [1,4,9] thì đầu ra phải là 98.\n    lst = [1,3,5,7] thì đầu ra phải là 84.\n    lst = [1.4,4.2,0] thì đầu ra phải là 29.\n    lst = [-2.4,1,1] thì đầu ra phải là 6.\n    \n\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"Cho một danh sách các số.\n    Bạn cần trả về tổng của bình phương các số trong danh sách đã cho,\n    làm tròn từng phần tử trong danh sách đã cho đến upper int(Ceiling) trước.\n    Ví dụ:\n    lst = [1,2,3] thì đầu ra phải là 14\n    lst = [1,4,9] thì đầu ra phải là 98\n    lst = [1,3,5,7] thì đầu ra phải là 84\n    lst = [1.4,4.2,0] thì đầu ra phải là 29\n    lst = [-2.4,1,1] thì đầu ra phải là 6\n    \n\n    \"\"\""]}
{"text": ["def check_if_last_char_is_a_letter(txt):\n    '''\n    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\n    và không phải là một phần của từ.\n    Nếu không, trả về False.\n    Lưu ý: \"từ\" là nhóm ký tự được phân tách bằng khoảng trắng.\n\n    Ví dụ:\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False \n    '''", "def check_if_last_char_is_a_letter(txt):\n    '''\n    Tạo một hàm trả về True nếu ký tự cuối cùng\n    của một chuỗi đã cho là ký tự chữ cái và không phải là\n    một phần của một từ, và False nếu không.\n    Lưu ý: \"từ\" là một nhóm ký tự được phân tách bằng dấu cách.\n\n    Ví dụ:\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False \n    '''", "def check_if_last_char_is_a_letter(txt):\n    '''\n    Tạo một hàm trả về True nếu ký tự cuối cùng\n    của chuỗi đầu vào là một ký tự chữ cái và không\n    thuộc một từ, và trả về False nếu không phải.\n    Lưu ý: \"từ\" là một nhóm các ký tự được ngăn cách bằng dấu cách.\n\n    Ví dụ:\n    check_if_last_char_is_a_letter(\"apple pie\") ➞ False\n    check_if_last_char_is_a_letter(\"apple pi e\") ➞ True\n    check_if_last_char_is_a_letter(\"apple pi e \") ➞ False\n    check_if_last_char_is_a_letter(\"\") ➞ False \n    '''"]}
{"text": ["def can_arrange(arr):\n    \"\"\"Tạo một hàm trả về chỉ số lớn nhất của một phần tử mà\n    không lớn hơn hoặc bằng phần tử ngay trước đó. Nếu\n    không có phần tử nào như vậy, trả về -1. Mảng đã cho sẽ không chứa\n    các giá trị trùng lặp.\n\n    Ví dụ:\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\"", "def can_arrange(arr):\n    \"\"\"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    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.\n\n    Ví dụ:\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\"", "def can_arrange(arr):\n    \"\"\"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ó\n    trong mảng đã cho. Nếu không tồn tại phần tử như vậy, trả về -1.\n    Mảng đã cho không chứa các giá trị trùng lặp.\n\n    Ví dụ:\n    can_arrange([1,2,4,3,5]) = 3\n    can_arrange([1,2,3]) = -1\n    \"\"\""]}
{"text": ["def largest_smallest_integers(lst):\n    '''\n    Tạo một hàm trả về một tuple (a, b), trong đó 'a' là\n    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    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.\n\n    Ví dụ:\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''", "def largest_smallest_integers(lst):\n    '''\n    Tạo một hàm trả về một tuple (a, b), trong đó 'a' là\n    số nguyên âm lớn nhất và 'b' là số nguyên dương \n    nhỏ nhất trong một danh sách.\n    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.\n\n    Ví dụ:\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''", "def largest_smallest_integers(lst):\n    '''\n    Tạo một hàm trả về một bộ đôi (a, b), trong đó 'a' là\n    số nguyên âm lớn nhất, và 'b' là số nguyên dương nhỏ nhất\n    trong danh sách.\n    Nếu không có số nguyên âm hoặc số nguyên dương, trả về None cho chúng.\n\n    Ví dụ:\n    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n    largest_smallest_integers([]) == (None, None)\n    largest_smallest_integers([0]) == (None, None)\n    '''"]}
{"text": ["def compare_one(a, b):\n    \"\"\"\n    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\n    cho các số thực, và trả về biến lớn hơn trong kiểu biến đã cho.\n    Trả về None nếu các giá trị bằng nhau.\n    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.\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\"", "def compare_one(a, b):\n    \"\"\"\n    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\n    cho các số thực, và trả về giá trị lớn hơn trong loại biến đã cho.\n    Trả về None nếu các giá trị bằng nhau.\n    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 ,\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\"", "def compare_one(a, b):\n    \"\"\"\n    Tạo một hàm lấy số nguyên, số thực hoặc chuỗi biểu thị\n    số thực và trả về biến lớn hơn trong kiểu biến đã cho.\n    Trả về None nếu các giá trị bằng nhau.\n    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 ,\n\n    compare_one(1, 2.5) ➞ 2.5\n    compare_one(1, \"2,3\") ➞ \"2,3\"\n    compare_one(\"5,1\", \"6\") ➞ \"6\"\n    compare_one(\"1\", 1) ➞ None\n    \"\"\""]}
{"text": ["def is_equal_to_sum_even(n):\n    \"\"\"Đá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.\n    Ví dụ:\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\"", "def is_equal_to_sum_even(n):\n    \"\"\"Đá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\n    Ví dụ\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\"", "def is_equal_to_sum_even(n):\n    \"\"\"Đá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\n    Example\n    is_equal_to_sum_even(4) == False\n    is_equal_to_sum_even(6) == False\n    is_equal_to_sum_even(8) == True\n    \"\"\""]}
{"text": ["def special_factorial(n):\n    \"\"\"Giai thừa Brazil được định nghĩa như sau:\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    trong đó n > 0\n\n    Ví dụ:\n    >>> special_factorial(4)\n    288\n\n    Hàm sẽ nhận một số nguyên làm đầu vào và trả về giai thừa đặc biệt\n    của số nguyên này.\n    \"\"\"", "def special_factorial(n):\n    \"\"\"Giai thừa Brazil được định nghĩa là:\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    trong đó n > 0\n\n    Ví dụ:\n    >>> special_factorial(4)\n    288\n\n    Hàm sẽ nhận một số nguyên làm đầu vào và sẽ trả về giai thừa \n    đặc biệt của số nguyên này.\n    \"\"\"", "def special_factorial(n):\n    \"\"\"Giai thừa Brazil được định nghĩa như sau:\n    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n    với n > 0\n\n    Ví dụ:\n    >>> special_factorial(4)\n    288\n\n    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.\n    \"\"\""]}
{"text": ["def fix_spaces(text):\n    \"\"\"\n    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,\n    và nếu một chuỗi có nhiều hơn 2 khoảng trắng liên tiếp,\n    thì thay thế tất cả các khoảng trắng liên tiếp bằng -\n\n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example   3\") == \"_Example-3\"\n    \"\"\"", "def fix_spaces(text):\n    \"\"\"\n    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, \n    và nếu chuỗi có hơn 2 khoảng trắng liên tiếp, \n    thì thay thế tất cả các khoảng trắng liên tiếp bằng dấu gạch nối.\n    \n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example   3\") == \"_Example-3\"\n    \"\"\"", "def fix_spaces(text):\n    \"\"\"\n    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, \n    và nếu chuỗi có hơn 2 khoảng trắng liên tiếp. \n    thì thay thế tất cả các khoảng trắng liên tiếp bằng dấu gạch ngang. \n    \n    fix_spaces(\"Example\") == \"Example\"\n    fix_spaces(\"Example 1\") == \"Example_1\"\n    fix_spaces(\" Example 2\") == \"_Example_2\"\n    fix_spaces(\" Example   3\") == \"_Example-3\"\n    \"\"\""]}
{"text": ["def file_name_check(file_name):\n    \"\"\"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ề\n    'Yes' nếu tên tệp hợp lệ, và trả về 'No' nếu không hợp lệ.\n    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:\n    - Tên tệp không được chứa quá ba chữ số ('0'-'9').\n    - Tên tệp chứa đúng một dấu chấm '.'.\n    - 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').\n    - Phần chuỗi sau dấu chấm phải là một trong các từ sau: ['txt', 'exe', 'dll']\n    Ví dụ:\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No' (tên phải bắt đầu bằng một chữ cái Latinh)\n    \"\"\"", "def file_name_check(file_name):\n    \"\"\"Tạo một hàm lấy một chuỗi biểu diễn tên tệp và trả về\n    'Yes' nếu tên tệp hợp lệ và trả về 'No' nếu không.\n    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\n    được đáp ứng:\n    - Không được có quá ba chữ số ('0'-'9') trong tên tệp.\n    - Tên tệp chỉ chứa đúng một dấu chấm '.'\n    - 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ừ\n    chữ cái latinh ('a'-'z' và 'A'-'Z').\n    - Chuỗi con sau dấu chấm phải là một trong những chuỗi sau: ['txt', 'exe', 'dll']\n    Ví dụ:\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No' (tên phải bắt đầu bằng một chữ cái latinh)\n    \"\"\"", "def file_name_check(file_name):\n    \"\"\"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'.\n    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:\n    - Tên tệp không được có nhiều hơn ba chữ số ('0'-'9').\n    - Tên tệp phải chứa chính xác một dấu chấm '.'.\n    - 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').\n    - Phần chuỗi con sau dấu chấm phải là một trong các giá trị sau: ['txt', 'exe', 'dll']\n    Ví dụ:\n    file_name_check(\"example.txt\") # => 'Yes'\n    file_name_check(\"1example.dll\") # => 'No' (Tên phải bắt đầu bằng chữ cái Latin)\n    \"\"\""]}
{"text": ["def sum_squares(lst):\n    \"\"\"\"\n    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, \n    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ố \n    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ử.\n    \n    Ví dụ:\n    Với lst = [1,2,3]  thì đầu ra phải là 6\n    Với lst = [] thì đầu ra phải là 0\n    Với lst = [-1,-5,2,-1,-5]  thì đầu ra phải là -126\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"\"\n    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à \n    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\n    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.\n    Ví dụ:\n    For lst = [1,2,3] the output should be 6\n    For lst = []  the output should be 0\n    For lst = [-1,-5,2,-1,-5]  the output should be -126\n    \"\"\"", "def sum_squares(lst):\n    \"\"\"\"\n    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.\n\n    Ví dụ:\n    Đối với lst = [1,2,3], đầu ra phải là 6\n    Đối với lst = [], đầu ra phải là 0\n    Đối với lst = [-1,-5,2,-1,-5], đầu ra phải là -126\n    \"\"\""]}
{"text": ["def words_in_sentence(sentence):\n    \"\"\"\n    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ả \n    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 \n    chuỗi gốc.\n\n    Ví dụ 1:\n        Đầu vào: sentence = \"This is a test\"\n        Đầu ra: \"is\"\n\n    Ví dụ 2:\n        Đầu vào: sentence = \"lets go for swimming\"\n        Đầu ra: \"go for\"\n\n    Điều kiện ràng buộc:\n        * 1 <= len(sentence) <= 100\n        * sentence chỉ bao gồm các chữ cái\n    \"\"\"", "def words_in_sentence(sentence):\n    \"\"\"\n    Bạn được cho một chuỗi đại diện cho một câu,\n    câu chứa một số từ được phân cách bằng dấu cách,\n    và bạn phải trả về một chuỗi chứa các từ trong câu gốc, \n    có độ dài là số nguyên tố,\n    thứ tự của các từ trong chuỗi mới phải giống với chuỗi gốc.\n\n    Ví dụ 1:\n        Đầu vào: sentence = \"This is a test\"\n        Đầu ra: \"is\"\n\n    Ví dụ 2:\n        Đầu vào: sentence = \"lets go for swimming\"\n        Đầu ra: \"go for\"\n\n    Giới hạn:\n        * 1 <= len(sentence) <= 100\n        * câu chỉ chứa các chữ cái\n    \"\"\"", "def words_in_sentence(sentence):\n    \"\"\"\n    Bạn được cung cấp một chuỗi biểu diễn một câu,\n    câu này chứa một số từ được phân cách bằng dấu cách,\n    và bạn phải trả về một chuỗi chứa các từ trong câu gốc,\n    có độ dài là số nguyên tố,\n    thứ tự các từ trong chuỗi mới phải giống với chuỗi ban đầu.\n\n    Ví dụ 1:\n        Đầu vào: sentence = \"This is a test\"\n        Đầu ra: \"is\"\n\n    Ví dụ 2:\n        Đầu vào: sentence = \"lets go for swimming\"\n        Đầu ra: \"go for\"\n\n    Ràng buộc:\n        * 1 <= len(sentence) <= 100\n        * sentence chỉ chứa các chữ cái.\n    \"\"\""]}
{"text": ["def simplify(x, n):\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.\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.\n    x và n đều là biểu diễn chuỗi của phân số, có định dạng như sau:\n    <tử số>/<mẫu số> trong đó tử số và mẫu số đều là số nguyên dương.\n\n    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.\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\"", "def simplify(x, n):\n    \"\"\"\"Nhiệm vụ của bạn là triển khai một hàm để đơn giản hóa biểu thức\n    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.\n    Cả x và n đều là chuỗi đại diện cho một phân số, có định dạng là\n    <tử số>/<mẫu số> trong đó cả tử số và mẫu số đều là số nguyên dương.\n\n    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.\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\"", "def simplify(x, n):\n    \"\"\"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\n    x * n. Hàm trả về True nếu x * n tính ra một số nguyên và False\n    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:\n    <tử số>/<mẫu số> trong đó cả tử số và mẫu số đều là các số nguyên dương.\n\n    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.\n\n    simplify(\"1/5\", \"5/1\") = True\n    simplify(\"1/6\", \"2/1\") = False\n    simplify(\"7/10\", \"10/2\") = False\n    \"\"\""]}
{"text": ["def order_by_points(nums):\n    \"\"\"\n    Viết một hàm sắp xếp danh sách các số nguyên đã cho\n    theo thứ tự tăng dần theo tổng các chữ số của chúng.\n    Lưu ý: nếu có một số mục có tổng các chữ số tương tự nhau,\n    hãy sắp xếp chúng dựa trên chỉ số của chúng trong danh sách gốc.\n\n    Ví dụ:\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\"", "def order_by_points(nums):\n    \"\"\"\n    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\n    dựa trên tổng các chữ số của chúng.\n    Lưu ý: nếu có nhiều phần tử có tổng chữ số giống nhau,\n    hãy sắp xếp chúng theo chỉ số của chúng trong danh sách ban đầu.\n\n    Ví dụ:\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\"", "def order_by_points(nums):\n    \"\"\"\n    Viết một hàm sắp xếp danh sách các số nguyên đã cho\n    theo thứ tự tăng dần theo tổng các chữ số của chúng.\n    Lưu ý: nếu có một số mục có tổng các chữ số tương tự nhau,\n    hãy sắp xếp chúng dựa trên chỉ số của chúng trong danh sách gốc.\n    Ví dụ:\n    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n    >>> order_by_points([]) == []\n    \"\"\""]}
{"text": ["def specialFilter(nums):\n    \"\"\"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 \n    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).\n    Ví dụ:\n    specialFilter([15, -73, 14, -15]) => 1 \n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\"", "def specialFilter(nums):\n    \"\"\"Viết một hàm nhận vào một mảng số và trả về \n    số lượng phần tử trong mảng thỏa mãn hai điều kiện là lớn hơn 10 và cả \n    chữ số đầu tiên và chữ số cuối cùng của số đó đều là số lẻ (1, 3, 5, 7, 9).\n    Ví dụ:\n    specialFilter([15, -73, 14, -15]) => 1 \n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\"", "def specialFilter(nums):\n    \"\"\"Viết một hàm lấy một mảng số làm đầu vào và trả về\n    số phần tử trong mảng lớn hơn 10 và cả\n    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).\n    Ví dụ:\n    specialFilter([15, -73, 14, -15]) => 1 \n    specialFilter([33, -2, -3, 45, 21, 109]) => 2\n    \"\"\""]}
{"text": ["def get_max_triples(n):\n    \"\"\"\n    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.\n    Với mỗi i (1 ≤ i ≤ n), giá trị của a[i] = i * i - i + 1.\n    Trả về số bộ ba (a[i], a[j], a[k]) của a trong đó i < j < k,\n    và a[i] + a[j] + a[k] là bội số của 3.\n\n    Ví dụ:\n    Đầu vào: n = 5\n    Đầu ra: 1\n    Giải thích:\n    a = [1, 3, 7, 13, 21]\n    Bộ ba hợp lệ duy nhất là (1, 7, 13).\n    \"\"\"", "def get_max_triples(n):\n    \"\"\"\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.\n        Đối với mỗi i (1 ≤ i ≤ n), giá trị của a[i] = i * i - i + 1.\n        Trả về số lượng bộ ba (a[i], a[j], a[k]) của a sao cho i < j < k,\n    và a[i] + a[j] + a[k] là bội của 3.\n\n    Ví dụ:\n        Input: n = 5\n        Output: 1\n        Giải thích:\n        a = [1, 3, 7, 13, 21]\n        Bộ ba hợp lệ duy nhất là (1, 7, 13).\n    \"\"\"", "def get_max_triples(n):\n    \"\"\"\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.\n        Với mỗi i (1 ≤ i ≤ n), giá trị của a[i] là i * i - i + 1.\n        Trả về số lượng bộ ba (a[i], a[j], a[k]) trong a với i < j < k.\n        Và a[i] + a[j] + a[k] là bội số của 3.\n\n    Ví dụ:\n        Đầu vào: n = 5\n        Đầu ra: 1\n        Giải thích: \n        a = [1, 3, 7, 13, 21]\n        Bộ ba hợp lệ duy nhất là (1, 7, 13).\n    \"\"\""]}
{"text": ["def bf(planet1, planet2):\n    '''\n    Hệ mặt trời có tám hành tinh: gần mặt trời nhất là Sao Thủy,\n    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.\n    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.\n    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,\n    được sắp xếp theo thứ tự gần mặt trời nhất.\n    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.\n    Ví dụ\n    bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n    bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n    bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n    '''", "def bf(planet1, planet2):\n    '''\n    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\n    là Sao Thủy, tiếp theo là Sao Kim, sau đó là Trái Đất, Sao Hỏa, Sao Mộc, Sao Thổ,\n    Sao Thiên Vương, Sao Hải Vương.\n    Viết một hàm lấy hai tên hành tinh dưới dạng chuỗi planet1 và planet2.\n    Hàm này sẽ trả về một bộ chứa tất cả các hành tinh có quỹ đạo\n    nằm giữa quỹ đạo của planet1 và quỹ đạo của planet2, được sắp xếp theo\n    khoảng cách đến Mặt trời.\n    Hàm này sẽ trả về một bộ rỗng nếu planet1 hoặc planet2\n    không phải là tên hành tinh chính xác.\n    Ví dụ\n    bf(\"Sao Mộc\", \"Sao Hải Vương\") ==> (\"Sao Thổ\", \"Sao Thiên Vương\")\n    bf(\"Trái Đất\", \"Sao Thủy\") ==> (\"Sao Kim\")\n    bf(\"Sao Thủy\", \"Sao Thiên Vương\") ==> (\"Sao Kim\", \"Trái Đất\", \"Sao Hỏa\", \"Sao Mộc\", \"Sao Thổ\")\n    '''", "def bf(planet1, planet2):\n    '''\n    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 \n    là Sao Thủy, tiếp theo là Sao Kim, rồi đến Trái Đất, Sao Hỏa, Sao Mộc, Sao Thổ, \n    Sao Thiên Vương, và Sao Hải Vương.\n    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. \n    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 \n    quỹ đạo của planet1 và quỹ đạo của planet2, được sắp xếp theo độ gần Mặt Trời.\n    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ệ.\n    Ví dụ:\n    bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n    bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n    bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n    '''"]}
{"text": ["def sorted_list_sum(lst):\n    \"\"\"Viết một hàm nhận một danh sách các chuỗi làm tham số,\n    xóa các chuỗi có độ dài lẻ,\n    và trả về danh sách kết quả theo thứ tự đã sắp xếp,\n    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ố\n    và nó có thể chứa các bản sao.\n    Thứ tự của danh sách phải tăng dần theo độ dài của mỗi từ và\n    phải trả về danh sách được sắp xếp theo quy tắc đó.\n    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.\n    Hàm phải trả về danh sách các chuỗi theo thứ tự đã sắp xếp.\n    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.\n    Ví dụ:\n    assert sorted_list_sum([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    assert sorted_list_sum([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\"", "def sorted_list_sum(lst):\n    \"\"\"Viết một hàm chấp nhận một danh sách các chuỗi làm tham số,\n    xóa các chuỗi có độ dài lẻ khỏi nó,\n    và trả về danh sách kết quả với thứ tự đã sắp xếp,\n    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ố,\n    và nó có thể chứa các bản sao.\n    Thứ tự của danh sách phải tăng dần theo độ dài của mỗi từ và bạn\n    phải trả về danh sách được sắp xếp theo quy tắc đó.\n    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.\n    Hàm phải trả về danh sách các chuỗi theo thứ tự đã sắp xếp.\n    Bạn có thể cho rằng tất cả các từ sẽ có cùng độ dài.\n    Ví dụ:\n    assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\"", "def sorted_list_sum(lst):\n    \"\"\"Viết một hàm nhận một danh sách các chuỗi làm tham số,\n    xóa các chuỗi có độ dài lẻ khỏi danh sách,\n    và trả về danh sách kết quả đã được sắp xếp,\n    Danh sách luôn là danh sách các chuỗi  không phải là mảng số,\n    và có thể chứa các phần tử trùng lặp.\n    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\n    cần trả về danh sách đã sắp xếp theo quy tắc đó.\n    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.\n    Hàm phải trả về một danh sách các chuỗi theo thứ tự đã sắp xếp.\n    Có thể giả định rằng độ dài của tất cả các từ là như nhau.\n    Ví dụ:\n    assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n    assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n    \"\"\""]}
{"text": ["def x_or_y(n, x, y):\n    \"\"\"Một chương trình đơn giản, sẽ trả về giá trị của x nếu n là \n    một số nguyên tố và sẽ trả về giá trị của y nếu không phải.\n\n    Ví dụ:\n    cho x_or_y(7, 34, 12) == 34\n    cho x_or_y(15, 8, 5) == 5\n    \n    \"\"\"", "def x_or_y(n, x, y):\n    \"\"\"Một chương trình đơn giản, trả về giá trị của x nếu n là số nguyên tố,\n    và trả về giá trị của y nếu không phải số nguyên tố.\n\n    Ví dụ:\n    for x_or_y(7, 34, 12) == 34\n    for x_or_y(15, 8, 5) == 5\n    \n    \"\"\"", "def x_or_y(n, x, y):\n    \"\"\"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.\n\n    Ví dụ:\n    for x_or_y(7, 34, 12) == 34\n    for x_or_y(15, 8, 5) == 5\n    \n    \"\"\""]}
{"text": ["def double_the_difference(lst):\n    '''\n    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.\n    Bỏ qua các số âm hoặc không phải là số nguyên.\n\n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n\n    Nếu danh sách đầu vào rỗng, trả về 0.\n    '''", "def double_the_difference(lst):\n    '''\n    Trả về tổng bình phương của các số lẻ trong danh sách số đã cho.\n    Bỏ qua các số âm hoặc không phải số nguyên.\n    \n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n    \n    Nếu danh sách đầu vào trống, trả về 0.\n    '''", "def double_the_difference(lst):\n    '''\n    Cho một danh sách các số, trả về tổng bình phương của các số\n    trong danh sách là số lẻ. Bỏ qua các số âm hoặc không phải là số nguyên.\n    \n    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n    double_the_difference([-1, -2, 0]) == 0\n    double_the_difference([9, -2]) == 81\n    double_the_difference([0]) == 0  \n   \n    Nếu danh sách đầu vào rỗng, trả về 0.\n    '''"]}
{"text": ["def compare(game, guess):\n    \"\"\"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. \n    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.\n    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.\n    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.\n    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    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ố.\n    \n    \n    ví dụ:\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    \"\"\"", "def compare(game,guess):\n    \"\"\"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.\n    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.\n    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.\n    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,\n    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ố.\n    \n    \n    ví dụ:\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    \"\"\"", "def compare(game,guess):\n    \"\"\"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\n    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 đó\n    chắc chắn đáng để ghi lại và so sánh.\n    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.\n    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.\n    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,\n    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ố.\n    \n    \n    Ví dụ:\n\n    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n    \"\"\""]}
{"text": ["def Strongest_Extension(class_name, extensions):\n    \"\"\"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.\n    Các phần mở rộng sẽ được sử dụng để tải các lớp bổ sung vào lớp.\n    Độ mạnh của phần mở rộng như sau: Giả sử CAP là số chữ cái viết hoa\n    trong tên phần mở rộng và giả sử SM là số chữ cái viết thường\n    trong tên phần mở rộng, độ mạnh được biểu thị bằng phân số CAP - SM.\n    Bạn sẽ tìm phần mở rộng mạnh nhất và trả về một chuỗi theo\n    định dạng này: ClassName.StrongestExtensionName.\n    Nếu có hai hoặc nhiều phần mở rộng có cùng độ mạnh, bạn sẽ\n    chọn phần mở rộng đứng đầu trong danh sách.\n    Ví dụ: nếu bạn được cung cấp \"Slices\" làm lớp và danh sách các\n    phần mở rộng: ['SErviNGSliCes', 'Cheese', 'StuFfed'] thì bạn sẽ\n    trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất\n    (sức mạnh của nó là -1).\n    Ví dụ:\n    đối với Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n    \"\"\"", "def Strongest_Extension(class_name, extensions):\n    \"\"\"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.\n    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. \n    Độ 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\n    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,\n    độ mạnh được tính bằng công thức CAP - SM.\n    Bạn cần tìm phần mở rộng mạnh nhất và trả về chuỗi theo định dạng: \n    ClassName.StrongestExtensionName.\n    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.\n    Ví dụ, nếu bạn được cho \"Slices\" là lớp và danh sách các phần mở rộng: \n    ['SErviNGSliCes', 'Cheese', 'StuFfed'], thì bạn nên trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất \n    (độ mạnh của nó là -1).\n    Ví dụ:\n    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n    \"\"\"", "def Strongest_Extension(class_name, extensions):\n    \"\"\"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.\n    Các phần mở rộng sẽ được sử dụng để tải các lớp bổ sung vào lớp. Độ\n    mạnh của phần mở rộng như sau: Giả sử CAP là số chữ cái viết hoa\n    trong tên phần mở rộng và giả sử SM là số chữ cái viết thường\n    trong tên phần mở rộng, độ mạnh được biểu thị bằng phân số CAP -SM.\n    Bạn sẽ tìm phần mở rộng mạnh nhất và trả về một chuỗi theo \n    định dạng này: ClassName.StrongestExtensionName.\n    Nếu có hai hoặc nhiều phần mở rộng có cùng độ mạnh, hãy\n    chọn phần mở rộng đứng đầu trong danh sách.\n    Ví dụ: nếu bạn được cho \"Slices\" làm lớp và danh sách các\n    phần mở rộng: ['SErviNGSliCes', 'Cheese', 'StuFfed'] thì bạn sẽ\n    trả về 'Slices.SErviNGSliCes' vì 'SErviNGSliCes' là phần mở rộng mạnh nhất.\n    (độ mạnh của nó là-1).\n    Ví dụ:\n    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n    \"\"\""]}
{"text": ["def cycpattern_check(a, b):\n    \"\"\"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.\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whassup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n    \"\"\"", "def cycpattern_check(a , b):\n    \"\"\"Cho hai từ. Nếu từ thứ hai hoặc một trong những cụm con xoay vòng của nó là một phần của từ thứ nhất, thì phải trả về True.\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whassup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n\n    \"\"\"", "def cycpattern_check(a , b):\n    \"\"\"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\n    cycpattern_check(\"abcd\",\"abd\") => False\n    cycpattern_check(\"hello\",\"ell\") => True\n    cycpattern_check(\"whassup\",\"psus\") => False\n    cycpattern_check(\"abab\",\"baa\") => True\n    cycpattern_check(\"efef\",\"eeff\") => False\n    cycpattern_check(\"himenss\",\"simen\") => True\n\n    \"\"\""]}
{"text": ["def even_odd_count(num):\n    \"\"\"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.\n\n     Ví dụ:\n        even_odd_count(-12) ==> (1, 1)\n        even_odd_count(123) ==> (1, 2)\n    \"\"\"", "def even_odd_count(num):\n    \"\"\"Cho một số nguyên. trả trả về một tuple chứa số chữ số chẵn và lẻ tương ứng.\n\n     Ví dụ:\n        even_odd_count(-12) ==> (1, 1)\n        even_odd_count(123) ==> (1, 2)\n    \"\"\"", "def even_odd_count(num):\n    \"\"\"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.\n\n     Ví dụ:\n        even_odd_count(-12) ==> (1, 1)\n        even_odd_count(123) ==> (1, 2)\n    \"\"\""]}
{"text": ["def int_to_mini_roman(number):\n    \"\"\"\n    Cho một số nguyên dương, lấy số La Mã tương đương của nó dưới dạng chuỗi,\n    và trả về dưới dạng chữ thường.\n    Hạn chế: 1 <= num <= 1000\n\n    Ví dụ:\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\"", "def int_to_mini_roman(number):\n    \"\"\"\n    Cho một số nguyên dương được đưa ra, lấy chuỗi số La Mã tương ứng,\n    và trả về dưới dạng chữ thường.\n    Điều kiện giới hạn: 1 <= num <= 1000\n\n    Ví dụ:\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\"", "def int_to_mini_roman(number):\n    \"\"\"\n    Cho một số nguyên dương, lấy số La Mã tương đương của nó dưới dạng chuỗi,\n    và trả về dưới dạng chữ thường.\n    Điều kiện: 1 <= num <= 1000\n\n    Ví dụ:\n    >>> int_to_mini_roman(19) == 'xix'\n    >>> int_to_mini_roman(152) == 'clii'\n    >>> int_to_mini_roman(426) == 'cdxxvi'\n    \"\"\""]}
{"text": ["def right_angle_triangle(a, b, c):\n    '''\n    Cho độ dài của ba cạnh của một tam giác. Trả về True nếu ba\n    cạnh tạo thành một tam giác vuông, False nếu không.\n    Một tam giác vuông là một tam giác trong đó một góc là góc vuông hoặc\n    90 độ.\n    Ví dụ:\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''", "def right_angle_triangle(a, b, c):\n    '''\n    Cho độ dài ba cạnh của một tam giác. Trả về True nếu ba cạnh tạo thành một tam giác vuông, False nếu không.\n    Một tam giác vuông là tam giác có một góc vuông (90 độ).\n    Ví dụ:\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''", "def right_angle_triangle(a, b, c):\n    '''\n    Cho độ dài của ba cạnh của một tam giác. Nếu ba cạnh tạo thành một tam giác vuông thì trả về True,\n    nếu không thì trả về False.\n    Tam giác vuông là tam giác có một góc vuông hoặc 90 độ.\n    Ví dụ:\n    right_angle_triangle(3, 4, 5) == True\n    right_angle_triangle(1, 2, 3) == False\n    '''"]}
{"text": ["def find_max(words):\n    \"\"\"Viết một hàm nhận vào một danh sách các chuỗi.\n    Danh sách chứa các từ khác nhau. Trả về từ có số lượng ký tự duy nhất lớn nhất. Nếu có nhiều từ có số lượng chữ cái\n    lớn nhất, trả về từ xuất hiện trước theo thứ tự từ điển.\n    \n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\", \"cc\"]) == \"aaaaaaa\"\n    \"\"\"", "def find_max(words):\n    \"\"\"Viết một hàm chấp nhận một danh sách các chuỗi.\n    Danh sách chứa các từ khác nhau. Trả về từ có số lượng ký tự \n    duy nhất tối đa. Nếu nhiều chuỗi có số lượng ký tự duy nhất tối đa \n    hãy trả về chuỗi đứng đầu theo thứ tự từ điển.\n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\n    \"\"\"", "def find_max(words):\n    \"\"\"Viết một hàm nhận vào một danh sách các chuỗi.\n    Danh sách chứa các từ khác nhau. Trả về từ có số lượng ký tự duy nhất nhiều nhất.\n    Nếu có nhiều từ có số lượng ký tự duy nhất tối đa, hãy trả về từ có thứ tự trước trong bảng chữ cái.\n\n    find_max([\"name\", \"of\", \"string\"]) == \"string\"\n    find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n    find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"aaaaaaa\"\n    \"\"\""]}
{"text": ["def eat(number, need, remaining):\n    \"\"\"\n    Bạn là một con thỏ đói, và bạn đã ăn một số lượng cà rốt nhất định,\n    nhưng bây giờ bạn cần ăn thêm cà rốt để hoàn thành bữa ăn trong ngày.\n    Bạn nên trả về một mảng gồm [ tổng số cà rốt đã ăn sau bữa ăn của bạn,\n                                    số cà rốt còn lại sau bữa ăn của bạn ]\n    Nếu không có đủ cà rốt còn lại, bạn sẽ ăn hết tất cả cà rốt còn lại, nhưng vẫn sẽ cảm thấy đói.\n\n    Ví dụ:\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n\n    Biến:\n    @number : số nguyên\n        số lượng cà rốt mà bạn đã ăn.\n    @need : số nguyên\n        số lượng cà rốt mà bạn cần ăn.\n    @remaining : số nguyên\n        số lượng cà rốt còn lại trong kho\n\n    Giới hạn:\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    Chúc vui vẻ :)\n    \"\"\"", "def eat(number, need, remaining):\n    \"\"\"\n    Bạn là một chú thỏ đói, và bạn đã ăn một số lượng cà rốt nhất định,\n    nhưng bây giờ bạn cần ăn thêm cà rốt để hoàn thành bữa ăn trong ngày,\n    bạn nên trả về một mảng [tổng số cà rốt đã ăn sau bữa ăn của bạn,\n                                    số lượng cà rốt còn lại sau bữa ăn của bạn]\n    nếu không có đủ cà rốt còn lại, bạn sẽ ăn hết số cà rốt còn lại, nhưng vẫn sẽ đói.\n    Ví dụ:\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n    \n    Variables:\n    @number : số nguyên\n        số lượng cà rốt bạn đã ăn.\n    @need : số nguyên\n        số lượng cà rốt bạn cần ăn.\n    @remaining : số nguyên\n        số lượng cà rốt còn lại trong kho\n    \n    Constrain:\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    Have fun :)\n    \"\"\"", "def eat(number, need, remaining):\n    \"\"\"\n    Bạn là một chú thỏ đói, và bạn đã ăn một số lượng cà rốt nhất định,\n    nhưng bây giờ bạn cần ăn thêm cà rốt để hoàn thành bữa ăn trong ngày.\n    Bạn cần trả về một mảng gồm [ tổng số cà rốt đã ăn sau bữa ăn của bạn,\n                                    số cà rốt còn lại sau bữa ăn của bạn ]\n    Nếu số cà rốt còn lại không đủ, bạn sẽ ăn hết tất cả số cà rốt còn lại, nhưng vẫn sẽ đói.\n    \n    Ví dụ:\n    * eat(5, 6, 10) -> [11, 4]\n    * eat(4, 8, 9) -> [12, 1]\n    * eat(1, 10, 10) -> [11, 0]\n    * eat(2, 11, 5) -> [7, 0]\n    \n    Các biến:\n    @number : số nguyên\n        số lượng cà rốt mà bạn đã ăn.\n    @need : số nguyên\n        số lượng cà rốt mà bạn cần ăn.\n    @remaining : số nguyên\n        số cà rốt còn lại trong kho.\n    \n    Điều kiện:\n    * 0 <= number <= 1000\n    * 0 <= need <= 1000\n    * 0 <= remaining <= 1000\n\n    Chúc bạn vui vẻ :)\n    \"\"\""]}
{"text": ["def do_algebra(operator, operand):\n    \"\"\"\n    Cho hai danh sách operator và operand. Danh sách đầu tiên chứa các phép toán đại số cơ bản, và \n    danh sách thứ hai là một danh sách các số nguyên. Sử dụng hai danh sách đã cho để xây dựng \n    biểu thức đại số và trả về kết quả tính toán của biểu thức này.\n\n    Các phép toán đại số cơ bản:\n    Cộng ( + ) \n    Trừ ( - ) \n    Nhân ( * ) \n    Chia lấy phần nguyên ( // ) \n    Lũy thừa ( ** ) \n\n    Ví dụ:\n    operator = ['+', '*', '-']\n    array = [2, 3, 4, 5]\n    kết quả = 2 + 3 * 4 - 5\n    => kết quả = 9\n\n    Lưu ý:\n        Độ dài của danh sách operator bằng độ dài của danh sách operand trừ đi một.\n        Operand là một danh sách các số nguyên không âm.\n        Danh sách operator có ít nhất một phép toán, và danh sách operand có ít nhất hai toán hạng.\n    \"\"\"", "def do_algebra(operator, operand):\n    \"\"\"\n    Cho hai danh sách toán tử và toán hạng. Danh sách đầu tiên có các phép toán đại số cơ bản và\n    danh sách thứ hai là danh sách các số nguyên. Sử dụng hai danh sách đã cho để xây dựng biểu thức\n    đại số và trả về kết quả đánh giá của biểu thức này.\n\n    Các phép toán đại số cơ bản:\n    Phép cộng ( + ) \n    Phép trừ ( - ) \n    Phép nhân ( * ) \n    Phép chia lấy phần nguyên ( // ) \n    Phép luỹ thừa ( ** ) \n\n    Ví dụ:\n    toán tử['+', '*', '-']\n    mảng = [2, 3, 4, 5]\n    kết quả = 2 + 3 * 4 - 5\n    => kết quả = 9\n\n    Lưu ý:\n        Độ dài của danh sách toán tử bằng độ dài của danh sách toán hạng trừ đi một.\n        Toán hạng là danh sách các số nguyên không âm.\n        Danh sách toán tử có ít nhất một toán tử và danh sách toán hạng có ít nhất hai toán hạng.\n\n    \"\"\"", "def do_algebra(operator, operand):\n    \"\"\"\n    Cho hai danh sách operator và operand. Danh sách đầu tiên chứa các phép toán đại số cơ bản,\n    và danh sách thứ hai là một danh sách các số nguyên. Sử dụng hai danh sách này để xây dựng \n    biểu thức đại số và trả về kết quả đánh giá của biểu thức này.\n\n    Các phép toán đại số cơ bản:\n    Cộng ( + ) \n    Trừ ( - ) \n    Nhân ( * ) \n    Chia lấy phần nguyên ( // ) \n    Lũy thừa ( ** ) \n\n    Ví dụ:\n    operator['+', '*', '-']\n    array = [2, 3, 4, 5]\n    result = 2 + 3 * 4 - 5\n    => result = 9\n\n    Lưu ý:\n        Độ dài của danh sách operator bằng độ dài của danh sách operand trừ đi một đơn vị.\n        Operand là danh sách các số nguyên không âm.\n        Danh sách operator có ít nhất một toán tử và danh sách operand có ít nhất hai toán hạng.\n    \"\"\""]}
{"text": ["def solve(s):\n    \"\"\"Chuỗi s được cung cấp.\n    Nếu s[i] là chữ cái, chuyển chữ thường thành chữ hoa hoặc từ chữ hoa thành chữ thường,\n    nếu không thì giữ nguyên.\n    Nếu chuỗi không chứa chữ cái nào, hãy đảo ngược chuỗi.\n    Hàm phải trả về chuỗi kết quả.\n    Ví dụ\n    solve(\"1234\") = \"4321\"\n    solve(\"ab\") = \"AB\"\n    solve(\"#a@C\") = \"#A@c\"\n    \"\"\"", "def solve(s):\n    \"\"\"Bạn được cung cấp một chuỗi s.\n    nếu s[i] là một chữ cái, hãy đảo ngược trường hợp của nó từ thường sang hoa hoặc ngược lại,\n    nếu không thì giữ nguyên như vậy.\n    Nếu chuỗi không chứa chữ cái nào, hãy đảo ngược chuỗi.\n    Hàm sẽ trả về chuỗi kết quả.\n    Ví dụ\n    solve(\"1234\") = \"4321\"\n    solve(\"ab\") = \"AB\"\n    solve(\"#a@C\") = \"#A@c\"\n    \"\"\"", "def solve(s):\n    \"\"\"Bạn được cho một chuỗi s.\n    nếu s[i] là một chữ cái, đảo ngược chữ hoa từ thường sang hoa hoặc ngược lại, \n    nếu không thì giữ nguyên như vậy.\n    Nếu chuỗi không chứa chữ cái nào, đảo ngược chuỗi.\n    Hàm sẽ trả về chuỗi kết quả.\n    Ví dụ\n    solve(\"1234\") = \"4321\"\n    solve(\"ab\") = \"AB\"\n    solve(\"#a@C\") = \"#A@c\"\n    \"\"\""]}
{"text": ["def string_to_md5(text):\n    \"\"\"\n    Cho một chuỗi 'text', trả về chuỗi tương đương băm md5 của nó.\n    Nếu 'text' là một chuỗi rỗng, trả về None.\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n    \"\"\"", "def string_to_md5(text):\n    \"\"\"\n    Cho một chuỗi 'text', trả về chuỗi tương đương với mã băm md5 của nó.\n    Nếu 'text' là một chuỗi rỗng, trả về None.\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n    \"\"\"", "def string_to_md5(text):\n    \"\"\"\n    Cho chuỗi 'text', trả về chuỗi băm md5 tương ứng.\n    Nếu 'text' là chuỗi rỗng, trả về None.\n\n    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62 '\n    \"\"\""]}
{"text": ["def generate_integers(a, b):\n    \"\"\"\n    Cho hai số nguyên dương a và b, trả về các số chẵn giữa a và b, theo thứ tự tăng dần.\n\n    Ví dụ:\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\"", "def generate_integers(a, b):\n    \"\"\"\n    Cho hai số nguyên dương a và b, trả về các số chẵn giữa a\n    và b, theo thứ tự tăng dần.\n\n    Ví dụ:\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\"", "def generate_integers(a, b):\n    \"\"\"\n    Cho hai số nguyên dương a và b, trả về các số chẵn giữa a và b theo thứ tự tăng dần.\n\n    Ví dụ:\n    generate_integers(2, 8) => [2, 4, 6, 8]\n    generate_integers(8, 2) => [2, 4, 6, 8]\n    generate_integers(10, 14) => []\n    \"\"\""]}