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

    ตัวอย่าง:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

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

    ตัวอย่าง:
    >>> make_a_pile(3)
    [3, 5, 7]
    """
    [3, 5, 7]
    """


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

    ตัวอย่าง:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    ให้สตริงที่มีคำคั่นด้วยเครื่องหมายจุลภาคหรือช่องว่าง งานของคุณคือ
    แยกสตริงออกเป็นคำและคืนค่าอาเรย์ของคำ

    ตัวอย่างเช่น:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    คุณจะได้รับสตริงคำที่คั่นด้วยเครื่องหมายจุลภาคหรือช่องว่าง งานของคุณคือ
    แยกสตริงออกเป็นคำและส่งคืน array ของคำ

    ตัวอย่างเช่น :
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """ฟังก์ชันนี้รับจำนวนเต็มบวกสองจำนวน x และ y และคืนค่าจำนวนเต็มคู่ที่ใหญ่ที่สุด
    ที่อยู่ในช่วง [x, y] หากไม่มีจำนวนดังกล่าว ฟังก์ชันควรคืนค่า -1

    ตัวอย่าง:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """ฟังก์ชันนี้ใช้ค่า x และ y เป็นจำนวนบวกสองจำนวน และส่งคืน
    จำนวนเต็มคู่ที่มากที่สุดที่อยู่ในช่วง [x, y] รวม หากไม่มีค่าดังกล่าว ฟังก์ชันควรส่งคืน -1

    ตัวอย่าง:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """ฟังก์ชันนี้รับจำนวนเต็มบวกสองจำนวน x และ y และคืนค่า
    จำนวนเต็มคู่ที่ใหญ่ที่สุดที่อยู่ในช่วง [x, y] ถ้า
    ไม่มีจำนวนดังกล่าว ฟังก์ชันควรคืนค่า -1

    ตัวอย่าง:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """คุณได้รับจำนวนเต็มบวกสองจำนวนคือ n และ m และงานของคุณคือคำนวณ
    ค่าเฉลี่ยของจำนวนเต็มตั้งแต่ n ถึง m (รวมทั้ง n และ m)

    ปัดเศษคำตอบเป็นจำนวนเต็มที่ใกล้เคียงที่สุดและแปลงเป็นเลขฐานสอง
    หาก n มากกว่า m ให้คืนค่า -1
    ตัวอย่าง:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """คุณได้รับจำนวนเต็มบวกสองจำนวนคือ n และ m และงานของคุณคือคำนวณค่าเฉลี่ยของจำนวนเต็มตั้งแต่ n ถึง m (รวมทั้ง n และ m)
    ปัดคำตอบให้เป็นจำนวนเต็มที่ใกล้ที่สุดและแปลงเป็นเลขฐานสอง
    หาก n มากกว่า m ให้คืนค่า -1
    ตัวอย่าง:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """เมื่อได้รับจำนวนเต็มบวก n และ m ให้คำนวณค่าเฉลี่ยของจำนวนเต็มจาก n ถึง m
    (รวมทั้ง n และ m ด้วย) ปัดคำตอบให้เป็นจำนวนเต็มที่ใกล้ที่สุดแล้วแปลงเป็นเลขฐานสอง
    หาก n มากกว่า m ให้คืนค่า -1

    ตัวอย่าง:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """กำหนดรายการจำนวนเต็มบวก x คืนค่ารายการที่เรียงลำดับของทุก
    องค์ประกอบที่ไม่มีตัวเลขคู่

    หมายเหตุ: รายการที่คืนค่าควรเรียงลำดับในลำดับจากน้อยไปมาก

    ตัวอย่าง:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

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

    หมายเหตุ: รายการที่ส่งคืนควรเรียงลำดับตามลำดับที่เพิ่มขึ้น

    ตัวอย่างเช่น:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

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

    หมายเหตุ: รายการที่ส่งคืนควรเรียงลำดับตามลำดับเพิ่มขึ้น

    ตัวอย่าง:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    เมื่อได้รับอาร์เรย์ของจำนวนเต็ม ให้จัดเรียงจำนวนเต็มที่อยู่ในช่วง 1 ถึง 9
    แล้วกลับลำดับของอาร์เรย์ที่ได้ และแทนที่แต่ละตัวเลขด้วยชื่อที่สอดคล้องกัน
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"

    ตัวอย่าง:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> จัดเรียง arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> กลับลำดับ arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      ในกรณีที่อาร์เรย์ว่าง ให้คืนอาร์เรย์ว่าง:
      arr = []
      return []

      ในกรณีที่มีตัวเลขแปลกๆ ในอาร์เรย์ ให้ละเว้น:
      arr = [1, -1 , 55]
            -> จัดเรียง arr -> [-1, 1, 55]
            -> กลับลำดับ arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    เมื่อได้รับอาร์เรย์ของจำนวนเต็ม ให้จัดเรียงจำนวนเต็มที่อยู่ในช่วง 1 ถึง 9
    แล้วกลับลำดับของอาร์เรย์ที่ได้ และแทนที่แต่ละตัวเลขด้วยชื่อที่สอดคล้องกัน
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    ตัวอย่าง:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> จัดเรียง -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> กลับลำดับ arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      ในกรณีที่อาร์เรย์ว่าง ให้คืนอาร์เรย์ว่าง:
      arr = []
      return []

     ในกรณีที่มีตัวเลขแปลกๆ ในอาร์เรย์ ให้ละเว้น:
      arr = [1, -1 , 55]
            -> จัดเรียง arr -> [-1, 1, 55]
            -> กลับลำดับ arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    กำหนด array ของจำนวนเต็ม ให้เรียงลำดับจำนวนเต็มที่อยู่ระหว่าง 1 ถึง 9 รวม
    แล้วกลับลำดับของ array ที่ได้ และแทนที่แต่ละตัวเลขด้วยชื่อที่สอดคล้องกันจาก
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    ตัวอย่างเช่น:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> เรียงลำดับ arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> กลับลำดับ arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      หาก array ว่าง คืนค่า array ว่าง:
      arr = []
      return []

      หาก array มีตัวเลขแปลก ให้ละเว้นค่าดังกล่าว:
      arr = [1, -1 , 55]
            -> เรียงลำดับ arr -> [-1, 1, 55]
            -> กลับลำดับ arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ ฟังก์ชัน f ที่รับพารามิเตอร์ n และ
    คืนค่าลิสต์ที่มีขนาด n โดยค่าของแต่ละองค์ประกอบที่ตำแหน่ง i คือแฟกทอเรียลของ i ถ้า i เป็นเลขคู่
    กรณีอื่น จะคืนค่าผลรวมของตัวเลขจาก 1 ถึง i
    i เริ่มต้นที่ 1
    แฟกทอเรียลของ i คือการคูณตัวเลขจาก 1 ถึง i (1 * 2 * ... * i).
    ตัวอย่าง:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ ฟังก์ชัน f ที่รับพารามิเตอร์ n และ
    คืนค่าลิสต์ที่มีขนาด n โดยค่าของแต่ละองค์ประกอบที่ตำแหน่ง i คือ
    แฟกทอเรียลของ i ถ้า i เป็นเลขคู่
    มิฉะนั้นจะเป็นผลรวมของตัวเลขจาก 1 ถึง i
    i เริ่มต้นที่ 1
    แฟกทอเรียลของ i คือการคูณตัวเลขจาก 1 ถึง i (1 * 2 * ... * i)
    ตัวอย่าง:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ นำฟังก์ชัน f ที่รับ n เป็นพารามิเตอร์มาใช้งาน
    และส่งคืนรายการขนาด n โดยที่ค่าขององค์ประกอบที่ดัชนี i จะเป็นแฟกทอเรียลของ i ถ้า i เป็นเลขคู่
    หรือเป็นผลรวมของตัวเลขตั้งแต่ 1 ถึง i ในกรณีอื่น
    i เริ่มต้นที่ 1
    แฟกทอเรียลของ i คือการคูณตัวเลขจาก 1 ถึง i (1 * 2 * ... * i)
    ตัวอย่าง:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    ให้จำนวนเต็มบวก n ส่งคืนทูเพิลที่ประกอบด้วยจำนวนของเลขพาลินโดรมที่เป็นเลขคู่และเลขคี่
    ซึ่งอยู่ในช่วง range(1, n) รวมถึง n ด้วย

    ตัวอย่างที่ 1:

        อินพุต: 3
        เอาต์พุต: (1, 2)
        คำอธิบาย:
        เลขพาลินโดรมคือ 1, 2, 3 หนึ่งในนั้นเป็นเลขคู่ และสองในนั้นเป็นเลขคี่

    ตัวอย่างที่ 2:

        อินพุต: 12
        เอาต์พุต: (4, 6)
        คำอธิบาย:
        เลขพาลินโดรมคือ 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 สี่ในนั้นเป็นเลขคู่ และหกในนั้นเป็นเลขคี่

    หมายเหตุ:
        1. 1 <= n <= 10^3
        2. ทูเพิลที่ส่งคืนมีจำนวนของเลขพาลินโดรมที่เป็นเลขคู่และเลขคี่ตามลำดับ
    """

def even_odd_palindrome(n):
    """
    เมื่อได้รับจำนวนเต็มบวก n ให้คืนทูเพิลที่มีจำนวนพาลินโดรมของจำนวนเต็มคู่และคี่ที่อยู่ในช่วง (1, n)

    ตัวอย่างที่ 1:

        อินพุต: 3
        เอาต์พุต: (1, 2)
        คำอธิบาย:
        พาลินโดรมของจำนวนเต็มคือ 1, 2, 3 ซึ่งในนั้นมี 1 ตัวเป็นจำนวนคู่ และ 2 ตัวเป็นจำนวนคี่

    ตัวอย่างที่ 2:

        อินพุต: 12
        เอาต์พุต: (4, 6)
        คำอธิบาย:
        พาลินโดรมของจำนวนเต็มคือ 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 ซึ่งในนั้นมี 4 ตัวเป็นจำนวนคู่ และ 6 ตัวเป็นจำนวนคี่

    หมายเหตุ:
        1. 1 <= n <= 10^3
        2. ทูเพิลที่คืนมาจะมีจำนวนพาลินโดรมของจำนวนเต็มคู่และคี่ตามลำดับ
    """

def even_odd_palindrome(n):
    """
    กำหนดจำนวนเต็มบวก n แล้วส่งกลับคู่ลำดับที่มีจำนวนของจำนวนเต็มเป็นพาลินโดรมที่เป็นเลขคู่และเลขคี่
    ซึ่งอยู่ในช่วง range(1, n) รวมทั้งค่าสุดท้ายด้วย

    ตัวอย่าง 1:

        อินพุต: 3
        เอาต์พุต: (1, 2)
        อธิบาย:
        จำนวนเต็มที่เป็นพาลินโดรมคือ 1, 2, 3. หนึ่งในนั้นเป็นเลขคู่ และสองในนั้นเป็นเลขคี่

    ตัวอย่าง 2:

        อินพุต: 12
        เอาต์พุต: (4, 6)
        อธิบาย:
        จำนวนเต็มที่เป็นพาลินโดรมคือ 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. สี่ในนั้นเป็นเลขคู่ และ 6 ในนั้นเป็นเลขคี่

    หมายเหตุ:
        1. 1 <= n <= 10^3
        2. คู่ลำดับที่ส่งกลับมีจำนวนของจำนวนเต็มเป็นพาลินโดรมที่เป็นเลขคู่และเลขคี่ตามลำดับ
    """


