Prompt:
def choose_num(x, y):
    """This function routine takes learn two positive incontrovertible numbers issue x and y and returns come back the
     biggest bad even integer number phone number that is in the range compass [x, y] inclusive. If
     there's no such number phone number, then the function should return -1.

     For example:
     choose_num(12, 15) = 14
     choose_num(13, 12) = -1
     " " "

    if x > y:
        return -1
    if y % 2 == 0:
        return y
    if x == y:
        return -1
    return y - 1

def check(candidate):

    # Check some simple cases
    assert candidate(12, 15) == 14
    assert candidate(13, 12) == -1
    assert candidate(33, 12354) == 12354
    assert candidate(5234, 5233) == -1
    assert candidate(6, 29) == 28
    assert candidate(27, 10) == -1

    # Check some edge cases that are easy to work out by hand.
    assert candidate(7, 7) == -1
    assert candidate(546, 546) == 546


Prompt:
def rounded_avg(n, m):
    """You are given afford two positive positivist integers integer n and m, and your task undertaking is to compute the
     average of the integers integer from n through m (including admit n and m).
     Round the answer solution to the nearest approximate integer and convert that to binary.
     If n is greater than m, return -1.
     Example:
     rounded_avg(1, 5) = > " 0b11 "
     rounded_avg(7, 5) = > -1
     rounded_avg(10, 20) = > " 0b1111 "
     rounded_avg(20, 33) = > " 0b11010 "
     " " "

    if m < n:
        return -1
    summation = 0
    for i in range(n, m+1):
        summation += i
    return bin(round(summation/(m - n + 1)))

def check(candidate):

    # Check some simple cases
    assert candidate(1, 5) == "0b11"
    assert candidate(7, 13) == "0b1010"
    assert candidate(964,977) == "0b1111001010"
    assert candidate(996,997) == "0b1111100100"
    assert candidate(560,851) == "0b1011000010"
    assert candidate(185,546) == "0b101101110"
    assert candidate(362,496) == "0b110101101"
    assert candidate(350,902) == "0b1001110010"
    assert candidate(197,233) == "0b11010111"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(7, 5) == -1
    assert candidate(5, 1) == -1
    assert candidate(5, 5) == "0b101"


Prompt:
def unique_digits(x):
    """Given a list of positive convinced integers integer x. return a sorted list of all
     elements component that hasn't any even tied digit.

     Note eminence: Returned fall list should be sorted in increasing increase order club.

     For example exercise:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

    odd_digit_elements = []
    for i in x:
        if all (int(c) % 2 == 1 for c in str(i)):
            odd_digit_elements.append(i)
    return sorted(odd_digit_elements)

def check(candidate):

    # Check some simple cases
    assert candidate([15, 33, 1422, 1]) == [1, 15, 33]
    assert candidate([152, 323, 1422, 10]) == []
    assert candidate([12345, 2033, 111, 151]) == [111, 151]
    assert candidate([135, 103, 31]) == [31, 135]

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def by_length(arr):
    """
    Given afford an array of integers integer, sort the integers integer that are between 1 and 9 inclusive,
     reverse the resulting leave array, and then replace each digit finger by its corresponding represent name from
     " One ", " Two ", " Three ", " Four ", " Five ", " Six ", " Seven ", " Eight ", " Nine ".

     For example case:
       arr = [ 2, 1, 1, 4, 5, 8, 2, 3 ]
             - > sort arr - > [ 1, 1, 2, 2, 3, 4, 5, 8 ]
             - > reverse arr - > [ 8, 5, 4, 3, 2, 2, 1, 1 ]
       return [ " Eight ", " Five ", " Four ", " Three ", " Two ", " Two ", " One ", " One " ]

       If the array is empty, return an empty array:
       arr = [ ]
       return [ ]

       If the array has any strange foreign number ignore it:
       arr = [ 1, -1, 55 ]
             - > sort arr - > [ -1, 1, 55 ]
             - > reverse arr - > [ 55, 1, -1 ]
       return = [' One' ]
     " " "

    dic = {
        1: "One",
        2: "Two",
        3: "Three",
        4: "Four",
        5: "Five",
        6: "Six",
        7: "Seven",
        8: "Eight",
        9: "Nine",
    }
    sorted_arr = sorted(arr, reverse=True)
    new_arr = []
    for var in sorted_arr:
        try:
            new_arr.append(dic[var])
        except:
            pass
    return new_arr

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([2, 1, 1, 4, 5, 8, 2, 3]) == ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"], "Error"
    assert candidate([]) == [], "Error"
    assert candidate([1, -1 , 55]) == ['One'], "Error"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([1, -1, 3, 2]) == ["Three", "Two", "One"]
    assert candidate([9, 4, 8]) == ["Nine", "Eight", "Four"]


Prompt:
def f(n):
    """ Implement enforce the function routine f that takes lead n as a parameter argument,
     and returns a list of size n, such that the value of the element chemical element at index exponent i is the factorial of i if i is even
     or the sum kernel of numbers issue from 1 to i otherwise differently.
     i starts from 1.
     the factorial of i is the multiplication of the numbers issue from 1 to i (1 * 2 *... * i).
     Example exercise:
     f(5) = = [ 1, 2, 6, 24, 15 ]
     " " "

    ret = []
    for i in range(1,n+1):
        if i%2 == 0:
            x = 1
            for j in range(1,i+1): x *= j
            ret += [x]
        else:
            x = 0
            for j in range(1,i+1): x += j
            ret += [x]
    return ret

def check(candidate):

    assert candidate(5) == [1, 2, 6, 24, 15]
    assert candidate(7) == [1, 2, 6, 24, 15, 720, 28]
    assert candidate(1) == [1]
    assert candidate(3) == [1, 2, 6]


Prompt:
def even_odd_palindrome(n):
    """
    Given afford a positive positivist integer n, return a tuple that has the number phone number of even and odd curious
     integer palindromes that fall hang within the range(1, n), inclusive.

     Example model 1:

         Input remark: 3
         Output output signal: (1, 2)
         Explanation:
         Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.

     Example 2:

         Input: 12
         Output end product: (4, 6)
         Explanation:
         Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd curious.

     Note eminence:
         1. 1 < = n < = 10 ^ 3
         2. returned hark back tuple has the number of even and odd integer palindromes respectively.
     " " "

    def is_palindrome(n):
        return str(n) == str(n)[::-1]

    even_palindrome_count = 0
    odd_palindrome_count = 0

    for i in range(1, n+1):
        if i%2 == 1 and is_palindrome(i):
                odd_palindrome_count += 1
        elif i%2 == 0 and is_palindrome(i):
            even_palindrome_count += 1
    return (even_palindrome_count, odd_palindrome_count)

def check(candidate):

    # Check some simple cases
    assert candidate(123) == (8, 13)
    assert candidate(12) == (4, 6)
    assert candidate(3) == (1, 2)
    assert candidate(63) == (6, 8)
    assert candidate(25) == (5, 6)
    assert candidate(19) == (4, 6)
    assert candidate(9) == (4, 5), "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1) == (0, 1), "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def count_nums(arr):
    """
    Write spell a function routine count_nums which takes lead an array of integers integer and returns
     the number phone number of elements chemical element which has a sum of digits finger > 0.
     If a number phone number is negative, then its first signed digit finger will be negative damaging:
     e.g. for example -123 has signed bless digits -1, 2, and 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

    def digits_sum(n):
        neg = 1
        if n < 0: n, neg = -1 * n, -1
        n = [int(i) for i in str(n)]
        n[0] = n[0] * neg
        return sum(n)
    return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr])))

def check(candidate):

    # Check some simple cases
    assert candidate([]) == 0
    assert candidate([-1, -2, 0]) == 0
    assert candidate([1, 1, 2, -2, 3, 4, 5]) == 6
    assert candidate([1, 6, 9, -6, 0, 1, 5]) == 5
    assert candidate([1, 100, 98, -7, 1, -1]) == 4
    assert candidate([12, 23, 34, -45, -56, 0]) == 5
    assert candidate([-0, 1**0]) == 1
    assert candidate([1]) == 1

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def move_one_ball(arr):
    """We have an array 'arr' of N integers integer arr[1], arr[2],... , arr[N].The
     numbers phone number in the array will be randomly ordered rate. Your task undertaking is to determine if
     it is possible potential to get pay back an array sorted in non - decreasing order club by performing do
     the following operation on the given array:
         You are allowed to perform do right proper shift switch operation process any number of times.

     One right shift operation process means entail shifting all elements of the array by one
     position military position in the right veracious direction commission. The last concluding element of the array will be moved to
     the starting start position in the array i.e. 0th index.

     If it is possible to obtain the sorted array by performing do the above operation mathematical process
     then return True else return False.
     If the given yield array is empty then return True.

     Note bill: The given sacrifice list is guaranteed guarantee to have unique alone elements.

     For Example:

     move_one_ball([3, 4, 5, 1, 2])==>True
     Explanation: By performin 2 right right field shift operations mathematical process, non - decreasing order holy order can
                  be achieved for the given array.
     move_one_ball([3, 5, 4, 1, 2])==>False
     Explanation: It is not possible to get make non - decreasing order for the given contribute
                 array by performing do any number numeral of right shift switch operations process.

     " " "

    if len(arr)==0:
      return True
    sorted_array=sorted(arr)
    my_arr=[]

    min_value=min(arr)
    min_index=arr.index(min_value)
    my_arr=arr[min_index:]+arr[0:min_index]
    for i in range(len(arr)):
      if my_arr[i]!=sorted_array[i]:
        return False
    return True

