Prompt:
def rounded_avg(n, m):
    """You are given two positive integers integer n and m, and your task job is to compute the
     average of the integers integer from n through m (including admit n and m).
     Round the answer solution 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 integers x. return a sorted list of all
     elements element that hasn't any even tied digit.

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

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

     For example case:
       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 issue ignore neglect it:
       arr = [ 1, -1, 55 ]
             - > sort arr - > [ -1, 1, 55 ]
             - > reverse arr - > [ 55, 1, -1 ]
       return = [' One' ]
     " " "

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

def check(candidate):

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

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


Prompt:
def f(n):
    """ Implement the function f that takes fill n as a parameter argument,
     and returns a list of size n, such that the value of the element chemical element at index exponent i is the factorial of i if i is even
     or the sum union of numbers from 1 to i otherwise differently.
     i starts get down 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 a positive integer n, return a tuple that has the number phone number of even and odd leftover
     integer palindromes that fall precipitate within the range(1, n), inclusive.

     Example model 1:

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

     Example exemplar 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 curious.

     Note bill:
         1. 1 < = n < = 10 ^ 3
         2. returned retort tuple has the number of even and odd leftover 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 a function count_nums which takes fill an array of integers integer and returns
     the number phone number of elements component which has a sum of digits finger > 0.
     If a number is negative minus, then its first inaugural signed digit will be negative damaging:
     e.g. for example -123 has signed sign digits -1, 2, and 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

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

def check(candidate):

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

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


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

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

     If it is possible potential to obtain prevail the sorted array by performing perform the above operation mathematical process
     then return True else return False.
     If the given afford array is empty then return True.

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

     For Example:

     move_one_ball([3, 4, 5, 1, 2])==>True
     Explanation: By performin 2 right right field shift transformation operations, non - decreasing order can
                  be achieved for the given move over array.
     move_one_ball([3, 5, 4, 1, 2])==>False
     Explanation: It is not possible potential to get non - decreasing order holy order for the given collapse
                 array by performing any number act of right veracious 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, you will implement a function routine that takes learn two lists of numbers numeral,
     and determines determine whether it is possible potential to perform an exchange of elements chemical element
     between them to make lst1 a list of only even numbers phone number.
     There is no limit on the number of exchanged exchange elements between lst1 and lst2.
     If it is possible to exchange elements component between the lst1 and lst2 to make draw
     all the elements of lst1 to be even, return " YES ".
     Otherwise, return " NO ".
     For example model:
     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 lists will be non - empty.
     " " "

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

def check(candidate):

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

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


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

     Example:
     histogram('a b bacillus c speed of light') = = {' a': 1,' b bacillus': 1,' c': 1 }
     histogram('a b boron b a') = = {' a': 2,' b': 2 }
     histogram('a b c a b boron') = = {' a': 2,' b': 2 }
     histogram('b b barn b b bel a') = = {' b': 4 }
     histogram('') = = { }

     " " "

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

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

                dict1[i]=t
    return dict1

def check(candidate):

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

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


Prompt:
def reverse_delete(s,c):
    """Task
     We are given two strings string s and c, you have to deleted delete all the characters in s that are equal adequate to any character fictional character in c
     then check match if the result string drawstring is palindrome.
     A string is called bid palindrome if it reads the same backward as forward.
     You should return a tuple containing contain the result string and True/False for the check bridle.
     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 resultant role should be (' cdedc',True)
     " " "

    s = ''.join([char for char in s if char not in c])
    return (s,s[::-1] == s)

def check(candidate):

    assert candidate("abcde","ae") == ('bcd',False)
    assert candidate("abcdef", "b") == ('acdef',False)
    assert candidate("abcdedcba","ab") == ('cdedc',True)
    assert candidate("dwik","w") == ('dik',False)
    assert candidate("a","a") == ('',True)
    assert candidate("abcdedcba","") == ('abcdedcba',True)
    assert candidate("abcdedcba","v") == ('abcdedcba',True)
    assert candidate("vabba","v") == ('abba',True)
    assert candidate("mamma", "mia") == ("", True)


Prompt:
def odd_count(lst):
    """Given a list of strings, where each string consists dwell of only digits finger, return a list.
     Each element i of the output end product should be " the number issue of odd leftover elements in the
     string drawstring i of the input. " where all the i's should be replaced substitute by the number
     of odd digits finger in the i'th string of the input input signal.

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

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

def check(candidate):

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

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


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

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