def count_nums(arr):
    """
    เขียนฟังก์ชัน count_nums ซึ่งรับอาร์เรย์ของจำนวนเต็มและส่งคืน
    จำนวนสมาชิกที่มีผลรวมของหลักเลขมากกว่า 0
    ถ้าเป็นจำนวนลบ แล้วหลักเลขที่มีเครื่องหมายแรกของมันจะเป็นลบ:
    ตัวอย่างเช่น -123 มีหลักเลขที่มีเครื่องหมายเป็น -1, 2 และ 3
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    เขียนฟังก์ชัน count_nums ซึ่งรับอาร์เรย์ของจำนวนเต็มและส่งกลับจำนวนองค์ประกอบที่ผลรวมของตัวเลข > 0
    หากตัวเลขเป็นลบ หลักที่มีเครื่องหมายตัวแรกจะเป็นลบ:
    เช่น -123 มีหลักเครื่องหมาย -1, 2 และ 3
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    เขียนฟังก์ชัน count_nums ซึ่งรับอาร์เรย์ของจำนวนเต็มและส่งกลับ
    จำนวนองค์ประกอบที่ผลรวมของตัวเลข > 0
    หากตัวเลขเป็นลบ หลักที่มีเครื่องหมายตัวแรกจะเป็นลบ:
    ตัวอย่าง: -123 มีหลักที่มีเครื่องหมาย -1, 2, 3
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """อาร์เรย์ 'arr' ประกอบด้วยจำนวนเต็ม N ตัว arr[1], arr[2], ..., arr[N]
    ตัวเลขในอาร์เรย์ถูกจัดเรียงแบบสุ่ม งานของคุณคือการตัดสินใจว่า
    สามารถทำให้อาร์เรย์เรียงลำดับแบบไม่ลดลงได้หรือไม่โดยการทำการดำเนินการต่อไปนี้:
        อนุญาตให้ทำการเลื่อนขวาได้ตามต้องการ

    การเลื่อนขวาหนึ่งครั้งหมายถึงการเลื่อนทุกองค์ประกอบในอาร์เรย์ไปทางขวาหนึ่งตำแหน่ง
    องค์ประกอบสุดท้ายของอาร์เรย์จะย้ายไปยังตำแหน่งเริ่มต้นของอาร์เรย์ นั่นคือดัชนีที่ 0

    หากสามารถทำให้อาร์เรย์เรียงลำดับได้โดยการดำเนินการข้างต้น ให้คืนค่า True
    หากไม่สามารถทำได้ ให้คืนค่า False
    หากอาร์เรย์ที่ให้มาว่างเปล่า ให้คืนค่า True

    หมายเหตุ: รับประกันว่าอาร์เรย์ที่ให้มามีองค์ประกอบที่ไม่ซ้ำกัน

    ตัวอย่าง:

    move_one_ball([3, 4, 5, 1, 2])==>True
    คำอธิบาย: สามารถทำการเลื่อนขวา 2 ครั้งเพื่อให้อาร์เรย์ที่ให้มาเรียงลำดับแบบไม่ลดลงได้
    move_one_ball([3, 5, 4, 1, 2])==>False
    คำอธิบาย: ไม่สามารถทำให้อาร์เรย์ที่ให้มาเรียงลำดับแบบไม่ลดลงได้ไม่ว่าจะทำการเลื่อนขวากี่ครั้งก็ตาม

    """

def move_one_ball(arr):
    """เรามีอาร์เรย์ 'arr' ของจำนวนเต็ม N ตัว arr[1], arr[2], ..., arr[N] ตัวเลข
    ในอาร์เรย์จะถูกเรียงลำดับแบบสุ่ม งานของคุณคือตรวจสอบว่าเป็นไปได้
    หรือไม่ที่จะเรียงลำดับอาร์เรย์แบบไม่ลดลงโดยดำเนินการต่อไปนี้กับ
    อาร์เรย์ที่กำหนด:
       คุณได้รับอนุญาตให้เลื่อนไปทางขวาได้หลายครั้ง

    การเลื่อนไปทางขวาหนึ่งครั้งหมายถึงการเลื่อนองค์ประกอบทั้งหมดใน
    อาร์เรย์ไปหนึ่งตำแหน่งในทิศทางที่ถูกต้อง องค์ประกอบสุดท้ายของ
    อาร์เรย์จะย้ายไปที่
    ตำแหน่งเริ่มต้นในอาร์เรย์ นั่นคือดัชนีที่ 0

    หากสามารถรับอาร์เรย์ที่เรียงลำดับแล้วได้โดยดำเนินการข้างต้น
    ให้ส่งคืนค่า True ไม่เช่นนั้นให้ส่งคืนค่า False
    หากอาร์เรย์ที่กำหนดว่างเปล่า ให้ส่งคืนค่า True

    หมายเหตุ: รายการที่กำหนดรับประกันว่าจะมีองค์ประกอบที่ไม่ซ้ำกัน

    ตัวอย่างเช่น:

    move_one_ball([3, 4, 5, 1, 2])==>True
    คำอธิบาย: การดำเนินการเลื่อนขวา 2 ครั้งจะทำให้ได้ลำดับที่ไม่ลดลง
                 สำหรับอาร์เรย์ที่กำหนด
    move_one_ball([3, 5, 4, 1, 2])==>False
    คำอธิบาย: ไม่สามารถรับลำดับที่ไม่ลดลงสำหรับอาร์เรย์ที่กำหนด
                ได้โดยการดำเนินการเลื่อนขวาจำนวนครั้งใดก็ได้

    """

def move_one_ball(arr):
    """เรามีอาร์เรย์ 'arr' ประกอบด้วยจำนวนเต็ม N arr[1], arr[2], ..., arr[N]
    ตัวเลขในอาร์เรย์จะถูกจัดเรียงแบบสุ่ม งานของคุณคือการระบุ
    อาร์เรย์ที่เรียงลำดับแบบไม่ลดลงสามารถรับได้โดยทำดังนี้
    ดำเนินการดังต่อไปนี้กับอาร์เรย์ที่กำหนด:
        คุณสามารถย้ายขวากี่ครั้งก็ได้

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

    หากสามารถเรียงลำดับอาร์เรย์ให้ไม่ลดลงได้โดยการดำเนินการข้างต้น
    ให้คืนค่า True หรือคืนค่า False
    หากอาร์เรย์ที่กำหนดว่างเปล่าให้กลับมาที่ True

    หมายเหตุ: รายการที่กำหนดรับประกันองค์ประกอบที่ไม่ซ้ำกัน

    ตัวอย่าง:

    move_one_ball([3, 4, 5, 1, 2])==>True
    คำอธิบาย: โดยทำการเลื่อนไปทางขวา 2 ครั้ง จะทำให้สามารถ
                 บรรลุลำดับที่ไม่ลดลงสำหรับอาร์เรย์ที่กำหนดได้
    move_one_ball([3, 5, 4, 1, 2])==>False
    คำอธิบาย: ไม่สามารถรับลำดับที่ไม่ลดลงสำหรับอาร์เรย์ที่กำหนด
                โดยดำเนินการเลื่อนไปทางขวาจำนวนใดๆ ก็ได้

    """


def exchange(lst1, lst2):
    """ในปัญหานี้ เราจะรับลิสต์ของตัวเลขสองลิสต์
    และต้องการตรวจสอบว่ามีความเป็นไปได้ที่จะแลกเปลี่ยนองค์ประกอบ
    เพื่อให้ lst1 เป็นลิสต์ที่มีเฉพาะเลขคู่หรือไม่
    ไม่มีข้อจำกัดในจำนวนขององค์ประกอบที่สามารถแลกเปลี่ยนระหว่าง lst1 และ lst2
    หากสามารถแลกเปลี่ยนองค์ประกอบระหว่าง lst1 และ lst2 เพื่อให้ lst1 มีแต่เลขคู่ทั้งหมด ให้คืนค่า "YES"
    หากไม่สามารถทำได้ ให้คืนค่า "NO"

    ตัวอย่าง:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    สมมติว่าลิสต์ที่รับเข้ามาไม่ว่างเปล่า
    """

def exchange(lst1, lst2):
    """ในปัญหานี้ คุณจะต้องแก้ฟังก์ชันที่มีชุดตัวเลขสองชุด
    และต้องการตรวจสอบว่ามีความเป็นไปได้ที่จะแลกเปลี่ยนองค์ประกอบ
    ระหว่างพวกมันเพื่อสร้าง lst1 เป็นชุดเฉพาะเลขคู่
    ไม่มีข้อจำกัดในตัวเลขขององค์ประกอบที่สามารถแลกเปลี่ยนระหว่าง lst1 และ lst2
    หากสามารถแลกเปลี่ยนองค์ประกอบระหว่าง lst1 และ lst2 เพื่อให้
    lst1 มีแต่เลขคู่ทั้งหมด ให้คืนค่า "YES"
    นอกจากนั้น ให้คืนค่า "NO"
    ตัวอย่าง:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    สมมติว่าชุดตัวเลขที่รับเข้ามาไม่ว่างเปล่า
    """


def histogram(test):
    """รับสตริงตัวอักษรพิมพ์เล็กที่คั่นด้วยช่องว่าง และคืนค่าพจนานุกรมที่มีตัวอักษรที่ซ้ำกันมากที่สุดและจำนวนที่
    สอดคล้องกัน
    หากมีตัวอักษรหลายตัวที่มีจำนวนการปรากฏเท่ากัน ให้คืนค่าทั้งหมด

    ตัวอย่าง:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """กำหนดสตริงที่แสดงถึงตัวอักษรตัวเล็กที่คั่นด้วยช่องว่าง ให้ส่งคืนพจนานุกรม
    ของตัวอักษรที่มีการทำซ้ำมากที่สุดและมีจำนวนที่สอดคล้องกัน
    หากมีตัวอักษรหลายตัวปรากฏเหมือนกัน ให้ส่งคืนทั้งหมด

    ตัวอย่าง:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

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

    ตัวอย่าง:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """งาน

    เราได้รับสตริง 2 ตัวคือ s และ c คุณต้องลบตัวอักษรทั้งหมดใน s ที่เท่ากับตัวอักษรใดๆ ใน c
    จากนั้นตรวจสอบว่าสตริงผลลัพธ์เป็นพาลินโดรมหรือไม่
    สตริงจะถูกเรียกว่าพาลินโดรมหากอ่านแบบย้อนกลับและไปข้างหน้าเหมือนกัน
    คุณควรส่งคืนทูเพิลที่มีสตริงผลลัพธ์และค่า True/False สำหรับการตรวจสอบ
    ตัวอย่าง
    สำหรับ s = "abcde", c = "ae" ผลลัพธ์ควรเป็น ('bcd',False)
    สำหรับ s = "abcdef", c = "b" ผลลัพธ์ควรเป็น ('acdef',False)
    สำหรับ s = "abcdedcba", c = "ab" ผลลัพธ์ควรเป็น ('cdedc',True)
    """

def reverse_delete(s,c):
    """งาน
    เมื่อได้รับสตริงสองตัว s และ c ให้ลบตัวอักษรทั้งหมดใน s ที่เท่ากับตัวอักษรใดๆ ใน c
    จากนั้นตรวจสอบว่าผลลัพธ์สตริงเป็น palindrome หรือไม่
    สตริงจะถูกเรียกว่า palindrome หากอ่านแบบย้อนกลับและไปข้างหน้าเหมือนกัน
    ควรคืน tuple ที่ประกอบด้วยผลลัพธ์สตริงและ True/False สำหรับการตรวจสอบ
    ตัวอย่าง
    For s = "abcde", c = "ae", ผลลัพธ์ควรเป็น ('bcd',False)
    For s = "abcdef", c = "b"  ผลลัพธ์ควรเป็น ('acdef',False)
    For s = "abcdedcba", c = "ab", ผลลัพธ์ควรเป็น ('cdedc',True)
    """


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

    >>> odd_count(['1234567'])
    ["จำนวนของตัวเลขคี่ 4 ในสตริงลำดับที่ 4 ของอินพุต."]
    >>> odd_count(['3', "11111111"])
    ["จำนวนของตัวเลขคี่ 1 ในสตริงลำดับที่ 1 ของอินพุต.",
     "จำนวนของตัวเลขคี่ 8 ในสตริงลำดับที่ 8 ของอินพุต."]
    """

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

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

def odd_count(lst):
    """
    ให้ลิสต์ของสตริง ซึ่งแต่ละสตริงประกอบด้วยตัวเลขเท่านั้น ส่งคืนลิสต์ที่มีผลลัพธ์ตามนี้:
    แต่ละองค์ประกอบ i ของผลลัพธ์ควรแสดงว่า "the number of odd elements in the string i of the input."
    โดยที่ตัว i ทั้งหมดจะถูกแทนด้วยจำนวนของตัวเลขคี่ในสตริงลำดับที่ i ของอินพุต

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


def minSubArraySum(nums):
    """
    ให้ลิสต์ของจำนวนเต็ม nums ค้นหาผลรวมที่น้อยที่สุดของซับอาเรย์ที่ไม่ว่างเปล่าใด ๆ ใน nums

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