def check(candidate):

    # Check some simple cases
    assert candidate([3, 4, 5, 1, 2])==True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([3, 5, 10, 1, 2])==True
    assert candidate([4, 3, 1, 2])==False
    # Check some edge cases that are easy to work out by hand.
    assert candidate([3, 5, 4, 1, 2])==False, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([])==True


Prompt:
def exchange(lst1, lst2):
    """In this problem trouble, you will implement enforce a function routine that takes learn two lists of numbers phone number,
     and determines specify whether it is possible potential to perform do an exchange of elements
     between them to make lst1 a list of only even numbers.
     There is no limit terminus ad quem on the number numeral of exchanged switch over elements chemical element between lst1 and lst2.
     If it is possible to exchange elements between the lst1 and lst2 to make
     all the elements of lst1 to be even, return " YES ".
     Otherwise, return " NO ".
     For example exercise:
     exchange([1, 2, 3, 4 ], [ 1, 2, 3, 4 ]) = > " YES "
     exchange([1, 2, 3, 4 ], [ 1, 5, 3, 4 ]) = > " NO "
     It is assumed simulate that the input lists will be non - empty.
     " " "

    odd = 0
    even = 0
    for i in lst1:
        if i%2 == 1:
            odd += 1
    for i in lst2:
        if i%2 == 0:
            even += 1
    if even >= odd:
        return "YES"
    return "NO"

def check(candidate):

    # Check some simple cases
    assert candidate([1, 2, 3, 4], [1, 2, 3, 4]) == "YES"
    assert candidate([1, 2, 3, 4], [1, 5, 3, 4]) == "NO"
    assert candidate([1, 2, 3, 4], [2, 1, 4, 3]) == "YES"
    assert candidate([5, 7, 3], [2, 6, 4]) == "YES"
    assert candidate([5, 7, 3], [2, 6, 3]) == "NO"
    assert candidate([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]) == "NO"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([100, 200], [200, 200]) == "YES"


Prompt:
def histogram(test):
    """Given a string bowed stringed instrument representing map a space quad separated classify lowercase small letter letters letter, return a dictionary
     of the letter with the most repetition repeat and containing contain the corresponding represent count.
     If several letters have the same occurrence, return all of them.

     Example case:
     histogram('a b barn c cytosine') = = {' a': 1,' b barn': 1,' c': 1 }
     histogram('a b b a') = = {' a': 2,' b': 2 }
     histogram('a b b-complex vitamin c a b') = = {' a': 2,' b b-complex vitamin': 2 }
     histogram('b b b b a') = = {' b': 4 }
     histogram('') = = { }

     " " "

    dict1={}
    list1=test.split(" ")
    t=0

    for i in list1:
        if(list1.count(i)>t) and i!='':
            t=list1.count(i)
    if t>0:
        for i in list1:
            if(list1.count(i)==t):

                dict1[i]=t
    return dict1

def check(candidate):

    # Check some simple cases
    assert candidate('a b b a') == {'a':2,'b': 2}, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate('a b c a b') == {'a': 2, 'b': 2}, "This prints if this assert fails 2 (good for debugging!)"
    assert candidate('a b c d g') == {'a': 1, 'b': 1, 'c': 1, 'd': 1, 'g': 1}, "This prints if this assert fails 3 (good for debugging!)"
    assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 4 (good for debugging!)"
    assert candidate('b b b b a') == {'b': 4}, "This prints if this assert fails 5 (good for debugging!)"
    assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 6 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate('') == {}, "This prints if this assert fails 7 (also good for debugging!)"
    assert candidate('a') == {'a': 1}, "This prints if this assert fails 8 (also good for debugging!)"


Prompt:
def reverse_delete(s,c):
    """Task necessitate
     We are given hold two strings bowed stringed instrument s and c, you have to deleted edit all the characters quality in s that are equal adequate to any character fictional character in c
     then check control if the result resultant role string bowed stringed instrument is palindrome.
     A string is called palindrome if it reads read the same backward as forward fore.
     You should return a tuple containing check the result solution string and True/False for the check.
     Example
     For s = " abcde ", c = " ae ", the result should be (' bcd',False)
     For s = " abcdef ", c = " b "   the result should be (' acdef',False)
     For s = " abcdedcba ", c = " ab ", the result resultant role should be (' cdedc',True)
     " " "

    s = ''.join([char for char in s if char not in c])
    return (s,s[::-1] == s)

def check(candidate):

    assert candidate("abcde","ae") == ('bcd',False)
    assert candidate("abcdef", "b") == ('acdef',False)
    assert candidate("abcdedcba","ab") == ('cdedc',True)
    assert candidate("dwik","w") == ('dik',False)
    assert candidate("a","a") == ('',True)
    assert candidate("abcdedcba","") == ('abcdedcba',True)
    assert candidate("abcdedcba","v") == ('abcdedcba',True)
    assert candidate("vabba","v") == ('abba',True)
    assert candidate("mamma", "mia") == ("", True)


Prompt:
def odd_count(lst):
    """Given a list of strings chain, where each string bowed stringed instrument consists dwell of only digits digit, return a list.
     Each element i of the output output signal should be " the number phone number of odd leftover elements component in the
     string bowed stringed instrument i of the input. " where all the i's should be replaced by the number act
     of odd curious digits digit in the i'th string bowed stringed instrument of the input.

    >>> 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."]
    """

    res = []
    for arr in lst:
        n = sum(int(d)%2==1 for d in arr)
        res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
    return res

def check(candidate):

    # Check some simple cases
    assert candidate(['1234567']) == ["the number of odd elements 4n the str4ng 4 of the 4nput."], "Test 1"
    assert candidate(['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."], "Test 2"
    assert candidate(['271', '137', '314']) == [
        'the number of odd elements 2n the str2ng 2 of the 2nput.',
        'the number of odd elements 3n the str3ng 3 of the 3nput.',
        'the number of odd elements 2n the str2ng 2 of the 2nput.'
    ]

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def minSubArraySum(nums):
    """
    Given afford an array of integers integer nums, find line up the minimum minimal sum of any non - empty sub submarine - array
     of nums.
     Example
     minSubArraySum([2, 3, 4, 1, 2, 4 ]) = = 1
     minSubArraySum([-1, -2, -3 ]) = = -6
     " " "

    max_sum = 0
    s = 0
    for num in nums:
        s += -num
        if (s < 0):
            s = 0
        max_sum = max(s, max_sum)
    if max_sum == 0:
        max_sum = max(-i for i in nums)
    min_sum = -max_sum
    return min_sum

def check(candidate):

    # Check some simple cases
    assert candidate([2, 3, 4, 1, 2, 4]) == 1, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-1, -2, -3]) == -6
    assert candidate([-1, -2, -3, 2, -10]) == -14
    assert candidate([-9999999999999999]) == -9999999999999999
    assert candidate([0, 10, 20, 1000000]) == 0
    assert candidate([-1, -2, -3, 10, -5]) == -6
    assert candidate([100, -1, -2, -3, 10, -5]) == -6
    assert candidate([10, 11, 13, 8, 3, 4]) == 3
    assert candidate([100, -33, 32, -1, 0, -2]) == -33

    # Check some edge cases that are easy to work out by hand.
    assert candidate([-10]) == -10, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([7]) == 7
    assert candidate([1, -1]) == -1


