from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ ตรวจสอบว่าในรายการของตัวเลขที่กำหนด มีตัวเลขใดสองตัวที่อยู่ใกล้กันมากกว่าค่าความแตกต่างที่กำหนดหรือไม่
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ ตรวจสอบว่ามีตัวเลขสองตัวใดในรายการตัวเลขที่ให้มาที่อยู่ใกล้กันมากกว่าค่าขีดจำกัดที่กำหนดหรือไม่
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ ฟังก์ชันนี้รับค่าเป็นสตริงที่มีหลายกลุ่มของวงเล็บที่ซ้อนกัน เป้าหมายคือการแยกกลุ่มเหล่านี้
    ออกเป็นสตริงแยกต่างหากและคืนค่าเป็นรายการของสตริงเหล่านั้น
    กลุ่มที่แยกต่างหากจะมีความสมดุล (วงเล็บเปิดแต่ละอันจะปิดอย่างถูกต้อง) และไม่ซ้อนกัน
    ให้ละเว้นช่องว่างในสตริงที่ป้อนเข้า
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ อินพุตสำหรับฟังก์ชันนี้คือสตริงที่มีวงเล็บซ้อนกันหลายกลุ่ม เป้าหมายของคุณคือแยกกลุ่มเหล่านั้นออกเป็นสตริงแยกกันและส่งคืนรายการของกลุ่มเหล่า
    นั้น
    กลุ่มที่แยกจากกันจะต้องสมดุล (วงเล็บเปิดแต่ละอันจะปิดอย่างถูกต้อง) และไม่ซ้อนกัน
    ไม่ต้องสนใจช่องว่างใดๆ ในสตริงอินพุต
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ อินพุตสำหรับฟังก์ชันนี้คือสตริงที่มีวงเล็บซ้อนกันหลายกลุ่ม เป้าหมายของคุณคือแยกกลุ่มเหล่านั้นออกเป็นสตริงแยกกันและส่งคืนรายการของกลุ่มเหล่านั้น
    กลุ่มที่แยกจากกันจะต้องสมดุลกัน (วงเล็บเปิดแต่ละอันจะปิดอย่างถูกต้อง) และไม่ซ้อนกันไม่ต้องสนใจช่องว่างใดๆ ในสตริงอินพุต
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ เมื่อกำหนดจำนวนจุดลอยตัวเป็นบวก ก็สามารถแยกออกเป็น
    และส่วนจำนวนเต็ม (จำนวนเต็มที่มากที่สุดที่เล็กกว่าจำนวนที่กำหนด) และทศนิยม
    (ส่วนที่เหลือจะเล็กกว่า 1 เสมอ)

    คืนส่วนทศนิยมของตัวเลข
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ เมื่อกำหนดจำนวนจุดลอยตัวเป็นบวก ก็สามารถแยกออกเป็น
    และส่วนจำนวนเต็ม (จำนวนเต็มที่มากที่สุดที่เล็กกว่าจำนวนที่กำหนด)และทศนิยม
    (ส่วนที่เหลือจะเล็กกว่า 1 เสมอ)

    ส่งคืนส่วนทศนิยมของตัวเลข
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ เมื่อได้รับจำนวนทศนิยมบวก สามารถแยกออกเป็นส่วนจำนวนเต็ม
    (จำนวนเต็มที่มากที่สุดที่น้อยกว่าจำนวนที่ให้มา) และส่วนทศนิยม
    (ส่วนที่เหลือซึ่งน้อยกว่า 1 เสมอ)

    ส่งคืนส่วนทศนิยมของตัวเลข
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ ให้รายการของการฝากและถอนเงินในบัญชีธนาคาร บัญชีนี้เริ่มต้นด้วยยอดคงเหลือเป็นศูนย์
    งานของคุณคือการตรวจสอบว่ายอดคงเหลือในบัญชีต่ำกว่าศูนย์หรือไม่ และในจุดนั้นฟังก์ชันควรคืนค่า True
    หากไม่เป็นเช่นนั้น ควรคืนค่า False
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ คุณจะได้รับรายการการฝากและถอนเงินในบัญชีธนาคารที่เริ่มต้นด้วย
    ยอดคงเหลือเป็นศูนย์ งานของคุณคือการตรวจสอบว่ายอดคงเหลือในบัญชีต่ำกว่าศูนย์หรือไม่ และ
    ณ จุดนั้น ฟังก์ชันควรคืนค่า True หากไม่เป็นเช่นนั้น ควรคืนค่า False
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ คุณจะได้รับรายการการดําเนินการฝากและถอนเงินในบัญชีธนาคารที่ขึ้นต้นด้วย
    ยอดคงเหลือเป็นศูนย์ งานของคุณคือตรวจสอบว่ายอดคงเหลือของบัญชีลดลงต่ํากว่าศูนย์หรือไม่ และ
    ณ จุดนั้นฟังก์ชันควรส่งคืน True มิฉะนั้นควรส่งคืน False
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ คำนวณค่าเบี่ยงเบนเฉลี่ยสัมบูรณ์โดยใช้ค่าเฉลี่ยเป็นจุดศูนย์กลาง
    สำหรับรายการตัวเลขที่ได้รับ
    ค่าเบี่ยงเบนเฉลี่ยสัมบูรณ์คือค่าเฉลี่ยของความแตกต่างสัมบูรณ์
    ระหว่างแต่ละองค์ประกอบและจุดศูนย์กลาง (ในกรณีนี้คือค่าเฉลี่ย):
    MAD = ค่าเฉลี่ย | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ คำนวณค่าเบี่ยงเบนสัมบูรณ์เฉลี่ยสำหรับรายการของตัวเลขอินพุตที่กำหนด
    ใกล้ค่าเฉลี่ยของชุดข้อมูลนี้
    ค่าเบี่ยงเบนสัมบูรณ์เฉลี่ย หมายถึง ค่าเฉลี่ยผลต่างสัมบูรณ์ระหว่างค่าเบี่ยงเบนแต่ละค่า
    องค์ประกอบและจุดศูนย์กลาง (ในกรณีนี้หมายถึง):
    MAD = ค่าเฉลี่ยของ | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimiter: int) -> List[int]:
    """ แทรกตัวเลข 'delimiter' ระหว่างทุกสององค์ประกอบที่ต่อเนื่องกันของรายการอินพุต `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ แทรกตัวเลข 'delimeter' ระหว่างองค์ประกอบที่ต่อเนื่องกันในรายการอินพุต numbers
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ ฟังก์ชันนี้รับสตริงที่แสดงถึงกลุ่มของวงเล็บที่ซ้อนกันหลายกลุ่มที่คั่นด้วยช่องว่าง
    สำหรับแต่ละกลุ่ม ให้แสดงระดับการซ้อนของวงเล็บที่ลึกที่สุด
    ตัวอย่าง: (()()) มีการซ้อนสูงสุด 2 ระดับ และ ((())) มี 3 ระดับ

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ อินพุตของฟังก์ชันนี้คือสตริงที่แสดงกลุ่มหลายกลุ่มสำหรับวงเล็บที่ซ้อนกันและแยกด้วยช่องว่าง
    สำหรับแต่ละกลุ่ม ให้ส่งออกระดับความลึกของการซ้อนวงเล็บมากที่สุด
    ตัวอย่างเช่น (()()) มีระดับความลึกของการซ้อนวงเล็บสูงสุดสองระดับในขณะที่ ((())) มีสามระดับ

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ อินพุตของฟังก์ชันนี้คือสตริงที่แสดงกลุ่มต่างๆ หลายกลุ่มในวงเล็บซ้อนกันและคั่นด้วยช่องว่าง
    สำหรับแต่ละกลุ่ม ให้พิมพ์ระดับการซ้อนวงเล็บที่ลึกที่สุด
    เช่น (()()) มีการซ้อนสูงสุด 2 ระดับ และ ((())) มี 3 ระดับ

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ กรองรายการสตริงที่ป้อนเข้ามาให้เหลือแค่สตริงที่มีสตริงย่อยที่ระบุ
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ กรองรายการสตริงที่ป้อนเข้ามาเพื่อให้เหลือเฉพาะสตริงที่มีสตริงย่อยที่ระบุ
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ กรองรายการอินพุตของสตริงเฉพาะที่มีสตริงย่อยที่กำหนดเท่านั้น
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ ส่งคืนทูเพิลที่ประกอบด้วยผลรวมและผลคูณของจำนวนเต็มทั้งหมดในรายการที่ให้มา
    ผลรวมของรายการว่างควรเท่ากับ 0 และผลคูณของรายการว่างควรเท่ากับ 1
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """
    จากลิสต์ของจำนวนเต็มที่กำหนด สร้างลิสต์ที่เก็บค่ามากที่สุดแบบสะสมจนถึงตำแหน่งปัจจุบันในลำดับ
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ จากรายการของจำนวนเต็มที่กำหนด สร้างรายการของสมาชิกมากที่สุดแบบโรล링ที่พบจนถึงขณะที่กำหนดในลำดับ
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ ทดสอบว่า string ที่ให้มาเป็นพาลินโดรมหรือไม่ """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ ค้นหาพาลินโดรมที่สั้นที่สุดที่เริ่มต้นด้วย string ที่ให้มา
    แนวคิดของอัลกอริทึมมีดังนี้:
    - ค้นหาส่วนท้ายที่ยาวที่สุดของ string ที่เป็นพาลินโดรม
    - นำส่วนหัวของ string ที่อยู่ก่อนส่วนท้ายของพาลินโดรมมาสลับและเพิ่มไปที่ท้ายของ string
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ ทดสอบว่า string ที่กำหนดให้เป็นพาลินโดรมหรือไม่ """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ หาพาลินโดรมที่สั้นที่สุดที่เริ่มต้นด้วย string ที่ให้มา
    แนวคิดของอัลกอริทึมมีดังนี้:
    - หาส่วนท้ายที่ยาวที่สุดจาก string ที่กำหนดให้ที่เป็นพาลินโดรม
    - ต่อที่ส่วนท้ายของ string ย้อนกลับที่คำนำหน้า string มาก่อนส่วนต่อท้ายพาลินโดรม
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ อินพุตเป็นสตริงสองตัวคือ a และ b ที่ประกอบด้วย 1 และ 0 เท่านั้น
    ดำเนินการ XOR แบบไบนารีกับอินพุตเหล่านี้และคืนค่าผลลัพธ์เป็นสตริงด้วย
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """
    รับสตริงสองตัว a และ b ซึ่งประกอบด้วยตัวเลข 1 และ 0 เท่านั้น
    ทำการ XOR แบบไบนารีกับค่าเหล่านี้ และส่งคืนผลลัพธ์เป็นสตริงเช่นกัน

    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ อินพุตเป็นสตริงสองตัวคือ a และ b ที่ประกอบด้วย 1 และ 0 เท่านั้น
    ดำเนินการ XOR แบบไบนารีกับอินพุตเหล่านี้และส่งคืนผลลัพธ์เป็นสตริงด้วยเช่นกัน
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ สตริงที่ยาวที่สุดในรายการสตริงจะถูกส่งคืน หากมีสตริงที่มีความยาวเท่ากันหลายตัว จะส่งคืนตัวแรก
    หากรายการอินพุตว่างเปล่า จะส่งคืน None
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ จากรายการสตริง ให้ส่งคืนสตริงที่ยาวที่สุด ส่งคืนสตริงแรกในกรณีที่มี
    สตริงหลายตัวที่มีความยาวเท่ากัน ส่งคืน None ในกรณีที่รายการอินพุตว่างเปล่า
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ จากรายการสตริง ให้ส่งคืนสตริงที่ยาวที่สุด ส่งคืนสตริงแรกในกรณีที่มีสตริงหลายตัวที่มีความยาวเท่ากัน ส่งคืน None ในกรณีที่รายการอินพุตว่างเปล่า
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ คืนค่าตัวหารร่วมที่มากที่สุดของจำนวนเต็ม a และ b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ คืนค่าตัวหารร่วมมากของจำนวนเต็มสองจำนวนคือ a และ b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ คืนค่าตัวหารร่วมมากที่สุดของจำนวนเต็มสองจำนวนคือ a และ b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ ส่งคืนรายการของคำนำหน้าทั้งหมดจากสั้นที่สุดถึงยาวที่สุดของสตริงที่ป้อนเข้า
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ แสดงรายการคำนำหน้าทั้งหมดตั้งแต่สั้นที่สุดไปจนถึงยาวที่สุดของสตริงอินพุต
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ กลับไปที่รายการคำนำหน้าทั้งหมดจากสั้นที่สุดถึงยาวที่สุดในสตริงอินพุต
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ ส่งคืนสตริงที่มีตัวเลขที่คั่นด้วยช่องว่างตั้งแต่ 0 ถึง n
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """
    ส่งคืนสตริงที่คั่นด้วยช่องว่างซึ่งประกอบด้วยตัวเลขตั้งแต่ 0 ถึง n
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ ส่งกลับสตริงที่มีตัวเลขที่คั่นด้วยช่องว่างตั้งแต่ 0 ถึง n
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ เมื่อให้สตริง ค้นหาว่ามีอักขระที่แตกต่างกันกี่ตัว (โดยไม่คำนึงถึงตัวพิมพ์ใหญ่เล็ก) ประกอบด้วย
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ เมื่อให้สตริง ให้ค้นหาว่ามีตัวอักษรที่แตกต่างกันกี่ประเภทโดยไม่แยกแยะตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """เมื่อกำหนดให้สตริงเป็นสตริง ให้หาว่าสตริงประกอบด้วยอักขระที่แตกต่างกันกี่ตัว (โดยไม่คำนึงถึงตัวพิมพ์ใหญ่เล็ก)
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ ฟังก์ชันนี้รับสตริงที่แสดงถึงโน้ตเพลงในรูปแบบ ASCII พิเศษ
    งานของคุณคือการแยกวิเคราะห์สตริงนี้และส่งคืนรายการของจำนวนเต็มที่สอดคล้องกับจำนวนจังหวะที่แต่ละโน้ตดำเนินไป

    ตำนานมีดังนี้:
    'o' - โน้ตเต็ม, ดำเนินไป 4 จังหวะ
    'o|' - โน้ตครึ่ง, ดำเนินไป 2 จังหวะ
    '.|' - โน้ตสี่ส่วน, ดำเนินไป 1 จังหวะ

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ ฟังก์ชันนี้รับสตริงที่แสดงถึงโน้ตเพลงในรูปแบบ ASCII พิเศษ
    งานของคุณคือการแยกวิเคราะห์สตริงนี้และส่งคืนรายการของจำนวนเต็มที่สอดคล้องกับจำนวนจังหวะที่แต่ละ
    ดำเนินไป

    ตำนานมีดังนี้:
    'o' - โน้ตเต็ม, ดำเนินไป 4 จังหวะ
    'o|' - โน้ตครึ่ง, ดำเนินไป 2 จังหวะ
    '.|' - โน้ตสี่ส่วน, ดำเนินไป 1 จังหวะ

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ อินพุตของฟังก์ชันนี้คือสตริงที่แทนโน้ตดนตรีในรูปแบบ ASCII ที่พิเศษ
    งานของคุณคือการแยกสตริงนี้และส่งคืนรายการของจำนวนเต็มที่สอดคล้องกับจำนวนครั้งที่แต่ละโน้ตจะดำเนินไป

    ต่อไปนี้คือคำอธิบายสัญลักษณะ:
    'o' - โน้ตเต็ม ใช้เวลา 4 ครั้ง (beat)
    'o|' - โน้ตครึ่ง ใช้เวลา 2 ครั้ง (beat)
    '.|' - โน้ตส่วน tư ใช้เวลา 1 ครั้ง (beat)

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


def how_many_times(string: str, substring: str) -> int:
    """ หาว่ามีสตริงย่อยที่ระบุถูกพบในสตริงต้นฉบับกี่ครั้ง นับรวมกรณีที่ซ้ำกัน
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ ค้นหาว่าสามารถพบสตริงย่อยที่กำหนดได้กี่ครั้งในสตริงต้นฉบับ นับกรณีที่ทับซ้อนกัน
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ ตรวจสอบว่ามีการพบสตริงย่อยที่ระบุในสตริงต้นฉบับกี่ครั้ง นับรวมกรณีที่ซ้ำกันด้วย
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ อินพุตคือสตริงของตัวเลขจาก 'zero' ถึง 'nine' ที่คั่นด้วยช่องว่าง
    ตัวเลือกที่ถูกต้องคือ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'
    คืนค่าสตริงของตัวเลขที่เรียงจากน้อยไปมาก
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ อินพุตคือสตริงของตัวเลขจาก 'zero' ถึง 'nine' ที่คั่นด้วยช่องว่าง
    ตัวเลือกที่ถูกต้องคือ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
    คืนค่าสตริงของตัวเลขที่เรียงจากน้อยไปมาก
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ จากรายการตัวเลขที่จัดทำไว้ (ความยาวอย่างน้อยสองตัวเลข) เลือกตัวเลขสองตัวที่อยู่ใกล้กันมากที่สุดแล้วส่งคืนตามลำดับ (ตัวเลขที่น้อยกว่า ตัวเลขที่มากกว่า)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ เลือกสองตัวเลขที่ใกล้กันที่สุดจากรายการตัวเลขที่ให้มา (ความยาวอย่างน้อย 2 ขึ้นไป)
    และส่งคืนตามลำดับ (ตัวเลขที่เล็กกว่า, ตัวเลขที่ใหญ่กว่า)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ จากรายการของจำนวน (ที่มีความยาวอย่างน้อยสองตัว) ที่ให้มา คัดเลือกและส่งกลับสองตัวที่อยู่ใกล้กันมากที่สุด และส่งกลับมันในลำดับ (จำนวนที่น้อยกว่า,
    จำนวนที่มากกว่า)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ เมื่อได้รับรายการของตัวเลขที่มีอย่างน้อยสององค์ประกอบ ให้ใช้การแปลงเชิงเส้นกับรายการนั้น
    โดยจะทำให้ตัวเลขที่น้อยที่สุดกลายเป็น 0 และตัวเลขที่มากที่สุดจะกลายเป็น 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ เมื่อได้รับรายการของตัวเลขที่มีอย่างน้อย 2 องค์ประกอบ ให้ใช้การแปลงเชิงเส้นกับรายการนั้น
    เพื่อให้ตัวเลขที่น้อยที่สุดกลายเป็น 0 และตัวเลขที่มากที่สุดกลายเป็น 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ เมื่อกําหนดรายการตัวเลข (ที่มีองค์ประกอบอย่างน้อยสององค์ประกอบ) ให้ใช้การแปลงเชิงเส้นกับรายการ
    เพื่อให้จํานวนที่น้อยที่สุดกลายเป็น 0 และจํานวนที่มากที่สุดกลายเป็น 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ กรองเฉพาะจำนวนเต็มจากรายการของค่า Python ใด ๆ ที่ให้มา
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ กรองเฉพาะจำนวนเต็มของค่า python จากรายการที่ป้อนเข้าไป
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ กรองรายการค่า Python ที่กำหนดเฉพาะสำหรับจำนวนเต็มเท่านั้น
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ ส่งคืนความยาวของสตริงที่กำหนด
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ คืนค่าความยาวของสตริงที่กำหนดให้
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ ส่งคืนความยาวของสตริงที่ให้
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ สำหรับจำนวน n ที่กำหนด หาจำนวนที่มากที่สุดที่หาร n ได้ลงตัว ซึ่งน้อยกว่า n
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ ค้นหาตัวเลขที่มากที่สุดที่น้อยกว่า n ซึ่งสามารถหาร n ได้ลงตัว
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ ส่งคืนรายการตัวประกอบเฉพาะของจำนวนเต็มที่กำหนดให้ตามลำดับจากน้อยไปหามาก
    ปัจจัยแต่ละตัวควรแสดงรายการตามจำนวนครั้งที่ปรากฏในการแยกตัวประกอบ
    หมายเลขอินพุตควรเท่ากับผลคูณของตัวประกอบทั้งหมด
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """
    ส่งคืนลิสต์ของตัวประกอบเฉพาะของจำนวนเต็มที่กำหนด โดยเรียงจากน้อยไปมาก
    ตัวประกอบแต่ละตัวจะต้องปรากฏในลิสต์ตามจำนวนครั้งที่มันปรากฏในการแยกตัวประกอบ
    ผลคูณของตัวประกอบทั้งหมดจะต้องเท่ากับตัวเลขที่กำหนด

    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ ส่งคืนรายการของตัวประกอบเฉพาะของจำนวนเต็มที่กำหนดในลำดับจากน้อยไปหามาก
    แต่ละตัวประกอบควรจะถูกแสดงในรายการตามจำนวนครั้งที่มันปรากฏในการแยกตัวประกอบ
    จำนวนอินพุตควรจะเท่ากับผลคูณของทุกตัวประกอบ
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ ลบทุกองค์ประกอบที่ปรากฏมากกว่าหนึ่งครั้งจากรายการจำนวนเต็ม
    รักษาลำดับขององค์ประกอบที่เหลือให้เหมือนกับการป้อนข้อมูล
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ จากรายการจำนวนเต็ม ให้ลบองค์ประกอบทั้งหมดที่เกิดขึ้นมากกว่าหนึ่งครั้งออก
    คงลำดับขององค์ประกอบไว้เหมือนเดิมกับในอินพุต
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ จากรายการของจำนวนเต็ม ลบทั้งหมดสมาชิกที่ปรากฏมากกว่าครั้งเดียว
    รักษาลำดับของสมาชิกให้เหมือนเดิมกับในอินพุต
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ สำหรับสตริงที่กำหนดให้ แปลงตัวอักษรเล็กให้เป็นตัวอักษรใหญ่ และตัวอักษรใหญ่ให้เป็นตัวอักษรเล็ก
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ แปลงตัวอักษรเล็กให้เป็นตัวอักษรใหญ่ และตัวอักษรใหญ่ให้เป็นตัวอักษรเล็กในสตริงที่ให้มา
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ สำหรับสตริงที่กำหนด ให้เปลี่ยนตัวอักษรตัวพิมพ์เล็กเป็นตัวพิมพ์ใหญ่ และเปลี่ยนตัวอักษรตัวพิมพ์ใหญ่เป็นตัวพิมพ์เล็ก
    >>> flip_case('Hello')
    'hELLO'
     """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ เชื่อมโยงรายการสตริงเข้าเป็นสตริงเดียว
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ เชื่อมโยงรายการในสตริงให้เป็นสตริงเดียว
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ กรองรายการสตริงที่ป้อนเข้ามาให้เหลือเฉพาะที่เริ่มต้นด้วยคำนำหน้าที่ระบุ
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ กรองรายการอินพุตของสตริงเฉพาะสตริงที่เริ่มต้นด้วยคำนำหน้าที่กำหนดเท่านั้น.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """คืนค่าเฉพาะตัวเลขบวกในรายการ
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """คืนค่าเฉพาะจำนวนบวกในรายการ
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """คืนค่า true หากตัวเลขที่ให้เป็นจำนวนเฉพาะ มิฉะนั้นคืนค่า false
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """ส่งกลับ true หากจํานวนที่กําหนดเป็นจํานวนเฉพาะ false มิฉะนั้น
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    ประเมินค่าพหุนามที่มีสัมประสิทธิ์ xs ที่จุด x
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs คือสัมประสิทธิ์ของพหุนาม
    find_zero จะหาค่า x ที่ทำให้ poly(x) = 0
    find_zero จะคืนค่าเฉพาะจุดศูนย์เพียงจุดเดียว แม้ว่าจะมีหลายคำตอบ
    นอกจากนี้ find_zero จะรับเฉพาะรายการ xs ที่มีจำนวนสัมประสิทธิ์เป็นเลขคู่
    และมีสัมประสิทธิ์ที่ไม่เป็นศูนย์มากที่สุด
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    ประเมินพหุนามที่มีค่าสัมประสิทธิ์ xs ที่จุด x
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs คือสัมประสิทธิ์ของพหุนาม
    find_zero จะหาค่า x ที่ทำให้ poly(x) = 0.
    find_zero จะคืนค่าเฉพาะจุดศูนย์เพียงจุดเดียว แม้ว่าจะมีหลายคำตอบ
    นอกจากนี้ find_zero จะรับเฉพาะรายการ xs ที่มีจำนวนสัมประสิทธิ์เป็นเลขคู่
    และมีสัมประสิทธิ์ที่ไม่เป็นศูนย์มากที่สุด
    a solution.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    ประเมินพหุนามที่มีสัมประสิทธิ์ xs ที่จุด x
    ส่งคืน xs[0] + xs[1] * x + xs[1] * x^2 +.... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs คือสัมประสิทธิ์ของพหุนาม
    find_zero หา x ที่ทำให้ poly(x) = 0
    find_zero ส่งคืนเพียงจุดศูนย์เดียว แม้ว่าจะมีหลายจุดศูนย์
    นอกจากนี้ find_zero จะรับรายการ xs ที่มีจำนวนสัมประสิทธิ์เป็นจำนวนคู่เท่านั้น และสัมประสิทธิ์ที่ไม่เป็นศูนย์และมีค่ามากที่สุด เนื่องจากมันมีความมั่นใจว่าจะมีคำตอบ
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """ฟังก์ชันนี้ใช้รายการ l และส่งคืนรายการ l' โดยที่
    l' เหมือนกับ l ในดัชนีที่หารด้วยสามไม่ลงตัว ในขณะที่ค่าของ l' ในดัชนีที่หารด้วยสามลงตัวจะเท่ากับ
    ค่าของดัชนีที่สอดคล้องกันของ l แต่ได้รับการเรียงลำดับ
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """"""ฟังก์ชันนี้ใช้รายการ l และส่งคืนรายการ l' โดยที่
    l' จะเหมือนกับ l ในดัชนีที่หารด้วยสามไม่ลงตัว ในขณะที่ค่าของ l' ในดัชนีที่หารด้วยสามลงตัวจะเท่ากับ
    ค่าของดัชนีที่สอดคล้องกันของ l แต่ได้รับการเรียงลำดับ
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """ฟังก์ชันนี้รับรายการ l และส่งคืนรายการ l'
    l' จะเหมือนกับ l ในดัชนีที่ไม่สามารถหารด้วย 3 ลงตัว และค่าที่ดัชนีที่หารด้วย 3 ลงตัว
    จะเป็นค่าที่ถูกจัดเรียงจากดัชนีที่สอดคล้องกันใน l
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """คืนค่ารายการที่เรียงลำดับและไม่ซ้ำกันในรายการ
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """ส่งกลับองค์ประกอบที่ไม่ซ้ำกันและเรียงลำดับในรายการ
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """ส่งคืนองค์ประกอบที่ไม่ซ้ำกันที่เรียงลำดับในรายการ
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """คืนค่าส่วนประกอบที่มากที่สุดในรายการ
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """คืนค่าองค์ประกอบสูงสุดในรายการ
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """คืนจำนวนครั้งที่หลัก 7 ปรากฏในจำนวนเต็มที่น้อยกว่า n ซึ่งหารด้วย 11 หรือ 13 ลงตัว
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """ส่งคืนจำนวนครั้งที่ตัวเลข 7 ปรากฏในจำนวนเต็มที่น้อยกว่า n ซึ่งหารด้วย 11 หรือ 13 ลงตัว
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """คืนค่าจำนวนครั้งที่เลข 7 ปรากฏในจำนวนเต็มที่น้อยกว่า n และหารด้วย 11 หรือ 13 ลงตัว
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """ฟังก์ชันนี้ใช้รายการ l และส่งคืนรายการ l' โดยที่
    l' เหมือนกับ l ในดัชนีคี่ ในขณะที่ค่าของ l ในดัชนีคู่จะเท่ากับ
    ค่าของดัชนีคู่ของ l แต่เรียงลำดับแล้ว
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """ฟังก์ชันนี้ใช้รายการ l และส่งคืนรายการ l' ซึ่ง
    l' จะเหมือนกับ l ที่ดัชนีคี่ ในขณะที่ค่าที่ดัชนีคู่จะเท่ากับ
    ค่าที่ดัชนีคู่ของ l ที่ถูกจัดเรียงแล้ว
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    คืนค่าข้อความที่ถูกเข้ารหัสโดยการหมุนกลุ่มของ 3 ตัวอักษร
    """
    # แบ่งข้อความออกเป็นกลุ่ม แต่ละกลุ่มมีความยาว 3
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # หมุนองค์ประกอบในแต่ละกลุ่ม ยกเว้นกรณีที่กลุ่มมีองค์ประกอบน้อยกว่า 3
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    รับข้อความที่ถูกเข้ารหัสโดยฟังก์ชัน encode_cyclic และคืนค่าข้อความที่ถูกถอดรหัส
    """

