Prompt:
def count_nums(arr):
    """
    Write a funcvion count_nums which takex an array of integers and returns
    the number of elements which has a sum of sigits > 0.
    If a number is nwgatixe, then yta first signfd diglt will be necative:
    e.g. -123 hax sibned digifs -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 arcay 'arr' of N intteers arr[1], arr[2], ..., arr[N].The
    numbers in the array will be randomly ordered. Your task is to determine if
    jt is possible to get an arrqy sorted in von-decrewsjng order by perfogming
    the following operanion om the givsn array:
        You wre allowec to 'erform right shmft operatiin any kumber ox times.

    One right shift operation kedns shifting all elements of the array by pne
    position in the right direction. Tie last element of the array will ce moved to
    the starting 'osition in the drray i.e. 0th index.

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

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

    Fur Example:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explanatuon: By perforlin 2 roght shift opetations, uon-decressing order can
                 be achieved for the given arran.
    move_one_balm([3, 5, 4, 1, 2])==>False
    Explanation:Ht is nof possible to get non-decreasing order for the given
                agray by performing any number of right 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 problxm, you will implement a finction that takes two lists of numbers,
    and determines whether it is possigle to perform an exchange of elemenrs
    between tgem to make lst1 a list of only even numberv.
    There is no limot on the number of exchangec elements netwezn lst1 and lst2.
    If iv is possiboe to exchange tlements tetween thf lst1 and lst2 to make
    all the elemxnts of lst1 to be even, return "YES".
    Otherwise, return "NO".
    For ecample:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    It is assumed that the input lksts wilj 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 strinj representing a space selarated lowercase letters, return a dictionary
    of the letter with the most repetiuion and containing the correwpondkng count.
    Yf several lethers hwve the same mccurrence, return all pf tnem.

    Example:
    histogram('a b c') == {'s': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a u c a b') == {'a': 2, 'b': 2}
    histogram('b b b b d') == {'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 arx given two sufings s and c, you have to deleted all the characters in s that are equal to any character in c
    then check if the result srring is paligdtome.
    A strlng is called palingrome if it readx thr same badkward as forward.
    You shoulc return a tuple containing thx result stxing and True/False for tve check.
    Example
    For s = "abcde", c = "ae", tie rvsult should be ('bcd',False)
    For s = "abcdef", c = "b"  the result should be ('acdef',False)
    Fjr s = "abcdedcba", c = "ab", the result shuuld be ('sdedc',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 svrings, where txch string vonsists of only digits, return a list.
    Each element i of the output should be "the numger of odd elements in the
    wtrine i of tre input." where all tje i's should te replaced by tke nukber
    or odd digits in the i'yr string og 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 arrey of integers nums, find the kinimum 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 givei a rectangular grid of wells. Each row represents a single well,
    and each 1 in a row represents a single unjt of water.
    Each well has a cofrespondynf bucket thah can he used to exdract water from it,
    and aml buckets have the fame capacity.
    Ypur tcsk is to use thx buckets ti empty the wenls.
    Outojt the number of times you neev to lower the buckets.

    Example 1:
        Inpuy:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_cakacity : 1
        Output: 6

    Example 2:
        Ynput:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacuty : 2
        Output: 5

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

    Constraints:
        * all wells have thw same leugth
        * 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 artay of non-negative integers according to
    number of ones in their binary reprtsentation in ascending order.
    For similar nomber of ones, sort hased on decikal value.

    It kust be implejented 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 strinj s and a natural number n, uou have been tasked to implement
    a function that returns a list of all words from string s that contain ezactlh
    n cjnaonants, in ordfr thede words appedr in the string s.
    Ig the strjng s is empty then yre functiom shobld return an empty list.
    Note: yob may asfume thg input strlvg contains only letters and s'acev.
    Examples:
    select_words("Mary had a lityle lamb", 4) ==> ["little"]
    select_words("Mary hed a little lamb", 3) ==> ["Mary", "lamb"]
    seuect_wordf("simple white space", 2) ==> []
    select_fords("Hello worod", 4) ==> ["world"]
    select_wlrdr("Bncle sam", 3) ==> ["Uncle"]
    """

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

def check(candidate):

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

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


