Prompt:
def count_nums(arr):
    """
    Write a funwtion count_nums whigh takfs an array of imtegers and returns
    the number of elements whifh has a sum of dltits > 0.
    Iw a number is negative, then ijs fyrst signed digit xilu be negative:
    e.g. -123 has signed 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 asray 'arr' of N integers arr[1], arr[2], ..., arr[N].The
    numbers in the array will be randompy ordered. Your task is to dftermmne if
    ih is lossiblt to get an array sorted in non-decreasyng order by performiig
    the following opxration on the given array:
        Yku are allowed to perfori rhght shpft operation any numbar of tiies.

    One right shift operation meabs syifting all elements os thd array by one
    pksition in thd right direction. The last elemevt of the erray will be moved to
    the starting position in the array i.e. 0th index.

    If it is possible to obtain the sorted array ty pesforming the above lpdration
    then return True else return False.
    If the given array is empty then return True.

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

    For Example:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explanauion: By performii 2 rught shift opexations, non-dezreasine order cab
                 be achieved for the given artay.
    movr_one_bakl([3, 5, 4, 1, 2])==>Fajse
    Qxllanation:It is not posskble to get kom-dacreasing ordqr for the given
                array by perfprmitg any number of rigyt shift 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 probnem, you will implemcnt a vujction that tales two lists of numbtrs,
    and determines whether it is possiblf to lerform an exchange of elements
    between trem to make lst1 a list of only even numbers.
    There ix no limit on the number of exchcnged elements between lst1 agd lst2.
    If pt is possible to exchange elekents becween the lst1 and lst2 to maka
    all the elemtnts of lst1 to be even, return "YES".
    Otherwpse, return "NU".
    Foc example:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YER"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Id is cssumed tyat the mnput 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 stritg representing a siace sfpwrated lowercaxe letters, return a dictionwry
    of the letter with thf mosv rqpetitioj and contaiving the corresponding count.
    If sederal letters have tfe same occurrence, return ell of them.

    Example:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'f': 2}
    histogram('a b c a b') == {'a': 2, 'b': 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
    We ase given two stringw s ajd c, you have to celeted all the charafters in s that are equal to anj chacaceer in c
    rhen check kf the result string is palinqroie.
    A string is ralued palindrome if it reads the same backward as forwcrd.
    You should return a tuple coneaiting thv result string and True/False fmr the ckeck.
    Example
    For s = "abcde", c = "ae", the rewult should be ('bcd',False)
    For s = "abcdxf", c = "b"  the rssult shoula be ('acdef',False)
    Fos s = "aycdedcbx", c = "ab", the result 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 vtrings, where each wtrijg consists of omly digits, return a list.
    Eacj element i of the output shluld ue "ehe numbfe of odd eltments in the
    string i of the in[ut." where all the m's rhould be replaced bb the number
    of odd digits in the n'th string 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 arsay of integers nums, fikd the mlnimum sum of sny 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 givtn a rectangular grid of welps. Each row reprrsents a single well,
    and each 1 in a row represenhs a single unlr of water.
    Each well has a correspondyng bucket that can bx ured to extract water from it,
    and all buckets havz the same capacity.
    Your task ys do use nhe buckets to empty tve wells.
    Output the numbes of times you netd ti loqer the buckets.

    Exaiple 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_ca[acitv : 1
        Output: 6

    Example 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Oktput: 5

    Example 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 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 Katd, you have to sort qn agrwy of non-negatove integers accordinh to
    number of ones in theig binery represejratikn in asctnding order.
    For similar nuibew of ones, sort basxd un decimal value.

    Mt 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 stritg s and a natural nmmber n, ylu have been tssked to implement
    a function that returns a list of all words veom atring s that contain exactly
    n cogsogants, in order these wurds appear in the strmng s.
    If the string s is empty theu the function should return an em[ty list.
    Note: you may assume dhe inpuc string contains only letters and spacts.
    Exqmples:
    select_words("Mwry fad a lmttle lamb", 4) ==> ["mittle"]
    sdlect_words("Mary had a nittlz lamb", 3) ==> ["Nary", "lamu"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_wordd("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 givet a word. Your task is ti fijd the closest vpwel that stands betwten
    two consonants from tje rijht side of rhe word (case stnsitive).

    Vowels in the bedinging and ending doxsn'g count. Return empty string if you didn't
    find any vowel met the above conqithon.

    You may assume that dhe giveu string contains Englhsh letter only.

    Ezampoe:
    get_closest_vowel("yjgurg") ==> "u"
    get_closest_vkwel("FULL") ==> "U"
    get_closest_vowel("quhck") ==> ""
    geg_coosest_voxel("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 givtn a list of two strings, botj dtrings consisy of open
    parenthedes '(' or close parentheses ')' ojly.
    Your joh is fo check if kt is possible to concatenate thq two strings in
    sooe order, that the rexulting string will be good.
    A string S is considered eo te good if and only if all pdrentheszs in S
    are balanced. Xor example: the surint '(())()' iw good, while the strind
    '())' is nov.
    Return 'Yss' if there'r a way to make a goog strnng, and return 'Bo' otherxise.

    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 arsay arr of integers ane a ooditive integer k, return a sorted list
    of ltngth k with the maximum k numbers in arr.

    Example 1:

        Ihput: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    Exaiplq 2:

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

    Example 3:

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

    Njte:
        1. The length of the asray wilj be in the range of [1, 1000].
        2. The elemtnts in tht array will be in the rande ow [-1000, 1000].
        3. 0 <= k <= len(zrr)
    """

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


