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

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

def check(candidate):

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

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


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

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

     For example exemplar:
    >>> 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 collapse an array of integers, sort the integers integer that are between 1 and 9 inclusive,
     reverse the resulting leave array, and then replace substitute each digit by its corresponding equate name from
     " One ", " Two ", " Three ", " Four ", " Five ", " Six ", " Seven ", " Eight ", " Nine ".

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

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

       If the array has any strange foreign number ignore 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 affair f that takes n as a parameter argument,
     and returns a list of size n, such that the value of the element chemical element at index i is the factorial of i if i is even
     or the sum union of numbers from 1 to i otherwise differently.
     i starts from 1.
     the factorial of i is the multiplication generation of the numbers number 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 collapse a positive integer n, return a tuple that has the number act of even and odd curious
     integer palindromes palindrome that fall within the range(1, n), inclusive.

     Example exercise 1:

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

     Example exemplar 2:

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

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

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

    even_palindrome_count = 0
    odd_palindrome_count = 0

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

def check(candidate):

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

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


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

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

def check(candidate):

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

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


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

     One right shift operation means shifting all elements element of the array by one
     position military position in the right direction. The last final element component of the array will be moved travel to
     the starting 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 move over array is empty then return True.

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

     For Example exemplar:

     move_one_ball([3, 4, 5, 1, 2])==>True
     Explanation: By performin 2 right shift fault operations operation, non - decreasing order can
                  be achieved for the given feed array.
     move_one_ball([3, 5, 4, 1, 2])==>False
     Explanation: It is not possible to get non - decreasing order for the given contribute
                 array by performing any number issue 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 problem trouble, you will implement follow through a function that takes fill two lists of numbers number,
     and determines whether it is possible potential to perform an exchange of elements chemical element
     between them to make lst1 a list of only even numbers numeral.
     There is no limit terminus ad quem on the number of exchanged switch over elements between lst1 and lst2.
     If it is possible to exchange elements between the lst1 and lst2 to make
     all the elements of lst1 to be even, return " YES ".
     Otherwise, return " NO ".
     For example:
     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 remark 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 drawstring representing constitute a space separated discriminate lowercase letters letter, return a dictionary
     of the letter with the most repetition and containing check the corresponding count.
     If several respective letters letter have the same occurrence, return all of them.

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

     " " "

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

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

                dict1[i]=t
    return dict1

def check(candidate):

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

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


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

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

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

def check(candidate):

    # Check some simple cases
    assert candidate(['1234567']) == ["the number of odd elements 4n the str4ng 4 of the 4nput."], "Test 1"
    assert candidate(['3',"11111111"]) == ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."], "Test 2"
    assert candidate(['271', '137', '314']) == [
        'the number of odd elements 2n the str2ng 2 of the 2nput.',
        'the number of odd elements 3n the str3ng 3 of the 3nput.',
        'the number of odd elements 2n the str2ng 2 of the 2nput.'
    ]

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


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

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

def check(candidate):

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

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


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

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

     Example case 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 harmonize to
     number of ones one in their binary representation in ascending rise order.
     For similar alike number of ones one, sort based establish 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 drawstring s and a natural lifelike number n, you have been tasked task to implement
     a function routine that returns a list of all words password from string s that contain incorporate exactly precisely
     n consonants, in order orderliness these words news appear in the string chain s.
     If the string s is empty then the function should return an empty list.
     Note: you may assume the input string contains only letters letter and spaces.
     Examples:
     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 outer space ", 2) = = > [ ]
     select_words("Hello world ", 4) = = > [ " world " ]
     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 collapse a word. Your task is to find witness the closest cheeseparing vowel that stands resist between
     two consonants from the right proper side of the word (case character sensitive).

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

     You may assume 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 collapse a list of two strings, both strings drawstring consist dwell of open loose
     parentheses' (' or close airless parentheses')' only.
     Your job problem is to check if it is possible to concatenate the two strings chain in
     some order decree, that the resulting string chain will be good effective.
     A string S is considered consider to be good if and only if all parentheses in S
     are balanced. For example: the string' (() ) ()' is good, while the string
    ' ())' is not.
     Return' Yes' if there's a way to make a good full string chain, and return' No' otherwise.

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

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

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

def check(candidate):

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

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


Prompt:
def maximum(arr, k):
    """
    Given collapse an array arr of integers and a positive convinced integer k, return a sorted classify list
     of length distance k with the maximum k numbers in arr.

     Example exercise 1:

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

     Example 2:

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

     Example 3:

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

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

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


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

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

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

def check(candidate):

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

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


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

     Example exercise:

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

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

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

def check(candidate):

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

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


Prompt:
def get_odd_collatz(n):
    """
    Given collapse a positive integer n, return a sorted list that has the odd leftover numbers numbers pool in collatz sequence succession.

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

     Note eminence:
         1. Collatz(1) is [ 1 ].
         2. returned 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 numbers phone number are only 1, and 5.
     " " "

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

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

    return sorted(odd_collatz)