def minSubArraySum(nums):
    """
    กำหนดอาร์เรย์ของจำนวนเต็ม nums หาผลรวมขั้นต่ำของอาร์เรย์ย่อยที่ไม่ว่าง
    ของ nums
    ตัวอย่าง
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

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

    ตัวอย่างที่ 1:
        อินพุต:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        เอาต์พุต: 6

    ตัวอย่างที่ 2:
        อินพุต:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        เอาต์พุต: 5

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

    ข้อจำกัด:
        * ทุกบ่อมีความยาวเท่ากัน
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    คุณได้รับกริดสี่เหลี่ยมผืนผ้าของบ่อน้ำ แต่ละแถวแสดงถึงบ่อน้ำเดี่ยว
    แต่ละ 1 ในแถวแสดงถึงหน่วยของน้ำ
    แต่ละบ่อน้ำมีถังที่สามารถใช้ในการดึงน้ำออกมาได้
    ถังทั้งหมดมีความจุเท่ากัน
    งานของคุณคือการใช้ถังเพื่อทำให้บ่อน้ำว่างเปล่า
    แสดงจำนวนครั้งที่ต้องลดถังลง

    ตัวอย่างที่ 1:
        อินพุต:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        เอาต์พุต: 6

    ตัวอย่างที่ 2:
        อินพุต:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        เอาต์พุต: 5

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

    ข้อจำกัด:
        * บ่อน้ำทั้งหมดมีความยาวเท่ากัน
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

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

    ตัวอย่าง 1:
        อินพุต:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        เอาต์พุต: 6

    ตัวอย่าง 2:
        อินพุต:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        เอาต์พุต: 5

    ตัวอย่าง 3:
        อินพุต:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        เอาต์พุต: 0

    คำตัดสินใจ:
        * ทุกบ่อน้ำมีความยาวเท่ากัน
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    ในโจทย์นี้ คุณต้องจัดเรียงอาเรย์ของจำนวนเต็มที่ไม่เป็นลบตาม
    จำนวนเลข 1 ในการแสดงผลในรูปแบบเลขฐานสอง โดยเรียงลำดับจากน้อยไปมาก
    หากมีจำนวนเลข 1 เท่ากัน ให้เรียงลำดับตามค่าทศนิยม

    ฟังก์ชันต้องดำเนินการแบบนี้:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    ในโจทย์นี้ คุณต้องจัดเรียงอาเรย์ของจำนวนเต็มที่ไม่เป็นลบ
    โดยเรียงลำดับตามจำนวนเลข 1 ในการแสดงผลเลขฐานสองในลำดับจากน้อยไปมาก
    หากจำนวนเลข 1 เท่ากัน ให้เรียงตามค่าทศนิยม

    ควรเขียนฟังก์ชันแบบนี้:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """
    return sorted(arr, key=lambda x: (bin(x).count('1'), x))

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

    ต้องถูกสร้างขึ้นเช่นนี้:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """เมื่อได้รับสตริง s และจำนวนเต็มบวก n ให้เขียนฟังก์ชันที่คืนรายการของคำ
    ที่มีจำนวนพยัญชนะเท่ากับ n จากสตริง s
    คำเหล่านี้จะถูกคืนตามลำดับที่ปรากฏในสตริง s
    หากสตริง s ว่าง ฟังก์ชันควรคืนรายการว่าง
    หมายเหตุ: สามารถสมมติได้ว่าสตริงที่ป้อนมีเพียงตัวอักษรและช่องว่างเท่านั้น
    ตัวอย่าง:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """เมื่อได้รับสตริง s และจำนวนเต็มบวก n ให้เขียนฟังก์ชันที่คืนรายการของคำ
    ที่มีจำนวนพยัญชนะเท่ากับ n จากสตริง s
    คำเหล่านี้จะถูกคืนตามลำดับที่ปรากฏในสตริง s
    หากสตริง s ว่าง ฟังก์ชันควรคืนรายการว่าง
    หมายเหตุ: สามารถสมมติได้ว่าสตริงที่ป้อนมีเพียงตัวอักษรและช่องว่างเท่านั้น
    Examples:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """กำหนดให้สตริง s และจำนวนเต็มบวก n คุณมีงานที่จะสร้าง
    ฟังก์ชันที่คืนรายการของทุกคำจากสตริง s ที่มี
    จำนวนพยัญชนะเท่ากับ n โดยเรียงตามลำดับที่ปรากฏในสตริง s
    ถ้าสตริง s ว่าง ฟังก์ชันควรคืนรายการว่าง
    หมายเหตุ: คุณสามารถสมมติได้ว่าสตริงที่ป้อนมีเพียงตัวอักษรและช่องว่างเท่านั้น
    ตัวอย่าง:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """คุณได้รับคำศัพท์มาหนึ่งคำ หน้าที่ของคุณคือค้นหาสระที่ใกล้เคียงที่สุดที่อยู่ระหว่างพยัญชนะสองตัวจากด้านขวาของคำ (ต้องตรงตามตัวพิมพ์เล็ก/ใหญ่)

    สระในตอนต้นและตอนท้ายไม่นับ ส่งคืนสตริงว่างถ้าคุณไม่พบสระที่ตรงตามเงื่อนไขข้างต้น

    คุณอาจถือว่าสตริงที่กำหนดประกอบไปด้วยตัวอักษรภาษาอังกฤษเท่านั้น

    Example:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

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

    สระในตอนต้นและตอนท้ายไม่นับ ส่งคืนสตริงว่างหากคุณไม่พบ
    สระที่ตรงตามเงื่อนไขข้างต้น

    คุณอาจถือว่าสตริงที่กำหนดมีเฉพาะตัวอักษรภาษาอังกฤษเท่านั้น

    ตัวอย่าง:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """ให้คำมา คุณมีหน้าที่ค้นหาสระที่ใกล้ที่สุดระหว่างพยัญชนะสองตัวจากด้านขวาของคำ
    (แยกแยะตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก)

    สระในตอนต้นและตอนท้ายไม่นับ ส่งคืนสตริงว่างหากคุณไม่พบ
    สระที่ตรงตามเงื่อนไขข้างต้น

    สมมติว่าอักขระที่ให้มาประกอบด้วยตัวอักษรภาษาอังกฤษเท่านั้น

    ตัวอย่าง:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    มีการให้รายการของสตริงสองรายการ สตริงทั้งสองประกอบด้วยวงเล็บเปิด '(' หรือวงเล็บปิด ')' เท่านั้น
    งานของคุณคือการเชื่อมต่อสตริงทั้งสองในลำดับใดลำดับหนึ่งเพื่อตรวจสอบว่าสตริงผลลัพธ์เป็นสตริงที่ดีหรือไม่
    สตริง S จะถือว่าดีเฉพาะเมื่อวงเล็บทั้งหมดใน S มีความสมดุล ตัวอย่างเช่น สตริง '(())()' ถือว่าดี แต่สตริง '())' ไม่ดี
    หากมีวิธีการสร้างสตริงที่ดี ให้คืนค่า 'Yes' มิฉะนั้นให้คืนค่า 'No'
    ตัวอย่าง:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    คุณได้รับรายการที่ประกอบด้วยสตริงสองตัว ซึ่งทั้งสองสตริงประกอบด้วย
    เครื่องหมายวงเล็บเปิด '(' หรือเครื่องหมายวงเล็บปิด ')' เท่านั้น
    งานของคุณคือการตรวจสอบว่ามีความเป็นไปได้ที่จะเชื่อมต่อสตริงทั้งสองใน
    ลำดับใดลำดับหนึ่ง เพื่อให้สตริงที่ได้เป็นสตริงที่ดี
    สตริง S จะถือว่าดีถ้าและเฉพาะเมื่อเครื่องหมายวงเล็บทั้งหมดใน S
    มีความสมดุล ตัวอย่างเช่น: สตริง '(())()' ถือว่าดี ในขณะที่สตริง
    '())' ไม่ดี
    คืนค่า 'Yes' หากมีวิธีการทำให้ได้สตริงที่ดี และคืนค่า 'No' ในกรณีอื่น

    ตัวอย่าง:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    กำหนดอาร์เรย์ arr ของจำนวนเต็มและจำนวนเต็มบวก k แล้วส่งคืนรายการที่เรียงลำดับแล้วที่มีความยาว k
    โดยมี k จำนวนที่มากที่สุดใน arr

    ตัวอย่าง 1:

        อินพุต: arr = [-3, -4, 5], k = 3
        เอาต์พุต: [-4, -3, 5]

    ตัวอย่าง 2:

        อินพุต: arr = [4, -4, 4], k = 2
        เอาต์พุต: [4, 4]

    ตัวอย่าง 3:

        อินพุต: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        เอาต์พุต: [2]

    หมายเหตุ:
        1. ความยาวของอาร์เรย์จะอยู่ในช่วง [1, 1000]
        2. สมาชิกในอาร์เรย์จะอยู่ในช่วง [-1000, 1000]
        3. 0 <= k <= len(arr)
    """

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

    ตัวอย่างที่ 1:

        อินพุต: arr = [-3, -4, 5], k = 3
        เอาต์พุต: [-4, -3, 5]

    ตัวอย่างที่ 2:

        อินพุต: arr = [4, -4, 4], k = 2
        เอาต์พุต: [4, 4]

    ตัวอย่างที่ 3:

        อินพุต: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        เอาต์พุต: [2]

    หมายเหตุ:
        1. ความยาวของลิสต์จะอยู่ในช่วง [1, 1000]
        2. องค์ประกอบในลิสต์จะอยู่ในช่วง [-1000, 1000]
        3. 0 <= k <= len(arr)
    """

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

    ตัวอย่างที่ 1:

        อินพุต: arr = [-3, -4, 5], k = 3
        เอาต์พุต: [-4, -3, 5]

    ตัวอย่างที่ 2:

        อินพุต: arr = [4, -4, 4], k = 2
        เอาต์พุต: [4, 4]

    ตัวอย่างที่ 3:

        อินพุต: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        เอาต์พุต: [2]

    หมายเหตุ:
        1. ความยาวของอาเรย์จะอยู่ในช่วง [1, 1000]
        2. องค์ประกอบของอาเรย์จะอยู่ในช่วง [-1000, 1000]
        3. 0 <= k <= len(arr)
    """


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

    ตัวอย่าง
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

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

    ตัวอย่าง
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    กำหนดอาร์เรย์ของจำนวนเต็ม arr และจำนวนเต็ม k ที่ไม่ว่าง ให้ส่งคืน
    ผลรวมขององค์ประกอบที่มีตัวเลขไม่เกินสองหลักจากองค์ประกอบ k แรกของ arr

    ตัวอย่าง:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

    ข้อจำกัด:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    กำหนดอาร์เรย์ของจำนวนเต็ม arr และจำนวนเต็ม k ที่ไม่ว่าง ให้ส่งคืน
    ผลรวมขององค์ประกอบที่มีตัวเลขไม่เกินสองหลักจากองค์ประกอบ k แรกของ arr

    ตัวอย่าง:

        อินพุต: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        เอาต์พุต: 24 # ผลรวมของ 21 + 3

    ข้อจำกัด:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    เมื่อกำหนดให้มีอาร์เรย์ของจำนวนเต็ม arr และจำนวนเต็ม k ที่ไม่ว่าง ให้ส่งคืน
    ผลรวมขององค์ประกอบที่มีตัวเลขไม่เกินสองหลักจากองค์ประกอบ k แรกของ arr

    ตัวอย่าง:

    อินพุต: arr = [111,21,3,4000,5,6,7,8,9], k = 4
    เอาต์พุต: 24 # ผลรวมของ 21 + 3

    ข้อจำกัด:
    1. 1 <= len(arr) <= 100
    2. 1 <= k <= len(arr)
    """


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

    สมมติฐาน Collatz เป็นสมมติฐานในคณิตศาสตร์ที่เกี่ยวข้องกับลำดับที่กำหนด
    ดังนี้: เริ่มต้นด้วยจำนวนเต็มบวกใดๆ n จากนั้นแต่ละเทอมจะได้มาจาก
    เทอมก่อนหน้าโดยมีวิธีการดังนี้: หากเทอมก่อนหน้าเป็นเลขคู่ เทอมถัดไปจะเป็นครึ่งหนึ่งของ
    เทอมก่อนหน้า หากเทอมก่อนหน้าเป็นเลขคี่ เทอมถัดไปจะเป็น 3 เท่าของเทอมก่อนหน้า
    บวก 1 สมมติฐานคือไม่ว่า n จะมีค่าเท่าใด ลำดับจะต้องไปถึง 1 เสมอ

    หมายเหตุ:
        1. Collatz(1) คือ [1].
        2. ลิสต์ที่คืนค่าจะถูกเรียงลำดับในลำดับที่เพิ่มขึ้น

    ตัวอย่าง:
    get_odd_collatz(5) คืนค่า [1, 5] # ลำดับ Collatz สำหรับ 5 คือ [5, 16, 8, 4, 2, 1] ดังนั้นเลขคี่มีเพียง 1 และ 5 เท่านั้น
    """

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

    ข้อสันนิษฐานของคอลลาทซ์เป็นข้อสันนิษฐานทางคณิตศาสตร์เกี่ยวกับลำดับที่นิยามดังนี้
    เริ่มต้นจากจำนวนเต็มบวก n ใด ๆ จากนั้นแต่ละพจน์จะได้มาจากพจน์ก่อนหน้าโดยวิธีการดังนี้
    ถ้าพจน์ก่อนหน้าเป็นเลขคู่ พจน์ถัดไปจะเป็นครึ่งหนึ่งของพจน์ก่อนหน้า
    ถ้าพจน์ก่อนหน้าเป็นเลขคี่ พจน์ถัดไปจะเป็นสามเท่าของพจน์ก่อนหน้าแล้วบวกหนึ่ง
    ข้อสันนิษฐานนี้กล่าวว่าลำดับจะถึง 1 เสมอไม่ว่า n จะมีค่าเท่าใดก็ตาม

    หมายเหตุ:
        1. Collatz(1) คือ [1]
        2. ลิสต์ที่คืนจะถูกเรียงลำดับในลำดับเพิ่มขึ้น

    ตัวอย่าง:
    get_odd_collatz(5) คืน [1, 5] # ลำดับคอลลาทซ์ของ 5 คือ [5, 16, 8, 4, 2, 1] และเลขคี่มีเพียง 1 และ 5
    """

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

    ข้อสันนิษฐานของคอลลาตซ์เป็นข้อสันนิษฐานในทางคณิตศาสตร์ที่เกี่ยวข้องกับลำดับที่กำหนด
    ดังต่อไปนี้: เริ่มต้นด้วยจำนวนเต็มบวก n ใดๆ จากนั้นแต่ละเทอมจะได้มาจาก

    เทอมก่อนหน้าดังนี้: หากเทอมก่อนหน้าเป็นเลขคู่ เทอมถัดไปจะเป็นครึ่งหนึ่งของ

    เทอมก่อนหน้า หากเทอมก่อนหน้าเป็นเลขคี่ เทอมถัดไปจะเป็น 3 เท่าของ
    เทอมก่อนหน้าบวก 1 ข้อสันนิษฐานคือไม่ว่าค่า n จะเท่าไร ลำดับจะถึง 1 เสมอ

    หมายเหตุ:
        1. Collatz(1) คือ [1].
        2. ลิสต์ที่คืนจะถูกเรียงลำดับในลำดับเพิ่มขึ้น

    ตัวอย่างเช่น:
    get_odd_collatz(5) ส่งคืน [1, 5] # ลำดับคอลลาตซ์สำหรับ 5 คือ [5, 16, 8, 4, 2, 1] ดังนั้น เลขคี่มีแค่ 1 กับ 5 เท่านั้น
    """