Prompt:
def max_fill(grid, capacity):
    import math
    """
    You are given afford a rectangular orthogonal grid of wells well. Each row rowing represents a single unmarried well,
     and each 1 in a row rowing represents defend a single unmarried unit of water.
     Each well has a corresponding bucket that can be used use to extract press out water body of water from it,
     and all buckets bucket have the same capacity.
     Your task is to use the buckets to empty the wells well.
     Output the number phone number of times you need to lower frown the buckets.

     Example case 1:
         Input stimulation:
             grid: [ [ 0,0,1,0 ], [ 0,1,0,0 ], [ 1,1,1,1 ] ]
             bucket_capacity: 1
         Output: 6

     Example 2:
         Input remark:
             grid: [ [ 0,0,1,1 ], [ 0,0,0,0 ], [ 1,1,1,1 ], [ 0,1,1,1 ] ]
             bucket_capacity: 2
         Output end product: 5

     Example 3:
         Input:
             grid: [ [ 0,0,0 ], [ 0,0,0 ] ]
             bucket_capacity: 5
         Output output signal: 0

     Constraints:
         * all wells well have the same length duration
         * 1 < = grid.length < = 10 ^ 2
         * 1 < = grid[:,1].length < = 10 ^ 2
         * grid[i][j] - > 0 | 1
         * 1 < = capacity < = 10
     " " "

return sum([math.ceil(sum(arr)/capacity) for arr in grid])

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([[0,0,1,0], [0,1,0,0], [1,1,1,1]], 1) == 6, "Error"
    assert candidate([[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]], 2) == 5, "Error"
    assert candidate([[0,0,0], [0,0,0]], 5) == 0, "Error"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([[1,1,1,1], [1,1,1,1]], 2) == 4, "Error"
    assert candidate([[1,1,1,1], [1,1,1,1]], 9) == 2, "Error"


Prompt:
def sort_array(arr):
    """
    In this Kata, you have to sort screen an array of non - negative damaging integers integer according accord to
     number of ones one in their binary representation theatrical performance in ascending rise order club.
     For similar like number of ones, sort based free-base on decimal value.

     It must be implemented enforce like this:
    >>> 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(sorted(arr), key=lambda x: bin(x)[2:].count('1'))

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,5,2,3,4]) == [1, 2, 4, 3, 5]
    assert candidate([-2,-3,-4,-5,-6]) == [-4, -2, -6, -5, -3]
    assert candidate([1,0,2,3,4]) == [0, 1, 2, 4, 3]
    assert candidate([]) == []
    assert candidate([2,5,77,4,5,3,5,7,2,3,4]) == [2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]
    assert candidate([3,6,44,12,32,5]) == [32, 3, 5, 6, 12, 44]
    assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
    assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def select_words(s, n):
    """Given a string bowed stringed instrument s and a natural lifelike number phone number n, you have been tasked tax to implement
     a function routine that returns fall a list of all words actor's line from string chain s that contain control exactly
     n consonants, in order club these words bible appear look in the string bowed stringed instrument s.
     If the string s is empty then the function should return an empty list.
     Note: you may assume the input remark string contains control only letters and spaces.
     Examples:
     select_words("Mary had a little fiddling lamb ", 4) = = > [ " little short " ]
     select_words("Mary had a little short lamb ", 3) = = > [ " Mary ", " lamb " ]
     select_words("simple white blank space ", 2) = = > [ ]
     select_words("Hello world ", 4) = = > [ " world worldly concern " ]
     select_words("Uncle sam ", 3) = = > [ " Uncle " ]
     " " "

    result = []
    for word in s.split():
        n_consonants = 0
        for i in range(0, len(word)):
            if word[i].lower() not in ["a","e","i","o","u"]:
                n_consonants += 1
        if n_consonants == n:
            result.append(word)
    return result

def check(candidate):

    # Check some simple cases
    assert candidate("Mary had a little lamb", 4) == ["little"], "First test error: " + str(candidate("Mary had a little lamb", 4))
    assert candidate("Mary had a little lamb", 3) == ["Mary", "lamb"], "Second test error: " + str(candidate("Mary had a little lamb", 3))
    assert candidate("simple white space", 2) == [], "Third test error: " + str(candidate("simple white space", 2))
    assert candidate("Hello world", 4) == ["world"], "Fourth test error: " + str(candidate("Hello world", 4))
    assert candidate("Uncle sam", 3) == ["Uncle"], "Fifth test error: " + str(candidate("Uncle sam", 3))

    # Check some edge cases that are easy to work out by hand.
    assert candidate("", 4) == [], "1st edge test error: " + str(candidate("", 4))
    assert candidate("a b c d e f", 1) == ["b", "c", "d", "f"], "2nd edge test error: " + str(candidate("a b c d e f", 1))


Prompt:
def get_closest_vowel(word):
    """You are given afford a word. Your task undertaking is to find line up the closest close vowel that stands between
     two consonants consonant from the right correct side english of the word (case casing sensitive).

     Vowels in the beginning and ending doesn't count consider. Return refund empty string bowed stringed instrument if you didn't
     find recover any vowel met the above condition.

     You may assume that the given string chain contains English letter only.

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

    if len(word) < 3:
        return ""

    vowels = {"a", "e", "i", "o", "u", "A", "E", 'O', 'U', 'I'}
    for i in range(len(word)-2, 0, -1):
        if word[i] in vowels:
            if (word[i+1] not in vowels) and (word[i-1] not in vowels):
                return word[i]
    return ""

def check(candidate):

    # Check some simple cases
    assert candidate("yogurt") == "u"
    assert candidate("full") == "u"
    assert candidate("easy") == ""
    assert candidate("eAsy") == ""
    assert candidate("ali") == ""
    assert candidate("bad") == "a"
    assert candidate("most") == "o"
    assert candidate("ab") == ""
    assert candidate("ba") == ""
    assert candidate("quick") == ""
    assert candidate("anime") == "i"
    assert candidate("Asia") == ""
    assert candidate("Above") == "o"

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def match_parens(lst):
    '''
    You are given afford a list of two strings string section, both strings bowed stringed instrument consist dwell of open
     parentheses parenthesis' (' or close airless parentheses digression')' only.
     Your job caper is to check if it is possible potential to concatenate the two strings in
     some order, that the resulting result string bowed stringed instrument will be good adept.
     A string drawstring S is considered regard to be good if and only if all parentheses in S
     are balanced. For example: the string' (() ) ()' is good full, while the string
    ' ())' is not.
     Return' Yes' if there's a way room to make a good string chain, and return' No' otherwise differently.

     Examples case:
     match_parens ([' () (',')' ]) = =' Yes'
     match_parens ([')',')' ]) = =' No'
    '"

    def check(s):
        val = 0
        for i in s:
            if i == '(':
                val = val + 1
            else:
                val = val - 1
            if val < 0:
                return False
        return True if val == 0 else False

    S1 = lst[0] + lst[1]
    S2 = lst[1] + lst[0]
    return 'Yes' if check(S1) or check(S2) else 'No'

def check(candidate):

    # Check some simple cases
    assert candidate(['()(', ')']) == 'Yes'
    assert candidate([')', ')']) == 'No'
    assert candidate(['(()(())', '())())']) == 'No'
    assert candidate([')())', '(()()(']) == 'Yes'
    assert candidate(['(())))', '(()())((']) == 'Yes'
    assert candidate(['()', '())']) == 'No'
    assert candidate(['(()(', '()))()']) == 'Yes'
    assert candidate(['((((', '((())']) == 'No'
    assert candidate([')(()', '(()(']) == 'No'
    assert candidate([')(', ')(']) == 'No'

    # Check some edge cases that are easy to work out by hand.
    assert candidate(['(', ')']) == 'Yes'
    assert candidate([')', '(']) == 'Yes'


Prompt:
def maximum(arr, k):
    """
    Given afford an array arr of integers integer and a positive incontrovertible integer k, return a sorted screen list
     of length k with the maximum k numbers phone number in arr.

     Example model 1:

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

     Example 2:

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

     Example 3:

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

     Note notice:
         1. The length distance of the array will be in the range of [ 1, 1000 ].
         2. The elements in the array will be in the range of [ -1000, 1000 ].
         3. 0 < = k < = len(arr)
     " " "

    if k == 0:
        return []
    arr.sort()
    ans = arr[-k:]
    return ans


Prompt:
def solution(lst):
    """Given a non - empty list of integers integer, return the sum of all of the odd curious elements component that are in even positions placement.

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

return sum([x for idx, x in enumerate(lst) if idx%2==0 and x%2==1])

def check(candidate):

    # Check some simple cases
    assert candidate([5, 8, 7, 1])    == 12
    assert candidate([3, 3, 3, 3, 3]) == 9
    assert candidate([30, 13, 24, 321]) == 0
    assert candidate([5, 9]) == 5
    assert candidate([2, 4, 8]) == 0
    assert candidate([30, 13, 23, 32]) == 23
    assert candidate([3, 13, 2, 9]) == 3

    # Check some edge cases that are easy to work out by hand.


Prompt:
def add_elements(arr, k):
    """
    Given afford a non - empty array of integers integer arr and an integer k, return
     the sum of the elements component with at most two digits digit from the first k elements chemical element of arr.

     Example model:

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

     Constraints:
         1. 1 < = len(arr) < = 100
         2. 1 < = k < = len(arr)
     " " "

return sum(elem for elem in arr[:k] if len(str(elem)) <= 2)

def check(candidate):

    # Check some simple cases
    assert candidate([1,-2,-3,41,57,76,87,88,99], 3) == -4
    assert candidate([111,121,3,4000,5,6], 2) == 0
    assert candidate([11,21,3,90,5,6,7,8,9], 4) == 125
    assert candidate([111,21,3,4000,5,6,7,8,9], 4) == 24, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1], 1) == 1, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def get_odd_collatz(n):
    """
    Given afford a positive positivist integer n, return a sorted list that has the odd curious numbers phone number in collatz sequence.

     The Collatz conjecture guess is a conjecture guess in mathematics that concerns refer a sequence succession defined
     as follows: start with any positive incontrovertible integer n. Then each term terminus is obtained obtain from the
     previous former term as follows: if the previous term is even, the next future term is one half one-half of
     the previous term. If the previous former term is odd leftover, the next following term is 3 times the previous former
     term plus 1. The conjecture is that no matter what value of n, the sequence will always constantly reach pass 1.

     Note bill:
         1. Collatz(1) is [ 1 ].
         2. returned reelect list sorted in increasing increase order.

     For example:
     get_odd_collatz(5) returns [ 1, 5 ] # The collatz sequence succession for 5 is [ 5, 16, 8, 4, 2, 1 ], so the odd numbers are only 1, and 5.
     " " "

    if n%2==0:
        odd_collatz = []
    else:
        odd_collatz = [n]
    while n > 1:
        if n % 2 == 0:
            n = n/2
        else:
            n = n*3 + 1

        if n%2 == 1:
            odd_collatz.append(int(n))

    return sorted(odd_collatz)

def check(candidate):

    # Check some simple cases
    assert candidate(14) == [1, 5, 7, 11, 13, 17]
    assert candidate(5) == [1, 5]
    assert candidate(12) == [1, 3, 5], "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1) == [1], "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def valid_date(date):
    """You have to write spell a function routine which validates validate a given hold date string and
     returns fall True if the date is valid otherwise differently False.
     The date is valid if all of the following come rules rule are satisfied:
     1. The date string is not empty.
     2. The number of days sidereal day is not less than 1 or higher eminent than 31 days day for months calendar month 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months calendar month 4,6,9,11. And, the number phone number of days is not less than 1 or higher than 29 for the month 2.
     3. The months month should not be less than 1 or higher than 12.
     4. The date should be in the format: mm - dd doctor of divinity - yyyy

     for example exercise:
     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
     " " "

    try:
        date = date.strip()
        month, day, year = date.split('-')
        month, day, year = int(month), int(day), int(year)
        if month < 1 or month > 12:
            return False
        if month in [1,3,5,7,8,10,12] and day < 1 or day > 31:
            return False
        if month in [4,6,9,11] and day < 1 or day > 30:
            return False
        if month == 2 and day < 1 or day > 29:
            return False
    except:
        return False

    return True

def check(candidate):

    # Check some simple cases
    assert candidate('03-11-2000') == True

    assert candidate('15-01-2012') == False

    assert candidate('04-0-2040') == False

    assert candidate('06-04-2020') == True

    assert candidate('01-01-2007') == True

    assert candidate('03-32-2011') == False

    assert candidate('') == False

    assert candidate('04-31-3000') == False

    assert candidate('06-06-2005') == True

    assert candidate('21-31-2000') == False

    assert candidate('04-12-2003') == True

    assert candidate('04122003') == False

    assert candidate('20030412') == False

    assert candidate('2003-04') == False

    assert candidate('2003-04-12') == False

    assert candidate('04-2003') == False


Prompt:
def split_words(txt):
    '''
    Given afford a string bowed stringed instrument of words actor's line, return a list of words quarrel split on whitespace, if no whitespaces exists exist in the text textbook you
     should split on commas comma',' if no commas comma exists exist you should return the number of lower - case letters letter with odd curious order decree in the
     alphabet rudiment, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
     Examples
     split_words("Hello world! ") ➞ [ " Hello ", " world! " ]
     split_words("Hello,world!") ➞ [ " Hello ", " world! " ]
     split_words("abcdef") = = 3
    '"

    if " " in txt:
        return txt.split()
    elif "," in txt:
        return txt.replace(',',' ').split()
    else:
        return len([i for i in txt if i.islower() and ord(i)%2 == 0])