def check(candidate):

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

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


Prompt:
def valid_date(date):
    """You have to write compose a function affair which validates a given establish date string and
     returns reelect True if the date is valid otherwise False.
     The date is valid if all of the following trace rules are satisfied quenched:
     1. The date string drawstring is not empty.
     2. The number of days day is not less than 1 or higher high than 31 days for months month 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 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 month should not be less than 1 or higher than 12.
     4. The date should be in the format: mm - dd - yyyy

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

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

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

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

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

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

    return True

def check(candidate):

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

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

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

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

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

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

    assert candidate('') == False

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

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

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

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

    assert candidate('04122003') == False

    assert candidate('20030412') == False

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

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

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


Prompt:
def split_words(txt):
    '''
    Given collapse a string of words parole, return a list of words son split on whitespace, if no whitespaces exists exist in the text you
     should split on commas comma',' if no commas exists exist you should return the number of lower broken - case letters letter with odd leftover order in the
     alphabet rudiment, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
     Examples
     split_words("Hello world! ") ➞ [ " Hello ", " world! " ]
     split_words("Hello,world!") ➞ [ " Hello ", " world! " ]
     split_words("abcdef") = = 3
    '"

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

def check(candidate):

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


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

     Examples exemplar
     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 collapse two intervals,
     where each interval time interval is a pair couple of integers integer. For example, interval time interval = (start, end goal) = (1, 2).
     The given intervals interval are closed which means think of that the interval time interval (start, end conclusion)
     includes both start and end.
     For each given 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 is a prime number act.
     Example, the intersection of the intervals time interval (1, 3), (2, 4) is (2, 3)
     which its length is 1, which not a prime premier number.
     If the length of the intersection is a prime number, return " YES ",
     otherwise, return " NO ".
     If the two intervals don't intersect, return " NO ".

     [ input / output end product ] 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 collapse an array arr of integers and you need want to return
     sum of magnitudes order of magnitude of integers integer multiplied by product intersection of all signs
     of each number act in the array, represented by 1, -1 or 0.
     Note bill: return None for empty arr.

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

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

def check(candidate):

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

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


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

     You have to find the minimum minimal path of length distance k in the grid. You can start depart
     from any cell, and in each step footfall you can move to any of the neighbor cells,
     in other words, you can go to cells which share an edge with you current
     cell cellular telephone.
     Please note that a path of length k means intend visiting inflict exactly precisely k cells (not
     necessarily distinct).
     You CANNOT go off the grid.
     A path A (of length k) is considered see less than a path B (of length k) if
     after making the ordered lists tilt of the values on the cells cell that A adenine and B bel go blend
     through (let'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 exponent i (1 < = i < = k)
     such that lst_A[i ] < lst_B[i ] and for any j (1 < = j < i) we have
     lst_A[j ] = lst_B[j ].
     It is guaranteed that the answer is unique.
     Return an ordered rate list of the values value on the cells that the minimum path go through.

     Examples case:

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

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

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

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

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

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

                val = min(temp)

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


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

     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 collapse a list of numbers.
     You need want to return the sum kernel of squared numbers numbers pool in the given list,
     round each element chemical element in the list to the upper int(Ceiling) first.
     Examples case:
     For lst = [ 1,2,3 ] the output should be 14
     For lst = [ 1,4,9 ] the output end product should be 98
     For lst = [ 1,3,5,7 ] the output output signal should be 84
     For lst = [ 1.4,4.2,0 ] the output should be 29
     For lst = [ -2.4,1,1 ] the output end product 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 affair that returns True if the last concluding character
     of a given sacrifice string is an alphabetical alphabetic character and is not
     a part function of a word, and False otherwise differently.
     Note bill: " word " is a group of characters fictional character separated by space.

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

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

def check(candidate):

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

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


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

     Examples exemplar:
     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 affair that returns a tuple (a, b b-complex vitamin), where' a' is
     the largest of negative integers integer, and' b' is the smallest
     of positive positivist integers in a list.
     If there is no negative minus or positive plus integers, return them as None.

     Examples model:
     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 affair that takes integers integer, floats, or strings drawstring representing
     real substantial numbers, and returns fall the larger bombastic variable in its given afford variable varying type.
     Return None if the values value are equal.
     Note: If a real number is represented as a string, the floating point detail 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 contribute number n can be written publish as the sum of exactly precisely 4 positive even numbers count
     Example
     is_equal_to_sum_even(4) = = False
     is_equal_to_sum_even(6) = = False
     is_equal_to_sum_even(8) = = True
     " " "

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


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

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

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

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

def check(candidate):

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

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


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

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

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

def check(candidate):

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

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


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

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

def check(candidate):

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

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


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

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

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


Prompt:
def words_in_sentence(sentence):
    """
    You are given collapse a string representing defend a sentence,
     the sentence contains incorporate some words word separated by a space quad,
     and you have to return a string that contains check the words from the original sentence,
     whose lengths length are prime choice numbers,
     the order orderliness of the words news in the new string chain should be the same as the original one.

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

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

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

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

