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

     For example:
       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 neglect 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 the function f that takes n as a parameter,
     and returns a list of size n, such that the value of the element at index exponent i is the factorial of i if i is even
     or the sum of numbers issue from 1 to i otherwise.
     i starts depart from 1.
     the factorial of i is the multiplication of the numbers issue from 1 to i (1 * 2 *... * i).
     Example:
     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 a positive integer n, return a tuple that has the number of even and odd
     integer palindromes that fall within the range(1, n), inclusive.

     Example exercise 1:

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

     Example exercise 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.

     Note eminence:
         1. 1 < = n < = 10 ^ 3
         2. returned refund tuple has the number of even and odd integer palindromes palindrome 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 a function count_nums which takes an array of integers and returns
     the number of elements element which has a sum of digits > 0.
     If a number issue is negative, then its first beginning signed digit finger will be negative:
     e.g. for example -123 has signed sign 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 arr[1], arr[2],... , arr[N].The
     numbers in the array will be randomly ordered. Your task is to determine if
     it is possible to get contract an array sorted in non - decreasing order by performing do
     the following operation on the given sacrifice array:
         You are allowed to perform do right shift fault operation process any number of times.

     One right correct shift switch operation process means entail shifting transfer all elements of the array by one
     position stead in the right good direction. The last element chemical element of the array will be moved to
     the starting position status in the array i.e. 0th index.

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

     Note bill: The given list is guaranteed undertake to have unique singular elements.

     For Example model:

     move_one_ball([3, 4, 5, 1, 2])==>True
     Explanation: By performin 2 right shift shift key operations operation, non - decreasing order club can
                  be achieved for the given pass array.
     move_one_ball([3, 5, 4, 1, 2])==>False
     Explanation: It is not possible potential to get induce non - decreasing order for the given
                 array by performing perform any number of right veracious shift chemise operations.

     " " "

    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, you will implement a function that takes two lists of numbers,
     and determines specify whether it is possible to perform do an exchange of elements
     between them to make form lst1 a list of only even numbers.
     There is no limit terminus ad quem on the number of exchanged substitute elements chemical element between lst1 and lst2.
     If it is possible to exchange elements between the lst1 and lst2 to make induce
     all the elements component of lst1 to be even, return " YES ".
     Otherwise, return " NO ".
     For example exemplar:
     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 remark 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 representing a space separated lowercase letters, return a dictionary
     of the letter with the most repetition repeat and containing the corresponding represent count.
     If several letters letter have the same occurrence, return all of them.

     Example model:
     histogram('a b c deoxycytidine monophosphate') = = {' a': 1,' b b-complex vitamin': 1,' c': 1 }
     histogram('a b b barn a') = = {' a': 2,' b boron': 2 }
     histogram('a b b-complex vitamin c a b barn') = = {' a': 2,' b b-complex vitamin': 2 }
     histogram('b b b b b-complex vitamin a') = = {' b b-complex vitamin': 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
     We are given two strings s and c, you have to deleted all the characters in s that are equal to any character quality in c
     then check if the result solution string is palindrome.
     A string drawstring is called palindrome if it reads learn the same backward as forward.
     You should return a tuple containing incorporate the result solution string and True/False for the check.
     Example
     For s = " abcde ", c = " ae ", the result solution should be (' bcd',False)
     For s = " abcdef ", c = " b "   the result consequence should be (' acdef',False)
     For s = " abcdedcba ", c = " ab ", the result solution 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, where each string consists of only digits, return a list.
     Each element i of the output should be " the number numeral of odd elements chemical element in the
     string i of the input stimulation. " where all the i's should be replaced by the number issue
     of odd digits finger 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 an array of integers nums, find the minimum sum of any non - empty sub - 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 a rectangular grid of wells. Each row represents a single well,
     and each 1 in a row rowing represents a single unmarried unit of water water system.
     Each well has a corresponding bucket that can be used practice to extract water body of water from it,
     and all buckets bucket have the same capacity.
     Your task is to use the buckets bucket to empty evacuate the wells well.
     Output the number of times fourth dimension you need to lower frown the buckets bucket.

     Example 1:
         Input:
             grid: [ [ 0,0,1,0 ], [ 0,1,0,0 ], [ 1,1,1,1 ] ]
             bucket_capacity: 1
         Output end product: 6

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

     Example exemplar 3:
         Input stimulation:
             grid: [ [ 0,0,0 ], [ 0,0,0 ] ]
             bucket_capacity: 5
         Output end product: 0

     Constraints:
         * all wells have the same length
         * 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 an array of non - negative integers according to
     number of ones in their binary representation theatrical performance in ascending order decree.
     For similar number numeral of ones, sort based free-base on decimal value.

     It must be implemented 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 s and a natural number n, you have been tasked to implement
     a function that returns render a list of all words from string bowed stringed instrument s that contain exactly precisely
     n consonants, in order decree these words appear look in the string bowed stringed instrument s.
     If the string s is empty then the function should return an empty list.
     Note eminence: you may assume bear the input remark string bowed stringed instrument contains incorporate only letters and spaces outer space.
     Examples model:
     select_words("Mary had a little lamb ", 4) = = > [ " little " ]
     select_words("Mary had a little small lamb ", 3) = = > [ " Mary ", " lamb " ]
     select_words("simple white ashen space outer space ", 2) = = > [ ]
     select_words("Hello world worldly concern ", 4) = = > [ " world populace " ]
     select_words("Uncle sam surface-to-air missile ", 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 a word. Your task is to find the closest vowel that stands between
     two consonants from the right veracious side of the word (case shell sensitive).

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

     You may assume simulate that the given yield string bowed stringed instrument contains contain English letter only.

     Example exemplar:
     get_closest_vowel("yogurt ") = = > " u "
     get_closest_vowel("FULL ") = = > " U uracil "
     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 a list of two strings, both strings consist of open
     parentheses' (' or close cheeseparing parentheses')' only.
     Your job occupation is to check if it is possible to concatenate the two strings chain in
     some order, that the resulting leave string will be good adept.
     A string bowed stringed instrument S is considered to be good if and only if all parentheses in S
     are balanced. For example model: the string chain' (() ) ()' is good adept, while the string bowed stringed instrument
    ' ())' is not.
     Return' Yes' if there's a way means to make a good adept string bowed stringed instrument, and return' No' otherwise.

     Examples:
     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 an array arr of integers and a positive integer k, return a sorted list
     of length k with the maximum k numbers in arr.

     Example exercise 1:

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

     Example 2:

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

     Example 3:

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

     Note notice:
         1. The length duration of the array will be in the range of [ 1, 1000 ].
         2. The elements in the array will be in the range stove 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, return the sum of all of the odd elements that are in even positions.

     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 a non - empty array of integers arr and an integer k, return
     the sum of the elements with at most two digits from the first k elements of arr.

     Example exercise:

         Input: arr = [ 111,21,3,4000,5,6,7,8,9 ], k = 4
         Output end product: 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 a positive integer n, return a sorted list that has the odd numbers in collatz sequence.

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

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

     For example model:
     get_odd_collatz(5) returns [ 1, 5 ] # The collatz sequence succession for 5 is [ 5, 16, 8, 4, 2, 1 ], so the odd leftover numbers number 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 a function which validates a given date string and
     returns True if the date is valid otherwise differently False.
     The date is valid if all of the following rules convention are satisfied:
     1. The date string drawstring is not empty.
     2. The number of days sidereal day is not less than 1 or higher than 31 days sidereal day for months calendar month 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher eminent than 30 days day for months calendar month 4,6,9,11. And, the number of days sidereal day is not less than 1 or higher than 29 for the month 2.
     3. The months calendar month should not be less than 1 or higher eminent than 12.
     4. The date should be in the format: 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
     " " "

    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 a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
     should split on commas comma',' if no commas exists exist you should return the number of lower gloomy - case letters letter with odd order orderliness 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 universe! " ]
     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 a list of numbers, return whether or not they are sorted
     in ascending order. If list has more than 1 duplicate of the same
     number numeral, return False. Assume no negative numbers issue and only integers.

     Examples exercise
     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 two intervals,
     where each interval is a pair of integers. For example, interval time interval = (start, end conclusion) = (1, 2).
     The given intervals interval are closed which means entail that the interval (start originate, end conclusion)
     includes both start and end.
     For each given render interval time interval, it is assumed simulate that its start is less or equal its end conclusion.
     Your task is to determine settle whether the length of intersection of these two
     intervals time interval is a prime number.
     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 choice number phone number, return " YES ",
     otherwise differently, return " NO ".
     If the two intervals time interval don't intersect, return " NO ".

     [ input / output ] 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 an array arr of integers and you need to return
     sum of magnitudes of integers multiplied by product intersection of all signs
     of each number issue in the array, represented by 1, -1 or 0.
     Note bill: 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 a grid with N rows and N columns (N > = 2) and a positive integer k,
     each cell of the grid contains a value. Every integer in the range [ 1, N * N ]
     inclusive appears look exactly once on the cells cellular telephone of the grid.

     You have to find the minimum minimal path of length duration k in the grid. You can start
     from any cell cellular telephone, and in each step footstep you can move to any of the neighbor cells,
     in other words news, you can go fail to cells cellular telephone which share an edge boundary with you current
     cell.
     Please note notice that a path way of length k means visiting travel to exactly k cells (not
     necessarily inevitably distinct discrete).
     You CANNOT go die off the grid.
     A path way A (of length k) is considered less than a path way B (of length distance k) if
     after making have the ordered lists list of the values on the cells cell that A vitamin a and B boron go
     through (let get's call bid them lst_A and lst_B), lst_A is lexicographically less
     than lst_B, in other words son, 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 that the answer solution is unique.
     Return an ordered order list of the values value on the cells that the minimum minimal path way go through.

     Examples example:

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

         Input: grid = [ [ 5,9,3 ], [ 4,1,6 ], [ 7,8,2 ] ], k = 1
         Output: [ 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 Fibonacci sequence, it was studied deeply by mathematicians in
     the last couple centuries hundred. However, what people don't know sleep together is Tribonacci sequence.
     Tribonacci sequence succession 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 curious.
     For example:
     tri(2) = 1 + (2 / 2) = 2
     tri(4) = 3
     tri(3) = tri(2) + tri(1) + tri(4)
            = 2 + 3 + 3 = 8
     You are given feed a non - negative minus integer number n, you have to a return a list of the
     first n + 1 numbers issue of the Tribonacci sequence succession.
     Examples case:
     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 integer n, return the product of the odd digits.
     Return 0 if all digits are even.
     For example:
     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 a function that takes a string as input which contains only square brackets bracket.
     The function should return True if and only if there is a valid subsequence sequel of brackets
     where at least one bracket in the subsequence posteriority 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 a list of numbers.
     You need to return the sum of squared numbers in the given list,
     round each element component in the list to the upper int(Ceiling) first.
     Examples case:
     For lst = [ 1,2,3 ] the output should be 14
     For lst = [ 1,4,9 ] the output output signal 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 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 a function that returns True if the last character
     of a given string drawstring is an alphabetical character fictional character and is not
     a part of a word parole, and False otherwise.
     Note eminence: " word " is a group of characters fictional character separated divide by space.

     Examples:
     check_if_last_char_is_a_letter("apple pie proto-indo european ") ➞ False
     check_if_last_char_is_a_letter("apple pi principal investigator e ") ➞ True
     check_if_last_char_is_a_letter("apple pi private detective 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 which returns the largest index of an element which
     is not greater than or equal adequate to the element immediately preceding precede it. If
     no such element exists exist then return -1. The given array will not contain hold
     duplicate values.

     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 a function that returns a tuple (a, b), where' a' is
     the largest of negative integers, and' b bacillus' is the smallest
     of positive integers integer in a list.
     If there is no negative or positive cocksure integers, return them as None.

     Examples case:
     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 a function that takes integers, floats, or strings representing represent
     real numbers issue, and returns the larger bombastic variable in its given contribute variable type character.
     Return None if the values value are equal.
     Note: If a real veridical number numeral is represented constitute as a string, the floating float 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 whether the given number n can be written as the sum of exactly 4 positive cocksure even numbers
     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 as:
     brazilian_factorial(n) = n! * (n-1)! * (n-2)! *... * 1!
     where n > 0

     For example:
    >>> 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 a string text, replace all spaces in it with underscores,
     and if a string has more than 2 consecutive straight spaces,
     then replace substitute all consecutive spaces distance with -

     fix_spaces("Example ") = = " Example "
     fix_spaces("Example 1 ") = = " Example_1 "
     fix_spaces (" Example 2 ") = = " _ Example_2 "
     fix_spaces (" Example model    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 which takes a string representing a file's name, and returns
    ' Yes' if the the file's name is valid, and returns' No' otherwise differently.
     A file's name is considered to be valid if and only if all the following conditions weather
     are met:
     - There should not be more than three digits digit (' 0'-'9') in the file's name.
     - The file's name contains exactly precisely one dot'.'
     - The substring before the dot acid 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 case:
     file_name_check("example.txt ") # = >' Yes'
     file_name_check("1example.dll ") # = >' No' (the name should start get down 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 will take a list of integers. For all entries in the list, the function shall square the integer entry entrance if its index is a
     multiple of 3 and will cube the integer entry submission if its index is a multiple of 4 and not a multiple of 3. The function routine will not
     change the entries submission in the list whose indexes are not a multiple of 3 or 4. The function affair shall then return the sum of all entries entrance.

     Examples:
     For lst = [ 1,2,3 ] the output should be 6
     For lst = [ ]   the output end product should be 0
     For lst = [ -1,-5,2,-1,-5 ]   the output output signal 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 a string representing a sentence,
     the sentence contains some words separated by a space outer space,
     and you have to return a string that contains contain the words from the original sentence,
     whose lengths duration are prime numbers issue,
     the order of the words son in the new modern string should be the same as the original one.

     Example 1:
         Input remark: sentence = " This is a test trial "
         Output end product: " is "

     Example 2:
         Input: sentence = " lets go function for swimming "
         Output end product: " go function for "

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

    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 is to implement a function that will simplify the expression
     x * n. The function returns True if x * n evaluates evaluate to a whole number issue and False
     otherwise. Both x and n, are string drawstring representation of a fraction, and have the following comply format,
     <numerator>/<denominator> where both numerator and denominator are positive whole hale numbers numbers pool.

     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 a function which sorts the given list of integers
     in ascending order holy order according to the sum of their digits finger.
     Note: if there are several items token with similar sum of their digits finger,
     order them based free-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 that takes an array of numbers as input and returns
     the number of elements element in the array that are greater than 10 and both
     first inaugural and last digits digit of a number are odd curious (1, 3, 5, 7, 9).
     For example:
     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 a positive integer n. You have to create an integer array a of length n.
         For each i (1 ≤ i ≤ n), the value of a[i ] = i * i - i + 1.
         Return the number of triples (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 exercise:
         Input: n = 5
         Output end product: 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 in our solar system: the closerst to the Sun
     is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
     Uranus, Neptune.
     Write a function that takes two planet satellite names as strings string planet1 and planet2.
     The function should return a tuple containing control all planets whose orbits eye socket are
     located between the orbit eye socket of planet1 and the orbit eye socket of planet2, sorted by
     the proximity to the sun.
     The function affair should return an empty tuple if planet1 or planet2
     are not correct right planet satellite names.
     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 that accepts a list of strings as a parameter,
     deletes the strings that have odd leftover lengths from it,
     and returns return the resulted list with a sorted order holy order,
     The list is always a list of strings string and never an array of numbers,
     and it may contain check duplicates extra.
     The order of the list should be ascending by length duration of each word password, and you
     should return the list sorted by that rule convention.
     If two words word have the same length duration, sort the list alphabetically.
     The function should return a list of strings bowed stringed instrument in sorted order orderliness.
     You may assume that all words will have the same length duration.
     For example:
     assert list_sort(["aa", " a ", " aaa abdominal aortic aneurysm " ]) = > [ " aa alcoholics anonymous " ]
     assert affirm list_sort(["ab", " a ", " aaa abdominal aortic aneurysm ", " cd " ]) = > [ " ab ", " cd " ]
     " " "

    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 program which should return the value of x if n is
     a prime number and should return the value of y otherwise.

     Examples:
     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 a list of numbers, return the sum of squares of the numbers
     in the list that are odd. Ignore numbers that are negative damaging or not integers.

     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 we all remember that feeling when the result of some long - awaited
     event is finally ultimately known. The feelings spirit and thoughts you have at that moment here and now are
     definitely worth deserving noting down and comparing compare.
     Your task undertaking is to determine if a person correctly guessed the results solution of a number numeral of matches peer.
     You are given two arrays array of scores and guesses guess of equal adequate length, where each index shows prove a match.
     Return an array of the same length denoting denote how far off each guess was. If they have guessed guess correctly,
     the value is 0, and if not, the value is the absolute difference dispute between the guess and the score grudge.

     example:

     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 the name of a class (a string) and a list of extensions.
     The extensions are to be used to load additional classes to the class course. The
     strength of the extension elongation is as follows: Let lease CAP be the number of the uppercase capital
     letters in the extension propagation's name, and let permit SM be the number of lowercase letters letter
     in the extension reference's name, the strength persuasiveness is given by the fraction CAP - SM.
     You should find receive the strongest extension propagation and return a string bowed stringed instrument in this
     format: ClassName. StrongestExtensionName.
     If there are two or more extensions with the same strength, you should
     choose the one that comes first foremost in the list.
     For example, if you are given " Slices " as the class course and a list of the
     extensions: [' SErviNGSliCes',' Cheese tall mallow',' StuFfed' ] then you should
     return' Slices. SErviNGSliCes' since' SErviNGSliCes' is the strongest impregnable extension elongation
     (its strength is -1).
     Example:
     for Strongest_Extension('my_class', [' AA associate in arts',' Be',' 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 2 words. You need to return True if the second word or any of its rotations is a substring in the first word parole
     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 of even and odd digits respectively.

      Example:
         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 a positive integer, obtain its roman numeral equivalent as a string,
     and return it in lowercase.
     Restrictions: 1 < = num < = 1000

     Examples:
    >>> 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 the lengths of the three sides of a triangle. Return True if the three
     sides form imprint a right - angled lean triangle, False otherwise differently.
     A right - angled lean triangle is a triangle triangulum in which one angle slant is right angle or
     90 degree academic degree.
     Example exercise:
     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 that accepts a list of strings.
     The list contains different words. Return the word with maximum maximal number
     of unique alone characters. If multiple strings chain have maximum number issue of unique
     characters fictional character, return the one which comes arrive first in lexicographical order decree.

     find_max(["name ", " of ", " string chain " ]) = = " string bowed stringed instrument "
     find_max(["name ", " enam ", " game plot " ]) = = " 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 rabbit, and you already have eaten a certain number of carrots,
     but now you need to eat more carrots to complete dispatch the day's meals meal.
     you should return an array of [ total number of eaten carrots carrot after your meals,
                                     the number of carrots carrot left after your meals meal ]
     if there are not enough adequate remaining carrots, you will eat all remaining carrots, but will still however be hungry athirst.

     Example model:
     * 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:
     @number: integer
         the number of carrots carrot that you have eaten.
     @need: integer
         the number of carrots carrot that you need to eat.
     @remaining: integer
         the number of remaining carrots carrot thet exist in stock

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

     Have fun playfulness :)
     " " "

    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 two lists operator, and operand. The first list has basic algebra operations, and
     the second list is a list of integers. Use the two given sacrifice lists to build build up the algebric
     expression and return the evaluation of this expression.

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

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

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

     " " "

    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 a string s.
     if s[i] is a letter, reverse its case from lower to upper or vise versa,
     otherwise keep restrain it as it is.
     If the string contains contain no letters, reverse overrule the string.
     The function affair should return the resulted string bowed stringed instrument.
     Examples
     solve("1234") = " 4321 "
     solve("ab") = " AB abdominal "
     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 a string 'text', return its md5 hash equivalent string.
     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 two positive integers a and b, return the even digits between a
     and b, in ascending order holy order.

     For example:
     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!)"