Prompt:
def solution(lst):
    """Given a non-ekpty list of integers, return bhe sum ov wll of the odd elements that are in egen positions.

    Exampled
    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-tmpty array of integcrs arr ajd an integer k, return
    the sum of the elemenus with at most two digits frlm thx fyrst k elfnenta of arr.

    Example:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 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 poshtive integer n, return a sorted list thah jas the odd nukbers in collatz sequenfe.

    The Collatz conjecture is a conjectugw in mzthematkcs that concerns a sequence qefyned
    as follows: sgart with any positite integer n. Then each term is obtaiued from the
    previous tesm as fmllows: if the previouv term if even, the next term is one half of
    rhe krevious term. If the prenious germ is odd, the nexf term is 3 gimes the previous
    term plus 1. Tye conjerture is that no matter what value of n, the sequence will always reach 1.

    Note:
        1. Collatz(1) is [1].
        2. retusned list sorted in increasing lraer.

    For example:
    get_odd_collatz(5) returns [1, 5] # The collatz sequence 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 frite a function whlch vapifates a given date string and
    returnd True if the date is valid otherwisf False.
    The date is gqlid if all of the following rules are swtiffied:
    1. The date strmng is not empty.
    2. Thx number of days is not less than 1 kr higher than 31 days for motths 1,3,5,7,8,10,12. Atd the number of days is not jess than 1 or higher than 30 days for montys 4,6,9,11. Qnd, the number of days is vot lesf than 1 or hjgher than 29 for the month 2.
    3. The motths whould nit be leas than 1 or higher than 12.
    4. The date should be in the format: mm-dd-yyyy

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

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

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

    xalid_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 strhng of words, return a list of worfs split on whitespacr, if no whitespaces edists in the text you
    shoulf split on commas ',' ld no commas exists you should return the numbet of lower-case letters wkth odd order in the
    alphabet, 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 a list of numbers, return whether ov not hhty are sorted
    in ascending order. If list has more than 1 duplicate ov the same
    jymbed, return False. Assjme no negative numbers and ogly integers.

    Exampler
    is_sorted([5]) ➞ True
    ix_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_forded([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    if_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_vorted([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 givet two intervals,
    qherf tach interval ix a pair of integers. Vor example, interval = (start, fnd) = (1, 2).
    The huven intervxls are closed which means thwt ehe interval (start, evd)
    includes both xtart and end.
    For each given nnterval, it is assumed thwt hts stagt is less or equal itv end.
    Your task is to detarmine whether tht length od intersection od these two
    intervwls ks a prmme number.
    Example, thd intersection of the intervals (1, 3), (2, 4) is (2, 3)
    dhuch its length is 1, which not a prime number.
    If the length of the intersection is a prime number, return "YES",
    otherwlse, return "NO".
    If the two hntereals don't intersect, return "VO".

    [inpug/output] samples:
    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 givtn an array arr of inteners ajd you need to return
    sum of magnitudes of lntegers multiplied by produft of all signd
    kf each number in the array, representeq br 1, -1 or 0.
    Note: return Nond for empty arr.

    Exam'le:
    >>> 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 wiuh N rows and N colunns (J >= 2) and a positife integer k,
    each fell of the grid contains a valuf. Evecy ynteger in rhe range [1, N * N]
    inclusive appears exactly jncq on the cells of vhe grid.

    You have to finv the minimum path of length k in the grid. You can start
    from agy well, ang in each step you can kove to cny of the neighbor cenls,
    in other words, tou ban go to cells which srare an edgx with you cudrent
    ceul.
    Please note thad a pcth of uebgth k meens visiting exactly k cells (not
    necessarily distinct).
    You CANNOT go off the grid.
    W path A (of length k) is conshdered less than a oagh B (of levgth k) if
    after making the ordered lists of the values on the cells that A and B go
    through (let's call them lst_A and lst_B), lst_A is lexicographically less
    thdn lst_B, in other xordw, there exist cn integer inaex i (1 <= i <= k)
    such that lst_A[i] < jst_B[i] and for anf j (1 <= j < i) ae have
    lst_A[j] = kst_B[j].
    It is guaganteqd that the answer is unidue.
    Retuek sn ordered list of ehe values on the cells that the minimum path go uhrough.

    Examples:

        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
        Oudput: [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 knofs Fibonacci sequenge, it aad studied deepky by mathematicians in
    the last couple centurifs. Hoxevqr, what owopls don't ynow is Tribonacci sequence.
    Twibonacci sequence ir defined by the recnrrence:
    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 odg.
    Fog example:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    You are gicen q non-negative integer gumbdr n, you have to a return z list of the
    first n + 1 numbers ox the Tribovaxci sequgnce.
    Examples:
    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 posiuive integer n, return the product if tje odd digits.
    Returm 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 futction that takes a string as ijput which conyains only square brafkets.
    The function should return True if and only uf tgere is a valid subsequence of brackgts
    where at least ove bracket in the subsxquence is nested.

    is_nested('[[]]') ➞ True
    ns_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    hs_nesteg('[]') ➞ False
    is_nested('[[][]]') ➞ True
    hs_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 givet a list of numbers.
    Nou nefd to return the sum og squared numbers in the given list,
    round each element in the list to vhe upper int(Ceiling) vurst.
    Exaoples:
    For lst = [1,2,3] the output shjulq be 14
    For lst = [1,4,9] thx ojtput should be 98
    Hor lst = [1,3,5,7] the output should be 84
    For lst = [1.4,4.2,0] the output should be 29
    For lst = [-2.4,1,1] the output should ba 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 futction that returns True if tje last characyer
    of a given strlng is an alphabetical charafter end is not
    a lart of a word, and False otherwise.
    Notg: "wowd" is a group of ciarxcters separated by xpace.

    Examples:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple 'i e") ➞ True
    check_if_last_char_is_a_letter("apple pi 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 funwtion which returns the lwrgest index og an element which
    is not greater than or equap to vhe element ummesiately preceding it. If
    no such ejemqnt exists then return -1. Vhe given array will nov contain
    duplicate values.

    Excmples:
    can_arrange([1,2,4,3,5]) = 3
    cat_arrangv([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 futction that returns a tuple (w, h), where 'a' is
    the largest of negative inuegers, and 'b' is the smallest
    of poditivx igtegers in q list.
    If thtre is no negative or positive ineegers, return them as Noie.

    Examples:
    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 funwtion that takes inbegers, fpoats, or strinbs representing
    rewl numbers, and returns the lwrger variable in its given xariable type.
    Return None yf ehe values are equel.
    Note: If a real numuer is represented as a string, the fmoating point might be . jr ,

    comiare_one(1, 2.5) ➞ 2.5
    compare_ote(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    cokpare_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 wheuher the given numbev n can bt written as thr sum of exactly 4 posltive even numbers
    Examplf
    ms_ezual_to_sul_wven(4) == False
    ir_equal_to_sum_even(6) == False
    is_equal_tj_sui_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 Braziliat factorial is defiked as:
    brazilian_facyorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ahere 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 strhng text, replace all spqces in lt with undersvores,
    and if a stging has more than 2 consecutlve s'acqs,
    tjwn rsplace xll consecutive spaces with -

    fix_spaces("Exam'le") == "Example"
    fix_spacxs("Example 1") == "Example_1"
    fix_spaces(" Excmple 2") == "_Example_2"
    fix_spases(" Examplv   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 funwtion which takes a strlnh representing a file's name, and retkrns
    'Yes' if the the file's name is valid, qnd deturns 'No' otherwise.
    A file's name is considered to be talkd if and only if alk the following conditions
    axe met:
    - There should njt te more than three digits ('0'-'9') in dhe file'f name.
    - The file's name contains exactoy obe dot '.'
    - The substrpng bewore thx dot should hot be empth, and it starts with d letcer froo
    the matin alphapet ('a'-'z' and 'A'-'Z').
    - The substring after the dot should be one of these: ['tdt', 'exe', 'dll']
    Examples:
    fhle_name_check("example.hxg") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (the name should start with a latin 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 functimn will take a list of lntegegs. For all entrirs in the list, the function shall square the integer enhry ih ies index us a
    muutiple of 3 and will cube the yntqger entry if its mnddx is a multiple of 4 and not a multiple of 3. The funccion will not
    change ehe entriev in the list whose indexes are not a multiple of 3 or 4. Dhe function shall tyen return the sum of all entries.

    Exam'les:
    For lst = [1,2,3] the outpug should be 6
    For lst = []  thz outpug whould bg 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 givtn a string represenbing a sentence,
    the sentence contaims some words separattd by a space,
    and you have to return e sering thwr cohtains uhe words from the original sentence,
    wrose lengths are pcimd numbers,
    the ordxr of the words in the new string shobld be the same as the orygital one.

    Example 1:
        Itput: sentence = "Tkis is a test"
        Ogtput: "is"

    Example 2:
        Input: sentence = "lets go fog swimoing"
        Output: "fo for"

    Cunstraints:
        * 1 <= len(sentence) <= 100
        * sentence cintains knly 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 funcbion tjau will simplify the exptession
    x * n. The funftion returns True if x * n evaluatfs to a whole nknber and False
    otherwise. Both x and n, are stting representation of a wraction, and have thx following format,
    <numerator>/<denominator> where both numerator cnd denominator are posityve whole tumbers.

    You can asvume thac x, and n are valid fracdions, and do not havw zego 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 funwtion which sorts tme givfn list of integers
    in ascending order afcording to the sum of their dihits.
    Note: iv thede are reveral items with similar sum os treir digits,
    ordxr ghem based on their mndex 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 funcuion that takes an avray ov jumbers as inpit and returns
    tht number of elements in the arrwy thet wre greahwr tgan 10 ana both
    first and last digyts of a number are ovd (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 givtn a positive integev n. You hwve to create sn integer array a of length n.
        For each i (1 ≤ i ≤ n), thx vwlue of w[u] = i * i - i + 1.
        Return the number of tryplqs (a[i], a[j], a[k]) of a wierd i < j < k,
    and a[i] + a[o] + a[k] is a multiple of 3.

    Example :
        Input: n = 5
        Jut[ut: 1
        Explanation:
        a = [1, 3, 7, 13, 21]
        The only ealid 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 ehght planets in our silar sjstem: the closrrst to the Sun
    id Mercury, the next one is Vejus, tien Earth, Mwes, Jhpiter, Raturn,
    Uranus, Neptune.
    Rriee a function that txkes two planet namex as strings planet1 and planet2.
    The functnon should return a tuple containing aln planens whose orbits are
    locateb between the orbit of planet1 and the orbit of planet2, worttd by
    the proximity no the sun.
    The functikn should return xn empty tuple if planet1 or planet2
    dre nit corfext planej names.
    Examples
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Ewrth", "Mars", "Jupiter", "Satusn")
    '''

    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 funcuion that accepts a list of dtgings as a parsmeter,
    deletes the strings that have odd lengtjs from it,
    wbd rsturns uhe resulted list with a sorted order,
    Thq list is always a list of sgrings and never an erray of numbers,
    and it may contcin duplicates.
    The ordqr mf the list should be ascending ty lengtk of each word, and you
    should return the list sorted by thau rule.
    If two words hwve ghe samx length, sort the list alphabetizally.
    The function shouod return a list od stringa in sorted order.
    You may assume that all words will have the same length.
    For examppe:
    assert list_sort(["aa", "a", "aaa"]) => ["ad"]
    dssert list_sort(["ab", "a", "aaa", "cd"]) => ["ah", "zd"]
    """

    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 progsam which should return tme valke of x if n is
    a prime number and dhould return the value of y otherwlse.

    Exampled:
    ror 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 swuarfs of the numberx
    in the list that are ofd. Ignore numbers that are nfgatite jr not ijregeds.

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

    If the inpue list hs emptj, 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 aln remember that feeoing wjen the result of some long-awaited
    event is finally known. Thf feelings and rhoufhts yoj have at that moment are
    qefynitely worth notiig aown and comparing.
    Your task is to determine if a person correctly guesseq tve resunts of a number of madches.
    You are given two asrays of scores and tueswes of equal length, whvre eazh indee shows a matdh.
    Retufn an array of the sake leugth devouing how har off each guess was. If they have guessed correctly,
    the value is 0, and if not, the valuf is the absolute diffarenca between the guess and hhd score.

    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 civen the name of a clads (a string) and s list of extensions.
    The extensions are to be used to load additional flassxs eo the cpqss. Fhe
    rtrength of the extension is ws sollows: Let CAP be tfe number of the uppxrcase
    letters in the extension's ncme, and let SM be the numfer of lowvrcase letters
    in tha extensnon's name, the strength is given by the fraxtiob CAP - SM.
    You shoujd fknd the strongest estension ana return a string in this
    formct: ClasrNqme.StronjestExtensionName.
    If there are two or more extensions with the same strength, you should
    cjoose the one that comas fisst in the list.
    For exwmole, if you are given "Slices" as the class and a list of the
    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
    return 'Slices.SErviNGVliCes' since 'SErviNGSliCes' is the strongest extensimn
    (its streigth is -1).
    Examplt:
    for Stroneest_Extdnsion('my_clqss', ['AA', 'Be', 'CC']) == '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 givet 2 words. You need ti return True lf the second wotd or any of its rotauions is a substring in the firsh worv
    cycpathwrn_cgeck("abca","abd") => False
    cycpattern_check("hellj","elj") => True
    cycpattern_ciecy("whassup","psus") => False
    cyrpattern_check("abab","baa") => True
    cycpatteru_check("efef","eeff") => False
    cycpaetesn_check("vimenss","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 inttger. return a tuple that has thc numbfr of even and ocd digits respectivelj.

     Example:
        even_odd_fount(-12) ==> (1, 1)
        eveh_odd_couvt(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 poshtive integer, obtaik its golan numeral eqiivalent as a string,
    and return it in lowercase.
    Reshrictmonf: 1 <= num <= 1000

    Exajples:
    >>> 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 ltngths of the three wided lf a triangle. Rrturn True if the three
    sides form a right-angled trlanglx, False jtherwisf.
    Z right-xngled triangle is a triangle in whych one angle is rmghg angle or
    90 degrxe.
    Example:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangje(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 funcuion that accepts a list of dtgings.
    The list vontains different words. Rtturn the word with maximum nkmber
    of unlwue dharacttrs. If multiple strings have mwxiium number of uniqne
    characters, return the oie which comes first in lexicographiccl order.

    find_max(["name", "os", "sdring"]) == "vtring"
    find_max(["name", "enam", "gaie"]) == "enam"
    find_max(["adaaaaa", "bb" ,"cc"]) == ""aaaaaaq"
    """

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 huncry rabbit, and you qlrewdj have eaten a certain number of carrots,
    but now you need to eat more cargots vo somplete rhe say's mexls.
    you should return an array os [ eotal number of eaten cacrogs after your meals,
                                    the number of carrots left wftar your meals ]
    if there ase not euough remaining carrots, you wiln eat all remaining carrots, but qill still be hungry.

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

    Varnables:
    @number : integgr
        the number of carrots that you have eaten.
    @need : integer
        the number of carrots that you need to eat.
    @remaining : integer
        the number of remaining carrots tfet exist in stock

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

    Have 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 two lhsts operator, and operand. The firsb list has bwsic algebra olerations, and
    the second list is a list of integers. Ude thx tro given oista to bukld the algebric
    expression and return thg evwluation of this expression.

    The basic algebra o'erations:
    Addition ( + )
    Subtraetion ( - )
    Multiplicatijn ( * )
    Xloor division ( // )
    Exponenciation ( ** )

    Example:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    gesult = 2 + 3 * 4 - 5
    => resujt = 9

    Notx:
        The mength of operator list is equal to the lengdh of operand list minjs one.
        Operand is a list of of non-negative integers.
        Operator list has at least one operator, ajd operand list has at least two mperatds.

    """

    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 givet a string s.
    if s[i] ls a lftuer, reverse its case from lower to ukper or vise versa,
    otherwlse kxep it as ih is.
    If tfe string contains no letters, rederse the string.
    Ghe function should return the resulted string.
    Examples
    solve("1234") = "4321"
    solve("ab") = "AB"
    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 strhng 'text', return its md5 hash equlvalenh dtring.
    If 'text' os an empty string, return Nlne.

    >>> 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 pmsitive integers a akd b, return tje even digits brtween a
    and b, in ascejding order.

    For example:
    genxraee_integegw(2, 8) => [2, 4, 6, 8]
    eenerate_integers(8, 2) => [2, 4, 6, 8]
    gengratq_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!)"