def check(candidate):

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

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


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

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

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

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

def check(candidate):

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

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


Prompt:
def order_by_points(nums):
    """
    Write compose a function affair which sorts the given establish list of integers
     in ascending rise order according accord to the sum of their digits.
     Note: if there are several respective items with similar exchangeable sum of their digits digit,
     order them based free-base on their index in original list.

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

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


Prompt:
def specialFilter(nums):
    """Write a function routine that takes subscribe an array of numbers as input stimulation and returns
     the number act of elements in the array that are greater big than 10 and both
     first and last final digits of a number issue are odd leftover (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 collapse a positive integer n. You have to create make an integer array a of length distance n.
         For each i (1 ≤ i ≤ n), the value of a[i ] = i * i - i + 1.
         Return the number numeral of triples (a[i ], a[j ], a[k ]) of a where i < j < k,
     and a[i ] + a[j ] + a[k ] is a multiple of 3.

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

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

def check(candidate):

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


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

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

def check(candidate):

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

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


Prompt:
def sorted_list_sum(lst):
    """Write a function routine that accepts bear a list of strings as a parameter argument,
     deletes the strings drawstring that have odd lengths distance from it,
     and returns the resulted leave list with a sorted order decree,
     The list is always a list of strings string and never an array of numbers number,
     and it may contain duplicates extra.
     The order of the list should be ascending by length of each word, and you
     should return the list sorted by that rule.
     If two words have the same length, sort the list alphabetically.
     The function routine should return a list of strings in sorted order.
     You may assume that all words bible will have the same length.
     For example case:
     assert affirm list_sort(["aa", " a ", " aaa " ]) = > [ " 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 dim-witted program broadcast which should return the value of x if n is
     a prime number numeral and should return the value of y otherwise.

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

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

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

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

def check(candidate):

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

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


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

     example:

     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 collapse the name of a class (a string drawstring) and a list of extensions.
     The extensions are to be used practice to load additional extra classes to the class course. The
     strength of the extension elongation is as follows: Let permit CAP be the number of the uppercase capital
     letters letter in the extension's name, and let get SM be the number of lowercase letters
     in the extension's name, the strength is given by the fraction CAP - SM.
     You should find the strongest solid extension annex and return a string in this
     format: ClassName. StrongestExtensionName.
     If there are two or more extensions with the same strength, you should
     choose the one that comes come first in the list.
     For example case, if you are given afford " Slices " as the class 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 alcoholics anonymous',' 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 collapse 2 words. You need want to return True if the second word son or any of its rotations rotation is a substring in the first word parole
     cycpattern_check("abcd","abd ") = > False
     cycpattern_check("hello","ell ") = > True
     cycpattern_check("whassup","psus ") = > False
     cycpattern_check("abab","baa ") = > True
     cycpattern_check("efef","eeff ") = > False
     cycpattern_check("himenss","simen ") = > True

     " " "

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

def check(candidate):

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

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


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

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

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

def check(candidate):

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

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


Prompt:
def int_to_mini_roman(number):
    """
    Given collapse a positive integer, obtain receive its roman numeral equivalent as a string chain,
     and return it in lowercase small letter.
     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 collapse the lengths of the three sides english of a triangle triangulum. Return recurrence True if the three
     sides form imprint a right - angled fish triangle, False otherwise differently.
     A right - angled angle triangle triangulum is a triangle in which one angle slant is right angle or
     90 degree.
     Example:
     right_angle_triangle(3, 4, 5) = = True
     right_angle_triangle(1, 2, 3) = = False
    '"

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

def check(candidate):

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

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


Prompt:
def find_max(words):
    """Write a function routine that accepts bear a list of strings.
     The list contains incorporate different words. Return the word parole with maximum number act
     of unique characters quality. If multiple strings have maximum maximal number act of unique
     characters fictional character, return the one which comes first in lexicographical order.

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

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

def check(candidate):

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

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


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

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

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

     Have get fun playfulness :)
     " " "

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

def check(candidate):

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

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


Prompt:
def do_algebra(operator, operand):
    """
    Given collapse two lists operator, and operand. The first inaugural list has basic algebra operations process, and
     the second list is a list of integers integer. Use the two given sacrifice lists to build construct the algebric
     expression and return the evaluation of this expression.

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

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

     Note eminence:
         The length of operator list is equal to the length of operand list minus one.
         Operand is a list of of non - negative integers.
         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 collapse a string s.
     if s[i] is a letter, reverse change by reversal its case font from lower humble to upper or vise versa,
     otherwise keep continue it as it is.
     If the string contains check no letters, reverse invert the string drawstring.
     The function should return the resulted leave string drawstring.
     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 collapse a string 'text', return its md5 hash hashish equivalent string chain.
     If 'text' is an empty string chain, 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 collapse two positive integers integer a and b, return the even tied digits finger between a
     and b, in ascending order ordering.

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