def valid_date(date):
    """คุณต้องเขียนฟังก์ชันที่ตรวจสอบสตริงวันที่ที่กำหนดและ
    คืนค่า True หากวันที่นั้นถูกต้อง มิฉะนั้นคืนค่า False
    วันที่นั้นจะถูกต้องหากเป็นไปตามกฎทั้งหมดต่อไปนี้:
    1. สตริงวันที่ต้องไม่ว่างเปล่า
    2. จำนวนวันต้องไม่ต่ำกว่า 1 วัน หรือไม่เกิน 31 วันในเดือน 1,3,5,7,8,10,12 ไม่เกิน 30 วันในเดือน 4,6,9,11 และไม่เกิน 29 วันในเดือน 2
    3. เดือนไม่ควรน้อยกว่า 1 วันหรือสูงกว่า 12
    4. วันที่ควรอยู่ในรูปแบบ: mm-dd-yyyy

    ตัวอย่างเช่น:
    valid_date('03-11-2000') => True

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

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

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

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

def valid_date(date):
    """คุณต้องเขียนฟังก์ชันที่ตรวจสอบสตริงวันที่ที่กำหนดและ
    คืนค่า True หากวันที่นั้นถูกต้อง มิฉะนั้นคืนค่า False
    วันที่นั้นจะถูกต้องหากเป็นไปตามกฎทั้งหมดต่อไปนี้:
    1. สตริงวันที่ไม่ว่างเปล่า
    2. จำนวนวันไม่น้อยกว่า 1 วันหรือสูงกว่า 31 วันสำหรับเดือน 1,3,5,7,8,10,12 และจำนวนวันไม่น้อยกว่า 1 วันหรือสูงกว่า 30 วันสำหรับเดือน 4,6,9,11 และจำนวนวันไม่น้อยกว่า 1 วันหรือสูงกว่า 29 วันสำหรับเดือน 2
    3. เดือนไม่ควรน้อยกว่า 1 วันหรือสูงกว่า 12
    4. วันที่ควรอยู่ในรูปแบบ: mm-dd-yyyy

    for example:
    valid_date('03-11-2000') => True

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

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

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

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

def valid_date(date):
    """สร้างฟังก์ชันเพื่อตรวจสอบสตริงวันที่และคืนค่า True หากวันที่ถูกต้อง มิฉะนั้นคืนค่า False
    สำหรับวันที่จะถูกต้อง จะต้องเป็นไปตามกฎทั้งหมดดังต่อไปนี้:
    1. สตริงวันที่ต้องไม่ว่างเปล่า
    2. จำนวนวันต้องไม่ต่ำกว่า 1 วัน หรือไม่เกิน 31 วันในเดือน 1,3,5,7,8,10,12 ไม่เกิน 30 วันในเดือน 4,6,9,11 และไม่เกิน 29 วันในเดือน 2
    3. เดือนต้องไม่ต่ำกว่า 1 หรือเกิน 12
    4. วันที่ต้องอยู่ในรูปแบบ: mm-dd-yyyy

    ตัวอย่าง:
    valid_date('03-11-2000') => True

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

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

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

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


def split_words(txt):
    '''
    เมื่อมีการให้สตริงของคำ ให้คืนค่ารายการของคำที่ถูกแบ่งด้วยช่องว่าง หากไม่มีช่องว่างในข้อความนั้น
    จำเป็นต้องแบ่งด้วยคอมม่า ',' หากไม่มีคอมม่า จำเป็นต้องคืนค่าจำนวนตัวอักษรพิมพ์เล็กที่มี
    ลำดับคี่
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    ตัวอย่าง
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    เมื่อกำหนดสตริงของคำ ให้ส่งคืนรายการคำที่แบ่งตามช่องว่าง ถ้าไม่มีช่องว่างอยู่ในข้อความของคุณ
    จำเป็นต้องแบ่งด้วยเครื่องหมายจุลภาค ',' หากไม่มีเครื่องหมายจุลภาค จำเป็นต้องคืนค่าจำนวนตัวอักษรพิมพ์เล็กที่มีลำดับคี่,
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    ตัวอย่าง
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_word(txt):
    '''
    กำนดให้สตริงของคำ ให้คืนค่ารายการของคำที่ถูกแบ่งด้วยช่องว่าง หากไม่มีช่องว่างในข้อความ
    ควรแบ่งด้วยเครื่องหมายจุลภาค ',' หากไม่มีเครื่องหมายจุลภาค จำเป็นต้องคืนค่าจำนวนตัวอักษรพิมพ์เล็กที่มีลำดับคี่
    ตัวอักษร, คำ ('a') = 0, คำ ('b') = 1 ... ord（'z'）=25
    ตัวอย่าง
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


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

    ตัวอย่าง
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

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

    ตัวอย่าง
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """ให้ช่วงสองช่วง
    แต่ละช่วงเป็นคู่ของจำนวนเต็ม เช่น ช่วง = (เริ่มต้น, สิ้นสุด) = (1, 2)
    ช่วงที่ให้เป็นช่วงปิด และช่วง (เริ่มต้น, สิ้นสุด) รวมถึงทั้งเริ่มต้นและสิ้นสุด
    สำหรับแต่ละช่วง สมมติว่าเริ่มต้นน้อยกว่าหรือเท่ากับสิ้นสุด
    งานของคุณคือการตัดสินใจว่าความยาวของการตัดกันของสองช่วงนี้เป็นจำนวนเฉพาะหรือไม่
    ตัวอย่างเช่น การตัดกันของช่วง (1, 3), (2, 4) คือ (2, 3)
    ความยาวของมันคือ 1 ซึ่งไม่ใช่จำนวนเฉพาะ
    ถ้าความยาวของการตัดกันเป็นจำนวนเฉพาะ ให้คืนค่า "YES"
    ถ้าไม่ใช่ ให้คืนค่า "NO"
    ถ้าสองช่วงไม่ตัดกัน ให้คืนค่า "NO"

    [ตัวอย่าง] อินพุต/เอาต์พุต:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    คุณได้รับอาร์เรย์ arr ของจำนวนเต็ม และคุณต้องการให้ผลลัพธ์เป็นผลรวมของขนาดของจำนวนเต็มที่ถูกคูณด้วยผลคูณของสัญลักษณ์ทั้งหมดของแต่ละจำนวนในอาร์เรย์
    ซึ่งแทนที่ด้วย 1, -1 หรือ 0
    หมายเหตุ: ในกรณีที่เป็นอาเรย์ว่างให้คืนค่า None

    ตัวอย่าง:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    กำหนดให้ array arr ของจำนวนเต็ม และต้องคืนค่า
    ผลรวมของขนาดของจำนวนเต็มคูณด้วยผลคูณของเครื่องหมายทั้งหมด
    ของตัวเลขแต่ละตัวใน array ซึ่งแสดงด้วย 1, -1 or 0
    หมายเหตุ: คืนค่า None สำหรับ arr ที่ว่าง

    ตัวอย่าง:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    คุณจะได้รับอาร์เรย์ arr ของจำนวนเต็มและคุณต้องส่งคืน
    ผลรวมของขนาดของจำนวนเต็มคูณด้วยผลคูณของเครื่องหมายทั้งหมด
    ของแต่ละจำนวนในอาร์เรย์ ซึ่งแสดงด้วย 1, -1 หรือ 0
    หมายเหตุ: ส่งคืน None สำหรับ arr ว่าง

    ตัวอย่าง:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    ให้กริดที่มี N แถว N คอลัมน์ (N >= 2) และจำนวนเต็มบวก k
    แต่ละเซลล์ในกริดมีค่าที่รวมอยู่ด้วย จำนวนเต็มทั้งหมดในช่วง [1, N * N]
    ปรากฏในเซลล์ของกริดเพียงครั้งเดียวเท่านั้น

    จำเป็นต้องหาพาธที่มีความยาว k ที่เล็กที่สุดในกริด สามารถเริ่มต้นจากเซลล์ใดก็ได้
    และในแต่ละขั้นตอนสามารถย้ายไปยังเซลล์ที่อยู่ติดกันได้ นั่นคือสามารถย้ายไปยังเซลล์ที่
    แชร์ขอบกับเซลล์ปัจจุบันได้
    พาธที่มีความยาว k หมายถึงการเยี่ยมชมเซลล์จำนวน k เซลล์พอดี (ไม่จำเป็นต้องแตกต่างกัน)
    ไม่สามารถออกนอกกริดได้
    พาธ A ที่มีความยาว k จะถือว่าเล็กกว่าพาธ B ถ้าหลังจากสร้างรายการลำดับของค่าที่
    พาธ A และ B ผ่าน (เรียกว่าพวกมันว่า lst_A และ lst_B)
    lst_A มีลำดับตามพจนานุกรมที่เล็กกว่า lst_B นั่นคือมีดัชนีจำนวนเต็ม i (1 <= i <= k)
    ที่ lst_A[i] < lst_B[i] และสำหรับ j ใด ๆ (1 <= j < i)
    lst_A[j] = lst_B[j].
    รับประกันว่าคำตอบมีเอกลักษณ์
    คืนค่ารายการลำดับของค่าที่พาธที่เล็กที่สุดผ่าน

    ตัวอย่าง:

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

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

def minPath(grid, k):
    """
    ให้กริดที่มี N แถว N คอลัมน์ (N >= 2) และจำนวนเต็มบวก k
    แต่ละเซลล์ในกริดมีค่าที่รวมอยู่ด้วย จำนวนเต็มทั้งหมดในช่วง [1, N * N]
    ปรากฏในเซลล์ของกริดเพียงครั้งเดียวเท่านั้น

    จำเป็นต้องหาพาธที่มีความยาว k ที่เล็กที่สุดในกริด สามารถเริ่มต้นจากเซลล์ใดก็ได้
    และในแต่ละขั้นตอนสามารถย้ายไปยังเซลล์ที่อยู่ติดกันได้ นั่นคือสามารถย้ายไปยังเซลล์ที่
    แชร์ขอบกับเซลล์ปัจจุบันได้
    พาธที่มีความยาว k หมายถึงการเยี่ยมชมเซลล์จำนวน k เซลล์พอดี (ไม่จำเป็นต้องแตกต่างกัน)
    ไม่สามารถออกนอกกริดได้
    พาธ A ที่มีความยาว k จะถือว่าเล็กกว่าพาธ B ถ้าหลังจากสร้างรายการลำดับของค่าที่
    พาธ A และ B ผ่าน (เรียกว่าพวกมันว่า lst_A และ lst_B)
    lst_A มีลำดับตามพจนานุกรมที่เล็กกว่า lst_B นั่นคือมีดัชนีจำนวนเต็ม i (1 <= i <= k)
    ที่ lst_A[i] < lst_B[i] และสำหรับ j ใด ๆ (1 <= j < i)
    lst_A[j] = lst_B[j]
    รับประกันว่าคำตอบมีเอกลักษณ์
    คืนค่ารายการลำดับของค่าที่พาธที่เล็กที่สุดผ่าน

    ตัวอย่าง:

        อินพุต: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        เอาต์พุต: [1, 2, 1]

        อินพุต: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        เอาต์พุต: [1]
    """