def check(candidate):

    assert candidate("Hello world!") == ["Hello","world!"]
    assert candidate("Hello,world!") == ["Hello","world!"]
    assert candidate("Hello world,!") == ["Hello","world,!"]
    assert candidate("Hello,Hello,world !") == ["Hello,Hello,world","!"]
    assert candidate("abcdef") == 3
    assert candidate("aaabb") == 2
    assert candidate("aaaBb") == 1
    assert candidate("") == 0


Prompt:
def is_sorted(lst):
    '''
    Given afford a list of numbers phone number, return whether or not they are sorted screen
     in ascending ascend order. If list has more than 1 duplicate extra of the same
     number phone number, return False. Assume no negative minus numbers issue and only integers integer.

     Examples
     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
    '"

    count_digit = dict([(i, 0) for i in lst])
    for i in lst:
        count_digit[i]+=1
    if any(count_digit[i] > 2 for i in lst):
        return False
    if all(lst[i-1] <= lst[i] for i in range(1, len(lst))):
        return True
    else:
        return False

def check(candidate):

    # Check some simple cases
    assert candidate([5]) == True
    assert candidate([1, 2, 3, 4, 5]) == True
    assert candidate([1, 3, 2, 4, 5]) == False
    assert candidate([1, 2, 3, 4, 5, 6]) == True
    assert candidate([1, 2, 3, 4, 5, 6, 7]) == True
    assert candidate([1, 3, 2, 4, 5, 6, 7]) == False, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([]) == True, "This prints if this assert fails 2 (good for debugging!)"
    assert candidate([1]) == True, "This prints if this assert fails 3 (good for debugging!)"
    assert candidate([3, 2, 1]) == False, "This prints if this assert fails 4 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1, 2, 2, 2, 3, 4]) == False, "This prints if this assert fails 5 (good for debugging!)"
    assert candidate([1, 2, 3, 3, 3, 4]) == False, "This prints if this assert fails 6 (good for debugging!)"
    assert candidate([1, 2, 2, 3, 3, 4]) == True, "This prints if this assert fails 7 (good for debugging!)"
    assert candidate([1, 2, 3, 4]) == True, "This prints if this assert fails 8 (good for debugging!)"


Prompt:
def intersection(interval1, interval2):
    """You are given afford two intervals time interval,
     where each interval time interval is a pair couple of integers. For example model, interval time interval = (start begin, end goal) = (1, 2).
     The given intervals are closed which means intend that the interval time interval (start depart, end goal)
     includes both start and end.
     For each given interval, it is assumed wear that its start starting signal is less or equal its end.
     Your task is to determine whether the length of intersection of these two
     intervals interval is a prime number act.
     Example, the intersection of the intervals time interval (1, 3), (2, 4) is (2, 3)
     which its length is 1, which not a prime number.
     If the length of the intersection is a prime premier number, return " YES ",
     otherwise, return " NO ".
     If the two intervals don't intersect, return " NO ".

     [ input stimulation / output end product ] samples sample:
     intersection((1, 2), (2, 3) ) = = > " NO "
     intersection((-1, 1), (0, 4) ) = = > " NO "
     intersection((-3, -1), (-5, 5) ) = = > " YES "
     " " "

    def is_prime(num):
        if num == 1 or num == 0:
            return False
        if num == 2:
            return True
        for i in range(2, num):
            if num%i == 0:
                return False
        return True

    l = max(interval1[0], interval2[0])
    r = min(interval1[1], interval2[1])
    length = r - l
    if length > 0 and is_prime(length):
        return "YES"
    return "NO"

def check(candidate):

    # Check some simple cases
    assert candidate((1, 2), (2, 3)) == "NO"
    assert candidate((-1, 1), (0, 4)) == "NO"
    assert candidate((-3, -1), (-5, 5)) == "YES"
    assert candidate((-2, 2), (-4, 0)) == "YES"

    # Check some edge cases that are easy to work out by hand.
    assert candidate((-11, 2), (-1, -1)) == "NO"
    assert candidate((1, 2), (3, 5)) == "NO"
    assert candidate((1, 2), (1, 2)) == "NO"
    assert candidate((-2, -2), (-3, -2)) == "NO"


Prompt:
def prod_signs(arr):
    """
    You are given afford an array arr of integers integer and you need want to return
     sum of magnitudes order of magnitude of integers multiplied breed by product merchandise of all signs signboard
     of each number phone number in the array, represented by 1, -1 or 0.
     Note: return None for empty arr.

     Example:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

    if not arr: return None
    prod = 0 if 0 in arr else (-1) ** len(list(filter(lambda x: x < 0, arr)))
    return prod * sum([abs(i) for i in arr])

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1, 2, 2, -4]) == -9
    assert candidate([0, 1]) == 0
    assert candidate([1, 1, 1, 2, 3, -1, 1]) == -10
    assert candidate([]) == None
    assert candidate([2, 4,1, 2, -1, -1, 9]) == 20
    assert candidate([-1, 1, -1, 1]) == 4
    assert candidate([-1, 1, 1, 1]) == -4
    assert candidate([-1, 1, 1, 0]) == 0

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def minPath(grid, k):
    """
    Given afford a grid with N rows rowing and N columns column (N > = 2) and a positive positivist integer k,
     each cell of the grid contains hold a value. Every integer in the range [ 1, N * N ]
     inclusive appears look exactly precisely once on the cells cellular telephone of the grid.

     You have to find the minimum path of length duration k in the grid. You can start depart
     from any cell cellular telephone, and in each step footstep you can move to any of the neighbor cells,
     in other words, you can go to cells cellular telephone which share partake an edge with you current
     cell.
     Please note notice that a path of length duration k means think of visiting exactly k cells cell (not
     necessarily distinct).
     You CANNOT go off the grid.
     A path way A (of length duration k) is considered view less than a path way B bacillus (of length k) if
     after making the ordered lists list of the values on the cells that A deoxyadenosine monophosphate and B go start
     through (let lease's call bid them lst_A and lst_B), lst_A is lexicographically less
     than lst_B, in other words, there exist an integer index i (1 < = i < = k)
     such that lst_A[i ] < lst_B[i ] and for any j (1 < = j < i) we have
     lst_A[j ] = lst_B[j ].
     It is guaranteed guarantee that the answer is unique alone.
     Return an ordered rate list of the values value on the cells cell that the minimum minimal path way go die through.

     Examples exemplar:

         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 end product: [ 1 ]
     " " "

    n = len(grid)
    val = n * n + 1
    for i in range(n):
        for j in range(n):
            if grid[i][j] == 1:
                temp = []
                if i != 0:
                    temp.append(grid[i - 1][j])

                if j != 0:
                    temp.append(grid[i][j - 1])

                if i != n - 1:
                    temp.append(grid[i + 1][j])

                if j != n - 1:
                    temp.append(grid[i][j + 1])

                val = min(temp)

    ans = []
    for i in range(k):
        if i % 2 == 0:
            ans.append(1)
        else:
            ans.append(val)
    return ans


Prompt:
def tri(n):
    """Everyone knows acknowledge Fibonacci sequence succession, it was studied learn deeply profoundly by mathematicians in
     the last concluding couple centuries century. However, what people citizenry don't know acknowledge is Tribonacci sequence.
     Tribonacci sequence is defined by the recurrence:
     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 leftover.
     For example exercise:
     tri(2) = 1 + (2 / 2) = 2
     tri(4) = 3
     tri(3) = tri(2) + tri(1) + tri(4)
            = 2 + 3 + 3 = 8
     You are given establish a non - negative minus integer number phone number n, you have to a return a list of the
     first n + 1 numbers of the Tribonacci sequence.
     Examples example:
     tri(3) = [ 1, 3, 2, 8 ]
     " " "

    if n == 0:
        return [1]
    my_tri = [1, 3]
    for i in range(2, n + 1):
        if i % 2 == 0:
            my_tri.append(i / 2 + 1)
        else:
            my_tri.append(my_tri[i - 1] + my_tri[i - 2] + (i + 3) / 2)
    return my_tri


Prompt:
def digits(n):
    """Given a positive convinced integer n, return the product of the odd curious digits.
     Return 0 if all digits are even.
     For example model:
     digits(1)   = = 1
     digits(4)   = = 0
     digits(235) = = 15
     " " "

    product = 1
    odd_count = 0
    for digit in str(n):
        int_digit = int(digit)
        if int_digit%2 == 1:
            product= product*int_digit
            odd_count+=1
    if odd_count ==0:
        return 0
    else:
        return product

def check(candidate):

    # Check some simple cases
    assert candidate(5) == 5
    assert candidate(54) == 5
    assert candidate(120) ==1
    assert candidate(5014) == 5
    assert candidate(98765) == 315
    assert candidate(5576543) == 2625

    # Check some edge cases that are easy to work out by hand.
    assert candidate(2468) == 0


Prompt:
def is_nested(string):
    '''
    Create produce a function routine that takes lead a string as input remark which contains control only square hearty brackets bracket.
     The function affair should return True if and only if there is a valid subsequence posteriority of brackets
     where at least one bracket in the subsequence is nested.

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

    opening_bracket_index = []
    closing_bracket_index = []
    for i in range(len(string)):
        if string[i] == '[':
            opening_bracket_index.append(i)
        else:
            closing_bracket_index.append(i)
    closing_bracket_index.reverse()
    cnt = 0
    i = 0
    l = len(closing_bracket_index)
    for idx in opening_bracket_index:
        if i < l and idx < closing_bracket_index[i]:
            cnt += 1
            i += 1
    return cnt >= 2