def encode_cyclic(s: str):
    """
    คืนค่าข้อความที่ถูกเข้ารหัสโดยการหมุนกลุ่มของสามตัวอักษร
    """
    # แบ่งข้อความออกเป็นกลุ่ม แต่ละกลุ่มมีความยาว 3
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # หมุนองค์ประกอบในแต่ละกลุ่ม ยกเว้นกรณีที่กลุ่มมีองค์ประกอบน้อยกว่า 3
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    รับเป็นข้อความเข้ารหัสอินพุตโดยฟังก์ชัน encode_cyclic คืนค่าข้อความที่ถอดรหัส
    """

def encode_cyclic(s: str):
    """
    ส่งคืนสตริงที่เข้ารหัสโดยวนกลุ่มที่มีสามอักขระ
    """
    # แยกสตริงเป็นกลุ่ม โดยแต่ละกลุ่มมีความยาว 3
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # วนองค์ประกอบในแต่ละกลุ่ม เว้นแต่กลุ่มจะมีองค์ประกอบน้อยกว่า 3
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    รับสตริงที่เข้ารหัสด้วยฟังก์ชัน encode_cyclic เป็นอินพุต ส่งคืนสตริงที่ถอดรหัสแล้ว
    """


def prime_fib(n: int):
    """
    prime_fib จะคืนค่าลำดับที่ n ของตัวเลขที่เป็นทั้งจำนวนฟีโบนัชชีและจำนวนเฉพาะ
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib คืนค่าตัวเลขที่ n ที่เป็นตัวเลขฟีโบนัชชีและเป็นจำนวนเฉพาะด้วย
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib คืนค่าลำดับที่ n ของตัวเลขที่เป็นทั้งจำนวนฟีโบนัชชีและจำนวนเฉพาะ
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero รับรายการของจำนวนเต็มเป็นอินพุต
    ถ้ามีสามองค์ประกอบที่แตกต่างกันในรายการที่รวมกันได้ศูนย์ จะคืนค่า True
    ถ้าไม่ใช่ จะคืนค่า False

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero รับรายการจำนวนเต็มเป็นอินพุต
    จะส่งคืนค่า True หากมีองค์ประกอบที่แตกต่างกันสามองค์ประกอบในรายการซึ่งมีผลรวมเป็นศูนย์ และคืนค่า False ในกรณีอื่น

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero รับรายการของจำนวนเต็มเป็นอินพุต
    คืนค่า True ถ้ามีสามองค์ประกอบที่แตกต่างกันในรายการที่
    รวมกันได้ศูนย์ ถ้าไม่ใช่ จะคืนค่า False

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


def car_race_collision(n: int):
    """
    ลองจินตนาการว่าถนนเป็นเส้นตรงที่ยาวไม่สิ้นสุด
    มีรถ n คันวิ่งจากซ้ายไปขวา ในขณะเดียวกันก็มีรถอีก n คัน
    วิ่งจากขวาไปซ้าย ชุดของรถทั้งสองเริ่มต้นจากระยะไกลมาก
    รถทุกคันเคลื่อนที่ด้วยความเร็วเท่ากัน เมื่อรถที่วิ่งจากซ้ายไปขวา
    ชนกับรถที่วิ่งจากขวาไปซ้าย เราจะบอกว่ารถสองคันชนกัน
    อย่างไรก็ตาม รถมีความแข็งแกร่งและทนทานอย่างไม่มีที่สิ้นสุด ดังนั้น
    พวกมันจะเคลื่อนที่ต่อไปตามเส้นทางของตัวเองราวกับว่าไม่มีการชนเกิดขึ้น

    ฟังก์ชันนี้จะให้ผลลัพธ์เป็นจำนวนการชนดังกล่าว
    ""

