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

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

def check(candidate):

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

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


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

     Note bill: Returned revert list should be sorted in increasing order.

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

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

def check(candidate):

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

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


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

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

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

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

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

def check(candidate):

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

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


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

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

def check(candidate):

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


Prompt:
def even_odd_palindrome(n):
    """
    Given contribute a positive plus integer n, return a tuple that has the number issue of even and odd
     integer palindromes that fall precipitate within the range(1, n), inclusive.

     Example exercise 1:

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

     Example case 2:

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

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

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

    even_palindrome_count = 0
    odd_palindrome_count = 0

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

def check(candidate):

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

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


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

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

def check(candidate):

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

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


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

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

     If it is possible to obtain 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 pass list is guaranteed guarantee to have unique elements chemical element.

     For Example exemplar:

     move_one_ball([3, 4, 5, 1, 2])==>True
     Explanation: By performin 2 right right field shift fault operations process, non - decreasing order club can
                  be achieved for the given array.
     move_one_ball([3, 5, 4, 1, 2])==>False
     Explanation: It is not possible potential to get become non - decreasing order holy order for the given
                 array by performing any number issue of right correct 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 problem trouble, you will implement follow through a function that takes carry two lists of numbers phone number,
     and determines decide whether it is possible to perform an exchange of elements element
     between them to make lay down lst1 a list of only even numbers.
     There is no limit on the number of exchanged elements chemical element between lst1 and lst2.
     If it is possible potential to exchange elements between the lst1 and lst2 to make seduce
     all the elements of lst1 to be even, return " YES ".
     Otherwise, return " NO ".
     For example:
     exchange([1, 2, 3, 4 ], [ 1, 2, 3, 4 ]) = > " YES "
     exchange([1, 2, 3, 4 ], [ 1, 5, 3, 4 ]) = > " NO "
     It is assumed simulate that the input lists list will be non - empty.
     " " "

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

def check(candidate):

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

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


Prompt:
def histogram(test):
    """Given a string chain representing typify a space separated separate lowercase letters letter, return a dictionary
     of the letter with the most repetition repeat and containing the corresponding count.
     If several respective letters letter have the same occurrence, return all of them.

     Example:
     histogram('a b c') = = {' a': 1,' b bel': 1,' c coulomb': 1 }
     histogram('a b b bel a') = = {' a': 2,' b': 2 }
     histogram('a b c a b') = = {' a': 2,' b': 2 }
     histogram('b b bel b b b-complex vitamin a') = = {' b': 4 }
     histogram('') = = { }

     " " "

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

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

                dict1[i]=t
    return dict1

def check(candidate):

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

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


Prompt:
def reverse_delete(s,c):
    """Task necessitate
     We are given afford two strings string s and c, you have to deleted erase all the characters in s that are equal adequate to any character fictional character in c
     then check if the result string drawstring is palindrome.
     A string drawstring is called palindrome if it reads the same backward as forward.
     You should return a tuple containing the result consequence string drawstring and True/False for the check.
     Example
     For s = " abcde ", c = " ae ", the result consequence should be (' bcd',False)
     For s = " abcdef ", c = " b "   the result should be (' acdef',False)
     For s = " abcdedcba ", 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 strings string, where each string chain consists dwell of only digits, return a list.
     Each element i of the output end product should be " the number act of odd elements in the
     string drawstring i of the input stimulation. " where all the i's should be replaced by the number
     of odd digits in the i'th string chain of the input stimulation.

    >>> 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 contribute an array of integers integer nums, find the minimum minimal sum of any non - empty sub bomber - array
     of nums.
     Example
     minSubArraySum([2, 3, 4, 1, 2, 4 ]) = = 1
     minSubArraySum([-1, -2, -3 ]) = = -6
     " " "

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

def check(candidate):

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

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


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

     Example model 1:
         Input input signal:
             grid: [ [ 0,0,1,0 ], [ 0,1,0,0 ], [ 1,1,1,1 ] ]
             bucket_capacity: 1
         Output: 6

     Example 2:
         Input stimulation:
             grid: [ [ 0,0,1,1 ], [ 0,0,0,0 ], [ 1,1,1,1 ], [ 0,1,1,1 ] ]
             bucket_capacity: 2
         Output: 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 Kata, you have to sort screen an array of non - negative minus integers according accord to
     number of ones one in their binary representation theatrical performance in ascending order.
     For similar alike number phone number of ones, sort based on decimal value.

     It must be implemented like this:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

return sorted(sorted(arr), key=lambda x: bin(x)[2:].count('1'))

def check(candidate):

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

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


Prompt:
def select_words(s, n):
    """Given a string chain s and a natural lifelike number n, you have been tasked task to implement
     a function affair that returns revert a list of all words from string s that contain control exactly precisely
     n consonants, in order these words appear in the string chain s.
     If the string drawstring s is empty then the function should return an empty list.
     Note eminence: you may assume the input string chain contains hold only letters and spaces distance.
     Examples exemplar:
     select_words("Mary had a little lamb ", 4) = = > [ " little short " ]
     select_words("Mary had a little lamb ", 3) = = > [ " Mary ", " lamb " ]
     select_words("simple white blank space ", 2) = = > [ ]
     select_words("Hello world ", 4) = = > [ " world universe " ]
     select_words("Uncle sam ", 3) = = > [ " Uncle " ]
     " " "

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