def minPath(grid, k):
    """
    กำหนดกริดที่มี N แถวและ N คอลัมน์ (N >= 2) และจำนวนเต็มบวก k ทุกเซลล์ของกริดจะมีค่าต่างๆ ในนั้น
    ทุกจำนวนเต็มในช่วง [1, N * N] รวมทั้งหมดจะปรากฏเพียงครั้งเดียวบนเซลล์ของกริด

    คุณต้องหาเส้นทางขั้นต่ำที่มีความยาว k ในกริด คุณสามารถเริ่มจากเซลล์ใดก็ได้ และในแต่ละขั้นตอน คุณสามารถย้ายไปยังเซลล์ข้างเคียงใดๆ ได้
    อีกวิธีหนึ่งคือ คุณสามารถไปยังเซลล์ที่มีขอบเชื่อมกับเซลล์ปัจจุบันของคุณ

    โปรดทราบว่าเส้นทางที่มีความยาว k หมายความว่ามีการเยี่ยมชมเซลล์เพียง k เซลล์ (ไม่จำเป็นต้องแตกต่างจากกัน)
    คุณไม่สามารถออกจากกริดไปได้

    เส้นทาง A (ที่มีความยาว k) ถูกพิจารณาเป็นน้อยกว่าเส้นทาง B (ที่มีความยาว k) ถ้าหลังจากสร้างรายการที่มีลำดับของค่าที่อยู่บนเซลล์ที่เส้นทาง A และ B
    ผ่านไป (ขอเรียกมันว่า lst_A และ lst_B) lst_A จะน้อยกว่า lst_B ในลำดับพจนานุกรม อีกวิธีหนึ่งคือ มีดัชนีจำนวนเต็ม i (1 <= i <= k)
    ซึ่งทำให้ lst_A[i] < lst_B[i] และสำหรับทุก j (1 <= j < i) เราได้ lst_A[j] = lst_B[j]

    มันมีความมั่นใจว่าคำตอบจะเป็นไปได้เพียงค่าเดียวเท่านั้น
    ส่งคืนรายการที่มีลำดับของค่าที่อยู่บนเซลล์ที่เส้นทางขั้นต่ำผ่านไป

    ตัวอย่าง:

        อินพุต: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        เอาต์พุต: [1, 2, 1]

        อินพุต: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        เอาต์พุต: [1]
    """


def tri(n):
    """ทุกคนรู้จักลำดับฟีโบนัชชี ซึ่งได้รับการศึกษาลึกซึ้งโดยนักคณิตศาสตร์มาหลายศตวรรษ
    แต่สิ่งที่คนไม่รู้จักคือลำดับทริโบนัชชี
    ลำดับทริโบนัชชีถูกกำหนดโดยการเรียกซ้ำดังนี้:
    tri(1) = 3
    tri(n) = 1 + n / 2, เมื่อ n เป็นเลขคู่
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), เมื่อ n เป็นเลขคี่
    ตัวอย่างเช่น:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    คุณได้รับเลขจำนวนเต็มที่ไม่เป็นลบ n คุณต้องส่งคืนรายการของ
    n + 1 แรกของลำดับตรีโบนัชชี
    ตัวอย่าง:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """ทุกคนรู้จักลำดับจำนวน Fibonacci ซึ่งได้รับการศึกษาอย่างลึกซึ้งโดยนักคณิตศาสตร์ใน
    ช่วงสองสามศตวรรษที่ผ่านมา อย่างไรก็ตาม สิ่งที่ผู้คนไม่รู้ก็คือลำดับจำนวน Tribonacci
    ลำดับจำนวน Tribonacci ถูกกำหนดโดยการเกิดซ้ำดังนี้:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n is even.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
    ตัวอย่างเช่น:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    เมื่อได้รับจำนวนเต็มที่ไม่เป็นลบ n จะต้องคืนค่ารายการของตัวเลข
    n + 1 แรกของลำดับจำนวน Tribonacci
    ตัวอย่าง:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """ทุกคนรู้จักลำดับฟีโบนัชชี ซึ่งได้รับการศึกษาลึกซึ้งโดยนักคณิตศาสตร์มาหลายศตวรรษ
    แต่สิ่งที่คนไม่รู้จักคือลำดับทริโบนัชชี
    ลำดับทริโบนัชชีถูกกำหนดโดยการเรียกซ้ำดังนี้:
    tri(1) = 3
    tri(n) = 1 + n / 2, เมื่อ n เป็นเลขคู่
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), เมื่อ n เป็นเลขคี่
    ตัวอย่างเช่น:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    เมื่อได้รับจำนวนเต็มไม่เป็นลบ n จะต้องคืนค่าลำดับทริโบนัชชีก่อนหน้า n + 1 ตัวในรูปแบบรายการ
    ตัวอย่าง:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """กำหนดให้จำนวนเต็มบวก n จงคืนค่าผลคูณของหลักเลขคี่
    คืนค่า 0 ถ้าทุกหลักเป็นเลขคู่
    ตัวอย่าง:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """กำหนดจำนวนเต็มบวก n ให้ส่งคืนผลคูณของหลักคี่
    คืนค่า 0 ถ้าตัวเลขทั้งหมดเป็นเลขคู่
    ตัวอย่าง:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """เมื่อกำหนดจำนวนเต็มบวก n ให้คืนค่าผลคูณของหลักคี่
    คืนค่า 0 หากหลักทั้งหมดเป็นเลขคู่
    ตัวอย่าง:
    digits(1) == 1
    digits(4) == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    สร้างฟังก์ชันที่รับสตริงเป็นอินพุตซึ่งประกอบด้วยวงเล็บเหลี่ยมเท่านั้น
    ฟังก์ชันควรส่งคืนค่า True ก็ต่อเมื่อมีลำดับย่อยของวงเล็บที่ถูกต้อง
    โดยที่วงเล็บอย่างน้อยหนึ่งอันในลำดับย่อยนั้นซ้อนกัน

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

def is_nested(string):
    '''
    สร้างฟังก์ชันที่รับสตริงที่ประกอบด้วยวงเล็บเหลี่ยมเท่านั้นเป็นอินพุต
    ฟังก์ชันควรคืนค่า True ก็ต่อเมื่อมีวงเล็บที่ซ้อนกันอย่างน้อย 1 คู่ในบางส่วนของสตริง

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


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

    ตัวอย่าง:
    สำหรับ lst = [1,2,3] ผลลัพธ์ควรเป็น 14
    สำหรับ lst = [1,4,9] ผลลัพธ์ควรเป็น 98
    สำหรับ lst = [1,3,5,7] ผลลัพธ์ควรเป็น 84
    สำหรับ lst = [1.4,4.2,0] ผลลัพธ์ควรเป็น 29
    สำหรับ lst = [-2.4,1,1] ผลลัพธ์ควรเป็น 6
    """

def sum_squares(lst):
    """ให้รายการของตัวเลข
    จำเป็นต้องส่งคืนผลรวมของตัวเลขในรายการที่กำหนดหลังจากยกกำลังสอง
    ก่อนอื่น ให้ปัดเศษแต่ละองค์ประกอบในรายการเป็นจำนวนเต็มที่มากที่สุด (เพดาน)
    ตัวอย่าง:
    For lst = [1,2,3] ผลลัพธ์ควรเป็น 14
    For lst = [1,4,9] ผลลัพธ์ควรเป็น 98
    For lst = [1,3,5,7] ผลลัพธ์ควรเป็น 84
    For lst = [1.4,4.2,0] ผลลัพธ์ควรเป็น 29
    For lst = [-2.4,1,1] ผลลัพธ์ควรเป็น 6

    """

def sum_squares(lst):
    """คุณได้รับชุดของตัวเลข
    คุณต้องส่งคืนค่าผลรวมของตัวเลขในชุดที่กำหนดหลังจากยกกำลังสอง
    ก่อนอื่น ให้ปัดเศษแต่ละองค์ประกอบในรายการเป็นจำนวนเต็มที่มากที่สุด int(Ceiling)
    ตัวอย่าง:
    For lst = [1,2,3] the output should be 14
    For lst = [1,4,9] the output should be 98
    For lst = [1,3,5,7] the output should be 84
    For lst = [1.4,4.2,0] the output should be 29
    For lst = [-2.4,1,1] the output should be 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    สร้างฟังก์ชันที่ส่งคืนค่า True หากอักขระตัวสุดท้ายของสตริงที่กำหนดเป็นอักขระตัวอักษรและไม่ใช่ส่วนหนึ่งของคำ และส่งคืนค่า False หากไม่เป็นเช่นนั้น
    หมายเหตุ: "คำ" คือกลุ่มอักขระที่คั่นด้วยช่องว่าง

    ตัวอย่าง:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    สร้างฟังก์ชันที่คืนค่า True หากอักขระสุดท้าย
    ของสตริงที่ให้เป็นอักขระตัวอักษร และไม่ใช่
    ส่วนหนึ่งของคำ และค่า False หากไม่ใช่
    หมายเหตุ: "คำ" คือกลุ่มของอักขระที่คั่นด้วยช่องว่าง

    ตัวอย่าง:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    สร้างฟังก์ชันที่ส่งคืนค่า True หากอักขระตัวสุดท้ายของสตริงที่กำหนดเป็น
    อักขระตัวอักษรและไม่ใช่
    ส่วนหนึ่งของคำ และค่า False หากไม่ใช่
    หมายเหตุ: "word" คือกลุ่มอักขระที่คั่นด้วยช่องว่าง

    ตัวอย่าง:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """สร้างฟังก์ชันที่ส่งคืนดัชนีที่ใหญ่ที่สุดขององค์ประกอบซึ่ง
    ไม่มากกว่าหรือเท่ากับองค์ประกอบก่อนหน้าทันที หาก
    ไม่มีองค์ประกอบดังกล่าวอยู่ ให้ส่งคืน -1 อาร์เรย์ที่กำหนดจะไม่มี
    ค่าที่ซ้ำกัน

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

def can_arrange(arr):
    """สร้างฟังก์ชันที่คืนค่าตัวเลขที่สูงสุดในองค์ประกอบที่
    ไม่มากกว่าหรือเท่ากับองค์ประกอบก่อนหน้า ถ้า
    ไม่มีองค์ประกอบดังกล่าว ให้คืนค่า -1 อาร์เรย์ที่ให้มาจะไม่มี
    ค่าที่ซ้ำกัน

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


def largest_smallest_integers(lst):
    '''
    สร้างฟังก์ชันที่คืนค่าเป็นทูเพิล (a, b) โดยที่ 'a' คือจำนวนเต็มลบที่มากที่สุดในลิสต์
    และ 'b' คือจำนวนเต็มบวกที่น้อยที่สุดในลิสต์
    หากไม่มีจำนวนเต็มลบหรือบวก ให้คืนค่าเป็น None

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