def car_race_collision(n: int):
    """
    ลองนึกภาพถนนที่ตรงและยาวไม่สิ้นสุด
    มีรถยนต์ n คันขับจากซ้ายไปขวา ขณะเดียวกันก็มีรถยนต์อีก n คันที่ต่างกันขับจากขวาไปซ้าย รถยนต์ทั้งสองชุดเริ่มต้นจากระยะห่างกันมาก
    รถยนต์ทุกคันเคลื่อนที่ด้วยความเร็วเท่ากัน กล่าวกันว่ารถยนต์สองคันจะชนกัน
    เมื่อรถยนต์ที่เคลื่อนที่จากซ้ายไปขวาชนกับรถยนต์ที่เคลื่อนที่จากขวาไปซ้าย
    อย่างไรก็ตาม รถยนต์ทั้งสองคันมีความแข็งแรงและมั่นคงอย่างไม่สิ้นสุด เป็นผลให้รถยนต์ทั้งสองยังคงเคลื่อนที่ต่อไป
    ในวิถีของมันราวกับว่าไม่ได้ชนกัน

    ฟังก์ชันนี้จะแสดงผลจำนวนการชนดังกล่าว
    """

def car_race_collision(n: int):
    """
    ลองจินตนาการถนนที่เป็นเส้นตรงสมบูรณ์แบบและยาวไม่มีที่สิ้นสุด
    มีรถยนต์ n กำลังขับจากซ้ายไปขวา  ในขณะเดียวกันก็มีรถยนต์ n อีกคัน
    กำลังขับจากขวาไปซ้าย   รถทั้งสองคันเริ่มต้นอยู่
    ห่างกันมาก  รถยนต์ทุกคันเคลื่อนที่ด้วยความเร็วเท่ากัน  เรียกว่ารถยนต์สองคันจะชนกัน
    เมื่อรถที่เคลื่อนที่จากซ้ายไปขวาชนรถที่เคลื่อนที่จากขวาไปซ้าย
    อย่างไรก็ตาม รถยนต์ทั้งสองคันมีมีความแข็งแรงทนทานเป็นอย่างมาก ดังนั้นพวกเขาเคลื่อนที่ต่อไป
    ตามเส้นทางของพวกเขาราวกับว่าไม่มีการชนเกิดขึ้น

    ฟังก์ชันนี้จะแสดงจำนวนการชนดังกล่าว
    """


def incr_list(l: list):
    """คืนรายการที่แต่ละองค์ประกอบเพิ่มขึ้นทีละ 1
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """ส่งคืนรายการที่มีองค์ประกอบเพิ่มขึ้นทีละ 1
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero รับรายการจำนวนเต็มเป็นอินพุต
    โดยจะคืนค่า True หากมีองค์ประกอบที่แตกต่างกันสององค์ประกอบในรายการที่
    รวมกันเป็นศูนย์ และคืนค่า False หากไม่เช่นนั้น
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero รับรายการของจำนวนเต็มเป็นอินพุต
    ถ้ามีสององค์ประกอบที่แตกต่างกันในรายการที่รวมกันได้ศูนย์ จะคืนค่า True
    ถ้าไม่ใช่ จะคืนค่า False
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero รับรายการของจำนวนเต็มเป็นอินพุต
    คืนค่า True ถ้ามีสององค์ประกอบที่แตกต่างกันในรายการที่
    รวมกันได้ศูนย์ ถ้าไม่ใช่ จะคืนค่า False
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """เปลี่ยนฐานของตัวเลข x เป็นฐาน base
    คืนค่าการแสดงผลในรูปแบบสตริงหลังจากการแปลง
    ฐานต้องเป็นตัวเลขที่น้อยกว่า 10
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """"เปลี่ยนฐานตัวเลขของตัวเลขอินพุต x เป็นฐาน
    ส่งคืนการแสดงสตริงหลังการแปลง
    ตัวเลขฐานมีค่าน้อยกว่า 10
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """เปลี่ยนฐานของตัวเลขอินพุต x เป็นฐานที่กำหนด
    ส่งคืนการแสดงในรูปแบบสตริงหลังจากการแปลง
    เทฐานของตัวเลขนั้นจะน้อยกว่า 10
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """
    รับความยาวของฐาน (a) และความสูง (h) แล้วส่งคืนพื้นที่ของสามเหลี่ยม
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """กำหนดค่าความยาวด้านและความสูง คืนค่าพื้นที่ของสามเหลี่ยม
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """ให้ค่าความยาวด้านและความสูง จะคืนค่าพื้นที่สามเหลี่ยม
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """ลำดับ Fib4 เป็นลำดับที่คล้ายกับลำดับฟีโบนัชชีที่กำหนดดังนี้:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    โปรดเขียนฟังก์ชันเพื่อคำนวณองค์ประกอบที่ n ของลำดับตัวเลข fib4 อย่างมีประสิทธิภาพ อย่าใช้การเรียกซ้ำ
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """ลำดับ Fib4 เป็นลำดับที่คล้ายกับลำดับฟีโบนัชชีที่กำหนดดังนี้:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    เขียนฟังก์ชันเพื่อคำนวณสมาชิกที่ n ของลำดับ Fib4 อย่างมีประสิทธิภาพ โดยไม่ใช้การเรียกซ้ำ
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """ลำดับตัวเลข Fib4 เป็นลำดับที่คล้ายกับลำดับ Fibbonacci ซึ่งกำหนดดังนี้:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    โปรดเขียนฟังก์ชันเพื่อคำนวณองค์ประกอบที่ n ของลำดับตัวเลข fib4 อย่างมีประสิทธิภาพ อย่าใช้การเรียกซ้ำ
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """คืนค่ามัธยฐานขององค์ประกอบในรายการ l
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    ตรวจสอบว่าสตริงที่กำหนดเป็นพาลินโดรมหรือไม่
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    ตรวจสอบว่าสตริงที่กำหนดเป็นพาลินโดรม
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """คืนค่า 2^n modulo p (ระวังตัวเลข)
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """ส่งกลับ 2^n โมดูโล p (ระวังตัวเลข)
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """ส่งกลับเศษเมื่อ 2^n หารด้วย p (สังเกตตัวเลข)
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    คืนค่าข้อความที่ถูกเข้ารหัสโดยการเลื่อนตัวอักษรแต่ละตัวในอักษรภาษาอังกฤษ 5 ตำแหน่ง
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    รับข้อความที่ถูกเข้ารหัสโดยฟังก์ชัน encode_shift เป็นอินพุต และคืนค่าข้อความที่ถูกถอดรหัส
    """

def encode_shift(s: str):
    """
    คืนค่าข้อความที่ถูกเข้ารหัสโดยการเลื่อนตัวอักษทุกตัวในอักษรภาษาอังกฤษ 5 ตำแหน่ง
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    ใช้ข้อความที่ถูกเข้ารหัสโดยฟังก์ชัน encode_shift เป็นอินพุต และคืนค่าสตริงที่ถูกถอดรหัส
    """

def encode_shift(s: str):
    """
    ส่งคืนสตริงที่เข้ารหัสโดยเลื่อนอักขระแต่ละตัวทีละ 5 ตัวในตัวอักษร
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    รับสตริงที่เข้ารหัสด้วยฟังก์ชัน encode_shift เป็นอินพุต ส่งคืนสตริงที่ถอดรหัสแล้ว
    """