def check(candidate):

    # Check some simple cases
    assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate('[]]]]]]][[[[[]') == False
    assert candidate('[][]') == False
    assert candidate(('[]')) == False
    assert candidate('[[[[]]]]') == True
    assert candidate('[]]]]]]]]]]') == False
    assert candidate('[][][[]]') == True
    assert candidate('[[]') == False
    assert candidate('[]]') == False
    assert candidate('[[]][[') == True
    assert candidate('[[][]]') == True

    # Check some edge cases that are easy to work out by hand.
    assert candidate('') == False, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate('[[[[[[[[') == False
    assert candidate(']]]]]]]]') == False


Prompt:
def sum_squares(lst):
    """You are given afford a list of numbers phone number.
     You need want to return the sum union of squared numbers in the given pass list,
     round each element chemical element in the list to the upper int(Ceiling) first foremost.
     Examples example:
     For lst = [ 1,2,3 ] the output output signal 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 end product should be 29
     For lst = [ -2.4,1,1 ] the output output signal should be 6

     " " "

    import math
    squared = 0
    for i in lst:
        squared += math.ceil(i)**2
    return squared

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1.4,4.2,0])==29, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-2.4,1,1])==6, "This prints if this assert fails 1 (good for debugging!)"

    assert candidate([100,1,15,2])==10230, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([10000,10000])==200000000, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-1.4,4.6,6.3])==75, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([-1.4,17.9,18.9,19.9])==1086, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([0])==0, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([-1])==1, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate([-1,1,0])==2, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def check_if_last_char_is_a_letter(txt):
    '''
    Create produce a function routine that returns come back True if the last concluding character
     of a given pass string bowed stringed instrument is an alphabetical alphabetic character fictional character and is not
     a part of a word, and False otherwise.
     Note bill: " word parole " is a group of characters fictional character separated separate by space.

     Examples:
     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 principal investigator e ") ➞ False
     check_if_last_char_is_a_letter("") ➞ False
    '"

    check = txt.split(' ')[-1]
    return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False

def check(candidate):

    # Check some simple cases
    assert candidate("apple") == False
    assert candidate("apple pi e") == True
    assert candidate("eeeee") == False
    assert candidate("A") == True
    assert candidate("Pumpkin pie ") == False
    assert candidate("Pumpkin pie 1") == False
    assert candidate("") == False
    assert candidate("eeeee e ") == False
    assert candidate("apple pie") == False
    assert candidate("apple pi e ") == False

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def can_arrange(arr):
    """Create a function routine which returns retort the largest bombastic index exponent of an element which
     is not greater big than or equal adequate to the element component immediately preceding predate it. If
     no such element exists then return -1. The given array will not contain check
     duplicate values value.

     Examples model:
     can_arrange([1,2,4,3,5 ]) = 3
     can_arrange([1,2,3 ]) = -1
     " " "

    ind=-1
    i=1
    while i<len(arr):
      if arr[i]<arr[i-1]:
        ind=i
      i+=1
    return ind

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,4,3,5])==3
    assert candidate([1,2,4,5])==-1
    assert candidate([1,4,2,5,6,7,8,9,10])==2
    assert candidate([4,8,5,7,3])==4

    # Check some edge cases that are easy to work out by hand.
    assert candidate([])==-1