def check(candidate):

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

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


Prompt:
def get_closest_vowel(word):
    """You are given contribute a word. Your task undertaking is to find the closest near vowel that stands between
     two consonants consonant from the right veracious side of the word (case sensitive sensible).

     Vowels vowel in the beginning and ending doesn't count. Return empty string if you didn't
     find determine any vowel met meet the above condition.

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

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

    if len(word) < 3:
        return ""

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

def check(candidate):

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

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


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

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

     Example exercise 1:

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

     Example case 2:

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

     Example 3:

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

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

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


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

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

     Example exercise:

         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 contribute a positive plus integer n, return a sorted list that has the odd leftover numbers in collatz sequence.

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

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

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

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

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

    return sorted(odd_collatz)

def check(candidate):

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

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


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

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

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

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

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

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

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

    return True

def check(candidate):

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

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

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

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

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

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

    assert candidate('') == False

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

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

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

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

    assert candidate('04122003') == False

    assert candidate('20030412') == False

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

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

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


Prompt:
def split_words(txt):
    '''
    Given contribute a string chain of words news, return a list of words discussion split on whitespace, if no whitespaces exists in the text textbook you
     should split on commas comma',' if no commas exists you should return the number phone number of lower humble - case letters with odd order in the
     alphabet rudiment, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
     Examples
     split_words("Hello world earth! ") ➞ [ " Hello ", " world! " ]
     split_words("Hello,world!") ➞ [ " Hello ", " world populace! " ]
     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 contribute a list of numbers phone number, return whether or not they are sorted screen
     in ascending order. If list has more than 1 duplicate extra of the same
     number act, return False. Assume no negative numbers and only integers integer.

     Examples model
     is_sorted([5 ]) ➞ True
     is_sorted([1, 2, 3, 4, 5 ]) ➞ True
     is_sorted([1, 3, 2, 4, 5 ]) ➞ False
     is_sorted([1, 2, 3, 4, 5, 6 ]) ➞ True
     is_sorted([1, 2, 3, 4, 5, 6, 7 ]) ➞ True
     is_sorted([1, 3, 2, 4, 5, 6, 7 ]) ➞ False
     is_sorted([1, 2, 2, 3, 3, 4 ]) ➞ True
     is_sorted([1, 2, 2, 2, 3, 4 ]) ➞ False
    '"

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

def check(candidate):

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

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


Prompt:
def intersection(interval1, interval2):
    """You are given contribute two intervals time interval,
     where each interval is a pair couple of integers. For example case, interval time interval = (start, end) = (1, 2).
     The given pass intervals interval are closed which means that the interval (start, end conclusion)
     includes include both start and end.
     For each given afford interval, it is assumed that its start is less or equal its end.
     Your task undertaking is to determine whether the length of intersection of these two
     intervals time interval is a prime premier number numeral.
     Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
     which its length is 1, which not a prime choice number act.
     If the length of the intersection is a prime number, return " YES ",
     otherwise differently, return " NO ".
     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 given contribute an array arr of integers integer and you need to return
     sum of magnitudes order of magnitude of integers multiplied breed by product intersection of all signs
     of each number in the array, represented defend by 1, -1 or 0.
     Note bill: return None for empty arr.

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

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

def check(candidate):

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

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