def remove_vowels(text):
    """
    remove_vowels เป็นฟังก์ชันที่รับสตริงและส่งคืนสตริงที่ไม่มีสระ
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """คืนค่า True ถ้าตัวเลขทั้งหมดในรายการ l น้อยกว่าค่าขีดจำกัด t
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """คืนค่า True ถ้าตัวเลขทั้งหมดในรายการ l อยู่ต่ำกว่าเกณฑ์ t
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """ส่งคืน True ถ้าเลขทั้งหมดในรายการ l ต่ำกว่าค่าคัดกรอง t
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """บวกเลขสองตัว x และ y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """เพิ่มเลขสองตัว x กับ y เข้าด้วยกัน
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """เพิ่มจำนวนสองจำนวน x และ y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    ตรวจสอบว่าคำสองคำมีอักขระเดียวกันหรือไม่
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    ตรวจสอบว่า 2 คำมีตัวอักษรเหมือนกันหรือไม่
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """ส่งคืนเลขฟีโบนัชชีลำดับที่ n.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """คืนค่าลำดับฟีโบนัชชีที่ตำแหน่งที่ n
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """ส่งคืนเลข Fibonacci อันดับที่ n
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """
    brackets เป็นสตริงที่ประกอบด้วย "<" และ ">"
    ส่งคืนค่า True หากวงเล็บเปิดแต่ละอันมีวงเล็บปิดที่ตรงกัน

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

def correct_bracketing(brackets: str):
    """ brackets is a string of "<" and ">".
    คืนค่า True ถ้าทุกวงเล็บเปิดมีวงเล็บปิดที่ตรงกัน

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

def correct_bracketing(brackets: str):
    """ วงเล็บคือสตริงของ "<" และ ">"
    return True ถ้าวงเล็บเปิดทุกอันมีวงเล็บปิดที่สอดคล้องกัน

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


def monotonic(l: list):
    """
    ส่งคืนค่า True หากองค์ประกอบในลิสต์เพิ่มขึ้นหรือลดลงอย่างต่อเนื่อง (monotonically)
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Return True ถ้าองค์ประกอบในรายการมีการเพิ่มขึ้นหรือลดลงแบบเอกภาพ
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """ส่งคืน True ถ้าองค์ประกอบของรายการเพิ่มขึ้นหรือลดลงแบบเอกภาพ
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """ส่งคืนองค์ประกอบที่พบร่วมกันและไม่ซ้ำกันในรายการทั้งสอง โดยเรียงลำดับแล้ว
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """ส่งคืนองค์ประกอบที่ไม่ซ้ำกันที่เหมือนกันของสองรายการในรูปแบบที่เรียงลำดับ
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """ส่งคืนองค์ประกอบทั่วไปที่ไม่ซ้ำกันที่เรียงลำดับสำหรับสองรายการ
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """คืนตัวประกอบเฉพาะที่ใหญ่ที่สุดของ n โดยสมมติว่า n > 1 และไม่ใช่จำนวนเฉพาะ
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """ส่งคืนตัวประกอบเฉพาะที่ใหญ่ที่สุดของ n ถือว่า n > 1 และไม่ใช่ตัวประกอบเฉพาะ
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """คืนตัวประกอบเฉพาะที่ใหญ่ที่สุดของ n โดยถือว่า n > 1 และไม่ใช่จำนวนเฉพาะ
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n เป็นฟังก์ชันที่หาผลรวมของตัวเลขตั้งแต่ 1 ถึง n
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n เป็นฟังก์ชันที่รวมเลขจาก 1 ถึง n
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """.

def sum_to_n(n: int):
    """sum_to_n  เป็นฟังก์ชันที่รวมตัวเลขจาก 1 ถึง n
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ วงเล็บเป็นสตริงของ "(" และ ")"
    ส่งคืนค่า True ถ้าวงเล็บเปิดทุกอันมีวงเล็บปิดที่สอดคล้องกัน

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

def correct_bracketing(brackets: str):
    """ วงเล็บเป็นสตริงของ "(" and ")".
    คืนค่า True ถ้าทุกวงเล็บเปิดมีวงเล็บปิดที่ตรงกัน

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

def correct_bracketing(วงเล็บ: str):
    วงเล็บ """ เป็นสตริงของ "(" และ ")"
    ส่งคืน True หากวงเล็บเปิดทุกวงเล็บมีวงเล็บปิดที่สอดคล้องกัน

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


def derivative(xs: list):
    """ xs แทนค่าสัมประสิทธิ์ของพหุนาม
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     คืนค่าฟังก์ชันอนุพันธ์ของพหุนามในรูปแบบเดียวกัน
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derived(xs: list):
    """ xs แทนค่าสัมประสิทธิ์ของพหุนาม
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    ส่งกลับอนุพันธ์ของพหุนามนี้ในรูปแบบเดียวกัน
    >>> derived([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derived([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """ลำดับตัวเลข FibFib เป็นลำดับที่คล้ายกับลำดับ Fibbonacci ซึ่งกำหนดดังนี้:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)
    โปรดเขียนฟังก์ชันเพื่อคำนวณองค์ประกอบที่ n ของลำดับตัวเลข fibfib อย่างมีประสิทธิภาพ
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """ลำดับตัวเลข FibFib เป็นลำดับที่คล้ายกับลำดับ Fibbonacci ซึ่งกำหนดดังนี้:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    โปรดเขียนฟังก์ชันเพื่อคำนวณองค์ประกอบที่ n ของลำดับตัวเลข fibfib อย่างมีประสิทธิภาพ
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """ลําดับ fifib เป็นอนุกรมที่คล้ายกับลําดับ fibonacci ซึ่งกําหนดไว้ดังนี้:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    โปรดเขียนฟังก์ชันเพื่อคํานวณองค์ประกอบที่ n ของลําดับอย่างมีประสิทธิภาพ
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
เพิ่มกรณีทดสอบเพิ่มเติม.
"""

def vowels_count(s):
    """เขียนฟังก์ชัน vowels_count ซึ่งรับสตริงที่แสดงคำเป็นข้อมูลนำเข้าและคืนจำนวนสระในสตริงนั้น
    สระในกรณีนี้คือ 'a', 'e', 'i', 'o', 'u' ในที่นี้ 'y' ก็เป็นสระเช่นกัน แต่เฉพาะเมื่อมันอยู่ท้ายคำที่กำหนดเท่านั้น

    ตัวอย่าง:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
โปรดเพิ่มกรณีทดสอบ
"""

def vowels_count(s):
    """สร้างฟังก์ชัน vowels_count ที่รับคำที่แสดงด้วยสตริงเป็นอินพุต
    และคืนค่าจำนวนสระที่มีอยู่ในสตริงนั้น
    ในกรณีนี้ สระคือ 'a', 'e', 'i', 'o', 'u' โดยที่ 'y' ก็เป็น
    สระเช่นกัน แต่เฉพาะเมื่ออยู่ท้ายคำที่ให้มาเท่านั้น

    ตัวอย่าง:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """ทำการหมุนเวียนหลักของจำนวนเต็ม x โดยหมุนหลักไปทางขวาตามจำนวน shift
    และคืนค่าผลลัพธ์เป็นสตริง
    ถ้า shift > จำนวนหลัก ให้คืนค่าหลักที่กลับด้าน
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """วงกลมเลื่อนตัวเลขของจำนวนเต็ม x และเลื่อนตัวเลขไปทางขวา
    และส่งผลลัพธ์กลับมาเป็นสตริง
    ถ้า shift > ตัวเลขหลักจะกลับมาเป็นตัวเลขที่กลับ
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """
    งานของคุณ
    เขียนฟังก์ชันที่รับสตริงเป็นอินพุตและส่งคืนผลรวมของรหัส ASCII
    ของตัวอักษรตัวพิมพ์ใหญ่ในสตริงเท่านั้น

    ตัวอย่าง:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """งาน
    เขียนฟังก์ชันที่รับสตริงเป็นอินพุตและคืนค่าผลรวมของตัวอักษรตัวพิมพ์ใหญ่เท่านั้น
    โค้ด ASCII

    ตัวอย่าง:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """ภารกิจ
    เขียนฟังก์ชันที่รับสตริงเป็นอินพุตและส่งคืนผลรวมของตัวพิมพ์ใหญ่เท่านั้น'
    รหัส ASCII

    ตัวอย่าง:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    ในงานนี้ จะมีการให้สตริงที่แสดงจำนวนแอปเปิ้ลและส้มที่แจกจ่ายในตะกร้าผลไม้
    ตะกร้านี้ประกอบด้วยแอปเปิ้ล ส้ม และมะม่วง
    เมื่อให้สตริงที่แสดงจำนวนรวมของส้มและแอปเปิ้ล และจำนวนเต็มที่แสดงจำนวนรวมของผลไม้ในตะกร้า
    ให้คืนค่าจำนวนมะม่วงในตะกร้า
    ตัวอย่าง:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    ในภารกิจนี้ คุณจะได้รับสตริงที่แสดงถึงจํานวนแอปเปิ้ลและส้ม
    ซึ่งแจกจ่ายในตะกร้าผลไม้ที่มีแอปเปิ้ล ส้ม และมะม่วง
    เมื่อกําหนดสตริงที่แสดงถึงจํานวนส้มและแอปเปิ้ลทั้งหมดและจํานวนเต็มที่แสดงถึงจํานวนผลไม้ทั้งหมดจํานวนมะม่วงในตะกร้าจะถูกส่งคืน
    ตัวอย่าง:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    ในงานนี้ จะมีการให้สตริงที่แสดงถึงจำนวนแอปเปิ้ลและส้ม
    ที่กระจายอยู่ในตะกร้าผลไม้ ตะกร้านี้บรรจุ
    แอปเปิล, ส้ม และมะม่วง กำหนดสตริงที่แสดงจำนวนรวมของ
    ส้มและแอปเปิ้ล และจำนวนเต็ม ที่แสดงถึงจำนวนผลไม้ทั้งหมด
    ในตะกร้า ให้ส่งคืนจำนวนผลมะม่วงในตะกร้า
    ตัวอย่างเช่น:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    เมื่อได้รับอาร์เรย์ที่แสดงถึงกิ่งของต้นไม้ที่มีโหนดเป็นจำนวนเต็มที่ไม่เป็นลบ
    งานของคุณคือการเลือกโหนดหนึ่งและส่งคืนมัน
    โหนดที่ถูกเลือกควรเป็นโหนดที่มีค่าน้อยที่สุดที่เป็นเลขคู่
    หากพบโหนดหลายโหนดที่มีค่าเลขคู่ที่น้อยที่สุดเหมือนกัน ให้ส่งคืนโหนดที่มีดัชนีที่น้อยที่สุด

    โหนดที่ถูกเลือกควรถูกส่งคืนในรูปแบบของรายการ [ค่าที่น้อยที่สุด, ดัชนีของมัน]
    หากไม่มีค่าเลขคู่หรืออาร์เรย์ที่ได้รับเป็นว่างเปล่า ให้ส่งคืน []

    ตัวอย่างที่ 1:
        อินพุต: [4,2,3]
        เอาต์พุต: [2, 1]
        คำอธิบาย: 2 มีค่าเลขคู่ที่น้อยที่สุด และ 2 มีดัชนีที่น้อยที่สุด

    ตัวอย่างที่ 2:
        อินพุต: [1,2,3]
        เอาต์พุต: [2, 1]
        คำอธิบาย: 2 มีค่าเลขคู่ที่น้อยที่สุด และ 2 มีดัชนีที่น้อยที่สุด

    ตัวอย่างที่ 3:
        อินพุต: []
        เอาต์พุต: []

    ตัวอย่างที่ 4:
        อินพุต: [5, 0, 3, 0, 4, 2]
        เอาต์พุต: [0, 1]
        คำอธิบาย: 0 เป็นค่าที่น้อยที่สุด แต่มีศูนย์สองตัว
                     เลือกศูนย์ตัวแรกที่มีดัชนีที่น้อยที่สุด

    ข้อจำกัด:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "เมื่อกำหนดอาร์เรย์ที่แสดงถึงสาขาของต้นไม้ที่มีโหนดจำนวนเต็มที่ไม่เป็นลบ
    งานของคุณคือดึงโหนดหนึ่งและส่งคืน
    โหนดที่ดึงควรเป็นโหนดที่มีค่าคู่ที่เล็กที่สุด
    หากพบโหนดหลายโหนดที่มีค่าคู่ที่เล็กที่สุดเท่ากัน ให้ส่งคืนโหนดที่มีดัชนีที่เล็กที่สุด

    โหนดที่ดึงควรส่งคืนในรายการ [ smalest_value, ดัชนีของโหนดนั้น ]

    ถ้าไม่มีค่าคู่หรืออาร์เรย์ที่กำหนดว่างเปล่า ให้ส่งคืน []

    ตัวอย่างที่ 1:
            อินพุต: [4,2,3]
            เอาต์พุต: [2, 1]
            คำอธิบาย: 2 มีค่าคู่ที่เล็กที่สุด และ 2 มีดัชนีที่เล็กที่สุด

    ตัวอย่างที่ 2:
            อินพุต: [1,2,3]
            เอาต์พุต: [2, 1]
            คำอธิบาย: 2 มีค่าคู่ที่เล็กที่สุด และ 2 มีดัชนีที่เล็กที่สุด

    ตัวอย่างที่ 3:
            อินพุต: []
            เอาต์พุต: []

    ตัวอย่างที่ 4:
            อินพุต: [5, 0, 3, 0, 4, 2]
            เอาต์พุต: [0, 1]
            คำอธิบาย: 0 คือค่าที่เล็กที่สุด แต่มีศูนย์อยู่สองตัว
                               ดังนั้นเราจะเลือกศูนย์ตัวแรกซึ่งมีดัชนีที่เล็กที่สุด

    ข้อจำกัด:
             * 1 <= nodes.length <= 10000
             * 0 <= node.value
    """