def check(candidate):

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

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


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

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

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

     Example exemplar 3:
         Input stimulation:
             grid: [ [ 0,0,0 ], [ 0,0,0 ] ]
             bucket_capacity: 5
         Output output signal: 0

     Constraints:
         * all wells well have the same length duration
         * 1 < = grid.length < = 10 ^ 2
         * 1 < = grid[:,1].length < = 10 ^ 2
         * grid[i][j] - > 0 | 1
         * 1 < = capacity < = 10
     " " "

return sum([math.ceil(sum(arr)/capacity) for arr in grid])

def check(candidate):

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

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


Prompt:
def sort_array(arr):
    """
    In this Kata, you have to sort an array of non - negative integers integer according harmonize to
     number of ones one in their binary representation theatrical performance in ascending ascend order.
     For similar like number of ones one, 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 s and a natural number phone number n, you have been tasked task to implement
     a function routine that returns return a list of all words news from string s that contain incorporate exactly precisely
     n consonants, in order these words word appear look in the string bowed stringed instrument s.
     If the string s is empty then the function affair should return an empty list.
     Note: you may assume the input string chain contains only letters letter and spaces distance.
     Examples:
     select_words("Mary had a little lamb ", 4) = = > [ " little " ]
     select_words("Mary had a little lamb ", 3) = = > [ " Mary ", " lamb " ]
     select_words("simple white space distance ", 2) = = > [ ]
     select_words("Hello world universe ", 4) = = > [ " world earth " ]
     select_words("Uncle sam surface-to-air missile ", 3) = = > [ " Uncle " ]
     " " "

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

def check(candidate):

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

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


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

     Vowels vowel in the beginning and ending doesn't count. Return come back empty string chain if you didn't
     find detect any vowel met the above condition circumstance.

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

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

    if len(word) < 3:
        return ""

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

def check(candidate):

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

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


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

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

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

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

def check(candidate):

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

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


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

     Example model 1:

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

     Example model 2:

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

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

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

def check(candidate):

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

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


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

     Example model:

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

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

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

def check(candidate):

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

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


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

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

     Note bill:
         1. Collatz(1) is [ 1 ].
         2. returned revert list sorted in increasing increase 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 curious numbers are only 1, and 5.
     " " "

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

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

    return sorted(odd_collatz)

def check(candidate):

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

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


Prompt:
def valid_date(date):
    """You have to write a function which validates validate a given contribute date string and
     returns refund True if the date is valid otherwise differently False.
     The date is valid if all of the following succeed rules principle are satisfied:
     1. The date string is not empty.
     2. The number phone number of days is not less than 1 or higher than 31 days day for months calendar month 1,3,5,7,8,10,12. And the number act of days is not less than 1 or higher high than 30 days for months 4,6,9,11. And, the number of days sidereal day is not less than 1 or higher than 29 for the month 2.
     3. The months month should not be less than 1 or higher high than 12.
     4. The date should be in the format: mm - dd - yyyy

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

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

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

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

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

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

    return True

def check(candidate):

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

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

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

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

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

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

    assert candidate('') == False

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

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

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

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

    assert candidate('04122003') == False

    assert candidate('20030412') == False

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

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

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


Prompt:
def split_words(txt):
    '''
    Given a string of words discussion, return a list of words actor's line split on whitespace, if no whitespaces exists in the text textbook you
     should split on commas comma',' if no commas comma exists you should return the number issue 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 universe! " ]
     split_words("Hello,world!") ➞ [ " Hello ", " world! " ]
     split_words("abcdef") = = 3
    '"

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

def check(candidate):

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


Prompt:
def is_sorted(lst):
    '''
    Given a list of numbers, return whether or not they are sorted screen
     in ascending ascend order. If list has more than 1 duplicate extra of the same
     number issue, return False. Assume no negative minus 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 two intervals,
     where each interval time interval is a pair couple of integers. For example exemplar, interval time interval = (start begin, end) = (1, 2).
     The given move over intervals are closed conclude which means that the interval (start originate, end)
     includes both start startle and end.
     For each given sacrifice interval, it is assumed simulate that its start is less or equal its end.
     Your task is to determine decide whether the length of intersection of these two
     intervals is a prime choice number numeral.
     Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
     which its length is 1, which not a prime number.
     If the length of the intersection is a prime number, return " YES ",
     otherwise differently, return " NO ".
     If the two intervals interval don't intersect, return " NO ".

     [ input remark / output output signal ] samples sample:
     intersection((1, 2), (2, 3) ) = = > " NO "
     intersection((-1, 1), (0, 4) ) = = > " NO "
     intersection((-3, -1), (-5, 5) ) = = > " YES "
     " " "

    def is_prime(num):
        if num == 1 or num == 0:
            return False
        if num == 2:
            return True
        for i in range(2, num):
            if num%i == 0:
                return False
        return True

    l = max(interval1[0], interval2[0])
    r = min(interval1[1], interval2[1])
    length = r - l
    if length > 0 and is_prime(length):
        return "YES"
    return "NO"