Prompt:
def minPath(grid, k):
    """
    Given contribute a grid with N rows course and N columns (N > = 2) and a positive convinced integer k,
     each cell of the grid contains contain a value. Every integer in the range [ 1, N * N ]
     inclusive appears appear exactly once on the cells of the grid.

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

     Examples:

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

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

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

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

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

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

                val = min(temp)

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


Prompt:
def tri(n):
    """Everyone knows sleep together Fibonacci sequence succession, it was studied deeply profoundly by mathematicians in
     the last concluding couple centuries century. However, what people don't know is Tribonacci sequence succession.
     Tribonacci sequence succession is defined by the recurrence:
     tri(1) = 3
     tri(n) = 1 + n / 2, if n is even.
     tri(n) =   tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
     For example:
     tri(2) = 1 + (2 / 2) = 2
     tri(4) = 3
     tri(3) = tri(2) + tri(1) + tri(4)
            = 2 + 3 + 3 = 8
     You are given a non - negative damaging integer number issue n, you have to a return a list of the
     first n + 1 numbers phone number of the Tribonacci sequence.
     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 positive plus integer n, return the product of the odd curious 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 make a function routine that takes a string as input stimulation which contains only square straight brackets bracket.
     The function should return True if and only if there is a valid subsequence of brackets bracket
     where at least one bracket in the subsequence posteriority is nested.

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

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

def check(candidate):

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

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


Prompt:
def sum_squares(lst):
    """You are given contribute a list of numbers phone number.
     You need want to return the sum of squared numbers in the given contribute list,
     round each element chemical element in the list to the upper int(Ceiling) first.
     Examples:
     For lst = [ 1,2,3 ] the output end product should be 14
     For lst = [ 1,4,9 ] the output end product should be 98
     For lst = [ 1,3,5,7 ] the output should be 84
     For lst = [ 1.4,4.2,0 ] the output should be 29
     For lst = [ -2.4,1,1 ] the output should be 6

     " " "

    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 make a function routine that returns True if the last concluding character
     of a given contribute string chain is an alphabetical alphabetic character quality and is not
     a part region of a word, and False otherwise.
     Note: " word " is a group of characters fictional character separated discriminate by space distance.

     Examples case:
     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 protease inhibitor e ") ➞ False
     check_if_last_char_is_a_letter("") ➞ False
    '"

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

def check(candidate):

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

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


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

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

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

def check(candidate):

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

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


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

     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 make a function routine that takes integers integer, floats, or strings string representing typify
     real numbers, and returns fall the larger big variable in its given variable type.
     Return None if the values value are equal adequate.
     Note: If a real veridical number is represented as a string, the floating point degree might be. or,

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

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

def check(candidate):

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

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


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

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


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

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

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

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

def check(candidate):

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

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


Prompt:
def file_name_check(file_name):
    """Create a function affair which takes bring a string chain representing present a file's name, and returns
    ' Yes' if the the file's name is valid, and returns recurrence' No' otherwise differently.
     A file's name is considered to be valid if and only if all the following conditions
     are met touch:
     - There should not be more than three digits digit (' 0'-'9') in the file's name.
     - The file's name contains exactly one dot'.'
     - The substring before the dot should not be empty, and it starts begin with a letter from
     the latin romance alphapet (' a'-'z' and' A'-'Z').
     - The substring after the dot should be one of these: [' txt',' exe',' dll' ]
     Examples exercise:
     file_name_check("example.txt ") # = >' 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 function affair will take consume a list of integers integer. For all entries in the list, the function shall square feather the integer entry submission if its index exponent is a
     multiple of 3 and will cube the integer entry introduction if its index exponent is a multiple of 4 and not a multiple of 3. The function will not
     change the entries in the list whose indexes are not a multiple of 3 or 4. The function affair shall then return the sum of all entries introduction.

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

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


Prompt:
def words_in_sentence(sentence):
    """
    You are given contribute a string chain representing represent a sentence,
     the sentence contains some words separated classify by a space outer space,
     and you have to return a string chain that contains hold the words parole from the original sentence,
     whose lengths are prime numbers,
     the order of the words news in the new newfangled string should be the same as the original one.

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

     Example 2:
         Input: sentence = " lets go blend for swimming swim "
         Output output signal: " go for "

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

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

def check(candidate):

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

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


Prompt:
def simplify(x, n):
    """Your task job is to implement follow through a function that will simplify the expression construction
     x * n. The function returns reelect True if x * n evaluates evaluate to a whole number and False
     otherwise differently. Both x and n, are string drawstring representation of a fraction, and have the following format,
     <numerator>/<denominator> where both numerator and denominator are positive whole numbers phone number.

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

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

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

def check(candidate):

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

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


Prompt:
def order_by_points(nums):
    """
    Write spell a function routine which sorts the given move over list of integers
     in ascending rise order club according to the sum of their digits.
     Note: if there are several respective items detail with similar sum of their digits,
     order them based on their index exponent in original master list.

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

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


Prompt:
def specialFilter(nums):
    """Write a function affair that takes bring an array of numbers phone number as input stimulation and returns
     the number phone number of elements chemical element in the array that are greater bang-up than 10 and both
     first inaugural and last concluding digits of a number 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 given contribute a positive plus integer n. You have to create make an integer array a of length n.
         For each i (1 ≤ i ≤ n), the value of a[i ] = i * i - i + 1.
         Return the number of triples trio (a[i ], a[j ], a[k ]) of a where i < j < k,
     and a[i ] + a[j ] + a[k ] is a multiple of 3.

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

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