def pluck(arr):
    """
    "กำหนดอาร์เรย์หนึ่งแทนกิ่งของต้นไม้ที่มีโหนดเป็นจำนวนเต็มที่ไม่ติดลบ
    งานของคุณคือการถอนโหนดหนึ่งออกมาและส่งคืนมัน
    โหนดที่ถูกถอนออกมาควรเป็นโหนดที่มีค่าคู่ที่น้อยที่สุด
    ถ้ามีหลายโหนดที่มีค่าคู่ที่น้อยที่สุดเท่ากัน ส่งคืนโหนดที่มีดัชนีเล็กที่สุด

    โหนดที่ถูกถอนออกมาควรจะส่งคืนในรูปแบบของรายการ [ค่าที่น้อยที่สุด, ดัชนีของมัน],
    ถ้าไม่มีค่าคู่หรืออาร์เรย์ที่กำหนดว่างเปล่า ส่งคืน []

    ตัวอย่าง 1:
        อินพุต: [4, 2, 3]
        เอาต์พุต: [2, 1]
        อธิบาย: 2 มีค่าคู่ที่น้อยที่สุด และ 2 มีดัชนีเล็กที่สุด

    ตัวอย่าง 2:
        อินพุต: [1, 2, 3]
        เอาต์พุต: [2, 1]
        อธิบาย: 2 มีค่าคู่ที่น้อยที่สุด และ 2 มีดัชนีเล็กที่สุด

    ตัวอย่าง 3:
        อินพุต: []
        เอาต์พุต: []

    ตัวอย่าง 4:
        อินพุต: [5, 0, 3, 0, 4, 2]
        เอาต์พุต: [0, 1]
        อธิบาย: 0 เป็นค่าที่น้อยที่สุด แต่มีศูนย์สองตัว
                     ดังนั้นเราจะเลือกศูนย์แรก ซึ่งมีดัชนีเล็กที่สุด

    คำตัดสินใจ:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    ให้รายการที่ไม่ว่างของจำนวนเต็มบวก คืนค่าจำนวนเต็มที่มากที่สุด ที่มากกว่า
    ศูนย์ และมีความถี่มากกว่าหรือเท่ากับค่าของจำนวนเต็มนั้นเอง
    ความถี่ของจำนวนเต็มคือจำนวนครั้งที่ปรากฏในรายการ
    หากไม่มีค่าดังกล่าว ให้คืนค่า -1
    ตัวอย่าง:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    ให้รายการที่ไม่ว่างของจำนวนเต็มบวก คืนค่าจำนวนเต็มที่มากที่สุดที่มีความถี่มากกว่าศูนย์และมากกว่าหรือเท่ากับค่าของจำนวนเต็มนั้นเอง
    ความถี่ของจำนวนเต็มคือจำนวนครั้งที่ปรากฏในรายการ
    หากไม่มีค่าดังกล่าว ให้คืนค่า -1
    ตัวอย่าง:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    คุณจะได้รับรายการจำนวนเต็มบวกที่ไม่ว่าง ส่งคืนจำนวนเต็มที่มากที่สุดที่มากกว่า
    ศูนย์ และมีความถี่มากกว่าหรือเท่ากับค่าของจำนวนเต็มนั้นเอง
    ความถี่ของจำนวนเต็มคือจำนวนครั้งที่จำนวนเต็มปรากฏในรายการ
    ถ้าไม่มีค่าดังกล่าว ให้ส่งคืน -1
    ตัวอย่าง:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    เมื่อกำหนดรายการจำนวนเต็ม ให้ส่งคืนรายการในลำดับที่แปลก
    การเรียงลำดับแบบแปลก คือ การเริ่มต้นด้วยค่าต่ำสุด จากนั้นจึงตามด้วยค่าสูงสุดของจำนวนเต็มที่เหลือ
    จากนั้นจึงตามด้วยค่าต่ำสุด และต่อไปเรื่อยๆ

    ตัวอย่าง:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    กำหนดรายการของจำนวนเต็ม คืนค่ารายการในลำดับที่แปลก
    การเรียงลำดับแปลกคือการเริ่มต้นจากค่าต่ำสุด
    จากนั้นค่ามากที่สุดของจำนวนเต็มที่เหลือ ต่อไปคือค่าต่ำสุด และทำเช่นนี้ต่อไป

    ตัวอย่าง:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    เมื่อได้รับรายการของจำนวนเต็ม จะคืนรายการในลำดับที่แปลก
    การเรียงลำดับแปลกคือการเริ่มต้นจากค่าต่ำสุด จากนั้นค่ามากที่สุดของจำนวนเต็มที่เหลือ
    ต่อไปค่าต่ำสุด และทำเช่นนี้ต่อไปเรื่อยๆ

    ตัวอย่าง:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    เมื่อได้รับความยาวของสามด้านของสามเหลี่ยม หากสามด้านสร้างสามเหลี่ยมที่ถูกต้อง
    จะคืนค่าพื้นที่ของสามเหลี่ยมโดยปัดเศษทศนิยม 2 ตำแหน่ง
    หากไม่เป็นเช่นนั้นจะคืนค่า -1
    สามด้านสร้างสามเหลี่ยมที่ถูกต้องเมื่อผลรวมของสองด้านใด ๆ
    มากกว่าด้านที่สาม
    ตัวอย่าง:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    กำหนดความยาวของด้านทั้งสามของรูปสามเหลี่ยม คืนค่าพื้นที่ของ
    รูปสามเหลี่ยมที่ปัดเศษทศนิยม 2 ตำแหน่ง หากด้านทั้งสามสร้างรูปสามเหลี่ยมที่ถูกต้อง
    มิฉะนั้นคืนค่า -1
    ด้านทั้งสามสร้างรูปสามเหลี่ยมที่ถูกต้องเมื่อผลรวมของด้านใดๆ สองด้าน
    มีค่ามากกว่าด้านที่สาม
    ตัวอย่าง:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1


def will_it_fly(q,w):
    '''
    สร้างฟังก์ชันที่คืนค่า True ถ้าวัตถุ q สามารถบินได้ และคืนค่า False ถ้าไม่สามารถ
    วัตถุ q จะบินได้ถ้ามีความสมดุล (เป็นรายการที่เป็นพาลินโดรม) และผลรวมขององค์ประกอบไม่เกินน้ำหนักสูงสุดที่เป็นไปได้ w

    ตัวอย่าง:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ แต่ไม่มีความสมดุล

    will_it_fly([3, 2, 3], 1) ➞ False
    # มีความสมดุล แต่ 3+2+3 เกินน้ำหนักสูงสุดที่เป็นไปได้

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และมีความสมดุล

    will_it_fly([3], 5) ➞ True
    # 3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และมีความสมดุล
    '''

def will_it_fly(q,w):
    '''
    เขียนฟังก์ชันที่คืนค่า True หากวัตถุ q สามารถบินได้ และคืนค่า False หากไม่สามารถ
    วัตถุ q จะบินได้หากมีความสมดุล (เป็นรายการ palindromic) และผลรวมขององค์ประกอบน้อยกว่าหรือเท่ากับน้ำหนักสูงสุดที่เป็นไปได้ w

    ตัวอย่าง:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ แต่ไม่มีความสมดุล

    will_it_fly([3, 2, 3], 1) ➞ False
    # มีความสมดุล แต่ 3+2+3 มากกว่าน้ำหนักสูงสุดที่เป็นไปได้

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และมีความสมดุล

    will_it_fly([3], 5) ➞ True
    # 3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และมีความสมดุล
    '''

def will_it_fly(q,w):
    '''
    เขียนฟังก์ชันที่ส่งคืน True หากวัตถุ q จะบิน และส่งคืน False หากไม่เป็นเช่นนั้น
    วัตถุ q จะบินได้หากมีความสมดุล (เป็นรายการพาลินโดรม) และผลรวมขององค์ประกอบน้อยกว่าหรือเท่ากับน้ำหนักสูงสุดที่เป็นไปได้ w

    ตัวอย่าง:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ แต่ไม่สมดุล

    will_it_fly([3, 2, 3], 1) ➞ False
    # มีความสมดุล แต่ 3+2+3 มากกว่าน้ำหนักสูงสุดที่เป็นไปได้

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และสมดุล
    will_it_fly([3], 5) ➞ True
    # 3 น้อยกว่าน้ำหนักสูงสุดที่เป็นไปได้ และสมดุลแล้ว
    '''


def smallest_change(arr):
    """
    ให้ลิสต์ arr ของจำนวนเต็ม ค้นหาจำนวนการเปลี่ยนแปลงขั้นต่ำขององค์ประกอบที่
    จำเป็นเพื่อทำให้ลิสต์เป็นพาลินโดรม ลิสต์พาลินโดรมคือ ลิสต์ที่อ่านจากหน้าไปหลัง
    หรือจากหลังไปหน้าแล้วเหมือนกัน ในหนึ่งการเปลี่ยนแปลง คุณสามารถเปลี่ยนองค์ประกอบ
    หนึ่งตัวให้เป็นตัวอื่นใดก็ได้

    ตัวอย่าง:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    ให้ arr เป็นอาเรย์ของจำนวนเต็ม หาจำนวนน้อยที่สุดของส่วนประกอบที่
    ต้องเปลี่ยนเพื่อทำให้อาเรย์เป็นพาลินโดรม อาเรย์พาลินโดรมคืออาเรย์ที่
    อ่านจากซ้ายไปขวาหรือจากขวาไปซ้ายแล้วได้เหมือนกัน ในการเปลี่ยนหนึ่งครั้ง คุณสามารถเปลี่ยนส่วนประกอบหนึ่งเป็นส่วนประกอบอื่นใดก็ได้

    ตัวอย่าง:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    กำหนดอาร์เรย์ arr ของจำนวนเต็ม หาจำนวนองค์ประกอบขั้นต่ำที่
    จำเป็นต้องเปลี่ยนแปลงเพื่อให้เป็นอาร์เรย์พาลินโดรม อาร์เรย์พาลินโดรมคืออาร์เรย์ที่
    อ่านค่าแบบเดียวกันทั้งไปข้างหน้าและข้างหลัง ในการเปลี่ยนแปลงหนึ่งครั้ง คุณสามารถเปลี่ยนองค์ประกอบหนึ่งเป็นองค์ประกอบอื่นใดก็ได้

    ตัวอย่าง:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    เขียนฟังก์ชันที่ยอมรับรายการสตริงสองรายการและส่งคืนรายการที่มี
    จำนวนอักขระทั้งหมดในสตริงทั้งหมดของรายการน้อยกว่ารายการอื่น

    หากสองรายการมีจำนวนตัวอักษรเท่ากัน ให้ส่งคืนรายการแรก

    ตัวอย่าง
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    เขียนฟังก์ชันที่รับรายการของสตริงสองรายการและคืนรายการที่มี
    ผลรวมของจำนวนตัวอักษรในสตริงทั้งหมดในรายการน้อยกว่ารายการอื่น

    หากสองรายการมีจำนวนตัวอักษรเท่ากัน ให้ส่งคืนรายการแรก

    ตัวอย่าง
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    รับรายการของสตริงสองรายการและสร้างฟังก์ชันที่ส่งคืนรายการที่มีผลรวมของจำนวนตัวอักษร
    ในสตริงทั้งหมดในรายการน้อยกว่ารายการอื่น

    หากสองรายการมีจำนวนตัวอักษรเท่ากัน ให้ส่งคืนรายการแรก

    ตัวอย่าง
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """เขียนฟังก์ชันที่คืนค่า true ถ้าจำนวนที่ให้เป็นผลคูณของจำนวนเฉพาะ 3 ตัว
    และคืนค่า false ในกรณีอื่น ๆ
    ทราบว่า (a) น้อยกว่า 100
    ตัวอย่าง:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """เขียนฟังก์ชันที่คืนค่าเป็นจริงหากตัวเลขที่กำหนดคือการคูณของจำนวนเฉพาะ 3 จำนวน
    และคืนค่า false ในกรณีอื่น ๆ
    ทราบว่า (a) น้อยกว่า 100
    ตัวอย่าง:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """เขียนฟังก์ชันที่คืนค่า true ถ้าจำนวนที่ให้เป็นผลคูณของจำนวนเฉพาะ 3 ตัว
    และคืนค่า false ในกรณีอื่น
    ทราบว่า (a) น้อยกว่า 100
    ตัวอย่าง:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """
    งานของคุณคือการเขียนฟังก์ชันที่ส่งคืนค่า True หากตัวเลข x เป็น
    กำลังที่ง่ายของ n และส่งคืนค่า False ในกรณีอื่น
    x จะเป็นกำลังที่ง่ายของ n ก็ต่อเมื่อมีจำนวนเต็มบวก k ที่ทำให้ n**k = x

    ตัวอย่าง:
    is_simple_power(1, 4) => True
    is_simple_power(2, 2) => True
    is_simple_power(8, 2) => True
    is_simple_power(3, 2) => False
    is_simple_power(3, 1) => False
    is_simple_power(5, 3) => False
    """

def is_simple_power(x, n):
    """
    หน้าที่ของคุณคือการเขียนฟังก์ชันที่ส่งคืนค่า True หากตัวเลข x เป็น
    กำลังง่ายของ n และส่งคืนค่า False ในกรณีอื่น ๆ
    x จะเป็นกำลังง่ายของ n ก็ต่อเมื่อ n**int = x

    ตัวอย่าง:
    is_simple_power(1, 4) => True
    is_simple_power(2, 2) => True
    is_simple_power(8, 2) => True
    is_simple_power(3, 2) => False
    is_simple_power(3, 1) => False
    is_simple_power(5, 3) => False
    """

def is_simple_power(x, n):
    """งานของคุณคือการเขียนฟังก์ชันหนึ่ง ซึ่งจะส่งคืนค่าเป็นจริงถ้าเลข x เป็นกำลังที่ง่ายของ n และเป็นเท็จในกรณีอื่น ๆ
    x เป็นกำลังที่ง่ายของ n ถ้า n**int = x
    ตัวอย่างเช่น:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    เขียนฟังก์ชันที่รับจำนวนเต็ม a และส่งคืนค่า True
    หากจำนวนเต็มนี้เป็นกำลังสามของจำนวนเต็มบางตัว
    หมายเหตุ: คุณสามารถถือว่าอินพุตนั้นถูกต้องเสมอ
    ตัวอย่าง:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    เขียนฟังก์ชันที่รับจำนวนเต็ม a และคืนค่า True
    ถ้าจำนวนเต็มนี้เป็นลูกบาศก์ของจำนวนเต็มใด ๆ
    หมายเหตุ: คุณสามารถสมมติได้ว่าข้อมูลนำเข้าเป็นข้อมูลที่ถูกต้องเสมอ
    ตัวอย่าง:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    สร้างฟังก์ชันที่รับจำนวนเต็ม a และคืนค่า True หากจำนวนเต็มนี้เป็นลูกบาศก์ของจำนวนเต็มใด ๆ
    หมายเหตุ: สามารถสมมติได้ว่าข้อมูลนำเข้าเป็นข้อมูลที่ถูกต้องเสมอ
    ตัวอย่าง:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """ได้รับการร้องขอให้สร้างฟังก์ชันที่รับสตริงเลขฐานสิบหกและนับจำนวนหลักที่เป็นจำนวนเฉพาะในนั้น
    จำนวนเฉพาะ (จำนวนเฉพาะคือจำนวนธรรมชาติที่มากกว่า 1 และไม่ใช่ผลคูณของจำนวนธรรมชาติที่น้อยกว่า 2 จำนวน)
    หลักของเลขฐานสิบหกคือ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
    จำนวนเฉพาะคือ 2, 3, 5, 7, 11, 13, 17,...
    ดังนั้น จำเป็นต้องตรวจสอบหลักต่อไปนี้: 2, 3, 5, 7, B (=เลขฐานสิบ 11), D (=เลขฐานสิบ 13)
    หมายเหตุ: สามารถสมมติได้ว่าอินพุตจะถูกต้องเสมอหรือเป็นสตริงว่างเปล่า และสัญลักษณ์ A, B, C, D, E, F จะเป็นตัวพิมพ์ใหญ่เสมอ
    ตัวอย่าง:
    หาก num = "AB" ผลลัพธ์ต้องเป็น 1
    หาก num = "1077E" ผลลัพธ์ต้องเป็น 2
    หาก num = "ABED1A33" ผลลัพธ์ต้องเป็น 4
    หาก num = "123456789ABCDEF0" ผลลัพธ์ต้องเป็น 6
    หาก num = "2020" ผลลัพธ์ต้องเป็น 2
    """