def check(candidate):

    # Check some simple cases
    assert candidate((1, 2), (2, 3)) == "NO"
    assert candidate((-1, 1), (0, 4)) == "NO"
    assert candidate((-3, -1), (-5, 5)) == "YES"
    assert candidate((-2, 2), (-4, 0)) == "YES"

    # Check some edge cases that are easy to work out by hand.
    assert candidate((-11, 2), (-1, -1)) == "NO"
    assert candidate((1, 2), (3, 5)) == "NO"
    assert candidate((1, 2), (1, 2)) == "NO"
    assert candidate((-2, -2), (-3, -2)) == "NO"


Prompt:
def prod_signs(arr):
    """
    You are given an array arr of integers and you need want to return
     sum of magnitudes magnitude of integers multiplied multiply by product intersection of all signs polarity
     of each number in the array, represented represent by 1, -1 or 0.
     Note: return None for empty arr.

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

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

def check(candidate):

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

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


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

     You have to find discover the minimum path way of length k in the grid. You can start
     from any cell cellular telephone, and in each step footfall you can move be active to any of the neighbor cells,
     in other words quarrel, you can go to cells which share an edge boundary with you current
     cell.
     Please note notice that a path way of length k means visiting exactly k cells (not
     necessarily inevitably distinct clear-cut).
     You CANNOT go belong off the grid.
     A path way A (of length duration k) is considered view less than a path way B bel (of length k) if
     after making the ordered lists tilt of the values value on the cells that A and B go blend
     through (let get's call them lst_A and lst_B), lst_A is lexicographically less
     than lst_B, in other words actor's line, 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 guarantee that the answer solution is unique.
     Return an ordered list of the values on the cells cellular telephone that the minimum path go become through.

     Examples:

         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 Fibonacci sequence, it was studied study deeply profoundly by mathematicians in
     the last final couple centuries hundred. However, what people citizenry 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 exercise:
     tri(2) = 1 + (2 / 2) = 2
     tri(4) = 3
     tri(3) = tri(2) + tri(1) + tri(4)
            = 2 + 3 + 3 = 8
     You are given feed a non - negative damaging integer number n, you have to a return a list of the
     first foremost 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 integer n, return the product of the odd digits.
     Return 0 if all digits are even.
     For example exemplar:
     digits(1)   = = 1
     digits(4)   = = 0
     digits(235) = = 15
     " " "

    product = 1
    odd_count = 0
    for digit in str(n):
        int_digit = int(digit)
        if int_digit%2 == 1:
            product= product*int_digit
            odd_count+=1
    if odd_count ==0:
        return 0
    else:
        return product

def check(candidate):

    # Check some simple cases
    assert candidate(5) == 5
    assert candidate(54) == 5
    assert candidate(120) ==1
    assert candidate(5014) == 5
    assert candidate(98765) == 315
    assert candidate(5576543) == 2625

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


Prompt:
def is_nested(string):
    '''
    Create a function that takes fill a string as input input signal which contains only square hearty brackets bracket.
     The function affair should return True if and only if there is a valid subsequence of brackets bracket
     where at least one bracket in the subsequence sequel is nested.

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

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

def check(candidate):

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

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


Prompt:
def sum_squares(lst):
    """You are given a list of numbers.
     You need want to return the sum union of squared numbers in the given yield list,
     round each element in the list to the upper int(Ceiling) first foremost.
     Examples exercise:
     For lst = [ 1,2,3 ] the output should be 14
     For lst = [ 1,4,9 ] the output output signal should be 98
     For lst = [ 1,3,5,7 ] the output end product 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 a function that returns reelect True if the last concluding character
     of a given yield string is an alphabetical alphabetic character fictional character and is not
     a part of a word son, and False otherwise.
     Note eminence: " word " is a group of characters separated branch by space outer space.

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

     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 a function that returns reelect a tuple (a, b bel), where' a' is
     the largest of negative integers integer, and' b boron' is the smallest
     of positive incontrovertible integers in a list.
     If there is no negative minus or positive convinced 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 a function that takes fill integers integer, floats, or strings string representing typify
     real actual numbers, and returns hark back the larger variable variable star in its given variable type character.
     Return None if the values value are equal adequate.
     Note: If a real actual number is represented as a string, the floating float point might be. or,

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

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