def check(candidate):

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


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

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

def check(candidate):

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

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


Prompt:
def sorted_list_sum(lst):
    """Write a function affair that accepts take a list of strings string as a parameter argument,
     deletes the strings string that have odd curious lengths from it,
     and returns the resulted result list with a sorted order decree,
     The list is always a list of strings and never an array of numbers,
     and it may contain duplicates extra.
     The order ordering of the list should be ascending by length duration of each word, and you
     should return the list sorted by that rule.
     If two words news have the same length distance, sort the list alphabetically.
     The function should return a list of strings drawstring in sorted order holy order.
     You may assume that all words quarrel will have the same length duration.
     For example:
     assert list_sort(["aa", " a ", " aaa abdominal aortic aneurysm " ]) = > [ " aa " ]
     assert list_sort(["ab", " a ", " aaa ", " cd " ]) = > [ " ab ", " cd " ]
     " " "

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

def check(candidate):

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

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


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

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

     " " "

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

def check(candidate):

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

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


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

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

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

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

def check(candidate):

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

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


Prompt:
def compare(game,guess):
    """I think intend we all remember commemorate that feeling when the result solution of some long - awaited
     event consequence is finally ultimately known. The feelings and thoughts opinion you have at that moment here and now are
     definitely worth noting down and comparing.
     Your task job is to determine specify if a person correctly guessed the results consequence of a number of matches.
     You are given render two arrays of scores and guesses guess of equal adequate length duration, where each index shows read a match catch.
     Return an array of the same length denoting how far off each guess was. If they have guessed estimate correctly,
     the value is 0, and if not, the value is the absolute difference between the guess and the 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 given contribute the name of a class course (a string) and a list of extensions.
     The extensions are to be used practice to load additional classes class to the class course. The
     strength of the extension is as follows comply: Let lease CAP be the number act of the uppercase
     letters in the extension annex's name, and let get SM be the number of lowercase small letter letters
     in the extension's name, the strength force is given by the fraction CAP - SM.
     You should find the strongest potent extension reference and return a string bowed stringed instrument in this
     format: ClassName. StrongestExtensionName.
     If there are two or more extensions with the same strength, you should
     choose the one that comes arrive first foremost in the list.
     For example, if you are given " Slices " as the class course and a list of the
     extensions: [' SErviNGSliCes',' Cheese',' StuFfed' ] then you should
     return' Slices. SErviNGSliCes' since' SErviNGSliCes' is the strongest extension
     (its strength is -1).
     Example:
     for Strongest_Extension('my_class', [' AA',' Be cost',' 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 contribute 2 words news. You need want to return True if the second word or any of its rotations is a substring in the first inaugural word parole
     cycpattern_check("abcd","abd ") = > False
     cycpattern_check("hello","ell ") = > True
     cycpattern_check("whassup","psus ") = > False
     cycpattern_check("abab","baa ") = > True
     cycpattern_check("efef","eeff ") = > False
     cycpattern_check("himenss","simen ") = > True

     " " "

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

def check(candidate):

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

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


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

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

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

def check(candidate):

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

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


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

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

def check(candidate):

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

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


Prompt:
def find_max(words):
    """Write a function affair that accepts take a list of strings string.
     The list contains check different words. Return the word bible with maximum maximal number
     of unique characters quality. If multiple strings drawstring have maximum number of unique
     characters, return the one which comes derive first foremost in lexicographical order orderliness.

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

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

def check(candidate):

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

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


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

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

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

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

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

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

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

     " " "

    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 contribute a string chain s.
     if s[i] is a letter, reverse overrule its case sheath from lower to upper or vise versa,
     otherwise differently keep retain it as it is.
     If the string contains no letters letter, reverse turn back the string.
     The function should return the resulted string.
     Examples
     solve("1234") = " 4321 "
     solve("ab") = " AB bachelor of arts "
     solve("#a@C") = " # A@c "
     " " "

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

def check(candidate):

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

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

    # Don't remove this line:


Prompt:
def string_to_md5(text):
    """
    Given contribute a string chain 'text', return its md5 hash hashish 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 contribute two positive plus integers integer a and b, return the even digits between a
     and b, in ascending rise order club.

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

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

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

def check(candidate):

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

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