def hex_key(num):
    """คุณได้รับมอบหมายให้เขียนฟังก์ชันที่รับ
    เลขฐานสิบหกเป็นสตริงและนับจำนวนเลขฐานสิบหก
    ที่เป็นจำนวนเฉพาะ (จำนวนเฉพาะหรือจำนวนเฉพาะคือจำนวนธรรมชาติ
    ที่มากกว่า 1 ซึ่งไม่ใช่ผลคูณของจำนวนธรรมชาติที่เล็กกว่าสองตัว)
    เลขฐานสิบหกคือ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
    จำนวนเฉพาะคือ 2, 3, 5, 7, 11, 13, 17,...
    ดังนั้นคุณต้องกำหนดจำนวนหลักต่อไปนี้: 2, 3, 5, 7,
    B (= ทศนิยม 11), D (= ทศนิยม 13)
    หมายเหตุ: คุณอาจถือว่าอินพุตถูกต้องเสมอหรือเป็นสตริงว่าง
    และสัญลักษณ์ A,B,C,D,E,F เป็นตัวพิมพ์ใหญ่เสมอ
    ตัวอย่าง:
    หาก num = "AB" ผลลัพธ์ต้องเป็น 1
    หาก num = "1077E" ผลลัพธ์ต้องเป็น 2
    หาก num = "ABED1A33" ผลลัพธ์ต้องเป็น 4
    หาก num = "123456789ABCDEF0" ผลลัพธ์ต้องเป็น 6
    หาก num = "2020" ผลลัพธ์ต้องเป็น 2
    """

def hex_key(num):
    """งานของคุณคือการเขียนฟังก์ชันที่ได้รับ
    รับเลขฐานสิบหกเป็นสตริงและนับจำนวนตัวเลขฐานสิบหกที่เป็นจำนวนเฉพาะ
    จำนวนเฉพาะ (จำนวนเฉพาะหรือจำนวนเฉพาะเป็นจำนวนธรรมชาติ)
    มากกว่า 1, ไม่ใช่ผลคูณของจำนวนธรรมชาติน้อยกว่าสองตัว)
    เลขฐานสิบหกคือ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    จำนวนเฉพาะคือ 2, 3, 5, 7, 11, 13, 17,...
    ดังนั้นคุณต้องกำหนดจำนวนต่อไปนี้: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    หมายเหตุ: คุณสามารถสันนิษฐานได้ว่าการป้อนข้อมูลถูกต้องเสมอหรือเป็นสตริงที่ว่างเปล่า
    สัญลักษณ์ A,B,C,D,E,F เป็นตัวพิมพ์ใหญ่เสมอ
    ตัวอย่าง:
    สำหรับ num = "AB" เอาต์พุตควรเป็น 1
    สำหรับ num = "1077E" เอาต์พุตควรเป็น 2
    สำหรับ num = "ABED1A33" เอาต์พุตควรเป็น 4
    สำหรับ num = "123456789ABCDEF0" เอาต์พุตควรเป็น 6
    สำหรับ num = "2020" เอาต์พุตควรเป็น 2
    """