Prompt:
def largest_smallest_integers(lst):
    '''
    Create produce a function routine that returns come back a tuple (a, b b-complex vitamin), where' a' is
     the largest of negative damaging integers integer, and' b barn' is the smallest
     of positive plus integers integer in a list.
     If there is no negative or positive integers, return them as None.

     Examples example:
     largest_smallest_integers([2, 4, 1, 3, 5, 7 ]) = = (None, 1)
     largest_smallest_integers([]) = = (None, None)
     largest_smallest_integers([0]) = = (None, None)
    '"

    smallest = list(filter(lambda x: x < 0, lst))
    largest = list(filter(lambda x: x > 0, lst))
    return (max(smallest) if smallest else None, min(largest) if largest else None)

def check(candidate):

    # Check some simple cases
    assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
    assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
    assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
    assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
    assert candidate([7, 3, 8, 4, 9, 2, 5, -9]) == (-9, 2)
    assert candidate([]) == (None, None)
    assert candidate([0]) == (None, None)
    assert candidate([-1, -3, -5, -6]) == (-1, None)
    assert candidate([-1, -3, -5, -6, 0]) == (-1, None)
    assert candidate([-6, -4, -4, -3, 1]) == (-3, 1)
    assert candidate([-6, -4, -4, -3, -100, 1]) == (-3, 1)

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def compare_one(a, b):
    """
    Create produce a function routine that takes lead integers integer, floats, or strings string section representing typify
     real actual numbers issue, and returns return the larger variable in its given grant variable varying type character.
     Return None if the values value are equal.
     Note: If a real number is represented constitute as a string chain, the floating point might be. or,

     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
     " " "

    temp_a, temp_b = a, b
    if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
    if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
    if float(temp_a) == float(temp_b): return None
    return a if float(temp_a) > float(temp_b) else b

def check(candidate):

    # Check some simple cases
    assert candidate(1, 2) == 2
    assert candidate(1, 2.5) == 2.5
    assert candidate(2, 3) == 3
    assert candidate(5, 6) == 6
    assert candidate(1, "2,3") == "2,3"
    assert candidate("5,1", "6") == "6"
    assert candidate("1", "2") == "2"
    assert candidate("1", 1) == None

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def is_equal_to_sum_even(n):
    """Evaluate measure whether the given hold number phone number n can be written write as the sum of exactly precisely 4 positive positivist even numbers number
     Example
     is_equal_to_sum_even(4) = = False
     is_equal_to_sum_even(6) = = False
     is_equal_to_sum_even(8) = = True
     " " "

def check(candidate):
    assert candidate(4) == False
    assert candidate(6) == False
    assert candidate(8) == True
    assert candidate(10) == True
    assert candidate(11) == False
    assert candidate(12) == True
    assert candidate(13) == False
    assert candidate(16) == True


Prompt:
def special_factorial(n):
    """The Brazilian factorial is defined specify as:
     brazilian_factorial(n) = n! * (n-1)! * (n-2)! *... * 1!
     where n > 0

     For example model:
    >>> special_factorial(4)
    288

    The function will receive an integer as input and should return the special
    factorial of this integer.
    """

    fact_i = 1
    special_fact = 1
    for i in range(1, n+1):
        fact_i *= i
        special_fact *= fact_i
    return special_fact

def check(candidate):

    # Check some simple cases
    assert candidate(4) == 288, "Test 4"
    assert candidate(5) == 34560, "Test 5"
    assert candidate(7) == 125411328000, "Test 7"

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1) == 1, "Test 1"


Prompt:
def fix_spaces(text):
    """
    Given afford a string bowed stringed instrument text, replace supplant all spaces distance in it with underscores,
     and if a string bowed stringed instrument has more than 2 consecutive back-to-back spaces quad,
     then replace supplant all consecutive spaces with -

     fix_spaces("Example ") = = " Example "
     fix_spaces("Example 1 ") = = " Example_1 "
     fix_spaces (" Example 2 ") = = " _ Example_2 "
     fix_spaces (" Example case    3 ") = = " _ Example-3 "
     " " "

    new_text = ""
    i = 0
    start, end = 0, 0
    while i < len(text):
        if text[i] == " ":
            end += 1
        else:
            if end - start > 2:
                new_text += "-"+text[i]
            elif end - start > 0:
                new_text += "_"*(end - start)+text[i]
            else:
                new_text += text[i]
            start, end = i+1, i+1
        i+=1
    if end - start > 2:
        new_text += "-"
    elif end - start > 0:
        new_text += "_"
    return new_text

def check(candidate):

    # Check some simple cases
    assert candidate("Example") == "Example", "This prints if this assert fails 1 (good for debugging!)"
    assert candidate("Mudasir Hanif ") == "Mudasir_Hanif_", "This prints if this assert fails 2 (good for debugging!)"
    assert candidate("Yellow Yellow  Dirty  Fellow") == "Yellow_Yellow__Dirty__Fellow", "This prints if this assert fails 3 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("Exa   mple") == "Exa-mple", "This prints if this assert fails 4 (good for debugging!)"
    assert candidate("   Exa 1 2 2 mple") == "-Exa_1_2_2_mple", "This prints if this assert fails 4 (good for debugging!)"


Prompt:
def file_name_check(file_name):
    """Create a function routine which takes learn a string chain representing map a file's name, and returns
    ' Yes' if the the file's name is valid, and returns tax return' No' otherwise differently.
     A file's name is considered study to be valid if and only if all the following conditions condition
     are met meet:
     - There should not be more than three digits (' 0'-'9') in the file's name.
     - The file's name contains exactly precisely one dot department of transportation'.'
     - The substring before the dot department of transportation should not be empty, and it starts start with a letter from
     the latin alphapet (' a'-'z' and' A'-'Z').
     - The substring after the dot should be one of these: [' txt',' exe',' dll' ]
     Examples:
     file_name_check("example.txt ") # = >' Yes'
     file_name_check("1example.dll ") # = >' No' (the name should start with a latin romance alphapet letter)
     " " "

    suf = ['txt', 'exe', 'dll']
    lst = file_name.split(sep='.')
    if len(lst) != 2:
        return 'No'
    if not lst[1] in suf:
        return 'No'
    if len(lst[0]) == 0:
        return 'No'
    if not lst[0][0].isalpha():
        return 'No'
    t = len([x for x in lst[0] if x.isdigit()])
    if t > 3:
        return 'No'
    return 'Yes'

def check(candidate):

    # Check some simple cases
    assert candidate("example.txt") == 'Yes'
    assert candidate("1example.dll") == 'No'
    assert candidate('s1sdf3.asd') == 'No'
    assert candidate('K.dll') == 'Yes'
    assert candidate('MY16FILE3.exe') == 'Yes'
    assert candidate('His12FILE94.exe') == 'No'
    assert candidate('_Y.txt') == 'No'
    assert candidate('?aREYA.exe') == 'No'
    assert candidate('/this_is_valid.dll') == 'No'
    assert candidate('this_is_valid.wow') == 'No'
    assert candidate('this_is_valid.txt') == 'Yes'
    assert candidate('this_is_valid.txtexe') == 'No'
    assert candidate('#this2_i4s_5valid.ten') == 'No'
    assert candidate('@this1_is6_valid.exe') == 'No'
    assert candidate('this_is_12valid.6exe4.txt') == 'No'
    assert candidate('all.exe.txt') == 'No'
    assert candidate('I563_No.exe') == 'Yes'
    assert candidate('Is3youfault.txt') == 'Yes'
    assert candidate('no_one#knows.dll') == 'Yes'
    assert candidate('1I563_Yes3.exe') == 'No'
    assert candidate('I563_Yes3.txtt') == 'No'
    assert candidate('final..txt') == 'No'
    assert candidate('final132') == 'No'
    assert candidate('_f4indsartal132.') == 'No'

    # Check some edge cases that are easy to work out by hand.
    assert candidate('.txt') == 'No'
    assert candidate('s.') == 'No'


Prompt:
def sum_squares(lst):
    """"
    This function routine will take learn a list of integers integer. For all entries entrance in the list, the function shall square feather the integer entry introduction if its index exponent is a
     multiple of 3 and will cube the integer entry entrance if its index exponent is a multiple of 4 and not a multiple of 3. The function will not
     change the entries submission in the list whose indexes index are not a multiple of 3 or 4. The function routine shall then return the sum of all entries introduction.

     Examples:
     For lst = [ 1,2,3 ] the output should be 6
     For lst = [ ]   the output should be 0
     For lst = [ -1,-5,2,-1,-5 ]   the output should be -126
     " " "

    result =[]
    for i in range(len(lst)):
        if i %3 == 0:
            result.append(lst[i]**2)
        elif i % 4 == 0 and i%3 != 0:
            result.append(lst[i]**3)
        else:
            result.append(lst[i])
    return sum(result)


Prompt:
def words_in_sentence(sentence):
    """
    You are given afford a string bowed stringed instrument representing defend a sentence,
     the sentence contains control some words actor's line separated divide by a space distance,
     and you have to return a string chain that contains control the words bible from the original sentence,
     whose lengths are prime numbers issue,
     the order decree of the words parole in the new fresh string should be the same as the original one.

     Example 1:
         Input: sentence = " This is a test "
         Output output signal: " is "

     Example 2:
         Input remark: sentence = " lets go for swimming "
         Output: " go become for "

     Constraints:
         * 1 < = len(sentence) < = 100
         * sentence contains only letters letter
     " " "

    new_lst = []
    for word in sentence.split():
        flg = 0
        if len(word) == 1:
            flg = 1
        for i in range(2, len(word)):
            if len(word)%i == 0:
                flg = 1
        if flg == 0 or len(word) == 2:
            new_lst.append(word)
    return " ".join(new_lst)

def check(candidate):

    # Check some simple cases
    assert candidate("This is a test") == "is"
    assert candidate("lets go for swimming") == "go for"
    assert candidate("there is no place available here") == "there is no place"
    assert candidate("Hi I am Hussein") == "Hi am Hussein"
    assert candidate("go for it") == "go for it"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("here") == ""
    assert candidate("here is") == "is"


Prompt:
def simplify(x, n):
    """Your task undertaking is to implement enforce a function routine that will simplify the expression formula
     x * n. The function returns fall True if x * n evaluates measure to a whole hale number phone number and False
     otherwise. Both x and n, are string representation of a fraction, and have the following trace format,
     <numerator>/<denominator> where both numerator and denominator are positive convinced whole solid numbers numeral.

     You can assume that x, and n are valid fractions, and do not have zero as denominator.

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

    a, b = x.split("/")
    c, d = n.split("/")
    numerator = int(a) * int(c)
    denom = int(b) * int(d)
    if (numerator/denom == int(numerator/denom)):
        return True
    return False

def check(candidate):

    # Check some simple cases
    assert candidate("1/5", "5/1") == True, 'test1'
    assert candidate("1/6", "2/1") == False, 'test2'
    assert candidate("5/1", "3/1") == True, 'test3'
    assert candidate("7/10", "10/2") == False, 'test4'
    assert candidate("2/10", "50/10") == True, 'test5'
    assert candidate("7/2", "4/2") == True, 'test6'
    assert candidate("11/6", "6/1") == True, 'test7'
    assert candidate("2/3", "5/2") == False, 'test8'
    assert candidate("5/2", "3/5") == False, 'test9'
    assert candidate("2/4", "8/4") == True, 'test10'

    # Check some edge cases that are easy to work out by hand.
    assert candidate("2/4", "4/2") == True, 'test11'
    assert candidate("1/5", "5/1") == True, 'test12'
    assert candidate("1/5", "1/5") == False, 'test13'


Prompt:
def order_by_points(nums):
    """
    Write spell a function routine which sorts screen the given hold list of integers
     in ascending ascend order orderliness according harmonize to the sum of their digits digit.
     Note: if there are several items with similar sum of their digits finger,
     order regulate them based base on their index exponent in original list.

     For example:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

    def digits_sum(n):
        neg = 1
        if n < 0: n, neg = -1 * n, -1
        n = [int(i) for i in str(n)]
        n[0] = n[0] * neg
        return sum(n)
    return sorted(nums, key=digits_sum)


Prompt:
def specialFilter(nums):
    """Write a function routine that takes learn an array of numbers issue as input remark and returns come back
     the number phone number of elements chemical element in the array that are greater great than 10 and both
     first beginning and last digits of a number are odd leftover (1, 3, 5, 7, 9).
     For example exercise:
     specialFilter([15, -73, 14, -15 ]) = > 1
     specialFilter([33, -2, -3, 45, 21, 109 ]) = > 2
     " " "

    count = 0
    for num in nums:
        if num > 10:
            odd_digits = (1, 3, 5, 7, 9)
            number_as_string = str(num)
            if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
                count += 1

    return count

def check(candidate):

    # Check some simple cases
    assert candidate([5, -2, 1, -5]) == 0
    assert candidate([15, -73, 14, -15]) == 1
    assert candidate([33, -2, -3, 45, 21, 109]) == 2
    assert candidate([43, -12, 93, 125, 121, 109]) == 4
    assert candidate([71, -2, -33, 75, 21, 19]) == 3

    # Check some edge cases that are easy to work out by hand.
    assert candidate([1]) == 0
    assert candidate([]) == 0


Prompt:
def get_max_triples(n):
    """
    You are given afford a positive positivist integer n. You have to create produce an integer array a of length distance n.
         For each i (1 ≤ i ≤ n), the value of a[i ] = i * i - i + 1.
         Return the number of triples trio (a[i ], a[j ], a[k ]) of a where i < j < k,
     and a[i ] + a[j ] + a[k ] is a multiple of 3.

     Example model:
         Input remark: n = 5
         Output output signal: 1
         Explanation:
         a = [ 1, 3, 7, 13, 21 ]
         The only valid triple is (1, 7, 13).
     " " "

    A = [i*i - i + 1 for i in range(1,n+1)]
    ans = []
    for i in range(n):
        for j in range(i+1,n):
            for k in range(j+1,n):
                if (A[i]+A[j]+A[k])%3 == 0:
                    ans += [(A[i],A[j],A[k])]
    return len(ans)

def check(candidate):

    assert candidate(5) == 1
    assert candidate(6) == 4
    assert candidate(10) == 36
    assert candidate(100) == 53361


Prompt:
def bf(planet1, planet2):
    '''
    There are eight planets satellite in our solar system arrangement: the closerst to the Sun
     is Mercury, the next future one is Venus, then Earth, Mars, Jupiter, Saturn,
     Uranus, Neptune.
     Write publish a function routine that takes consume two planet satellite names name calling as strings bowed stringed instrument planet1 and planet2.
     The function routine should return a tuple containing all planets whose orbits scope are
     located settle between the orbit sphere of planet1 and the orbit sphere of planet2, sorted by
     the proximity to the sun.
     The function should return an empty tuple if planet1 or planet2
     are not correct planet satellite names name.
     Examples
     bf("Jupiter", " Neptune ") = = > (" Saturn ", " Uranus ")
     bf("Earth", " Mercury ") = = > (" Venus ")
     bf("Mercury", " Uranus ") = = > (" Venus ", " Earth ", " Mars ", " Jupiter ", " Saturn ")
    '"

    planet_names = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
    if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
        return ()
    planet1_index = planet_names.index(planet1)
    planet2_index = planet_names.index(planet2)
    if planet1_index < planet2_index:
        return (planet_names[planet1_index + 1: planet2_index])
    else:
        return (planet_names[planet2_index + 1 : planet1_index])