def check(candidate):

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

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


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

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


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

     For example:
    >>> special_factorial(4)
    288

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

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

def check(candidate):

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

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


Prompt:
def fix_spaces(text):
    """
    Given a string text, replace substitute all spaces distance in it with underscores,
     and if a string drawstring has more than 2 consecutive straight spaces distance,
     then replace all consecutive straight spaces space 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 which takes a string bowed stringed instrument representing map a file's name, and returns
    ' Yes' if the the file's name is valid, and returns tax return' No' otherwise.
     A file's name is considered consider to be valid if and only if all the following conditions condition
     are met:
     - There should not be more than three digits finger (' 0'-'9') in the file's name.
     - The file's name contains contain exactly one dot'.'
     - The substring before the dot should not be empty, and it starts with a letter from
     the latin romance alphapet (' a'-'z' and' A'-'Z').
     - The substring after the dot department of transportation should be one of these: [' txt',' exe',' dll' ]
     Examples example:
     file_name_check("example.txt ") # = >' Yes'
     file_name_check("1example.dll ") # = >' No' (the name should start with a latin romance alphapet letter)
     " " "

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

def check(candidate):

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

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


Prompt:
def sum_squares(lst):
    """"
    This function will take a list of integers integer. For all entries entry in the list, the function shall square feather the integer entry introduction 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 routine will not
     change the entries in the list whose indexes index are not a multiple of 3 or 4. The function affair shall then return the sum of all entries entrance.

     Examples:
     For lst = [ 1,2,3 ] the output 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 a string representing defend a sentence,
     the sentence contains check some words separated classify by a space,
     and you have to return a string chain that contains check the words from the original sentence,
     whose lengths duration are prime numbers phone number,
     the order of the words in the new fresh string should be the same as the original one.

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

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

     Constraints:
         * 1 < = len(sentence) < = 100
         * sentence contains hold 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 is to implement a function routine that will simplify the expression formula
     x * n. The function returns refund True if x * n evaluates measure to a whole solid 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 numbers pool.

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

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

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

def check(candidate):

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

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


Prompt:
def order_by_points(nums):
    """
    Write a function which sorts screen the given contribute list of integers
     in ascending rise order orderliness according harmonize 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 exercise:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

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


Prompt:
def specialFilter(nums):
    """Write a function that takes an array of numbers act as input input signal and returns
     the number phone number of elements component in the array that are greater bang-up than 10 and both
     first and last concluding digits digit of a number are odd (1, 3, 5, 7, 9).
     For example exercise:
     specialFilter([15, -73, 14, -15 ]) = > 1
     specialFilter([33, -2, -3, 45, 21, 109 ]) = > 2
     " " "

    count = 0
    for num in nums:
        if num > 10:
            odd_digits = (1, 3, 5, 7, 9)
            number_as_string = str(num)
            if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
                count += 1

    return count

def check(candidate):

    # Check some simple cases
    assert candidate([5, -2, 1, -5]) == 0
    assert candidate([15, -73, 14, -15]) == 1
    assert candidate([33, -2, -3, 45, 21, 109]) == 2
    assert candidate([43, -12, 93, 125, 121, 109]) == 4
    assert candidate([71, -2, -33, 75, 21, 19]) == 3

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