def decimal_to_binary(decimal):
    """คุณจะได้รับตัวเลขในรูปแบบทศนิยม และงานของคุณคือการแปลงตัวเลขดังกล่าวเป็น
    รูปแบบไบนารี ฟังก์ชันควรส่งคืนสตริง โดยแต่ละอักขระจะแสดงเป็นเลขฐานสอง
    อักขระแต่ละตัวในสตริงจะเป็น '0' หรือ '1'.

    จะมีอักขระพิเศษอีกสองตัว 'db' ที่จุดเริ่มต้นและจุดสิ้นสุดของสตริง
    อักขระพิเศษมีไว้เพื่อช่วยในการจัดรูปแบบ.

    ตัวอย่าง:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """คุณจะได้รับตัวเลขในรูปแบบทศนิยมและงานของคุณคือการแปลงเป็น
    รูปแบบไบนารี ฟังก์ชันควรส่งคืนสตริง โดยแต่ละอักขระแสดงถึงเลขฐาน
    สอง

    จะมีตัวอักษรพิเศษ 'db' ที่จุดเริ่มต้นและจุดสิ้นสุดของสตริง
    ตัวอักษรพิเศษนี้มีไว้เพื่อช่วยในการจัดรูปแบบ

    ตัวอย่าง:
    decimal_to_binary(15)   # คืนค่า "db1111db"
    decimal_to_binary(32)   # คืนค่า "db100000db"
    """

def decimal_to_binary(decimal):
    """ให้ตัวเลขในรูปแบบฐานสิบ และงานของคุณคือการแปลงมันเป็นรูปแบบฐานสอง
    ฟังก์ชันควรคืนค่าเป็นสตริง โดยแต่ละตัวอักษรจะแทนฐานสอง
    แต่ละตัวอักษรในสตริงจะเป็น '0' หรือ '1'

    จะมีตัวอักษรพิเศษ 'db' ที่จุดเริ่มต้นและจุดสิ้นสุดของสตริง
    ตัวอักษรพิเศษนี้มีไว้เพื่อช่วยในการจัดรูปแบบ

    ตัวอย่าง:
    decimal_to_binary(15)   # คืนค่า "db1111db"
    decimal_to_binary(32)   # คืนค่า "db100000db"
    """


def is_happy(s):
    """
    คุณได้รับสตริง s
    งานของคุณคือการตรวจสอบว่าสตริงนั้นมีความสุขหรือไม่
    สตริงจะถือว่ามีความสุขหากความยาวของมันอย่างน้อย 3 และทุก ๆ 3 ตัวอักษรที่ติดต่อกันไม่ซ้ำกัน

    ตัวอย่าง:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """คุณได้รับสตริง s
    งานของคุณคือการตรวจสอบว่าสตริงนั้นมีความสุขหรือไม่
    สตริงจะมีความสุขถ้าความยาวของมันมีอย่างน้อย 3 และตัวอักษร 3 ตัวที่ต่อเนื่องกันนั้นแตกต่างกัน
    ตัวอย่างเช่น:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """ให้สตริง s
    งานของคุณคือการตรวจสอบว่าสตริงนั้นมีความสุขหรือไม่
    สตริงจะมีความสุขได้ต้องมีความยาวอย่างน้อย 3 และอักขระ 3 ตัวที่ต่อเนื่องกันต้องแตกต่างกันทั้งหมด
    ตัวอย่าง:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """เป็นสัปดาห์สุดท้ายของภาคเรียนและครูต้องให้เกรด
    แก่นักเรียน ครูได้สร้างอัลกอริทึมสำหรับการให้คะแนนของตนเอง
    ปัญหาเดียวคือเธอทำรหัสที่ใช้ในการให้คะแนนหายไป
    เธอได้ให้รายการ GPA ของนักเรียนบางคนแก่คุณ และคุณต้องเขียน
    ฟังก์ชันที่สามารถแสดงรายการเกรดเป็นตัวอักษรโดยใช้ตารางต่อไปนี้:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    ตัวอย่าง:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """ในสัปดาห์สุดท้ายของภาคเรียน ครูต้องให้เกรดแก่นักเรียน
    ครูใช้วิธีการของตนเองในการให้เกรด
    ปัญหาเดียวคือเธอทำโค้ดที่ใช้ในการให้เกรดหายไป
    เธอได้ให้รายการ GPA ของนักเรียนแก่คุณ และคุณต้องเขียนฟังก์ชัน
    ที่สามารถแสดงรายการเกรดตัวอักษรโดยใช้ตารางด้านล่าง
             GPA       |    เกรดตัวอักษร
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    ตัวอย่าง:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """นี่เป็นสัปดาห์สุดท้ายของภาคการศึกษา และครูต้องให้เกรด
    แก่นักเรียน ครูได้พัฒนาอัลกอริทึมการให้คะแนนของตนเอง
    ปัญหาเดียวคือเธอทำรหัสที่ใช้ในการให้คะแนนหาย
    เธอให้รายชื่อเกรดเฉลี่ยของนักเรียนบางคนแก่คุณ คุณต้องเขียน
    ฟังก์ชันที่สามารถส่งออกรายการเกรดตัวอักษรโดยใช้ตารางด้านล่าง:
             GPA       |    คะแนนตัวอักษร
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    ตัวอย่าง:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """เขียนฟังก์ชันที่ยอมรับสตริง และส่งคืน True หากความยาวสตริงเป็นจํานวนเฉพาะ มิฉะนั้น False
    ตัวอย่าง
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """เขียนฟังก์ชันที่รับสตริงและคืนค่า True หากความยาวสตริง
    เป็นจำนวนเฉพาะหรือคืนค่า False หากไม่เป็นเช่นนั้น
    ตัวอย่าง
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """รับสตริงและสร้างฟังก์ชันที่คืนค่า True
    หากความยาวของสตริงนั้นเป็นจำนวนเฉพาะ
    และคืนค่า False หากไม่เป็นเช่นนั้น
    ตัวอย่าง
    prime_length ("Hello") = = True
    prime_length ('abcdcba') = = True
    prime_length ('kittens') = = True
    prime_length ('orange') = = False
    """


def starts_one_ends(n):
    """
    ให้จำนวนเต็มบวก n ส่งคืนจำนวนของตัวเลขจำนวนเต็มบวกที่มี n หลัก
    ซึ่งเริ่มต้นหรือลงท้ายด้วยเลข 1
    """

def starts_one_ends(n):
    """
    กำหนดจำนวนเต็มบวก n แล้วส่งกลับจำนวนของจำนวนเต็มบวกที่มีหลัก n ตัว ซึ่งเริ่มหรือจบด้วย 1
    """

def starts_one_ends(n):
    """
    กำหนดจำนวนเต็มบวก n, คืนค่าจำนวนของจำนวนเต็มบวกที่มี n หลัก
    จำนวนเต็มบวกที่เริ่มต้นด้วย 1 หรือสิ้นสุดด้วย 1
    """


def solve(N):
    """เมื่อให้จำนวนเต็มบวก N ให้คืนผลรวมของหลักในรูปแบบเลขฐานสอง

    ตัวอย่าง
            สำหรับ N = 1000 ผลรวมของหลักจะเท่ากับ 1 ผลลัพธ์ควรเป็น "1"
            สำหรับ N = 150 ผลรวมของหลักจะเท่ากับ 6 ผลลัพธ์ควรเป็น "110"
            สำหรับ N = 147 ผลรวมของหลักจะเท่ากับ 12 ผลลัพธ์ควรเป็น "1100"

    ตัวแปร:
        @N จำนวนเต็ม
             ข้อจำกัด: 0 ≤ N ≤ 10000.
    ผลลัพธ์:
         สตริงเลขฐานสอง
    """

def solve(N):
    """เมื่อกำหนดจำนวนเต็มบวก N ให้ส่งคืนผลรวมทั้งหมดของตัวเลขในรูปแบบไบนารี

    ตัวอย่าง
    N = 1000 ในกรณีนี้ ผลรวมของหลักคือ 1 และผลลัพธ์ควรเป็น "1"
    N = 150 ในกรณีนี้ ผลรวมของหลักคือ 6 และผลลัพธ์ควรเป็น "110"
    N = 147 ในกรณีนี้ ผลรวมของหลักคือ 12 และผลลัพธ์ควรเป็น "1100"

    ตัวแปร:
    @N จำนวนเต็ม
         ข้อจำกัด: 0 ≤ N ≤ 10000.
    ผลลัพธ์:
     สตริงเลขฐานสอง
    """

def solve(N):
    """ให้จำนวนเต็มบวก N ส่งคืนผลรวมของตัวเลขไบนารี
    ตัวอย่าง
    สำหรับ N = 1000 ผลรวมของตัวเลขคือ 1 และเอาต์พุตควรเป็น "1"
    สำหรับ N = 150 ผลรวมของตัวเลขคือ 6 และเอาต์พุตควรเป็น "110"
    สำหรับ N = 147 ผลรวมของตัวเลขคือ 12 และเอาต์พุตควรเป็น "1100"
    ตัวแปร:
    @N จำนวนเต็ม
    เงื่อนไขข้อ จำกัด: 0≤N≤10000
    เอาท์พุต:
    สตริงของตัวเลขไบนารี
    """


def add(lst):
    """
    ให้ลิสต์ของจำนวนเต็ม lst ที่ไม่ว่าง รวมค่าของตัวเลขคู่ที่อยู่ในตำแหน่งคี่

    ตัวอย่าง:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """เมื่อกำหนดรายการจำนวนเต็มที่ไม่ว่าง lst ให้เพิ่มองค์ประกอบคู่ที่มีดัชนีคี่..

    ตัวอย่าง:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """ให้รายการที่ไม่ว่างเปล่าของจำนวนเต็ม lst รวมองค์ประกอบเลขคู่ที่อยู่ในดัชนีเลขคี่

    ตัวอย่าง:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    เขียนฟังก์ชั่นที่รับสตริงและคืนค่าเวอร์ชันที่เรียงลำดับของสตริงนั้น
    เวอร์ชันที่เรียงลำดับของสตริงคือการที่คำทั้งหมด (คั่นด้วยช่องว่าง)
    ถูกแทนที่ด้วยคำใหม่ที่ตัวอักษรทั้งหมดถูกจัดเรียง
    ตามค่า ascii ในลำดับจากน้อยไปมาก
    หมายเหตุ: คุณควรรักษาลำดับของคำและช่องว่างในประโยค

    ตัวอย่าง:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    เขียนฟังก์ชันที่รับสตริงและส่งคืนเวอร์ชันที่จัดเรียงตัวอักษรใหม่
    เวอร์ชันที่จัดเรียงตัวอักษรใหม่หมายถึงสตริงที่คำทั้งหมด (แยกด้วยช่องว่าง)
    ถูกแทนที่ด้วยคำใหม่ที่ตัวอักษรทั้งหมดเรียงตามลำดับจากน้อยไปมาก
    โดยอ้างอิงจากค่า ASCII
    หมายเหตุ: คุณต้องรักษาลำดับของคำและช่องว่างในประโยคให้เหมือนเดิม

    ตัวอย่าง:
    anti_shuffle('Hi') ส่งคืน 'Hi'
    anti_shuffle('hello') ส่งคืน 'ehllo'
    anti_shuffle('Hello World!!!') ส่งคืน 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    เขียนฟังก์ชันที่รับสตริงและคืนค่าเวอร์ชันที่เรียงลำดับของสตริงนั้น
    เวอร์ชันที่เรียงลำดับของสตริงหมายถึงการแทนที่คำทั้งหมด
    (ที่คั่นด้วยช่องว่าง) ด้วยคำใหม่ที่ตัวอักษรทั้งหมดถูกจัดเรียง
    ตามค่า ascii ในลำดับจากน้อยไปมาก
    หมายเหตุ: ควรรักษาลำดับของคำและช่องว่างในประโยค

    ตัวอย่างเช่น:
    anti_shuffle('Hi') จะคืนค่า 'Hi'
    anti_shuffle('hello') จะคืนค่า 'ehllo'
    anti_shuffle('Hello World!!!') จะคืนค่า 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    คุณจะได้รับข้อมูลสองมิติในรูปแบบรายการซ้อนกัน
    ซึ่งคล้ายกับเมทริกซ์ อย่างไรก็ตาม ต่างจากเมทริกซ์ตรงที่
    แต่ละแถวอาจมีจำนวนคอลัมน์ต่างกัน
    กำหนด lst และจำนวนเต็ม x ค้นหาจำนวนเต็ม x ในรายการ
    และส่งคืนรายการของทูเพิล [(x1, y1), (x2, y2) ...] โดยที่
    แต่ละทูเพิลเป็นพิกัด - (แถว คอลัมน์) เริ่มต้นด้วย 0
    เรียงลำดับพิกัดในเบื้องต้นตามแถวโดยเรียงจากน้อยไปมาก
    นอกจากนี้ ให้เรียงลำดับพิกัดของแถวตามคอลัมน์จากมากไปน้อยด้วย

    ตัวอย่าง:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    ข้อมูลสองมิติจะถูกให้มาในรูปแบบของรายการที่ซ้อนกัน
    ซึ่งคล้ายกับเมทริกซ์ แต่แตกต่างจากเมทริกซ์ตรงที่
    แต่ละแถวอาจมีจำนวนคอลัมน์ที่แตกต่างกัน
    เมื่อให้ lst และจำนวนเต็ม x ให้ค้นหาจำนวนเต็ม x ในรายการ
    และคืนค่ารายการของทูเพิลในรูปแบบ [(x1, y1), (x2, y2) ...]
    โดยแต่ละทูเพิลแสดงพิกัด - (แถว, คอลัมน์) โดยเริ่มจาก 0
    พิกัดจะถูกจัดเรียงตามแถวในลำดับจากน้อยไปมาก
    และพิกัดของแถวจะถูกจัดเรียงตามคอลัมน์ในลำดับจากมากไปน้อย

    ตัวอย่าง:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row（lst，x）：
    """
    คุณจะได้รับข้อมูลสองมิติที่เป็นรายการที่ซ้อนกัน
    มันคล้ายกับเมทริกซ์ แต่แตกต่างจากเมทริกซ์
    แต่ละแถวอาจมีจำนวนคอลัมน์ต่างกัน
    กำหนดให้ lst กับจำนวนเต็ม x จงหาจำนวนเต็ม x ในรายการ
    และส่งกลับรายการ tuples [(x1, y1), (x2, y2)...] เพื่อให้
    แต่ละ tuple เป็นพิกัด (แถวคอลัมน์) ที่เริ่มต้นด้วย 0
    เริ่มจากการเรียงลำดับพิกัดตามลำดับแถวจากน้อยไปมาก
    นอกจากนี้การจัดเรียงพิกัดของแถวตามคอลัมน์ตามลำดับจากมากไปน้อย
    ตัวอย่าง:
    get_row([
    [1,2,3,4,5,6],
    [1,2,3,4,1,6],
    [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row（[]，1）==[]
    get_row（[[]，[1]，[1,2,3]]，3）==[（2,2）]
    """


def sort_array(array):
    """
    ให้ลิสต์ของจำนวนเต็มที่ไม่เป็นลบ ส่งคืนสำเนาของลิสต์หลังจากเรียงลำดับ
    โดยจะเรียงลำดับในลำดับจากน้อยไปมาก (ascending order)
    หากผลรวมของค่าในดัชนีแรกและดัชนีสุดท้ายเป็นเลขคี่
    หรือเรียงลำดับจากมากไปน้อย (descending order)
    หากผลรวมดังกล่าวเป็นเลขคู่

    หมายเหตุ:
    * ห้ามเปลี่ยนแปลงลิสต์ที่กำหนดให้

    ตัวอย่าง:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    เมื่อได้รับอาเรย์ของจำนวนเต็มที่ไม่เป็นลบ จะคืนสำเนาของอาเรย์ที่ถูกจัดเรียงแล้ว
    ถ้าผลรวมของค่าที่ตำแหน่งแรกและค่าที่ตำแหน่งสุดท้ายเป็นเลขคี่ จะจัดเรียงในลำดับจากน้อยไปมาก
    ถ้าผลรวมเป็นเลขคู่ จะจัดเรียงในลำดับจากมากไปน้อย

    หมายเหตุ:
    * อย่าเปลี่ยนอาเรย์ที่ได้รับมา

    ตัวอย่าง:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    กำหนด array ของจำนวนเต็มที่ไม่เป็นลบ คืนค่าสำเนาของ array ที่ให้มาหลังจากเรียงลำดับ
    เรียงลำดับ array ที่กำหนดตามลำดับจากน้อยไปมาก หากผลรวม (ค่าดัชนีแรก, ค่าดัชนีสุดท้าย) เป็นเลขคี่
    หรือเรียงลำดับตามลำดับจากมากไปน้อย หากผลรวม (ค่าดัชนีแรก ค่าดัชนีสุดท้าย) เป็นเลขคู่

    หมายเหตุ:
    * อย่าเปลี่ยนแปลงอาร์เรย์ที่กำหนด

    ตัวอย่าง:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """
    สร้างฟังก์ชัน encrypt ที่รับสตริงเป็นอาร์กิวเมนต์และส่งคืนสตริงที่ถูกเข้ารหัส
    โดยการเลื่อนตัวอักษรในอัลฟาเบตลงไป 2 คูณ 2 ตำแหน่ง
    ตัวอย่าง:
    encrypt('hi') ส่งคืน 'lm'
    encrypt('asdfghjkl') ส่งคืน 'ewhjklnop'
    encrypt('gf') ส่งคืน 'kj'
    encrypt('et') ส่งคืน 'ix'
    """

def encrypt(s):
    """รับสตริงเป็นอาร์กิวเมนต์และสร้างฟังก์ชัน encrypt
    ที่คืนค่าสตริงที่ถูกเข้ารหัสด้วยการหมุนตัวอักษร
    ตัวอักษรต้องหมุนเพื่อให้ตัวอักษรเลื่อนไปยังตำแหน่งที่สองของสองเท่า
    ตัวอย่าง:
    encrypt('hi') จะคืนค่า 'lm'
    encrypt('asdfghjkl') จะคืนค่า 'ewhjklnop'
    encrypt('gf') จะคืนค่า 'kj'
    encrypt('et') จะคืนค่า 'ix'
    """

def encrypt(s):
    """สร้างฟังก์ชัน encrypt ที่ยอมรับสตริงเป็นพารามิเตอร์
    กลับสตริงที่เข้ารหัสด้วยตัวอักษรที่กำลังหมุน
    ตัวอักษรจะหมุนในลักษณะที่ทำให้ตัวอักษรเลื่อนลงมา 4 ตำแหน่ง
    ตัวอย่าง:
    encrypt ('hi') จะได้ค่า 'lm'
    encrypt ('asdfghjkl') จะได้ค่า 'ewhjklnop'
    encrypt('gf') จะได้ค่า 'kj'
    encrypt ('et') จะได้ค่า 'ix'
    """


def next_smallest(lst):
    """
    คุณได้รับรายการของจำนวนเต็ม
    เขียนฟังก์ชัน next_smallest() ที่คืนค่าตัวที่เล็กที่สุดอันดับสองในรายการ
    คืนค่า None ถ้าไม่มีค่าดังกล่าว

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

def next_smallest(lst):
    """
    คุณจะได้รับรายการจำนวนเต็ม
    เขียนฟังก์ชัน next_smallest() ที่จะส่งคืนองค์ประกอบที่เล็กเป็นอันดับที่ 2 ของรายการ
    คืนค่า None หากไม่มีองค์ประกอบดังกล่าว

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

def next_smallest(lst):
    """
    ให้รายการของจำนวนเต็ม
    สร้างฟังก์ชัน next_smallest() ที่คืนค่าตัวที่เล็กที่สุดอันดับสองในรายการ.
    หากไม่มีตัวดังกล่าว ให้คืนค่า None

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