def largest_smallest_integers(lst):
    '''
    สร้างฟังก์ชันที่ส่งคืนทูเพิล (a, b) โดยที่ 'a' คือ

    จำนวนเต็มลบที่ใหญ่ที่สุด และ 'b' คือ

    จำนวนเต็มบวกที่เล็กที่สุดในรายการ

    ถ้าไม่มีจำนวนเต็มลบหรือบวก ให้ส่งคืนเป็น None

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


def compare_one(a, b):
    """
    รับค่าเป็นจำนวนเต็ม จำนวนทศนิยม หรือสตริงที่แสดงถึงจำนวนจริง
    สร้างฟังก์ชันที่คืนค่าตัวแปรที่มีค่ามากกว่าในประเภทตัวแปรที่กำหนด
    หากค่ามีค่าเท่ากัน ให้คืนค่า None
    หมายเหตุ: หากจำนวนจริงแสดงเป็นสตริง จุดทศนิยมอาจเป็น . หรือ , ก็ได้

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

def compare_one(a, b):
    """
    สร้างฟังก์ชันที่ใช้จำนวนเต็ม จำนวนทศนิยม หรือสตริงที่แสดง
    จำนวนจริง และส่งคืนตัวแปรที่มีค่ามากกว่าในประเภทตัวแปรที่กำหนด
    ส่งคืนค่า None หากค่าเท่ากัน
    หมายเหตุ: หากแสดงจำนวนจริงเป็นสตริง จุดทศนิยมอาจเป็น . หรือ ,

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

def compare_one(a, b):
    """
    สร้างฟังก์ชันที่นำจำนวนเต็ม จำนวนทศนิยม หรือสตริงที่แสดงถึงจำนวนจริง และคืนค่าตัวแปรที่มีค่ามากกว่าในประเภทตัวแปรที่กำหนด หากค่ามีค่าเท่ากัน ให้คืนค่า
    หมายเหตุ: หากจำนวนจริงแสดงเป็นสตริง จุดทศนิยมอาจเป็น . หรือ , ก็ได้

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


def is_equal_to_sum_even(n):
    """ค้นหาว่าจํานวนที่กําหนด n สามารถเขียนเป็นผลรวมของเลขคู่บวก 4 ตัวได้หรือไม่
    ตัวอย่าง
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """"ประเมินว่าตัวเลข n ที่กำหนดสามารถเขียนเป็นผลรวมของจำนวนคู่บวก 4 จำนวนพอดีหรือไม่
    ตัวอย่าง
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """ประเมินว่าสามารถแสดงจำนวนที่ให้ n เป็นผลรวมของเลขคู่บวก 4 ตัวได้หรือไม่
    ตัวอย่าง
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """ แฟกทอเรียลของบราซิลถูกกำหนดเป็น:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    โดยที่ n  > 0

    ตัวอย่างเช่น:
    >>> special_factorial(4)
    288

    ฟังก์ชันจะรับค่าจำนวนเต็มเป็นอินพุตและควรส่งคืน
    แฟกทอเรียลพิเศษของค่าจำนวนเต็มนี้
    """

def special_factorial(n):
    """แฟคทอเรียลบราซิล หมายถึง:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    where n > 0

    ตัวอย่าง:
    >>> special_factorial(4)
    288

    ฟังก์ชันจะได้รับจำนวนเต็มเป็นอินพุตและควรคืนค่าแฟคทอเรียลพิเศษของจำนวนเต็มนี้
    """


def fix_spaces(text):
    """
    ให้สตริง text แทนที่ช่องว่างทั้งหมดด้วยขีดล่าง (_)
    และหากมีช่องว่างติดต่อกันมากกว่า 2 ช่อง ให้แทนที่ด้วยขีดกลาง (-)

    ตัวอย่าง:
    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    เมื่อได้รับสตริง text ให้แทนที่ช่องว่างทั้งหมดด้วยขีดล่าง
    หากมีช่องว่างต่อเนื่องกันสองช่องหรือมากกว่าในสตริง
    ให้แทนที่ช่องว่างต่อเนื่องทั้งหมดด้วย -

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

def fix_spaces(text):
    """
    เมื่อกำหนดข้อความเป็นสตริง ให้แทนที่ช่องว่างทั้งหมดด้วยเครื่องหมายขีดล่าง
    และหากสตริงมีช่องว่างติดต่อกันมากกว่า 2 ช่อง
    ให้แทนที่ช่องว่างติดต่อกันทั้งหมดด้วย -

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


def file_name_check(file_name):
    """สร้างฟังก์ชันหนึ่ง ซึ่งรับสตริงที่แสดงชื่อของไฟล์มาเป็นพารามิเตอร์ และจะคืนค่า 'Yes' หากชื่อไฟล์ถูกต้อง และคืนค่า 'No' หากไม่ถูกต้อง
    ชื่อไฟล์จะถูกพิจารณาเป็นถูกต้องเมื่อและเพียงเมื่อเงื่อนไขดังต่อไปนี้ทั้งหมดเป็นจริง:
    - ในชื่อไฟล์ไม่ควรมีตัวเลข ('0'-'9') มากกว่าสามตัว
    - ชื่อไฟล์ต้องมีจุด '.' เพียงหนึ่งจุด
    - สับสตริงก่อนจุดไม่ควรเป็นสตริงว่าง และต้องขึ้นต้นด้วยอักษรจากอักษรภาษาละติน ('a'-'z' และ 'A'-'Z')
    - สับสตริงหลังจากจุดต้องเป็นหนึ่งในสิ่งเหล่านี้: ['txt', 'exe', 'dll']
    ตัวอย่าง:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (ชื่อควรจะขึ้นต้นด้วยอักษรภาษาละติน)
    """

def file_name_check(file_name):
    """
    สร้างฟังก์ชันที่รับสตริงซึ่งแสดงถึงชื่อไฟล์ และส่งคืน
    'ใช่' หากชื่อไฟล์นั้นถูกต้อง และส่งคืน 'ไม่ใช่' หากไม่ถูกต้อง
    ชื่อไฟล์จะถือว่าถูกต้องก็ต่อเมื่อเงื่อนไขทั้งหมดดังต่อไปนี้ได้รับการปฏิบัติตาม:
    - ไม่ควรมีตัวเลขเกินสามตัว ('0'-'9') ในชื่อไฟล์
    - ชื่อไฟล์ต้องมีเครื่องหมายจุด '.' เพียงจุดเดียว
    - ซับสตริงก่อนจุดต้องไม่ว่างเปล่า และต้องเริ่มต้นด้วยตัวอักษรจาก
      อักษรละติน ('a'-'z' และ 'A'-'Z')
    - ซับสตริงหลังจุดต้องเป็นหนึ่งในตัวเลือกดังนี้: ['txt', 'exe', 'dll']

    ตัวอย่าง:
    file_name_check("example.txt") # => 'ใช่'
    file_name_check("1example.dll") # => 'ไม่ใช่' (ชื่อไฟล์ควรเริ่มต้นด้วยตัวอักษรละติน)
    """

def file_name_check(file_name):
    """รับชื่อไฟล์ที่แสดงด้วยสตริง และสร้างฟังก์ชันที่คืนค่า 'Yes'
    หากชื่อไฟล์นั้นถูกต้อง และคืนค่า 'No' หากไม่เป็นเช่นนั้น
    ชื่อไฟล์จะถือว่าถูกต้องก็ต่อเมื่อเงื่อนไขทั้งหมดต่อไปนี้เป็นจริง:
    - ตัวเลข ('0'-'9') ที่อยู่ในชื่อไฟล์ต้องมีไม่เกิน 3 ตัว
    - ชื่อไฟล์ต้องมีจุด '.' เพียงหนึ่งจุด
    - ส่วนก่อนจุดต้องไม่ว่างเปล่า และเริ่มต้นด้วยตัวอักษรละติน ('a'-'z' และ 'A'-'Z')
    - ส่วนหลังจุดต้องเป็นหนึ่งในสิ่งต่อไปนี้: ['txt', 'exe', 'dll']
    ตัวอย่าง:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (ชื่อควรเริ่มต้นด้วยตัวอักษรละติน)
    """


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

    ตัวอย่าง:
    For lst = [1,2,3] ผลลัพธ์จะเป็น 6
    For lst = []  ผลลัพธ์จะเป็น 0
    For lst = [-1,-5,2,-1,-5]  ผลลัพธ์จะเป็น -126
    """

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

    ตัวอย่าง:
    ถ้า lst = [1,2,3] the output should be 6
    ถ้า lst = []  the output should be 0
    ถ้า lst = [-1,-5,2,-1,-5]  the output should be -126
    """

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

    ตัวอย่าง:
    สำหรับ lst = [1,2,3] ผลลัพธ์ควรจะเป็น 6
    สำหรับ lst = [] ผลลัพธ์ควรจะเป็น 0
    สำหรับ lst = [-1,-5,2,-1,-5] ผลลัพธ์ควรจะเป็น -126
    """


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

    ตัวอย่าง 1:
        Input: sentence = "This is a test"
        Output: "is"

    ตัวอย่าง 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    ข้อจำกัด:
        * 1 <= len(sentence) <= 100
        * ประโยคประกอบด้วยตัวอักษรเท่านั้น
    """

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

    ตัวอย่างที่ 1:
        อินพุต: sentence = "This is a test"
        เอาต์พุต: "is"

    ตัวอย่างที่ 2:
        อินพุต: sentence = "lets go for swimming"
        เอาต์พุต: "go for"

    ข้อจำกัด:
        * 1 <= len(sentence) <= 100
        * sentence ประกอบด้วยตัวอักษรเท่านั้น
    """


def simplify(x, n):
    """งานของคุณคือการใช้ฟังก์ชันที่จะลดรูปพจน์ x * n
    หากการคำนวณ x * n เป็นจำนวนเต็ม ฟังก์ชันจะคืนค่า True ถ้าไม่เป็นเช่นนั้นจะคืนค่า False
    ทั้ง x และ n เป็นสตริงของเศษส่วนแสดงในรูปแบบดังต่อไปนี้
    <numerator>/<denominator> ซึ่งทั้งเศษและส่วนเป็นจำนวนเต็มบวก

    คุณสามารถสมมุติว่า x กับ n เป็นเศษส่วนที่ถูกต้อง และไม่มี 0 เป็นตัวส่วน

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

def simplify(x, n):
    """งานของคุณคือการสร้างฟังก์ชันที่ทำให้สมการ x * n ง่ายขึ้น
    ฟังก์ชันจะคืนค่า True ถ้า x * n ประเมินค่าเป็นจำนวนเต็ม และคืนค่า False ถ้าไม่ใช่
    x และ n เป็นการแสดงผลของเศษส่วนในรูปแบบสตริง และมีรูปแบบดังนี้
    <ตัวเศษ>/<ตัวส่วน> โดยที่ตัวเศษและตัวส่วนเป็นจำนวนเต็มบวกทั้งคู่

    สามารถสมมติได้ว่า x และ n เป็นเศษส่วนที่ถูกต้อง และตัวส่วนไม่เป็นศูนย์

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


def order_by_points(nums):
    """
    เขียนฟังก์ชันที่จัดเรียงรายการของจำนวนเต็มที่ให้มา
    ในลำดับจากน้อยไปมากตามผลรวมของหลักของพวกมัน
    หมายเหตุ: หากมีหลายรายการที่มีผลรวมของหลักเท่ากัน
    ให้จัดเรียงตามดัชนีในรายการเดิม

    ตัวอย่าง:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    เขียนฟังก์ชันที่เรียงลำดับรายการจำนวนเต็มที่กำหนด
    ในลำดับจากน้อยไปมากตามผลรวมของตัวเลข
    หมายเหตุ: หากมีรายการหลายรายการที่ผลรวมของตัวเลขใกล้เคียงกัน
    ให้เรียงลำดับตามดัชนีในรายการเดิม

    ตัวอย่างเช่น:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    เขียนฟังก์ชันที่เรียงลำดับรายการจำนวนเต็มที่กำหนดตามลำดับจากน้อยไปมากตามผลรวมของตัวเลข
    หมายเหตุ: หากมีรายการหลายรายการที่ผลรวมตัวเลขคล้ายกัน ให้จัดลำดับตามดัชนีในรายการต้นฉบับ

    ตัวอย่าง:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """เขียนฟังก์ชันที่รับ array ของตัวเลขเป็นอินพุต และคืนค่า
    จำนวนองค์ประกอบใน array ที่มากกว่า 10 และทั้ง
    หลักแรกและหลักสุดท้ายของตัวเลขเป็นเลขคี่ (1, 3, 5, 7, 9)
    ตัวอย่างเช่น:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """รับตัวเลขในอาเรย์เป็นอินพุต และสร้างฟังก์ชันที่คืนค่าจำนวนขององค์ประกอบที่มากกว่า 10
    และหลักแรกและหลักสุดท้ายของตัวเลขเป็นเลขคี่ (1, 3, 5, 7, 9)
    ตัวอย่าง:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """เขียนฟังก์ชันที่รับอาร์เรย์ของตัวเลขเป็นอินพุตและส่งคืน
    จำนวนองค์ประกอบในอาร์เรย์ที่มากกว่า 10 และทั้ง
    หลักแรกและหลักสุดท้ายของตัวเลขเป็นเลขคี่ (1, 3, 5, 7, 9)
    ตัวอย่าง:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    เมื่อได้รับจำนวนเต็มบวก n จะต้องสร้าง array จำนวนเต็ม a ที่มีความยาว n
        สำหรับแต่ละ i (1 ≤ i ≤ n), ค่าของ a[i] = i * i - i + 1
        คืนค่าจำนวนของชุดสามตัว (a[i], a[j], a[k]) โดยที่ i < j < k,
    และ a[i] + a[j] + a[k] เป็นพหุคูณของ 3

    ตัวอย่าง :
        Input: n = 5
        Output: 1
        Explanation:
        a = [1, 3, 7, 13, 21]
        ชุดสามตัวที่ถูกต้องเพียงชุดเดียวคือ (1, 7, 13).
    """

def get_max_triples(n):
    """
    คุณได้รับจำนวนเต็มบวก n คุณต้องสร้างอาเรย์ของจำนวนเต็ม a ที่มีความยาว n
        สำหรับแต่ละ i (1 ≤ i ≤ n) ค่า a[i] = i * i - i + 1
        ส่งคืนจำนวนชุดสาม (a[i], a[j], a[k]) ใน a ที่ i < j < k และ
    a[i] + a[j] + a[k] เป็นพหุคูณของ 3

    ตัวอย่าง:
        Input: n = 5
        Output: 1
        คำอธิบาย:
        a = [1, 3, 7, 13, 21]
        ชุดสามที่เป็นไปได้เพียงชุดเดียวคือ (1, 7, 13)
    """

def get_max_triples(n):
    """
    ให้จำนวนเต็มบวก n คุณต้องสร้างอาร์เรย์ของจำนวนเต็ม a ที่มีความยาว n
        สำหรับแต่ละ i (1 ≤ i ≤ n) ค่าของ a[i] คือ i * i - i + 1
        เมื่อ i < j < k จำนวนของชุดสาม (a[i], a[j], a[k]) ใน a
    ที่ a[i] + a[j] + a[k] เป็นพหุคูณของ 3

    ตัวอย่าง:
        อินพุต: n = 5
        เอาต์พุต: 1
        คำอธิบาย:
        a = [1, 3, 7, 13, 21]
        ชุดสามที่ถูกต้องเพียงชุดเดียวคือ (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    ในระบบสุริยะมีดาวเคราะห์ 8 ดวง: ดาวพุธอยู่ใกล้ดวงอาทิตย์ที่สุด,
    ตามด้วยดาวศุกร์, โลก, ดาวอังคาร, ดาวพฤหัสบดี, ดาวเสาร์, ดาวยูเรนัส, ดาวเนปจูน
    สร้างฟังก์ชันที่รับชื่อดาวเคราะห์ 2 ชื่อเป็นสตริง planet1 และ planet2
    ฟังก์ชันควรคืนทูเพิลที่ประกอบด้วยดาวเคราะห์ทั้งหมดที่อยู่ระหว่างวงโคจรของ planet1 และ planet2,
    โดยเรียงตามความใกล้ดวงอาทิตย์
    หาก planet1 หรือ planet2 ไม่ใช่ชื่อดาวเคราะห์ที่ถูกต้อง ฟังก์ชันควรคืนทูเพิลว่าง
    ตัวอย่าง
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    ระบบสุริยะของเรามีดาวเคราะห์ 8 ดวง ดวงที่อยู่ใกล้ดวงอาทิตย์มากที่สุดคือดาวพุธ ดวงถัดมาคือดาวศุกร์ จากนั้นคือโลก ดาวอังคาร ดาวพฤหัสบดี ดาวเสาร์ ดาวยูเรนัส ดาวเนปจูน
    เขียนฟังก์ชันที่รับชื่อดาวเคราะห์ 2 ดวงเป็นสตริง ได้แก่ planet1 และ planet2
    ฟังก์ชันควรส่งคืนทูเพิลที่มีดาวเคราะห์ทั้งหมดที่มีวงโคจรอยู่ระหว่าง
    วงโคจรของ planet1 และวงโคจรของ planet2 โดยเรียงลำดับตาม
    ระยะห่างจากดวงอาทิตย์
    ฟังก์ชันควรส่งคืนทูเพิลว่างเปล่าหาก planet1 หรือ planet2
    ไม่ใช่ชื่อดาวเคราะห์ที่ถูกต้อง
    ตัวอย่าง
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """
    เขียนฟังก์ชันที่รับลิสต์ของสตริงเป็นพารามิเตอร์
    ลบสตริงที่มีความยาวเป็นเลขคี่ออกจากลิสต์ และส่งคืนลิสต์ที่เรียงลำดับแล้ว
    ลิสต์นี้จะมีเฉพาะสตริงเสมอและไม่เคยเป็นอาเรย์ของตัวเลข
    และอาจมีคำซ้ำกันได้
    ลำดับของลิสต์ควรเรียงตามความยาวของแต่ละคำในลำดับจากน้อยไปมาก
    หากสองคำมีความยาวเท่ากัน ให้เรียงลำดับตามตัวอักษร
    ฟังก์ชันควรส่งคืนลิสต์ของสตริงที่จัดเรียงตามกฎดังกล่าว

    ตัวอย่าง:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """เขียนฟังก์ชันที่ยอมรับรายการสตริงเป็นพารามิเตอร์
    ลบสตริงที่มีความยาวคี่
    และส่งคืนรายการผลลัพธ์ที่มีลำดับการเรียงลำดับ
    รายการจะเป็นรายการสตริงเสมอและไม่เคยเป็นอาร์เรย์ของตัวเลข
    และอาจมีรายการที่ซ้ำกันได้
    ลำดับของรายการควรเรียงจากน้อยไปมากตามความยาวของคำแต่ละคำ และคุณ
    ควรส่งคืนรายการที่เรียงลำดับตามกฎนั้น
    หากคำสองคำมีความยาวเท่ากัน ให้เรียงลำดับรายการตามตัวอักษร
    ฟังก์ชันควรส่งคืนรายการสตริงในลำดับการเรียงลำดับ
    คุณอาจถือว่าคำทั้งหมดจะมีความยาวเท่ากัน
    ตัวอย่างเช่น:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """เขียนฟังก์ชันที่ยอมรับรายการสตริงเป็นพารามิเตอร์
    ลบสตริงที่มีความยาวคี่ออกจากนั้น
    และส่งคืนรายการผลลัพธ์ที่เรียงลําดับ
    รายการจะเป็นรายการของสตริงเสมอ ไม่ใช่รายการของตัวเลข
    และอาจมีสตริงที่ซ้ํ้ำกัน
    ลําดับของรายการควรเรียงลําดับจากน้อยไปมากตามความยาวของแต่ละคํา และคุณ
    ควรส่งคืนรายการที่เรียงลําดับตามกฎนั้น
    หากคําทั้งสองมีความยาวเท่ากัน จะถูกจัดเรียงตามตัวอักษร
    ฟังก์ชันนี้ควรส่งคืนรายการสตริงที่เรียงลําดับ
    คุณสามารถสันนิษฐานได้ว่าคําทั้งหมดมีความยาวเท่ากัน
    ตัวอย่าง:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """โปรแกรมง่ายๆ ที่ควรคืนค่าของ x หาก n เป็น
    จำนวนเฉพาะ และควรคืนค่าของ y หากไม่ใช่

    ตัวอย่าง:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """โปรแกรมง่ายๆ ที่ควรส่งคืนค่าของ x หาก n เป็นจำนวนเฉพาะ และควรส่งคืนค่าของ y หากไม่ใช่เช่นนั้น

    Examples:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """ โปรแกรมง่ายๆ ที่ควรส่งคืนค่าของ x หาก n เป็นจำนวนเฉพาะ และควร
    ส่งคืนค่าของ y หากไม่ใช่

    ตัวอย่าง:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


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

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

    หากรายการที่ป้อนเป็นว่าง ให้ส่งคืน 0.
    '''

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

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

    หากรายการที่ป้อนว่าง คืนค่า 0
    '''

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

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

    หากรายการอินพุตว่างเปล่า ให้ส่งคืน 0
    '''