Prompt:
def get_max_triples(n):
    """
    You are given a positive integer n. You have to create 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 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 model:
         Input input signal: 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 in our solar system: the closerst to the Sun
     is Mercury, the next following one is Venus, then Earth, Mars, Jupiter, Saturn,
     Uranus, Neptune.
     Write spell a function that takes lead two planet satellite names name as strings planet1 and planet2.
     The function affair should return a tuple containing contain all planets whose orbits are
     located between the orbit of planet1 and the orbit scope of planet2, sorted classify by
     the proximity to the sun sunday.
     The function should return an empty tuple if planet1 or planet2
     are not correct right 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 that accepts a list of strings string as a parameter argument,
     deletes the strings string that have odd leftover lengths length from it,
     and returns the resulted leave 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 orderliness of the list should be ascending rise by length of each word discussion, and you
     should return the list sorted by that rule.
     If two words have the same length, sort the list alphabetically.
     The function affair should return a list of strings in sorted order ordering.
     You may assume simulate that all words will have the same length.
     For example:
     assert list_sort(["aa", " a ", " aaa " ]) = > [ " aa alcoholics anonymous " ]
     assert affirm list_sort(["ab", " a ", " aaa abdominal aortic aneurysm ", " cd candle " ]) = > [ " ab ", " cd compact disk " ]
     " " "

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

def check(candidate):

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

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


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

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

     " " "

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

def check(candidate):

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

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


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

     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 we all remember that feeling touch when the result resultant role of some long - awaited
     event consequence is finally ultimately known sleep together. The feelings and thoughts thinking you have at that moment here and now are
     definitely worth noting notice down and comparing compare.
     Your task undertaking is to determine if a person correctly guessed think the results of a number of matches.
     You are given pass two arrays of scores mark and guesses guess of equal length, where each index shows a match.
     Return an array of the same length duration denoting denote how far off each guess was. If they have guessed guess correctly,
     the value is 0, and if not, the value is the absolute difference deviation 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 the name of a class (a string bowed stringed instrument) and a list of extensions.
     The extensions are to be used use to load additional classes course to the class course. The
     strength force of the extension propagation is as follows: Let CAP be the number phone number of the uppercase
     letters in the extension propagation's name, and let get SM be the number act of lowercase letters letter
     in the extension's name, the strength is given by the fraction CAP - SM.
     You should find find oneself the strongest extension reference and return a string chain in this
     format: ClassName. StrongestExtensionName.
     If there are two or more extensions with the same strength, you should
     choose the one that comes first in the list.
     For example, if you are given " Slices " as the class course and a list of the
     extensions: [' SErviNGSliCes',' Cheese tall mallow',' StuFfed' ] then you should
     return' Slices. SErviNGSliCes' since' SErviNGSliCes' is the strongest firm extension annex
     (its strength forte is -1).
     Example case:
     for Strongest_Extension('my_class', [' AA associate in arts',' 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 2 words. You need want to return True if the second word news or any of its rotations is a substring in the first inaugural word discussion
     cycpattern_check("abcd","abd ") = > False
     cycpattern_check("hello","ell ") = > True
     cycpattern_check("whassup","psus ") = > False
     cycpattern_check("abab","baa ") = > True
     cycpattern_check("efef","eeff ") = > False
     cycpattern_check("himenss","simen ") = > True

     " " "

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

def check(candidate):

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

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


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

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

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

def check(candidate):

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

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


Prompt:
def int_to_mini_roman(number):
    """
    Given a positive integer, obtain prevail its roman numeral equivalent as a string chain,
     and return it in lowercase.
     Restrictions: 1 < = num < = 1000

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

def check(candidate):

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

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


Prompt:
def right_angle_triangle(a, b, c):
    '''
    Given the lengths of the three sides side of a triangle triangulum. Return True if the three
     sides english form shape a right properly - angled triangle triangulum, False otherwise differently.
     A right - angled triangle triangulum is a triangle triangulum in which one angle slant is right angle slant 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 that accepts a list of strings string.
     The list contains check different words. Return the word parole with maximum maximal number numeral
     of unique characters character. If multiple strings have maximum maximal number of unique
     characters quality, return the one which comes occur first foremost in lexicographical order orderliness.

     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 rabbit, and you already have eaten feed a certain sealed number of carrots,
     but now you need to eat more carrots carrot to complete dispatch the day sidereal day's meals.
     you should return an array of [ total number of eaten eat carrots carrot after your meals,
                                     the number of carrots left entrust after your meals meal ]
     if there are not enough adequate remaining carrots, you will eat all remaining carrots carrot, 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 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 thet exist in stock

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

     Have fun :)
     " " "

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

def check(candidate):

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

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


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

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

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

     Note bill:
         The length duration of operator list is equal to the length distance 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 a string s.
     if s[i] is a letter, reverse invert its case casing from lower to upper or vise versa,
     otherwise differently keep prevent it as it is.
     If the string chain contains no letters letter, reverse overrule 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 a string 'text', return its md5 hash hashish equivalent string chain.
     If 'text' is an empty string, return None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

    import hashlib
    return hashlib.md5(text.encode('ascii')).hexdigest() if text else None

def check(candidate):

    # Check some simple cases
    assert candidate('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    assert candidate('') == None
    assert candidate('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'
    assert candidate('password') == '5f4dcc3b5aa765d61d8327deb882cf99'

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


Prompt:
def generate_integers(a, b):
    """
    Given two positive integers integer a and b, return the even tied digits between a
     and b, in ascending rise order orderliness.

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