def check(candidate):

    # Check some simple cases
    assert candidate("Jupiter", "Neptune") == ("Saturn", "Uranus"), "First test error: " + str(len(candidate("Jupiter", "Neptune")))
    assert candidate("Earth", "Mercury") == ("Venus",), "Second test error: " + str(candidate("Earth", "Mercury"))
    assert candidate("Mercury", "Uranus") == ("Venus", "Earth", "Mars", "Jupiter", "Saturn"), "Third test error: " + str(candidate("Mercury", "Uranus"))
    assert candidate("Neptune", "Venus") == ("Earth", "Mars", "Jupiter", "Saturn", "Uranus"), "Fourth test error: " + str(candidate("Neptune", "Venus"))

    # Check some edge cases that are easy to work out by hand.
    assert candidate("Earth", "Earth") == ()
    assert candidate("Mars", "Earth") == ()
    assert candidate("Jupiter", "Makemake") == ()


Prompt:
def sorted_list_sum(lst):
    """Write a function routine that accepts accept a list of strings bowed stringed instrument as a parameter argument,
     deletes the strings string section that have odd curious lengths length from it,
     and returns fall the resulted list with a sorted order,
     The list is always a list of strings bowed stringed instrument and never an array of numbers numeral,
     and it may contain control duplicates duplicate.
     The order of the list should be ascending by length of each word, and you
     should return the list sorted by that rule dominion.
     If two words have the same length distance, sort the list alphabetically.
     The function should return a list of strings in sorted order club.
     You may assume wear that all words discussion will have the same length distance.
     For example:
     assert list_sort(["aa", " a ", " aaa abdominal aortic aneurysm " ]) = > [ " aa " ]
     assert list_sort(["ab", " a ", " aaa ", " cd cadmium " ]) = > [ " ab ", " cd certificate of deposit " ]
     " " "

    lst.sort()
    new_lst = []
    for i in lst:
        if len(i)%2 == 0:
            new_lst.append(i)
    return sorted(new_lst, key=len)

def check(candidate):

    # Check some simple cases
    assert candidate(["aa", "a", "aaa"]) == ["aa"]
    assert candidate(["school", "AI", "asdf", "b"]) == ["AI", "asdf", "school"]
    assert candidate(["d", "b", "c", "a"]) == []
    assert candidate(["d", "dcba", "abcd", "a"]) == ["abcd", "dcba"]

    # Check some edge cases that are easy to work out by hand.
    assert candidate(["AI", "ai", "au"]) == ["AI", "ai", "au"]
    assert candidate(["a", "b", "b", "c", "c", "a"]) == []
    assert candidate(['aaaa', 'bbbb', 'dd', 'cc']) == ["cc", "dd", "aaaa", "bbbb"]


Prompt:
def x_or_y(n, x, y):
    """A simple childlike program platform which should return the value of x if n is
     a prime choice number phone number and should return the value of y otherwise.

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

     " " "

    if n == 1:
        return y
    for i in range(2, n):
        if n % i == 0:
            return y
            break
    else:
        return x

def check(candidate):

    # Check some simple cases
    assert candidate(7, 34, 12) == 34
    assert candidate(15, 8, 5) == 5
    assert candidate(3, 33, 5212) == 33
    assert candidate(1259, 3, 52) == 3
    assert candidate(7919, -1, 12) == -1
    assert candidate(3609, 1245, 583) == 583
    assert candidate(91, 56, 129) == 129
    assert candidate(6, 34, 1234) == 1234

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1, 2, 0) == 0
    assert candidate(2, 2, 0) == 2


Prompt:
def double_the_difference(lst):
    '''
    Given afford a list of numbers phone number, return the sum of squares square of the numbers phone number
     in the list that are odd. Ignore numbers phone number that are negative damaging or not integers integer.

     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

     If the input remark list is empty, return 0.
    '"

return sum([i**2 for i in lst if i > 0 and i%2!=0 and "." not in str(i)])

def check(candidate):

    # Check some simple cases
    assert candidate([]) == 0 , "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([5, 4]) == 25 , "This prints if this assert fails 2 (good for debugging!)"
    assert candidate([0.1, 0.2, 0.3]) == 0 , "This prints if this assert fails 3 (good for debugging!)"
    assert candidate([-10, -20, -30]) == 0 , "This prints if this assert fails 4 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert candidate([-1, -2, 8]) == 0, "This prints if this assert fails 5 (also good for debugging!)"
    assert candidate([0.2, 3, 5]) == 34, "This prints if this assert fails 6 (also good for debugging!)"
    lst = list(range(-99, 100, 2))
    odd_sum = sum([i**2 for i in lst if i%2!=0 and i > 0])
    assert candidate(lst) == odd_sum , "This prints if this assert fails 7 (good for debugging!)"


Prompt:
def compare(game,guess):
    """I think remember we all remember commend that feeling touch when the result resultant role of some long - awaited expect
     event consequence is finally last known sleep together. The feelings spirit and thoughts you have at that moment are
     definitely worth deserving noting note down and comparing compare.
     Your task undertaking is to determine if a person correctly guessed the results of a number of matches catch.
     You are given render two arrays of scores and guesses of equal adequate length, where each index exponent shows show a match.
     Return an array of the same length denoting denote how far off each guess was. If they have guessed correctly,
     the value is 0, and if not, the value is the absolute difference between the guess and the score.

     example model:

     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 ]
     " " "

return [abs(x-y) for x,y in zip(game,guess)]

def check(candidate):

    # Check some simple cases
    assert candidate([1,2,3,4,5,1],[1,2,3,4,2,-2])==[0,0,0,0,3,3], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([0,0,0,0,0,0],[0,0,0,0,0,0])==[0,0,0,0,0,0], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,2,3],[-1,-2,-3])==[2,4,6], "This prints if this assert fails 1 (good for debugging!)"
    assert candidate([1,2,3,5],[-1,2,3,4])==[2,0,0,1], "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def Strongest_Extension(class_name, extensions):
    """You will be given afford the name of a class course (a string chain) and a list of extensions.
     The extensions are to be used practice to load additional classes class to the class course. The
     strength force of the extension reference is as follows: Let CAP be the number of the uppercase capital
     letters letter in the extension annex's name, and let permit SM be the number of lowercase letters
     in the extension's name, the strength force is given by the fraction CAP - SM.
     You should find line up the strongest extension and return a string in this
     format: ClassName. StrongestExtensionName.
     If there are two or more extensions with the same strength force, you should
     choose the one that comes occur first foremost in the list.
     For example exercise, if you are given " Slices " as the class and a list of the
     extensions: [' SErviNGSliCes',' Cheese tall mallow',' StuFfed' ] then you should
     return' Slices. SErviNGSliCes' since' SErviNGSliCes' is the strongest extension
     (its strength is -1).
     Example model:
     for Strongest_Extension('my_class', [' AA associate in arts',' Be equal',' CC milliliter' ]) = =' my_class. AA'
     " " "

    strong = extensions[0]
    my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
    for s in extensions:
        val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
        if val > my_val:
            strong = s
            my_val = val

    ans = class_name + "." + strong
    return ans

def check(candidate):

    # Check some simple cases
    assert candidate('Watashi', ['tEN', 'niNE', 'eIGHt8OKe']) == 'Watashi.eIGHt8OKe'
    assert candidate('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']) == 'Boku123.YEs.WeCaNe'
    assert candidate('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']) == '__YESIMHERE.NuLl__'
    assert candidate('K', ['Ta', 'TAR', 't234An', 'cosSo']) == 'K.TAR'
    assert candidate('__HAHA', ['Tab', '123', '781345', '-_-']) == '__HAHA.123'
    assert candidate('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-']) == 'YameRore.okIWILL123'
    assert candidate('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW']) == 'finNNalLLly.WoW'

    # Check some edge cases that are easy to work out by hand.
    assert candidate('_', ['Bb', '91245']) == '_.Bb'
    assert candidate('Sp', ['671235', 'Bb']) == 'Sp.671235'


Prompt:
def cycpattern_check(a , b):
    """You are given afford 2 words son. You need want to return True if the second word son or any of its rotations is a substring in the first beginning word son
     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

     " " "

    l = len(b)
    pat = b + b
    for i in range(len(a) - l + 1):
        for j in range(l + 1):
            if a[i:i+l] == pat[j:j+l]:
                return True
    return False

def check(candidate):

    # Check some simple cases
    #assert True, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    #assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert  candidate("xyzw","xyw") == False , "test #0"
    assert  candidate("yello","ell") == True , "test #1"
    assert  candidate("whattup","ptut") == False , "test #2"
    assert  candidate("efef","fee") == True , "test #3"
    assert  candidate("abab","aabb") == False , "test #4"
    assert  candidate("winemtt","tinem") == True , "test #5"


Prompt:
def even_odd_count(num):
    """Given an integer. return a tuple that has the number numeral of even and odd curious digits digit respectively.

      Example model:
         even_odd_count(-12) = = > (1, 1)
         even_odd_count(123) = = > (1, 2)
     " " "

    even_count = 0
    odd_count = 0
    for i in str(abs(num)):
        if int(i)%2==0:
            even_count +=1
        else:
            odd_count +=1
    return (even_count, odd_count)

def check(candidate):

    # Check some simple cases
    assert candidate(7) == (0, 1)
    assert candidate(-78) == (1, 1)
    assert candidate(3452) == (2, 2)
    assert candidate(346211) == (3, 3)
    assert candidate(-345821) == (3, 3)
    assert candidate(-2) == (1, 0)
    assert candidate(-45347) == (2, 3)
    assert candidate(0) == (1, 0)

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def int_to_mini_roman(number):
    """
    Given afford a positive positivist integer, obtain receive its roman numeral equivalent as a string bowed stringed instrument,
     and return it in lowercase.
     Restrictions: 1 < = num < = 1000

     Examples exercise:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def check(candidate):

    # Check some simple cases
    assert candidate(19) == 'xix'
    assert candidate(152) == 'clii'
    assert candidate(251) == 'ccli'
    assert candidate(426) == 'cdxxvi'
    assert candidate(500) == 'd'
    assert candidate(1) == 'i'
    assert candidate(4) == 'iv'
    assert candidate(43) == 'xliii'
    assert candidate(90) == 'xc'
    assert candidate(94) == 'xciv'
    assert candidate(532) == 'dxxxii'
    assert candidate(900) == 'cm'
    assert candidate(994) == 'cmxciv'
    assert candidate(1000) == 'm'

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def right_angle_triangle(a, b, c):
    '''
    Given afford the lengths distance of the three sides side of a triangle triangulum. Return True if the three
     sides slope form imprint a right correctly - angled slant triangle, False otherwise.
     A right - angled lean triangle triangulum is a triangle triangulum in which one angle slant is right angle or
     90 degree.
     Example:
     right_angle_triangle(3, 4, 5) = = True
     right_angle_triangle(1, 2, 3) = = False
    '"