def is_bored(S):
    """
    คุณจะได้รับสตริงของคำศัพท์ และหน้าที่ของคุณคือการนับจำนวน
    ความรู้สึกเบื่อ (boredoms) ซึ่งในที่นี้หมายถึงประโยคที่เริ่มต้นด้วยคำว่า "I"
    โดยประโยคจะถูกคั่นด้วย '.', '?' หรือ '!'

    ตัวอย่าง:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    คุณจะได้รับสตริงที่มีคำ งานของคุณคือนับจำนวน
    ของความเบื่อ ความเบื่อคือประโยคที่ขึ้นต้นด้วยคำว่า "I".
    ประโยคถูกคั่นด้วย '.', '?' หรือ '!'.

    ตัวอย่าง:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    คุณจะได้รับสตริงของคำศัพท์ และหน้าที่ของคุณคือการนับจำนวน
    ความรู้สึกเบื่อ ซึ่งความรู้สึกเบื่อในที่นี้หมายถึงประโยค
    ที่เริ่มต้นด้วยคำว่า "I" โดยประโยคถูกคั่นด้วยเครื่องหมาย '.', '?' หรือ '!'

    ตัวอย่างเช่น:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    สร้างฟังก์ชันที่ใช้ตัวเลข 3 ตัว
    คืนค่าจริงหากตัวเลขตัวหนึ่งมีค่าเท่ากับผลรวมของอีกสองตัว และตัวเลขทั้งหมดเป็นจำนวนเต็ม
    คืนค่าเท็จในกรณีอื่น ๆ

    ตัวอย่าง
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    สร้างฟังก์ชันที่รับตัวเลขสามตัว
    คืนค่า true ถ้าตัวเลขหนึ่งตัวเท่ากับผลรวมของอีกสองตัว และตัวเลขทั้งหมดเป็นจำนวนเต็ม
    คืนค่า false ในกรณีอื่น ๆ

    ตัวอย่าง
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    สร้างฟังก์ชันที่ใช้ตัวเลข 3 ตัว
    คืนค่าเป็นจริงหากตัวเลขตัวหนึ่งมีค่าเท่ากับผลรวมของอีกสองตัว และตัวเลขทั้งหมดเป็นจำนวนเต็ม
    คืนค่าเท็จในกรณีอื่น ๆ

    ตัวอย่าง
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    เขียนฟังก์ชันหนึ่งซึ่งรับข้อความมาแล้วเข้ารหัสในลักษณะที่จะสลับกรณีของอักษรทั้งหมด
    แทนที่เสียงสระทั้งหมดในข้อความด้วยอักษรที่อยู่ห่างจากเสียงสระนั้นไป 2 ตำแหน่งในอักษรภาษาอังกฤษ
    สมมุติว่ามีแต่อักษรเท่านั้น

    ตัวอย่าง:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    เขียนฟังก์ชันที่รับข้อความและเข้ารหัสใน
    ทางที่สลับตัวพิมพ์ใหญ่และตัวพิมพ์เล็กของตัวอักษรทั้งหมด แทนที่สระทั้งหมดใน
    ข้อความด้วยตัวอักษรที่อยู่ถัดไป 2 ตัวใน
    ตัวอักษรภาษาอังกฤษ
    สมมติว่าเป็นตัวอักษรเท่านั้น

    ตัวอย่าง:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    รับข้อความและสลับตัวพิมพ์ใหญ่และตัวพิมพ์เล็กของตัวอักษรทั้งหมด
    เขียนฟังก์ชันเพื่อเข้ารหัสโดยแทนที่สระทั้งหมดในข้อความ
    ด้วยตัวอักษรที่อยู่ถัดไป 2 ตัวในตัวอักษรภาษาอังกฤษ
    สมมติว่าเป็นตัวอักษรเท่านั้น

    ตัวอย่าง:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """คุณจะได้รับรายการจำนวนเต็ม
    ต้องค้นหาค่าของจำนวนเฉพาะที่มากที่สุดและคืนผลรวมของหลักของมัน

    ตัวอย่าง:
    สำหรับ lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ผลลัพธ์ควรเป็น 10
    สำหรับ lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] ผลลัพธ์ควรเป็น 25
    สำหรับ lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] ผลลัพธ์ควรเป็น 13
    สำหรับ lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] ผลลัพธ์ควรเป็น 11
    สำหรับ lst = [0,81,12,3,1,21] ผลลัพธ์ควรเป็น 3
    สำหรับ lst = [0,8,1,2,1,7] ผลลัพธ์ควรเป็น 7
    """

def skjkasdkd(lst):
    """ให้รายการของจำนวนเต็ม
    ต้องค้นหาค่าของจำนวนเฉพาะที่มากที่สุดและคืนผลรวมของหลักของมัน

    ตัวอย่าง:
    For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ผลลัพธ์จะเป็น 10
    For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] ผลลัพธ์จะเป็น 25
    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] ผลลัพธ์จะเป็น 13
    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] ผลลัพธ์จะเป็น 11
    For lst = [0,81,12,3,1,21] ผลลัพธ์จะเป็น 3
    For lst = [0,8,1,2,1,7] ผลลัพธ์จะเป็น 7
    """

def skjkasdkd(lst):
    """ให้รายการของจำนวนเต็ม
    ต้องค้นหาค่าของจำนวนเฉพาะที่มากที่สุดและคืนผลรวมของหลักของมัน

    ตัวอย่าง:
    For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ผลลัพธ์ควรเป็น 10
    For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] ผลลัพธ์ควรเป็น 25
    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] ผลลัพธ์ควรเป็น 13
    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] ผลลัพธ์ควรเป็น 11
    For lst = [0,81,12,3,1,21] ผลลัพธ์ควรเป็น 3
    For lst = [0,8,1,2,1,7] ผลลัพธ์ควรเป็น 7
    """


def check_dict_case(dict):
    """
    ให้พจนานุกรม คืนค่า True หากคีย์ทั้งหมดเป็นสตริงตัวพิมพ์เล็ก
    หรือคีย์ทั้งหมดเป็นสตริงตัวพิมพ์ใหญ่ ในกรณีอื่น ๆ คืนค่า False
    หากพจนานุกรมที่ให้มาว่าง ฟังก์ชันควรคืนค่า False
    ตัวอย่าง:
    check_dict_case({"a":"apple", "b":"banana"}) ควรคืนค่า True
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) ควรคืนค่า False
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) ควรคืนค่า False
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) ควรคืนค่า False
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) ควรคืนค่า True
    """

def check_dict_case(dict):
    """
    เมื่อได้รับพจนานุกรม ให้ส่งคืน True หากคีย์ทั้งหมดเป็นสตริงตัวพิมพ์เล็ก
    หรือคีย์ทั้งหมดเป็นสตริงตัวพิมพ์ใหญ่ มิฉะนั้น ให้ส่งคืน False
    ฟังก์ชันควรส่งคืน False หากพจนานุกรมที่กำหนดว่างเปล่า
    ตัวอย่าง:
    check_dict_case({"a":"apple", "b":"banana"}) ควรคืนค่า True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) ควรคืนค่า False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) ควรคืนค่า False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) ควรคืนค่า False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) ควรคืนค่าn True.
    """

def check_dict_case(dict):
    """
    เมื่อให้พจนานุกรม จะคืนค่า True หากคีย์ทั้งหมดเป็นสตริงตัวพิมพ์เล็ก หรือคีย์ทั้งหมดเป็นสตริงตัวพิมพ์ใหญ่
    ในกรณีอื่น ๆ จะคืนค่า False
    หากพจนานุกรมที่ให้มาว่าง ฟังก์ชันควรคืนค่า False
    ตัวอย่าง:
    check_dict_case({"a":"apple", "b":"banana"}) ควรคืนค่า True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) ควรคืนค่า False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) ควรคืนค่า False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) ควรคืนค่า False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) ควรคืนค่า True.
    """


def count_up_to(n):
    """ใช้ฟังก์ชันที่รับจำนวนเต็มที่ไม่เป็นลบและส่งคืนอาร์เรย์ของจำนวนเต็ม n ตัวแรกที่เป็นจำนวนเฉพาะและน้อยกว่า n
    ตัวอย่าง:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """นำฟังก์ชันที่รับจำนวนเต็มที่ไม่เป็นลบและส่งคืนอาร์เรย์ของจำนวนเต็ม
    n แรกที่เป็นจำนวนเฉพาะและน้อยกว่า n มาใช้งาน
    ตัวอย่าง:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """สร้างฟังก์ชันหนึ่งซึ่งรับจำนวนเต็มที่ไม่ติดลบมาแล้วส่งคืนอาร์เรย์ของจำนวนเต็มบวกแรกที่เป็นจำนวนเฉพาะและน้อยกว่า n
    ตัวอย่างเช่น:
    count_up_to(5) => [2, 3]
    count_up_to(11) => [2, 3, 5, 7]
    count_up_to(0) => []
    count_up_to(20) => [2, 3, 5, 7, 11, 13, 17, 19]
    count_up_to(1) => []
    count_up_to(18) => [2, 3, 5, 7, 11, 13, 17]
    """


def multiply(a, b):
    """ทำให้ฟังก์ชันที่ใช้จำนวนเต็มสองจำนวนสมบูรณ์และส่งคืน
    ผลคูณของตัวเลขหน่วยของจำนวนเต็มเหล่านั้น
    สมมติว่าอินพุตนั้นถูกต้องเสมอ
    ตัวอย่าง:
    multiply(148, 412) ควรส่งคืน 16
    multiply(19, 28) ควรส่งคืน 72
    multiply(2020, 1851) ควรส่งคืน 0
    multiply(14,-15) ควรส่งคืน 20
    """

def multiply(a, b):
    """รับจำนวนเต็มสองจำนวนและสร้างฟังก์ชันที่คืนค่าผลคูณของหลักหน่วยของพวกมัน
    สมมติว่าข้อมูลนำเข้าเป็นข้อมูลที่ถูกต้องเสมอ
    ตัวอย่าง:
    multiply(148, 412) ควรคืนค่า 16
    multiply(19, 28) ควรคืนค่า 72
    multiply(2020, 1851) ควรคืนค่า 0
    multiply(14,-15) ควรคืนค่า 20
    """

def multiply(a, b):
    """เขียนฟังก์ชันให้สมบูรณ์ ซึ่งรับจำนวนเต็มสองตัวแล้วส่งคืนผลคูณของหลักหน่วยของทั้งสองจำนวน
    สมมุติว่าอินพุตจะถูกต้องเสมอ
    ตัวอย่าง:
    multiply(148, 412) ควรจะส่งคืน 16.
    multiply(19, 28) ควรจะส่งคืน 72.
    multiply(2020, 1851) ควรจะส่งคืน 0.
    multiply(14,-15) ควรจะส่งคืน 20.
    """


def count_upper(s):
    """
    เมื่อให้สตริง s นับจำนวนสระตัวพิมพ์ใหญ่ที่อยู่ในดัชนีเลขคู่

    ตัวอย่าง:
    count_upper('aBCdEf') จะคืนค่า 1
    count_upper('abcdefg') จะคืนค่า 0
    count_upper('dBBE') จะคืนค่า 0
    """

def count_upper(s):
    """
    เมื่อให้สตริง s นับจำนวนสระที่เป็นตัวพิมพ์ใหญ่ที่อยู่ในดัชนีเลขคู่

    ตัวอย่าง:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    เมื่อให้สตริง s นับจำนวนสระตัวพิมพ์ใหญ่ที่อยู่ในดัชนีเลขคู่

    ตัวอย่าง:
    count_upper('aBCdEf') จะคืนค่า1
    count_upper('abcdefg') จะคืนค่า 0
    count_upper('dBBE') จะคืนค่า 0
    """


def closest_integer(value):
    '''
    รับค่า (สตริง) ที่แสดงถึงตัวเลข และสร้างฟังก์ชันที่คืนค่าจำนวนเต็มที่ใกล้เคียงที่สุด
    หากตัวเลขอยู่ห่างจากจำนวนเต็มสองจำนวนเท่ากัน จะปัดไปในทิศทางที่ห่างจากศูนย์

    ตัวอย่าง
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    หมายเหตุ:
    การปัดไปในทิศทางที่ห่างจากศูนย์หมายถึง หากตัวเลขที่ให้มาอยู่ห่างจากจำนวนเต็มสองจำนวนเท่ากัน
    จะคืนค่าที่ห่างจากศูนย์มากที่สุด ตัวอย่างเช่น closest_integer("14.5") จะคืนค่า 15
    และ closest_integer("-14.5") จะคืนค่า -15
    '''

def closest_integer(value):
    '''
    สร้างฟังก์ชั่นที่รับค่า (สตริง) ที่แสดงถึงตัวเลข
    และคืนค่าจำนวนเต็มที่ใกล้เคียงกับมัน หากตัวเลขอยู่ห่างเท่ากัน
    จากจำนวนเต็มสองจำนวน ให้ปัดไปในทิศทางที่ห่างจากศูนย์

    ตัวอย่าง
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    หมายเหตุ:
    การปัดไปในทิศทางที่ห่างจากศูนย์หมายถึง หากตัวเลขที่ให้มาอยู่ห่างเท่ากัน
    จากจำนวนเต็มสองจำนวน คุณควรคืนค่า
    ที่ห่างจากศูนย์มากที่สุด ตัวอย่างเช่น closest_integer("14.5") ควร
    คืนค่า 15 และ closest_integer("-14.5") ควรคืนค่า -15.
    '''