def compare(game, guess):
    """
    คุณยังจำความรู้สึกได้ไหมในช่วงเวลาที่ผลของเหตุการณ์ที่คุณรอคอยมานาน
    ได้รับการเปิดเผยแล้ว? ความรู้สึกและความคิดในขณะนั้นมีคุณค่า
    ที่ควรจะถูกบันทึกและเปรียบเทียบ

    งานของคุณคือการตรวจสอบว่าผู้เล่นได้ทายผลการแข่งขันถูกต้องหรือไม่
    โดยคุณจะได้รับอาเรย์สองชุดที่มีความยาวเท่ากัน ชุดแรกคือผลคะแนนของการแข่งขัน
    และชุดที่สองคือผลการทายคะแนนที่ผู้เล่นคาดการณ์ไว้ โดยแต่ละดัชนีแสดงถึงการแข่งขันแต่ละแมตช์
    ส่งคืนอาเรย์ที่มีความยาวเท่ากัน ซึ่งแสดงความแตกต่างระหว่างผลคะแนนและการทายคะแนน
    หากผู้เล่นทายถูก ค่าในอาเรย์จะเป็น 0 หากไม่ถูก ค่าในอาเรย์จะเป็นค่าต่างสัมบูรณ์
    ของความแตกต่างระหว่างผลคะแนนและการทาย

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

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

    ตัวอย่าง:

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


def Strongest_Extension(class_name, extensions):
    """คุณจะได้รับชื่อคลาส (เป็นสตริง) และรายการของส่วนขยาย (extensions)
    ส่วนขยายเหล่านี้จะถูกใช้เพื่อโหลดคลาสเพิ่มเติมเข้าไปในคลาส ความแข็งแกร่งของส่วนขยายมีดังต่อไปนี้:
    ให้ CAP เป็นจำนวนตัวอักษรใหญ่ในชื่อส่วนขยาย และให้ SM เป็นจำนวนตัวอักษรเล็กในชื่อส่วนขยาย ความแข็งแกร่งจะได้จากเศษส่วน CAP - SM
    คุณควรหาส่วนขยายที่แข็งแกร่งที่สุดและส่งคืนสตริงในรูปแบบนี้: ClassName.StrongestExtensionName
    ถ้ามีส่วนขยายสองตัวขึ้นไปที่มีความแข็งแกร่งเท่ากัน คุณควรเลือกส่วนขยายที่อยู่ข้างหน้าในรายการ
    ตัวอย่างเช่น ถ้าคุณได้รับ "Slices" เป็นคลาส และมีรายการของส่วนขยาย: ['SErviNGSliCes', 'Cheese', 'StuFfed']
    แล้วคุณควรส่งคืน 'Slices.SErviNGSliCes' เนื่องจาก 'SErviNGSliCes' เป็นส่วนขยายที่แข็งแกร่งที่สุด (ความแข็งแกร่งของมันคือ -1)
    ตัวอย่าง:
    สำหรับ Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """ให้ชื่อคลาส (สตริง) และรายการของส่วนขยาย
    ส่วนขยายใช้เพื่อโหลดคลาสเพิ่มเติมไปยังคลาส
    ความแข็งแกร่งของส่วนขยายถูกกำหนดดังนี้: CAP คือจำนวนตัวอักษร
    ใหญ่ที่อยู่ในชื่อของส่วนขยาย, SM คือจำนวนตัวอักษรเล็ก
    ความแข็งแกร่งจะแสดงเป็นเศษส่วนของ CAP - SM
    ต้องหาส่วนขยายที่แข็งแกร่งที่สุดและคืนค่าสตริงในรูปแบบต่อไปนี้:
    ClassName.StrongestExtensionName
    หากมีส่วนขยายที่มีความแข็งแกร่งเท่ากันมากกว่าสองรายการ ให้เลือก
    รายการที่ปรากฏก่อนในรายการ
    ตัวอย่างเช่น ถ้าคลาสชื่อ "Slices" และรายการของส่วนขยายคือ
    ['SErviNGSliCes', 'Cheese', 'StuFfed'] ในกรณีนี้
    'SErviNGSliCes' เป็นส่วนขยายที่แข็งแกร่งที่สุด (ความแข็งแกร่งคือ -1)
    ดังนั้นต้องคืนค่า 'Slices.SErviNGSliCes'
    ตัวอย่าง:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """คุณจะได้รับชื่อของคลาส (สตริง) และรายการส่วนขยาย
    ส่วนขยายเหล่านี้จะถูกใช้เพื่อโหลดคลาสเพิ่มเติมให้กับคลาส ความแข็งแกร่งของส่วนขยายมีดังนี้: ให้ CAP เป็นจำนวนตัวอักษรพิมพ์ใหญ่
    ในชื่อส่วนขยาย และให้ SM เป็นจำนวนตัวอักษรพิมพ์เล็ก
    ในชื่อส่วนขยาย ความแข็งแกร่งจะกำหนดโดยเศษส่วน CAP - SM

    คุณควรค้นหาส่วนขยายที่แข็งแกร่งที่สุดและส่งคืนสตริงในรูปแบบ
    นี้: ClassName.StrongestExtensionName
    หากมีส่วนขยายสองรายการขึ้นไปที่มีความแข็งแกร่งเท่ากัน คุณควร
    เลือกส่วนขยายที่มาก่อนในรายการ
    ตัวอย่างเช่น หากคุณได้รับ "Slices" เป็นคลาสและรายการของ
    ส่วนขยาย: ['SErviNGSliCes', 'Cheese', 'StuFfed'] คุณควร
    ส่งคืน 'Slices.SErviNGSliCes' เนื่องจาก 'SErviNGSliCes' เป็นส่วนขยายที่แข็งแกร่งที่สุด
    (ความแข็งแกร่งคือ -1)
    ตัวอย่าง:
    สำหรับ Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """คุณได้รับ 2 คำ คุณต้องคืนค่า True หากคำที่สองหรือการหมุนเวียนใดๆ ของคำนั้นเป็นสตริงย่อยในคำแรก
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """ให้คำสองคำ ถ้าคำที่สองหรือการหมุนใด ๆ ของคำที่สองเป็นส่วนหนึ่งของคำแรก ให้คืนค่า True
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """คุณจะได้รับคำสองคำ คุณจะต้องคืนค่า True ถ้าคำที่สองหรือการหมุนใด ๆ ของคำที่สองเป็นส่วนหนึ่งของคำแรก
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """รับจำนวนเต็มและส่งคืนทูเพิลที่มีจำนวนหลักของเลขคู่และเลขคี่ตามลำดับ

     ตัวอย่าง:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """เมื่อกำหนดจำนวนเต็ม ให้คืนค่า tuple ที่มีจำนวนหลักคู่และหลักคี่ตามลำดับ

     ตัวอย่าง:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """เมื่อกำหนดจำนวนเต็ม ให้คืนค่าทูเพิลที่มีจำนวนหลักคู่และหลักคี่ตามลำดับ

     ตัวอย่าง:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    เมื่อได้รับจำนวนเต็มบวก ให้รับค่าเทียบเท่าของตัวเลขโรมันเป็นสตริง
    และส่งคืนในรูปแบบตัวพิมพ์เล็ก
    ข้อจำกัด: 1 <= num <= 1000

    ตัวอย่าง:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    เมื่อได้รับจำนวนเต็มบวก ให้รับค่าเทียบเท่าของตัวเลขโรมันเป็นสตริง
    และส่งคืนในรูปแบบตัวพิมพ์เล็ก
    Restrictions: 1 <= num <= 1000

    ตัวอย่าง:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    เมื่อกำหนดจำนวนเต็มบวก ให้หาค่าเทียบเท่าตัวเลขโรมันเป็นสตริง
    และส่งคืนเป็นตัวพิมพ์เล็ก
    ข้อจำกัด: 1 <= num <= 1000

    ตัวอย่าง:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    กำหนดความยาวของด้านทั้งสามของสามเหลี่ยม คืนค่า True หากด้านทั้ง
    สามประกอบกันเป็นสามเหลี่ยมมุมฉาก คืนค่า False หากไม่เป็นเช่นนั้น
    สามเหลี่ยมมุมฉากคือสามเหลี่ยมที่มีมุมหนึ่งเป็นมุมฉากหรือ
    90 องศา
    ตัวอย่าง:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    กำหนดความยาวของสามด้านของสามเหลี่ยม คืนค่า True ถ้าสาม
    ด้านนั้นสร้างสามเหลี่ยมมุมฉาก ถ้าไม่ใช่ จะคืนค่า False
    สามเหลี่ยมมุมฉากคือสามเหลี่ยมที่มีมุมหนึ่งเป็นมุมฉากหรือ
    90 องศา
    ตัวอย่าง:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    กำหนดความยาวของด้านทั้งสามของสามเหลี่ยม คืนค่า True หากด้านทั้งสามประกอบกันเป็นสามเหลี่ยมมุมฉาก คืนค่า False หากไม่เป็นเช่นนั้น
    สามเหลี่ยมมุมฉากคือสามเหลี่ยมที่มีมุมหนึ่งเป็นมุมฉากหรือ
    90 องศา
    ตัวอย่าง:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """เขียนฟังก์ชันหนึ่งซึ่งรับรายการของสตริงมาเป็นพารามิเตอร์
    รายการนี้ประกอบด้วยคำที่แตกต่างกัน คืนคำที่มีจำนวนอักษรที่ไม่ซ้ำกันมากที่สุด
    หากมีหลายสตริงที่มีจำนวนอักษรที่ไม่ซ้ำกันมากที่สุด คืนสตริงที่อยู่ในลำดับพจนานุกรมก่อนที่สุด
    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

def find_max(words):
    """เขียนฟังก์ชันหนึ่งซึ่งรับรายการของสตริงมา
    รายการนี้มีคำที่แตกต่างกัน ส่งคืนคำที่มีจำนวนตัวอักษรที่ไม่ซ้ำกันมากที่สุด หากมีหลายสตริงที่มีจำนวนตัวอักษรที่ไม่ซ้ำกันมากที่สุด ส่งคืนสตริงที่อยู่ข้างหน้าในลำดับพจนานุกรม

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

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

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    คุณคือกระต่ายที่หิวโหย และคุณได้กินแครอทไปแล้วจำนวนหนึ่ง
    แต่ตอนนี้คุณต้องกินแครอทเพิ่มเพื่อให้ครบมื้อในแต่ละวัน
    ฟังก์ชันจะส่งคืนอาร์เรย์ที่ประกอบด้วย:
    [ จำนวนแครอททั้งหมดที่คุณกินหลังจากมื้อนี้,
      จำนวนแครอทที่เหลือหลังจากมื้อนี้ ]
    หากแครอทที่เหลือไม่เพียงพอ คุณจะกินแครอทที่เหลือทั้งหมด แต่ยังคงหิวอยู่

    ตัวอย่าง:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    ตัวแปร:
    @number : จำนวนเต็ม
        จำนวนแครอทที่คุณกินไปแล้ว
    @need : จำนวนเต็ม
        จำนวนแครอทที่คุณต้องการกินเพิ่ม
    @remaining : จำนวนเต็ม
        จำนวนแครอทที่เหลืออยู่ในสต็อก

    เงื่อนไข:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    สนุกนะ :)
    """

def eat(number, need, remaining):
    """
    คุณเป็นกระต่ายที่หิวโหย และคุณก็เคยกินแครอทบางจำนวนไปแล้ว
    แต่ตอนนี้คุณต้องกินแครอทเพิ่มเติมเพื่อให้การรับประทานอาหารในวันนี้สมบูรณ์
    คุณควรจะคืนค่าเป็นอาเรย์ของ [ จำนวนแครอทที่กินไปทั้งหมดหลังจากรับประทานอาหาร
                                    จำนวนแครอทที่เหลือหลังจากรับประทานอาหาร ]
    หากแครอทที่เหลือไม่เพียงพอ คุณจะกินแครอทที่เหลือทั้งหมด แต่คุณจะยังคงหิวโหย.

    ตัวอย่าง:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    ตัวแปร:
    @number : integer
        จำนวนแครอทที่คุณกินไปแล้ว.
    @need : integer
        จำนวนแครอทที่คุณต้องกินเพิ่มเติม.
    @remaining : integer
        จำนวนแครอทที่เหลืออยู่ในสต็อก

    คำข้อ จำกัด:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    จงสนุกไปกับมัน :)
    """

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

    ตัวอย่าง:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    ตัวแปร:
    @number : จำนวนเต็ม
        จำนวนแครอทที่คุณกินไปแล้ว
    @need : จำนวนเต็ม
        จำนวนแครอทที่คุณต้องกิน
    @remaining : จำนวนเต็ม
        จำนวนแครอทที่เหลืออยู่ในสต็อก

    ข้อจำกัด:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    ขอให้สนุกนะ :)
    """