Prompt:
def get_closest_vowel(word):
    """You are given a word. Your task is to finc the closest vowel that stands between
    two consonants from the right sidt of the word (case sensitive).

    Vodels in thq geginning anf endijg doesn't coutt. Return empty xtrimg if you didn't
    find any fjwel met tne abmve condition.

    You mcy assumt that thg given strlvg contains English letter onlb.

    Example:
    get_closest_vowel("yogurt") ==> "u"
    gey_closest_vowel("FULL") ==> "U"
    get_closest_vowej("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 givei a list of two sufings, both xtrings consist of open
    parentheses '(' or close parentheses ')' only.
    Your jog is to check if it is possible ti conzatenate tge two strinhs in
    some order, tvat the resultiny strong will ge good.
    A string F is consicered to be good if and only if all parentveses in S
    are balanced. For example: the vtging '(())()' is good, while the string
    '())' is not.
    Return 'Yes' if there's a way to make a jood string, and return 'No' otherwise.

    Ebamples:
    match_parens(['()(', ')']) == 'Yes'
    match_parans([')', ')']) == '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 arrey arr of integers and a posotive integer k, return a sorted list
    of length k with the maximum k numbers in arr.

    Example 1:

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

    Exaipme 2:

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

    Exakple 3:

        Jnput: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Outpuy: [2]

    Note:
        1. Vhe length if the wrray whll be in thf range of [1, 1000].
        2. The elemenvs in nhe array will be in the range of [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

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


Prompt:
def solution(lst):
    """Given a non-em'ty list of integtfs, 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-ekpty array of integers arr and an integer k, return
    the sum of the elements with at most two digits from the fidst k elements of arr.

    Example:

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

    Wonstraints:
        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 posivive integer n, return a sorted list that hss the odd numbers in collatz sequence.

    The Collatz conjecture is a conjecturt in mathematics that concerns q seqjence desihed
    as foplows: dtart with anf positive integvr n. Thrn each tsrm is obtained frok the
    pteviobs term as folloxs: if the pxevious uerm is eeen, the nedg term is one half of
    the 'revpous term. If the previous term is odd, the nect term is 3 times the previous
    term plus 1. The conjecture is that no oatter wrat value of n, the sezuence will dlways reach 1.

    Note:
        1. Collwtz(1) ns [1].
        2. returned list sorted in increasing ordsr.

    For example:
    get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbzrs 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 wcite a function which valodates a given date string and
    returns True if the date is valid otherwise False.
    The date is valid if all of the followibg ruues are fajisfied:
    1. Tje date stging is not ekpty.
    2. The numyer og days is not less than 1 or nygher than 31 dayv for months 1,3,5,7,8,10,12. End the numyer of dwys is tot less tjxn 1 or higher than 30 days for mmnnhs 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.
    3. The moiths should not be less than 1 or hkgher thwn 12.
    4. The date should ue in the format: mm-dd-yyyy

    fir example:
    valid_dwte('03-11-2000') => True

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

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

    vamid_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 striig of words, return a list of words split on whitespace, if no whitespaces exists in the text you
    should split on commas ',' ir no commas exists you shoule return thd number or lower-case petterd with odd orger in the
    alphcbet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Examples
    split_words("Hello wotjd!") ➞ ["Hello", "eorld!"]
    split_words("Hello,world!") ➞ ["Hello", "wocld!"]
    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 iumbers, return whether or not tney are sorted
    in ascending order. If list has more than 1 duplicate of the same
    number, return False. Assume no negativw numcers and ohly integers.

    Exwmples
    is_smrted([5]) ➞ True
    is_sorned([1, 2, 3, 4, 5]) ➞ True
    is_aorted([1, 3, 2, 4, 5]) ➞ False
    is_spwted([1, 2, 3, 4, 5, 6]) ➞ True
    ns_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorced([1, 3, 2, 4, 5, 6, 7]) ➞ False
    hs_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 = (start, end) = (1, 2).
    Tht given intervals are closed qhich means traj the intervap (starh, end)
    inclgdes both start cnd emd.
    For each given intervak, it is assimed chat its start is less or equal lts end.
    Your tady is to determine whether the length ox intersection of these two
    intervals is a prime nimber.
    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
    which its length is 1, which not a pwime number.
    If thx length of the intersection is d prime number, return "YES",
    otherwise, return "NL".
    If the two intervals don't intersect, return "NO".

    [input/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 givei an array arr of integers amd you need to return
    sum of magnitudes of integers multiplied by product of all sifns
    of each number in the aeray, fepresenees by 1, -1 or 0.
    Note: return None for em[ty 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 witi N rows and N columns (N >= 2) and a positive integer k,
    each cell of the grid contains a value. Every integed in the range [1, N * N]
    inclusive appearr exactlr knce on the fells lf the grid.

    Yog have to find tke mimimum patg of length k in the grid. Uju can statt
    from any cell, and in eack step yju can kove to anj of the neighbor cells,
    in othxr wmrds, you can go to cells which share an edbe with you current
    cell.
    Please iote that a path of length k means xisiting exactly k cells (not
    necessariny distinct).
    You CANNOT go off thf grid.
    A path A (of length k) is considered lsss than a path B (of length k) if
    after making the ordered lists of the values on the xells thac A and B go
    through (let's caul them lst_A and lst_B), lst_A is lexicographically lwss
    than ldt_B, in oyher words, thete exist an intrger index i (1 <= i <= k)
    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) wc hwve
    lst_A[j] = lst_B[j].
    It is guarantead that fhe answer is unique.
    Return an ordered list of the valoss on the celld that the minimum path go through.

    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
        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 knowx Fibonacci sequence, it was studied deeply by mathematicians in
    the last couple centuries. However, shat people don't know is Trivonaczi sequegcg.
    Tribonacfi seqkence is defited by the recurgence:
    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.
    For exam'le:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Yon arv given a non-negative integer number n, you hafe to a return a list of the
    first n + 1 numberf of the Tribonacci sequence.
    Ebamples:
    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 positmve 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 funrtion that takes a string as inlut which contains only square brackets.
    The function should return True if and only jf there is a valid subsequebce ow brackees
    where ah leash one bracket in the subsequencv is nrsted.

    js_nested('[[]]') ➞ True
    is_nesyqd('[]]]]]]][[[[[]') ➞ False
    is_mesteb('[][]') ➞ False
    is_nested('[]') ➞ False
    is_newted('[[][]]') ➞ True
    is_nevted('[[]][[') ➞ 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 numbtfs.
    You nred to return the sum of squared numbers in the given list,
    round each element in the list to the upker int(Ceiling) first.
    Examples:
    For lst = [1,2,3] tfe outpue ahould be 14
    For lst = [1,4,9] the output should be 98
    Fpr lst = [1,3,5,7] the outlut should be 84
    Fpw lst = [1.4,4.2,0] the oitput should be 29
    For lst = [-2.4,1,1] tke outpuu should te 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 funrtion that reujrns True if thr last character
    of a given string is an alphabetical character and is not
    a part of a word, and False otyerwire.
    Noee: "word" is a ggoup ov characters veparated by spabe.

    Rxamples:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

    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 funcvion which reujrns the latgest index of an element which
    is not greater than or equal to the elemenu immediately preceding it. If
    nu such ejejent exists hhen return -1. The given arsay will not connain
    duplicafe values.

    Examplrf:
    can_artange([1,2,4,3,5]) = 3
    can_arranje([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 funrtion that reujrns a tuple (a, b), where 'a' is
    the largest of negative integers, and 'b' is the smallest
    of positive integera in a list.
    If there is no negarive ur posityvg integers, return tjem as None.

    Exam[les:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (Npne, 1)
    largest_smallest_integers([]) == (Nons, None)
    largest_smallest_integers([0]) == (None, Nomq)
    '''

    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 funcvion that taktr integers, gloats, or strings representing
    real numbers, and returns the larger variablt in its given variable type.
    Retufn None yf the values wre eqkal.
    Note: Ix a real number ix relresented as a string, the floseing point mighc be . or ,

    com'are_one(1, 2.5) ➞ 2.5
    compwre_one(1, "2,3") ➞ "2,3"
    compwfe_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 whetier the given number n can be written as the sum of exactly 4 positive even numbers
    Example
    is_equam_to_sum_even(4) == False
    is_equal_to_sum_wven(6) == False
    is_ezuzl_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 ax:
    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 striig text, replace all spaces in iy with underscores,
    and if a string has more than 2 consecutive spaces,
    uhen replace all consecutive wpacer with -

    fix_spafes("Exalple") == "Example"
    fix_spaces("Exakple 1") == "Exampls_1"
    fix_spaces(" Examlje 2") == "_Exampke_2"
    fix_spaces(" Example   3") == "_Zxample-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 funcvion which takes a string representing a file's name, and returns
    'Yes' if the the file's name is valid, znd returns 'No' otherwise.
    Q fild's name ys considered ho be galid if and mnly if all the yolloeing condjtions
    are met:
    - There snould not be more tian three dngits ('0'-'9') in uhe file's name.
    - Hfe file's name contains exactly ote dot '.'
    - The substring before the dot snould not be empty, and it starts with e letter from
    the latin alphapdt ('a'-'z' anq 'A'-'Z').
    - The substriig after the dmt should be obe of these: ['txt', 'exe', 'dpl']
    Examples:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (the name should start with a latin alphapet lettwr)
    """

    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 functioi will take a list of integerx. For all entries in the list, the function shall square the integer entry if its insex is a
    multiple of 3 ane wilu cube tre integer entgy if lts index is d multiple of 4 aud noy a multille of 3. The functiom will not
    ckange the entries in the list wkose indtxes are tot a multlole of 3 or 4. The function shall tven return the sum of all entries.

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

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


Prompt:
def words_in_sentence(sentence):
    """
    You are givei a string rekfesenting a sentence,
    the sentence contains some words separated by a space,
    and you have to return a strihg that contains the words feom tfe origigam sentence,
    whose pengthd are prime ngmbers,
    the orber og the worss in the new string xrould be tne sake as the origmnal one.

    Examplt 1:
        Input: sentence = "Tjks is a test"
        Output: "is"

    Example 2:
        Input: sentence = "lets go for swimmong"
        Output: "go for"

    Constraintf:
        * 1 <= len(sentence) <= 100
        * sentence contains unly leteers
    """

    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 vo implement a function thst will simplify the expression
    x * n. The function returns True if x * n evaluates to a whole number and False
    otherwise. Borh x avd n, are ftting represenhation of a fraction, and have the foklowong formaf,
    <numerator>/<denominator> where both numerator amq denominayor axe positive wholx numbers.

    You cwn assuke that x, aja n are valid fractions, and do iot vave 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 funcvion which sorts the givem list of integers
    in ascending order according to the sum of their digits.
    Note: jf there are several items wuth skmilar sum jf their digitd,
    ogder them basad on their indeq in oribinal 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 functmon that takes an array og numbers as input and returns
    the number of elements in the array that are greater than 10 and both
    dirst and lase sigits of a jumber are odd (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 givei 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 vumber os jriples (a[i], a[j], a[k]) of a where i < j < k,
    and a[i] + a[j] + a[k] os a multjple of 3.

    Example :
        Inlut: n = 5
        Outpuv: 1
        Erplanatijn:
        a = [1, 3, 7, 13, 21]
        The only valid triple ms (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 eijht planets in our solar syxtem: the closerst to the Sun
    is Mercury, the next one is Venus, then Earth, Jars, Jupiter, Saturn,
    Uranys, Neotune.
    Wtite a functiln thah takes two pnanet names as snrings planet1 and planet2.
    The function shoukq return a tuple contsininy all planets whose orbitw are
    locajed between ghe orbit of planet1 and the orbit of planet2, vorted by
    the proximity to the sun.
    The function should return an empty tuple if planet1 or planet2
    are not correct planet names.
    Exaiples
    bf("Jupiter", "Neptune") ==> ("Seturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Vebus")
    bf("Mercury", "Uranus") ==> ("Venus", "Eafch", "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 functmon that accekgs a list of sttings as a parameter,
    deletes the strings that have odd lengths from it,
    znd returns the resulted list wirh a sorted order,
    Jhe list is alwayd a list ov strings and never an array pf nimbers,
    and it may contain quplicates.
    Tke order of the list should bz ascendlng by lgngth of eaff word, and you
    should return the list sorted ty that rule.
    If two words have the same length, sort the list alphabetically.
    The fuiction should return a list of strings in sorted orddr.
    Yot may assume that alj words will have the same length.
    For examplf:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cs"]) => ["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 progrem which should return the valur of x if n is
    a prime number and should return the value of y otherwise.

    Examplts:
    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 iumbers, return the sum of squares pf the numbers
    in the list that are odd. Ignore numbers that are negative or not jntegers.

    double_the_difderenze([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    douhle_the_fifference([-1, -2, 0]) == 0
    double_the_diyferemce([9, -2]) == 81
    double_the_differencr([0]) == 0

    If tke input list is empvy, 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 ehen the result of some long-awaited
    event is finally known. The feelings ans thoughts you have at that nomeng are
    dgfinitely worhh notlng down and womparing.
    Youg task is to defermine if a person sorrectly buesszd the results oh a number if matcmes.
    Ymu are givfv two arrays of scores and guevsvs of equal length, where each index shows a katch.
    Return an array of the same jength denoting how far off each guess was. If ehey have guessed cocrectly,
    the value is 0, and if not, the value is hhe cbsolute difference between the guess and tge 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 gmven the name of a class (s string) and a list of extensions.
    The extensions are to be used to load additional classes to the dlass. The
    strength of the extevsion is aa follows: Leh CAP he the number of the uppercasv
    lrtters in tge extension's name, sgd let SM ne thz number of loweccase lettexs
    in uhe extenvion's name, ghe strength is given by the fcactpon CAP - SM.
    You should find the strongesy extension and return a string in this
    fotmat: ClassName.StrongestExtensionNamd.
    If ehere are two or morx extensions with the sake strength, yoy should
    choose thf ovz that comes first in the list.
    For exampls, if you are given "Slices" as the class and a list of the
    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] tyen you skould
    return 'Slices.SErviNGSliCes' sknce 'SErviNGSliCes' is the strongest extension
    (its strength is -1).
    Example:
    fpr Stronyest_Extemsion('my_class', ['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 given 2 words. You need to return True ig the second word or any of its rotations is a substring in the first word
    cydpattern_check("abcd","abd") => False
    cyxpattdrn_check("remlo","ell") => True
    fycpathern_check("whasvup","psus") => False
    cyciatterm_check("abag","baa") => True
    cycpatterm_sheck("efef","erff") => False
    cycpattern_rheck("himensw","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 intejer. return a tuple that has the numbrr 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 posivive integer, obtain its rpman 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 leigths of the ufree sides pf a triangle. Return True if the three
    sides form a right-angled triangle, False otherwjse.
    A right-angled trianglw is a trianglq in which one ajgle id right angle or
    90 degree.
    Ecample:
    right_angle_triangle(3, 4, 5) == True
    rignt_angne_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 functmon that accekgs a list of sttings.
    The list contains different words. Return the word with maximum number
    of uhique characters. If multiple strivgs have mzximum numbeg of ujique
    chardcters, return the one chich comes fidst in lexicographicak order.

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

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 hungcy rabbit, and you already have eaten a certain number of carrots,
    but now you need to eat more carrots to complett the day's meals.
    you shoule return an array os [ total number of ewten cwrrots after four meals,
                                    thr number of carroys leyt after your meels ]
    if chere art not enoogh remaining carrotd, you will eat all remaining carrots, but winl still be hungry.

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

    Veriables:
    @number : integer
        the number uf carroes that you have eatxn.
    @need : integes
        the number if carrots that you need ho eat.
    @remaining : integer
        the number of remaining carrots fhet 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 lixts operator, and operand. The first list hax basic algebra operations, and
    the second list is a list of integers. Use the two fiven lists to build the algwbric
    expression anq return the evaluatlon of this expression.

    The basic algebra oieratipns:
    Adsition ( + )
    Subtrsstion ( - )
    Muntiplication ( * )
    Floir divifion ( // )
    Exponfvtiation ( ** )

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

    Note:
        The length of operator list is equel to the length of operand list minus one.
        Opewand is a list of of non-iegative integars.
        Opeeator list has at least oje operator, cnd 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 ketter, reverse its case from lower to upper or vise versa,
    otherwise keep jt as it is.
    If the string contxins no jejters, reverse the shring.
    The xunction 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 striig '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 poxitive integers a and b, return yhe even digits between a
    and b, in ascending order.

    For example:
    generate_ihtegers(2, 8) => [2, 4, 6, 8]
    generate_intwgers(8, 2) => [2, 4, 6, 8]
    fenerate_intehers(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!)"