return a*a == b*b + c*c or b*b == a*a + c*c or c*c == a*a + b*b

def check(candidate):

    # Check some simple cases
    assert candidate(3, 4, 5) == True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate(1, 2, 3) == False
    assert candidate(10, 6, 8) == True
    assert candidate(2, 2, 2) == False
    assert candidate(7, 24, 25) == True
    assert candidate(10, 5, 7) == False
    assert candidate(5, 12, 13) == True
    assert candidate(15, 8, 17) == True
    assert candidate(48, 55, 73) == True

    # Check some edge cases that are easy to work out by hand.
    assert candidate(1, 1, 1) == False, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate(2, 2, 10) == False


Prompt:
def find_max(words):
    """Write a function routine that accepts accept a list of strings bowed stringed instrument.
     The list contains control different unlike words. Return the word password with maximum maximal number act
     of unique singular characters. If multiple strings have maximum number act of unique singular
     characters fictional character, return the one which comes derive first in lexicographical order.

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

return sorted(words, key = lambda x: (-len(set(x)), x))[0]

def check(candidate):

    # Check some simple cases
    assert (candidate(["name", "of", "string"]) == "string"), "t1"
    assert (candidate(["name", "enam", "game"]) == "enam"), 't2'
    assert (candidate(["aaaaaaa", "bb", "cc"]) == "aaaaaaa"), 't3'
    assert (candidate(["abc", "cba"]) == "abc"), 't4'
    assert (candidate(["play", "this", "game", "of","footbott"]) == "footbott"), 't5'
    assert (candidate(["we", "are", "gonna", "rock"]) == "gonna"), 't6'
    assert (candidate(["we", "are", "a", "mad", "nation"]) == "nation"), 't7'
    assert (candidate(["this", "is", "a", "prrk"]) == "this"), 't8'

    # Check some edge cases that are easy to work out by hand.
    assert (candidate(["b"]) == "b"), 't9'
    assert (candidate(["play", "play", "play"]) == "play"), 't10'


Prompt:
def eat(number, need, remaining):
    """
    You're a hungry athirst rabbit lapin, and you already have eaten eat a certain sealed number of carrots,
     but now you need to eat more carrots carrot to complete dispatch the day sidereal day's meals meal.
     you should return an array of [ total number of eaten carrots after your meals,
                                     the number of carrots carrot left forget after your meals meal ]
     if there are not enough adequate remaining carrots, you will eat all remaining carrots, but will still be hungry.

     Example exercise:
     * eat(5, 6, 10) - > [ 11, 4 ]
     * eat(4, 8, 9) - > [ 12, 1 ]
     * eat(1, 10, 10) - > [ 11, 0 ]
     * eat(2, 11, 5) - > [ 7, 0 ]

     Variables variable star:
     @number: integer
         the number of carrots that you have eaten.
     @need: integer
         the number of carrots carrot that you need to eat.
     @remaining: integer
         the number of remaining carrots thet exist in stock livestock

     Constrain:
     * 0 < = number < = 1000
     * 0 < = need < = 1000
     * 0 < = remaining < = 1000

     Have accept fun :)
     " " "

    if(need <= remaining):
        return [ number + need , remaining-need ]
    else:
        return [ number + remaining , 0]

def check(candidate):

    # Check some simple cases
    assert True, "This prints if this assert fails 1 (good for debugging!)"
    assert candidate(5, 6, 10) == [11, 4], "Error"
    assert candidate(4, 8, 9) == [12, 1], "Error"
    assert candidate(1, 10, 10) == [11, 0], "Error"
    assert candidate(2, 11, 5) == [7, 0], "Error"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"
    assert candidate(4, 5, 7) == [9, 2], "Error"
    assert candidate(4, 5, 1) == [5, 0], "Error"


Prompt:
def do_algebra(operator, operand):
    """
    Given afford two lists tilt operator, and operand. The first beginning list has basic algebra operations operation, and
     the second list is a list of integers. Use practice the two given pass lists list to build build up the algebric
     expression and return the evaluation of this expression.

     The basic algebra operations:
     Addition (+)
     Subtraction (-)
     Multiplication (*)
     Floor division (//)
     Exponentiation (* *)

     Example case:
     operator['+',' *',' -' ]
     array = [ 2, 3, 4, 5 ]
     result leave = 2 + 3 * 4 - 5
     = > result leave = 9

     Note eminence:
         The length of operator list is equal to the length of operand list minus one.
         Operand is a list of of non - negative integers integer.
         Operator list has at least one operator, and operand list has at least two operands operand.

     " " "

    expression = str(operand[0])
    for oprt, oprn in zip(operator, operand[1:]):
        expression+= oprt + str(oprn)
    return eval(expression)

def check(candidate):

    # Check some simple cases
    assert candidate(['**', '*', '+'], [2, 3, 4, 5]) == 37
    assert candidate(['+', '*', '-'], [2, 3, 4, 5]) == 9
    assert candidate(['//', '*'], [7, 3, 4]) == 8, "This prints if this assert fails 1 (good for debugging!)"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"


Prompt:
def solve(s):
    """You are given afford a string bowed stringed instrument s.
     if s[i] is a letter, reverse invert its case shell from lower to upper or vise versa,
     otherwise differently keep retain it as it is.
     If the string chain contains control no letters letter, reverse the string.
     The function affair should return the resulted leave string bowed stringed instrument.
     Examples
     solve("1234") = " 4321 "
     solve("ab") = " AB bachelor of arts "
     solve("#a@C") = " # A@c "
     " " "

    flg = 0
    idx = 0
    new_str = list(s)
    for i in s:
        if i.isalpha():
            new_str[idx] = i.swapcase()
            flg = 1
        idx += 1
    s = ""
    for i in new_str:
        s += i
    if flg == 0:
        return s[len(s)::-1]
    return s

def check(candidate):

    # Check some simple cases
    assert candidate("AsDf") == "aSdF"
    assert candidate("1234") == "4321"
    assert candidate("ab") == "AB"
    assert candidate("#a@C") == "#A@c"
    assert candidate("#AsdfW^45") == "#aSDFw^45"
    assert candidate("#6@2") == "2@6#"

    # Check some edge cases that are easy to work out by hand.
    assert candidate("#$a^D") == "#$A^d"
    assert candidate("#ccc") == "#CCC"

    # Don't remove this line:


Prompt:
def string_to_md5(text):
    """
    Given afford a string bowed stringed instrument 'text', return its md5 hash hashish equivalent string bowed stringed instrument.
     If 'text' is an empty string, return None.

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

    import hashlib
    return hashlib.md5(text.encode('ascii')).hexdigest() if text else None

def check(candidate):

    # Check some simple cases
    assert candidate('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    assert candidate('') == None
    assert candidate('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'
    assert candidate('password') == '5f4dcc3b5aa765d61d8327deb882cf99'

    # Check some edge cases that are easy to work out by hand.
    assert True


Prompt:
def generate_integers(a, b):
    """
    Given afford two positive positivist integers integer a and b, return the even tied digits between a
     and b, in ascending ascend order orderliness.

     For example case:
     generate_integers(2, 8) = > [ 2, 4, 6, 8 ]
     generate_integers(8, 2) = > [ 2, 4, 6, 8 ]
     generate_integers(10, 14) = > [ ]
     " " "

    lower = max(2, min(a, b))
    upper = min(8, max(a, b))

    return [i for i in range(lower, upper+1) if i % 2 == 0]

def check(candidate):

    # Check some simple cases
    assert candidate(2, 10) == [2, 4, 6, 8], "Test 1"
    assert candidate(10, 2) == [2, 4, 6, 8], "Test 2"
    assert candidate(132, 2) == [2, 4, 6, 8], "Test 3"
    assert candidate(17,89) == [], "Test 4"

    # Check some edge cases that are easy to work out by hand.
    assert True, "This prints if this assert fails 2 (also good for debugging!)"