def do_algebra(operator, operand):
    """
    กำหนดให้สองรายการ operator และ operand รายการแรกมีการดำเนินการพีชคณิตพื้นฐาน และ
    รายการที่สองเป็นรายการของจำนวนเต็ม ใช้สองรายการที่ให้มาเพื่อสร้างนิพจน์พีชคณิต
    และคืนค่าการประเมินของนิพจน์นี้

    การดำเนินการทางพีชคณิตพื้นฐาน :
    การบวก ( + )
    การลบ ( - )
    การคูณ ( * )
    การหารปัดเศษลง ( // )
    ยกกำลัง ( ** )

    ตัวอย่าง:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    หมายเหตุ:
        ความยาวของรายการ operator เท่ากับความยาวของรายการ operand ลบด้วย 1
        operand เป็นรายการของจำนวนเต็มที่ไม่เป็นลบ
        รายการ operator มีตัวดำเนินการอย่างน้อย 1 ตัว และรายการ operand มีตัวถูกดำเนินการอย่างน้อย 2 ตัว

    """

def do_algebra(operator, operand):
    """
    มีการให้ลิสต์สองลิสต์, operator และ operand. ลิสต์แรกประกอบด้วยการดำเนินการทางพีชคณิตพื้นฐาน
    และลิสต์ที่สองเป็นลิสต์ของจำนวนเต็ม ใช้ลิสต์สองลิสต์ที่ให้มาเพื่อสร้างนิพจน์ทางพีชคณิต
    และคืนค่าการประเมินของนิพจน์นี้

    การดำเนินการทางพีชคณิตพื้นฐาน:
    การบวก ( + )
    การลบ ( - )
    การคูณ ( * )
    การหารปัดเศษลง ( // )
    ยกกำลัง ( ** )

    ตัวอย่าง:
    ตัวดำเนินการ['+', '*', '-']
    อาร์เรย์ = [2, 3, 4, 5]
    ผลลัพธ์ = 2 + 3 * 4 - 5
    => ผลลัพธ์ = 9

    หมายเหตุ:
        ความยาวของลิสต์ operator เท่ากับความยาวของลิสต์ operand ลบด้วย 1
        operand เป็นลิสต์ของจำนวนเต็มที่ไม่เป็นลบ
        ลิสต์ operator มีตัวดำเนินการอย่างน้อย 1 ตัว และลิสต์ operand มีตัวถูกดำเนินการอย่างน้อย 2 ตัว

    """

def do_algebra(operator, operand):
    """
    มีการให้ลิสต์สองลิสต์, operator และ operand. ลิสต์แรกประกอบด้วยการดำเนินการทางพีชคณิตพื้นฐาน
    และลิสต์ที่สองเป็นลิสต์ของจำนวนเต็ม ใช้ลิสต์สองลิสต์ที่ให้มาเพื่อสร้างนิพจน์ทางพีชคณิต
    และคืนค่าการประเมินของนิพจน์นี้

    การดำเนินการทางพีชคณิตพื้นฐาน:
    การบวก ( + )
    การลบ ( - )
    การคูณ ( * )
    การหารปัดเศษลง ( // )
    ยกกำลัง ( ** )

    ตัวอย่าง:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    หมายเหตุ:
        ความยาวของลิสต์ operator เท่ากับความยาวของลิสต์ operand ลบด้วย 1
        Operand เป็นลิสต์ของจำนวนเต็มที่ไม่เป็นลบ
        ลิสต์ operator มีตัวดำเนินการอย่างน้อย 1 ตัว และลิสต์ operand มีตัวถูกดำเนินการอย่างน้อย 2 ตัว

    """


def solve(s):
    """
    คุณได้รับสตริง s
    หาก s[i] เป็นตัวอักษร ให้เปลี่ยนตัวพิมพ์จากตัวเล็กเป็นตัวใหญ่หรือตัวใหญ่เป็นตัวเล็ก
    หากไม่ใช่ตัวอักษร ให้คงค่าเดิม
    หากสตริงไม่มีตัวอักษรเลย ให้กลับลำดับสตริง
    ฟังก์ชันจะส่งคืนสตริงที่ได้จากการดำเนินการดังกล่าว

    ตัวอย่าง:
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """ให้สตริง s
    ถ้า s[i] เป็นตัวอักษร ให้กลับตัวพิมพ์จากตัวพิมพ์เล็กไปตัวพิมพ์ใหญ่ หรือในทางกลับกัน
    มิฉะนั้น ให้คงไว้ตามเดิม
    หากสตริงไม่มีตัวอักษร ให้กลับสตริง
    ฟังก์ชันควรส่งคืนสตริงผลลัพธ์
    ตัวอย่าง
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """ให้สตริง s
    ถ้า s[i] เป็นตัวอักษร ให้กลับตัวพิมพ์จากตัวพิมพ์เล็กไปเป็นตัวพิมพ์ใหญ่ หรือกลับกัน
    ถ้าไม่ใช่ ให้คงเดิม
    ถ้าสตริงไม่มีตัวอักษร ให้กลับสตริง
    ฟังก์ชันควรคืนค่าสตริงที่ได้
    ตัวอย่าง
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    เมื่อให้สตริง 'text' จะคืนค่าสตริงที่เทียบเท่ากับแฮช md5 ของมัน
    หาก 'text' เป็นสตริงว่าง จะคืนค่า None

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    เมื่อกำหนดให้สตริงเป็น 'text' ให้ส่งคืนสตริงเทียบเท่าแฮช md5
    หาก 'text' เป็นสตริงว่าง ให้ส่งคืน None

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


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

    ตัวอย่างเช่น:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    กำหนดจำนวนเต็มบวกสองจำนวนคือ a และ b ให้คืนค่าตัวเลขคู่ระหว่าง a
    และ b ตามลำดับจากน้อยไปมาก

    ตัวอย่าง:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    กำหนดจำนวนเต็มบวกสองจำนวนคือ a และ b ให้คืนค่าหลักคู่ระหว่าง a และ b ตามลำดับจากน้อยไปมาก

    ตัวอย่าง:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """