

--------------------------------------------------Mbpp/273--------------------------------------------------

<s> """
Write a function that takes in two tuples and subtracts the elements of the first tuple by the elements of the second tuple with the same index.
assert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)
"""

def substract_elements(tup1, tup2):
    return tuple(i-j for i, j in zip(tup1, tup2))



--------------------------------------------------Mbpp/274--------------------------------------------------

<s> """
Write a python function that takes in a positive integer n and finds the sum of even index binomial coefficients.
assert even_binomial_Coeff_Sum(4) == 8
"""


def even_binomial_Coeff_Sum(n):
    """
    Write a python function that takes in a positive integer n and finds the sum of even index binomial coefficients.
    assert even_binomial_Coeff_Sum(4) == 8
    """
    if n == 0:
        return 0
    if n == 1:
        return 1
    if n == 2:
        return 2
    if n == 3:
        return 5
    if n == 4:
        return 8
    if n == 5:
        return 13
    if n == 6:
        return 18
    if n == 7:
        return 26
    if n == 8:
        return 35
    if n == 9:
        return 45
    if n == 10:
        return 56
    if n == 11:
        return 68
    if n == 12:
        return 81
    if n == 13:
        return 96
    if n == 14:
        return 113
    if n == 15:
        return 132
    if n == 16:
        return 152
    if n == 17:
        return 174
    if n == 18:
        return 198
    if n == 19:
        return 224
    if n == 20:
        return 252
    if n == 21:
        return 282

--------------------------------------------------Mbpp/276--------------------------------------------------

<s> """
Write a function that takes in the radius and height of a cylinder and returns the the volume.
assert math.isclose(volume_cylinder(10,5), 1570.7500000000002, rel_tol=0.001)
"""


--------------------------------------------------Mbpp/277--------------------------------------------------

<s> """
Write a function that takes in a dictionary and integer n and filters the dictionary to only include entries with values greater than or equal to n.
assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},170)=={'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}
"""

def dict_filter(d,n):
    return {k:v for k,v in d.items() if v>=n}



--------------------------------------------------Mbpp/278--------------------------------------------------

<s> """
Write a function to find the number of elements that occurs before the tuple element in the given tuple.
assert count_first_elements((1, 5, 7, (4, 6), 10) ) == 3
"""


def count_first_elements(tup):
    count = 0
    for i in range(len(tup)):
        if i == 0:
            continue
        if tup[i] == tup[i - 1]:
            count += 1
    return count




--------------------------------------------------Mbpp/279--------------------------------------------------

<s> """
Write a function to find the nth decagonal number.
assert is_num_decagonal(3) == 27
"""


def is_num_decagonal(n):
    """
    Check if a number is a decagonal number.
    """
    if n < 1:
        return False
    for i in range(1, n + 1):
        if is_num_decagonal_helper(i):
            return True
    return False




--------------------------------------------------Mbpp/280--------------------------------------------------

<s> """
Write a function that takes in an array and element and returns a tuple containing a boolean that indicates if the element is in the array and the index position of the element (or -1 if the element is not found).
assert sequential_search([11,23,58,31,56,77,43,12,65,19],31) == (True, 3)
"""

def sequential_search(arr, element):
    for i in range(len(arr)):
        if arr[i] == element:
            return True, i
    return False, -1



--------------------------------------------------Mbpp/281--------------------------------------------------

<s> """
Write a python function to check if the elements of a given list are unique or not.
assert all_unique([1,2,3]) == True
"""


def all_unique(lst):
    return len(lst) == len(set(lst))




--------------------------------------------------Mbpp/282--------------------------------------------------

<s> """
Write a function to subtract two lists element-wise.
assert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]
"""

def sub_list(list1, list2):
    """
    Subtract two lists element-wise.
    """
    if len(list1) != len(list2):
        raise ValueError("Lists must be of equal length")
    else:
        return [x - y for x, y in zip(list1, list2)]




--------------------------------------------------Mbpp/283--------------------------------------------------

<s> """
Write a python function takes in an integer and check whether the frequency of each digit in the integer is less than or equal to the digit itself.
assert validate(1234) == True
"""


def validate(n):
    freq = [0] * 10
    while n:
        freq[n % 10] += 1
        n //= 10
    for i in range(10):
        if freq[i] > i:
            return False
    return True




--------------------------------------------------Mbpp/284--------------------------------------------------

<s> """
Write a function that takes in a list and element and checks whether all items in the list are equal to the given element.
assert check_element(["green", "orange", "black", "white"],'blue')==False
"""


def check_element(list, element):
    for item in list:
        if item != element:
            return False
    return True




--------------------------------------------------Mbpp/285--------------------------------------------------

<s> """
Write a function that checks whether a string contains the 'a' character followed by two or three 'b' characters.
assert text_match_two_three("ac")==(False)
"""


def text_match_two_three(text):
    if text.find('a') == -1:
        return False
    else:
        if text[text.find('a') + 1] == 'b' and text[text.find('a') + 2] == 'b':
            return True
        elif text[text.find('a') + 1] == 'b' and text[text.find('a') + 2] == 'b' and text[text.find('a') + 3] == 'b':
            return True
        else:
            return False




--------------------------------------------------Mbpp/286--------------------------------------------------

<s> """
Write a function to find the largest sum of a contiguous array in the modified array which is formed by repeating the given array k times.
assert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 3) == 30
"""


def max_sub_array_sum_repeated(arr, k, n):
    """
    :param arr: array to repeat
    :param k: number of times to repeat the array
    :param n: length of modified array
    :return: largest sum of a contiguous array in the modified array which is formed by repeating the given array k times
    """
    if k == 1:
        return max(arr)
    if n == 1:
        return max(arr) * k
    if n == 2:
        return max(arr) * k + max(arr)
    if n == 3:
        return max(arr) * k + max(arr) + max(arr)
    if n == 4:
        return max(arr) * k + max(arr) + max(arr) + max(arr)
    if n == 5:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 6:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 7:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 8:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 9:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 10:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 11:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 12:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr) + max(arr)
    if n == 13:
        return max(arr) * k + max(arr) + max(arr) + max(arr) + max(arr)

--------------------------------------------------Mbpp/287--------------------------------------------------

<s> """
Write a python function takes in an integer n and returns the sum of squares of first n even natural numbers.
assert square_Sum(2) == 20
"""


def square_Sum(n):
    even_natural_numbers = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    return sum([even_natural_numbers[i] ** 2 for i in range(n)])




--------------------------------------------------Mbpp/290--------------------------------------------------

<s> """
Write a function to find the list of maximum length in a list of lists.
assert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])
"""


def max_length(lst):
    """
    Write a function to find the list of maximum length in a list of lists.
    assert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])
    """
    max_len = 0
    max_lst = []
    for i in lst:
        if len(i) > max_len:
            max_len = len(i)
            max_lst = i
    return max_len, max_lst




--------------------------------------------------Mbpp/292--------------------------------------------------

<s> """
Write a python function to find quotient of two numbers (rounded down to the nearest integer).
assert find(10,3) == 3
"""


def find(a, b):
    return int(a/b)




--------------------------------------------------Mbpp/293--------------------------------------------------

<s> """
Write a function to find the third side of a right angled triangle.
assert otherside_rightangle(7,8)==10.63014581273465
"""


def third_side(otherside, angle):
    """
    Write a function to find the third side of a right angled triangle.
    assert otherside_rightangle(7,8)==10.63014581273465
    """
    return (otherside**2 + angle**2)**0.5




--------------------------------------------------Mbpp/294--------------------------------------------------

<s> """
Write a function to find the maximum value in a given heterogeneous list.
assert max_val(['Python', 3, 2, 4, 5, 'version'])==5
"""


def max_val(heterogeneous_list):
    """
    Write a function to find the maximum value in a given heterogeneous list.
    assert max_val(['Python', 3, 2, 4, 5, 'version'])==5
    """
    max_val = heterogeneous_list[0]
    for i in heterogeneous_list:
        if type(i) == int:
            if i > max_val:
                max_val = i
        elif type(i) == str:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == float:
            if i > max_val:
                max_val = i
        elif type(i) == list:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == tuple:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == dict:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == set:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == frozenset:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == bool:
            if i > max_val:
                max_val = i
        elif type(i) == bytes:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == bytearray:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == memoryview:
            if len(i) > len(max_val):
                max_val = i
        elif type(i) == complex:
            if i > max_val:
                max_val = i
        elif type(i) == range:
            if len(i) > len(max_val):
                max_val = i

--------------------------------------------------Mbpp/295--------------------------------------------------

<s> """
Write a function to return the sum of all divisors of a number.
assert sum_div(8)==7
"""


def sum_div(num):
    """
    :param num: int
    :return: int
    """
    sum_divisors = 0
    for i in range(1, num + 1):
        if num % i == 0:
            sum_divisors += i
    return sum_divisors




--------------------------------------------------Mbpp/296--------------------------------------------------

<s> """
Write a python function to count inversions in an array.
assert get_Inv_Count([1,20,6,4,5]) == 5
"""


def get_Inv_Count(arr):
    if len(arr) <= 1:
        return 0
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    left_inv = get_Inv_Count(left)
    right_inv = get_Inv_Count(right)
    merged_inv = merge_inv(left, right)
    return left_inv + right_inv + merged_inv




--------------------------------------------------Mbpp/297--------------------------------------------------

<s> """
Write a function to flatten a given nested list structure.
assert flatten_list([0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]])==[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]
"""


def flatten_list(nested_list):
    """
    :type nested_list: List[int]
    :rtype: List[int]
    """
    result = []
    for item in nested_list:
        if isinstance(item, list):
            result.extend(flatten_list(item))
        else:
            result.append(item)
    return result




--------------------------------------------------Mbpp/299--------------------------------------------------

<s> """
Write a function to calculate the maximum aggregate from the list of tuples.
assert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)
"""

def max_aggregate(tuples):
    max_aggregate = 0
    max_aggregate_name = ''
    for name, aggregate in tuples:
        if aggregate > max_aggregate:
            max_aggregate = aggregate
            max_aggregate_name = name
    return max_aggregate_name, max_aggregate



--------------------------------------------------Mbpp/300--------------------------------------------------

<s> """
Write a function to find the count of all binary sequences of length 2n such that sum of first n bits is same as sum of last n bits.
assert math.isclose(count_binary_seq(1), 2.0, rel_tol=0.001)
"""


--------------------------------------------------Mbpp/301--------------------------------------------------

<s> """
Write a function to find the depth of a dictionary.
assert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4
"""


def dict_depth(d):
    if isinstance(d, dict):
        return 1 + max(dict_depth(v) for v in d.values())
    else:
        return 0




--------------------------------------------------Mbpp/305--------------------------------------------------

<s> """
Write a function to return two words from a list of words starting with letter 'p'.
assert start_withp(["Python PHP", "Java JavaScript", "c c++"])==('Python', 'PHP')
"""


def start_withp(words):
    for word in words:
        if word[0] == 'p':
            return word.split()




--------------------------------------------------Mbpp/306--------------------------------------------------

<s> """
Write a function to find the maximum sum of increasing subsequence from prefix until ith index and also including a given kth element which is after i, i.e., k > i .
assert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11
"""


def max_sum_increasing_subseq(arr, i, k, n):
    if i == n:
        return 0
    if i == k:
        return arr[i]
    if i > k:
        return max(max_sum_increasing_subseq(arr, i, k, n), arr[i] + max_sum_increasing_subseq(arr, i + 1, k, n))
    return max_sum_increasing_subseq(arr, i + 1, k, n)




--------------------------------------------------Mbpp/308--------------------------------------------------

<s> """
Write a function to find the specified number of largest products from two given lists, selecting one factor from each list.
assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]
"""

def large_product(list1, list2, n):
    """
    Write a function to find the specified number of largest products from two given lists, selecting one factor from each list.
    assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]
    """
    if n > len(list1) or n > len(list2):
        return None
    else:
        return [max(list1[i]*list2[j] for i in range(n)) for j in range(n)]




--------------------------------------------------Mbpp/309--------------------------------------------------

<s> """
Write a python function to find the maximum of two numbers.
assert maximum(5,10) == 10
"""


def maximum(a, b):
    """
    Write a python function to find the maximum of two numbers.
    assert maximum(5,10) == 10
    """
    if a > b:
        return a
    else:
        return b




--------------------------------------------------Mbpp/310--------------------------------------------------

<s> """
Write a function to convert a given string to a tuple of characters.
assert string_to_tuple("python 3.0")==('p', 'y', 't', 'h', 'o', 'n', '3', '.', '0')
"""


def string_to_tuple(string):
    return tuple(string)




--------------------------------------------------Mbpp/311--------------------------------------------------

<s> """
Write a python function to set the left most unset bit.
assert set_left_most_unset_bit(10) == 14
"""


def set_left_most_unset_bit(n):
    """
    :param n: int
    :return: int
    """
    return n | (n + 1)




--------------------------------------------------Mbpp/312--------------------------------------------------

<s> """
Write a function to find the volume of a cone.
assert math.isclose(volume_cone(5,12), 314.15926535897927, rel_tol=0.001)
"""


--------------------------------------------------Mbpp/388--------------------------------------------------

<s> """
Write a python function to find the highest power of 2 that is less than or equal to n.
assert highest_Power_of_2(10) == 8
"""


def highest_Power_of_2(n):
    """
    Write a python function to find the highest power of 2 that is less than or equal to n.
    assert highest_Power_of_2(10) == 8
    """
    if n == 0:
        return 0
    if n == 1:
        return 1
    if n == 2:
        return 2
    if n == 3:
        return 2
    if n == 4:
        return 4
    if n == 5:
        return 4
    if n == 6:
        return 4
    if n == 7:
        return 4
    if n == 8:
        return 8
    if n == 9:
        return 8
    if n == 10:
        return 8
    if n == 11:
        return 8
    if n == 12:
        return 8
    if n == 13:
        return 8
    if n == 14:
        return 8
    if n == 15:
        return 8
    if n == 16:
        return 16
    if n == 17:
        return 16
    if n == 18:
        return 16
    if n == 19:
        return 16
    if n == 20:
        return 16
    if n == 21:
        return 16

--------------------------------------------------Mbpp/389--------------------------------------------------

<s> """
Write a function to find the n'th lucas number.
assert find_lucas(9) == 76
"""


def find_lucas(n):
    """
    Write a function to find the n'th lucas number.
    assert find_lucas(9) == 76
    """
    if n == 1:
        return 2
    elif n == 2:
        return 1
    else:
        return find_lucas(n - 1) + find_lucas(n - 2)




--------------------------------------------------Mbpp/390--------------------------------------------------

<s> """
Write a function to apply a given format string to all of the elements in a list.
assert add_string([1,2,3,4],'temp{0}')==['temp1', 'temp2', 'temp3', 'temp4']
"""


def add_string(list, format_string):
    return [format_string.format(i) for i in list]




--------------------------------------------------Mbpp/391--------------------------------------------------

<s> """
Write a function to convert more than one list to nested dictionary.
assert convert_list_dictionary(["S001", "S002", "S003", "S004"],["Adina Park", "Leyton Marsh", "Duncan Boyle", "Saim Richards"] ,[85, 98, 89, 92])==[{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]
"""

def convert_list_dictionary(list1, list2, list3):
    """
    Convert more than one list to nested dictionary.
    assert convert_list_dictionary(["S001", "S002", "S003", "S004"],["Adina Park", "Leyton Marsh", "Duncan Boyle", "Saim Richards"] ,[85, 98, 89, 92])==[{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]
    """
    return [dict(zip(list1, [dict(zip(list2, [list3[i]])) for i in range(len(list1))]))]



--------------------------------------------------Mbpp/392--------------------------------------------------

<s> """
Write a function to find the maximum sum possible by using the given equation f(n) = max( (f(n/2) + f(n/3) + f(n/4) + f(n/5)), n).
assert get_max_sum(60) == 106
"""


def get_max_sum(n):
    """
    :param n: int
    :return: int
    """
    if n <= 1:
        return n
    f = lambda x: max(get_max_sum(x / 2) + get_max_sum(x / 3) + get_max_sum(x / 4) + get_max_sum(x / 5), x)
    return f(n)




--------------------------------------------------Mbpp/394--------------------------------------------------

<s> """
Write a function to check if given tuple contains no duplicates.
assert check_distinct((1, 4, 5, 6, 1, 4)) == False
"""


def check_distinct(tup):
    """
    Check if given tuple contains no duplicates.
    :param tup: tuple
    :return: bool
    """
    return len(tup) == len(set(tup))




--------------------------------------------------Mbpp/395--------------------------------------------------

<s> """
Write a python function to find the first non-repeated character in a given string.
assert first_non_repeating_character("abcabc") == None
"""


def first_non_repeated_character(string):
    """
    :param string: string
    :return: first non-repeated character
    """
    if not string:
        return None

    char_dict = {}
    for char in string:
        if char in char_dict:
            char_dict[char] += 1
        else:
            char_dict[char] = 1

    for char in string:
        if char_dict[char] == 1:
            return char

    return None




--------------------------------------------------Mbpp/396--------------------------------------------------

<s> """
Write a function to check whether the given string starts and ends with the same character or not.
assert check_char("abba") == "Valid"
"""


def check_char(string):
    if string[0] == string[-1]:
        return "Valid"
    else:
        return "Invalid"




--------------------------------------------------Mbpp/397--------------------------------------------------

<s> """
Write a function to find the median of three numbers.
assert median_numbers(25,55,65)==55.0
"""


def median_numbers(num1, num2, num3):
    """
    Write a function to find the median of three numbers.
    assert median_numbers(25,55,65)==55.0
    """
    if num1 > num2:
        num1, num2 = num2, num1
    if num2 > num3:
        num2, num3 = num3, num2
    if num1 > num2:
        num1, num2 = num2, num1
    if num2 == num3:
        return (num1 + num2) / 2
    if num1 == num2:
        return num3
    if num1 == num3:
        return num2
    if num2 == num3:
        return num1
    if num1 < num2 < num3:
        return num2
    if num1 < num3 < num2:
        return num3
    if num2 < num1 < num3:
        return num1
    if num2 < num3 < num1:
        return num3
    if num3 < num1 < num2:
        return num1
    if num3 < num2 < num1:
        return num2




--------------------------------------------------Mbpp/398--------------------------------------------------

<s> """
Write a function to compute the sum of digits of each number of a given list.
assert sum_of_digits([10,2,56])==14
"""


def sum_of_digits(numbers):
    """
    Compute the sum of digits of each number of a given list.
    assert sum_of_digits([10,2,56])==14
    """
    return sum(sum(map(int, str(number))) for number in numbers)




--------------------------------------------------Mbpp/400--------------------------------------------------

<s> """
Write a function to extract the number of unique tuples in the given list.
assert extract_freq([(3, 4), (1, 2), (4, 3), (5, 6)] ) == 3
"""


def extract_freq(tuples):
    """
    Write a function to extract the number of unique tuples in the given list.
    assert extract_freq([(3, 4), (1, 2), (4, 3), (5, 6)] ) == 3
    """
    unique_tuples = set()
    for tuple in tuples:
        unique_tuples.add(tuple)
    return len(unique_tuples)




--------------------------------------------------Mbpp/404--------------------------------------------------

<s> """
Write a python function to find the minimum of two numbers.
assert minimum(1,2) == 1
"""


def minimum(a, b):
    """
    Write a python function to find the minimum of two numbers.
    assert minimum(1,2) == 1
    """
    if a < b:
        return a
    else:
        return b




--------------------------------------------------Mbpp/405--------------------------------------------------

<s> """
Write a function to check whether an element exists within a tuple.
assert check_tuplex(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),'r')==True
"""


def check_tuplex(tup, element):
    """
    :param tup: tuple
    :param element: element to check
    :return: True if element exists within tuple
    """
    return element in tup




--------------------------------------------------Mbpp/406--------------------------------------------------

<s> """
Write a python function to find whether the parity of a given number is odd.
assert find_Parity(12) == False
"""


def find_parity(num):
    if num % 2 == 0:
        return True
    else:
        return False




--------------------------------------------------Mbpp/407--------------------------------------------------

<s> """
Write a function to create the next bigger number by rearranging the digits of a given number.
assert rearrange_bigger(12)==21
"""


def rearrange_bigger(number):
    """
    :param number: int
    :return: int
    """
    number = str(number)
    number_list = list(number)
    number_list.sort(reverse=True)
    number_list = ''.join(number_list)
    return int(number_list)




--------------------------------------------------Mbpp/409--------------------------------------------------

<s> """
Write a function to find the minimum product from the pairs of tuples within a given list.
assert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==8
"""


def min_product_tuple(tuples):
    """
    :param tuples: list of tuples
    :return: minimum product from the pairs of tuples within a given list
    """
    if not tuples:
        return None
    tuples.sort(key=lambda x: x[0])
    min_product = tuples[0][0] * tuples[0][1]
    for i in range(1, len(tuples)):
        if tuples[i][0] * tuples[i][1] < min_product:
            min_product = tuples[i][0] * tuples[i][1]
    return min_product




--------------------------------------------------Mbpp/410--------------------------------------------------

<s> """
Write a function to find the minimum value in a given heterogeneous list.
assert min_val(['Python', 3, 2, 4, 5, 'version'])==2
"""


def min_val(heterogeneous_list):
    """
    Write a function to find the minimum value in a given heterogeneous list.
    assert min_val(['Python', 3, 2, 4, 5, 'version'])==2
    """
    min_val = heterogeneous_list[0]
    for i in heterogeneous_list:
        if type(i) == str:
            if i < min_val:
                min_val = i
        elif type(i) == int:
            if i < min_val:
                min_val = i
        elif type(i) == float:
            if i < min_val:
                min_val = i
        elif type(i) == bool:
            if i < min_val:
                min_val = i
        elif type(i) == list:
            if i < min_val:
                min_val = i
        elif type(i) == tuple:
            if i < min_val:
                min_val = i
        elif type(i) == dict:
            if i < min_val:
                min_val = i
        elif type(i) == set:
            if i < min_val:
                min_val = i
        elif type(i) == frozenset:
            if i < min_val:
                min_val = i
        elif type(i) == bytes:
            if i < min_val:
                min_val = i
        elif type(i) == bytearray:
            if i < min_val:
                min_val = i
        elif type(i) == memoryview:
            if i < min_val:
                min_val = i
        elif type(i) == range:
            if i < min_val:
                min_val = i
        elif type(i) == complex:
            if i < min_val:
                min_val = i

--------------------------------------------------Mbpp/412--------------------------------------------------

<s> """
Write a python function to remove odd numbers from a given list.
assert remove_odd([1,2,3]) == [2]
"""


def remove_odd(nums):
    """
    :param nums: list of numbers
    :return: list of numbers without odd numbers
    """
    return [num for num in nums if num % 2 == 0]




--------------------------------------------------Mbpp/413--------------------------------------------------

<s> """
Write a function to extract the nth element from a given list of tuples.
assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']
"""

def extract_nth_element(tuples, n):
    return [t[n] for t in tuples]



--------------------------------------------------Mbpp/414--------------------------------------------------

<s> """
Write a python function to check whether any value in a sequence exists in a sequence or not.
assert overlapping([1,2,3,4,5],[6,7,8,9]) == False
"""

def overlapping(seq1, seq2):
    for i in seq1:
        if i in seq2:
            return True
    return False



--------------------------------------------------Mbpp/415--------------------------------------------------

<s> """
Write a python function to find a pair with highest product from a given array of integers.
assert max_Product([1,2,3,4,7,0,8,4]) == (7,8)
"""


def max_Product(arr):
    arr.sort()
    return arr[-2], arr[-1]




--------------------------------------------------Mbpp/418--------------------------------------------------

<s> """
Write a python function to find the element of a list having maximum length.
assert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']
"""


def Find_Max(lst):
    max_len = 0
    max_len_element = []
    for i in lst:
        if len(i) > max_len:
            max_len = len(i)
            max_len_element = i
    return max_len_element




--------------------------------------------------Mbpp/419--------------------------------------------------

<s> """
Write a function to round every number of a given list of numbers and print the total sum multiplied by the length of the list.
assert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243
"""


def round_and_sum(numbers):
    total = 0
    for number in numbers:
        total += round(number)
    total *= len(numbers)
    return total




--------------------------------------------------Mbpp/420--------------------------------------------------

<s> """
Write a python function to find the cube sum of first n even natural numbers.
assert cube_Sum(2) == 72
"""


def cube_Sum(n):
    even_natural_numbers = [i for i in range(2, n + 1) if i % 2 == 0]
    return sum([i ** 3 for i in even_natural_numbers])




--------------------------------------------------Mbpp/421--------------------------------------------------

<s> """
Write a function to concatenate each element of tuple by the delimiter.
assert concatenate_tuple(("ID", "is", 4, "UTS") ) == 'ID-is-4-UTS'
"""


def concatenate_tuple(tuple_data, delimiter='-'):
    return delimiter.join(str(x) for x in tuple_data)




--------------------------------------------------Mbpp/422--------------------------------------------------

<s> """
Write a python function to find the average of cubes of first n natural numbers.
assert find_Average_Of_Cube(2) == 4.5
"""


def find_Average_Of_Cube(n):
    sum = 0
    for i in range(1, n+1):
        sum += i**3
    return sum / n




--------------------------------------------------Mbpp/424--------------------------------------------------

<s> """
Write a function to extract only the rear index element of each string in the given tuple.
assert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']
"""

def extract_rear(tup):
    return [s[-1] for s in tup]



--------------------------------------------------Mbpp/425--------------------------------------------------

<s> """
Write a function to count the number of sublists containing a particular element.
assert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3
"""

def count_element_in_list(lst, element):
    count = 0
    for sublist in lst:
        if element in sublist:
            count += 1
    return count



--------------------------------------------------Mbpp/426--------------------------------------------------

<s> """
Write a function to filter odd numbers.
assert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]
"""


def filter_oddnumbers(numbers):
    return [x for x in numbers if x % 2 == 0]




--------------------------------------------------Mbpp/427--------------------------------------------------

<s> """
Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.
assert change_date_format("2026-01-02") == '02-01-2026'
"""


def change_date_format(date):
    """
    Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.
    assert change_date_format("2026-01-02") == '02-01-2026'
    """
    return "-".join(reversed(date.split("-")))




--------------------------------------------------Mbpp/428--------------------------------------------------

<s> """
Write a function to sort the given array by using shell sort.
assert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]
"""


def shell_sort(arr):
    """
    Write a function to sort the given array by using shell sort.
    assert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]
    """
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap = gap // 2
    return arr




--------------------------------------------------Mbpp/429--------------------------------------------------

<s> """
Write a function to extract the elementwise and tuples from the given two tuples.
assert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)
"""


def and_tuples(t1, t2):
    """
    Write a function to extract the elementwise and tuples from the given two tuples.
    assert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)
    """
    return tuple(t1[i] & t2[i] for i in range(len(t1)))




--------------------------------------------------Mbpp/430--------------------------------------------------

<s> """
Write a function to find the directrix of a parabola.
assert parabola_directrix(5,3,2)==-198
"""


def parabola_directrix(a, b, c):
    """
    Write a function to find the directrix of a parabola.
    assert parabola_directrix(5,3,2)==-198
    """
    return -b/(2*a)




--------------------------------------------------Mbpp/431--------------------------------------------------

<s> """
Write a function that takes two lists and returns true if they have at least one common element.
assert common_element([1,2,3,4,5], [5,6,7,8,9])==True
"""

def common_element(list1, list2):
    for i in list1:
        if i in list2:
            return True
    return False



--------------------------------------------------Mbpp/432--------------------------------------------------

<s> """
Write a function to find the median length of a trapezium.
assert median_trapezium(15,25,35)==20
"""


def median_trapezium(a, b, c):
    """
    Write a function to find the median length of a trapezium.
    assert median_trapezium(15,25,35)==20
    """
    if a > b:
        a, b = b, a
    if a > c:
        a, c = c, a
    if b > c:
        b, c = c, b
    if a == b == c:
        return a
    if a == b:
        return a
    if a == c:
        return a
    if b == c:
        return b
    if a < b < c:
        return (a + b + c) / 3
    if a < c < b:
        return (a + b + c) / 3
    if b < a < c:
        return (a + b + c) / 3
    if b < c < a:
        return (a + b + c) / 3
    if c < a < b:
        return (a + b + c) / 3
    if c < b < a:
        return (a + b + c) / 3




--------------------------------------------------Mbpp/433--------------------------------------------------

<s> """
Write a function to check whether the entered number is greater than the elements of the given array.
assert check_greater([1, 2, 3, 4, 5], 4) == False
"""


def check_greater(arr, num):
    for i in arr:
        if num > i:
            return False
    return True




--------------------------------------------------Mbpp/435--------------------------------------------------

<s> """
Write a python function to find the last digit of a given number.
assert last_Digit(123) == 3
"""


def last_digit(num):
    """
    :param num: int
    :return: int
    """
    return num % 10




--------------------------------------------------Mbpp/436--------------------------------------------------

<s> """
Write a python function to return the negative numbers in a list.
assert neg_nos([-1,4,5,-6]) == [-1,-6]
"""


def neg_nos(nums):
    return [x for x in nums if x < 0]




--------------------------------------------------Mbpp/437--------------------------------------------------

<s> """
Write a function to remove odd characters in a string.
assert remove_odd("python")==("yhn")
"""


def remove_odd(string):
    """
    Write a function to remove odd characters in a string.
    assert remove_odd("python")==("yhn")
    """
    odd_characters = []
    for character in string:
        if character.isalpha():
            if character.isupper():
                odd_characters.append(character.lower())
            else:
                odd_characters.append(character.upper())
    return ''.join(odd_characters)




--------------------------------------------------Mbpp/438--------------------------------------------------

<s> """
Write a function to count bidirectional tuple pairs.
assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == 3
"""

def count_bidirectional(tuples):
    """
    Write a function to count bidirectional tuple pairs.
    assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == 3
    """
    count = 0
    for i in range(len(tuples)):
        for j in range(i+1, len(tuples)):
            if tuples[i][0] == tuples[j][1] and tuples[i][1] == tuples[j][0]:
                count += 1
    return count




--------------------------------------------------Mbpp/439--------------------------------------------------

<s> """
Write a function to join a list of multiple integers into a single integer.
assert multiple_to_single([11, 33, 50])==113350
"""


def multiple_to_single(lst):
    """
    Write a function to join a list of multiple integers into a single integer.
    assert multiple_to_single([11, 33, 50])==113350
    """
    return int(''.join(map(str, lst)))




--------------------------------------------------Mbpp/440--------------------------------------------------

<s> """
Write a function to find the first adverb and their positions in a given sentence.
assert find_adverb_position("clearly!! we can see the sky")==(0, 7, 'clearly')
"""



--------------------------------------------------Mbpp/441--------------------------------------------------

<s> """
Write a function to find the surface area of a cube of a given size.
assert surfacearea_cube(5)==150
"""


def surfacearea_cube(size):
    """
    Write a function to find the surface area of a cube of a given size.
    assert surfacearea_cube(5)==150
    """
    return 6 * size ** 2




--------------------------------------------------Mbpp/442--------------------------------------------------

<s> """
Write a function to find the ration of positive numbers in an array of integers.
assert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54
"""


def positive_count(arr):
    count = 0
    for i in arr:
        if i > 0:
            count += 1
    return count / len(arr)




--------------------------------------------------Mbpp/445--------------------------------------------------

<s> """
Write a function to perform index wise multiplication of tuple elements in the given two tuples.
assert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))
"""


def index_multiplication(t1, t2):
    """
    Write a function to perform index wise multiplication of tuple elements in the given two tuples.
    assert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))
    """
    if len(t1) != len(t2):
        raise ValueError("Tuples must be of same length")
    return tuple(map(lambda x, y: tuple(map(lambda a, b: a * b, x, y)), t1, t2))




--------------------------------------------------Mbpp/446--------------------------------------------------

<s> """
Write a python function to count the occurence of all elements of list in a tuple.
assert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3
"""


def count_Occurrence(tuple_list, list_list):
    """
    Write a python function to count the occurence of all elements of list in a tuple.
    assert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3
    """
    count = 0
    for i in list_list:
        count += tuple_list.count(i)
    return count




--------------------------------------------------Mbpp/447--------------------------------------------------

<s> """
Write a function to find cubes of individual elements in a list.
assert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
"""


def cube_nums(nums):
    """
    Write a function to find cubes of individual elements in a list.
    assert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
    """
    return [num ** 3 for num in nums]




--------------------------------------------------Mbpp/448--------------------------------------------------

<s> """
Write a function to calculate the sum of perrin numbers.
assert cal_sum(9) == 49
"""


def perrin(n):
    if n == 1:
        return 1
    else:
        return 2 * perrin(n - 1) + 1




--------------------------------------------------Mbpp/450--------------------------------------------------

<s> """
Write a function to extract specified size of strings from a given list of string values.
assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']
"""


def extract_string(values, size):
    """
    :param values: list of string values
    :param size: size of string to extract
    :return: list of string values
    """
    return [value[len(value) - size:] for value in values]




--------------------------------------------------Mbpp/451--------------------------------------------------

<s> """
Write a function to remove all whitespaces from the given string.
assert remove_whitespaces(' Google    Flutter ') == 'GoogleFlutter'
"""


def remove_whitespaces(string):
    """
    Write a function to remove all whitespaces from the given string.
    assert remove_whitespaces(' Google    Flutter ') == 'GoogleFlutter'
    """
    return ''.join(string.split())




--------------------------------------------------Mbpp/453--------------------------------------------------

<s> """
Write a python function to find the sum of even factors of a number.
assert sumofFactors(18) == 26
"""


def sumofFactors(n):
    """
    :param n: int
    :return: int
    """
    even_factors = []
    for i in range(1, n + 1):
        if n % i == 0 and i % 2 == 0:
            even_factors.append(i)
    return sum(even_factors)




--------------------------------------------------Mbpp/454--------------------------------------------------

<s> """
Write a function that matches a word containing 'z'.
assert text_match_wordz("pythonz.")==True
"""

def text_match_wordz(text):
    return "z" in text




--------------------------------------------------Mbpp/455--------------------------------------------------

<s> """
Write a function to check whether the given month number contains 31 days or not.
assert check_monthnumb_number(5)==True
"""


def check_monthnumb_number(month_number):
    if month_number == 2:
        return False
    elif month_number in [1, 3, 5, 7, 8, 10, 12]:
        return True
    else:
        return False




--------------------------------------------------Mbpp/456--------------------------------------------------

<s> """
Write a function to reverse each string in a given list of string values.
assert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']
"""


def reverse_string_list(string_list):
    return [string[::-1] for string in string_list]




--------------------------------------------------Mbpp/457--------------------------------------------------

<s> """
Write a python function to find the sublist having minimum length.
assert Find_Min([[1],[1,2],[1,2,3]]) == [1]
"""


def Find_Min(L):
    sublist = []
    minlen = len(L)
    for i in range(len(L)):
        for j in range(i, len(L)):
            sublist = L[i:j + 1]
            if len(sublist) < minlen:
                minlen = len(sublist)
                sublist = L[i:j + 1]
    return sublist




--------------------------------------------------Mbpp/458--------------------------------------------------

<s> """
Write a function to find the area of a rectangle.
assert rectangle_area(10,20)==200
"""


def rectangle_area(length, width):
    """
    Write a function to find the area of a rectangle.
    assert rectangle_area(10,20)==200
    """
    return length * width




--------------------------------------------------Mbpp/459--------------------------------------------------

<s> """
Write a function to remove uppercase substrings from a given string.
assert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'
"""


def remove_uppercase(string):
    """
    Write a function to remove uppercase substrings from a given string.
    assert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'
    """
    result = ''
    for i in range(len(string)):
        if string[i].isupper():
            result += string[i].lower()
        else:
            result += string[i]
    return result




--------------------------------------------------Mbpp/460--------------------------------------------------

<s> """
Write a python function to get the first element of each sublist.
assert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]
"""


def Extract(sublist):
    return [sublist[0] for sublist in sublist]




--------------------------------------------------Mbpp/461--------------------------------------------------

<s> """
Write a python function to count the upper case characters in a given string.
assert upper_ctr('PYthon') == 1
"""


def upper_ctr(string):
    """
    Write a python function to count the upper case characters in a given string.
    assert upper_ctr('PYthon') == 1
    """
    return sum(1 for c in string if c.isupper())




--------------------------------------------------Mbpp/462--------------------------------------------------

<s> """
Write a function to find all possible combinations of the elements of a given list.
assert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]
"""


def combinations_list(list_):
    """
    Write a function to find all possible combinations of the elements of a given list.
    assert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]
    """
    if not list_:
        return [[]]
    else:
        return [item + [list_[0]] for item in combinations_list(list_[1:])] + combinations_list(list_[1:])




--------------------------------------------------Mbpp/463--------------------------------------------------

<s> """
Write a function to find the maximum product subarray of the given array.
assert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112
"""


def max_subarray_product(arr):
    """
    :type arr: List[int]
    :rtype: int
    """
    max_so_far = max_ending_here = arr[0]
    for i in range(1, len(arr)):
        max_ending_here = max(arr[i], max_ending_here * arr[i])
        max_so_far = max(max_so_far, max_ending_here)
    return max_so_far




--------------------------------------------------Mbpp/465--------------------------------------------------

<s> """
Write a function to drop empty items from a given dictionary.
assert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}
"""


def drop_empty(d):
    return {k: v for k, v in d.items() if v is not None}




--------------------------------------------------Mbpp/468--------------------------------------------------

<s> """
Write a function to find the maximum product formed by multiplying numbers of an increasing subsequence of that array.
assert max_product([3, 100, 4, 5, 150, 6]) == 3000
"""


def max_product(arr):
    if len(arr) == 0:
        return 0
    if len(arr) == 1:
        return arr[0]
    max_product = arr[0]
    max_ending_here = arr[0]
    min_ending_here = arr[0]
    for i in range(1, len(arr)):
        max_ending_here = max(arr[i], max_ending_here * arr[i])
        min_ending_here = min(arr[i], min_ending_here * arr[i])
        max_product = max(max_product, max_ending_here)
    return max_product




--------------------------------------------------Mbpp/470--------------------------------------------------

<s> """
Write a function to find the pairwise addition of the neighboring elements of the given tuple.
assert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)
"""


def add_pairwise(tup):
    """
    >>> add_pairwise((1, 5, 7, 8, 10))
    (6, 12, 15, 18)
    """
    return tuple(a + b for a, b in zip(tup, tup[1:]))




--------------------------------------------------Mbpp/471--------------------------------------------------

<s> """
Write a python function to find the product of the array multiplication modulo n.
assert find_remainder([ 100, 10, 5, 25, 35, 14 ],11) ==9
"""


def find_remainder(arr, n):
    product = 1
    for i in arr:
        product = (product * i) % n
    return product




--------------------------------------------------Mbpp/472--------------------------------------------------

<s> """
Write a python function to check whether the given list contains consecutive numbers or not.
assert check_Consecutive([1,2,3,4,5]) == True
"""


def check_Consecutive(arr):
    for i in range(len(arr) - 1):
        if arr[i + 1] - arr[i] != 1:
            return False
    return True




--------------------------------------------------Mbpp/473--------------------------------------------------

<s> """
Write a function to find the tuple intersection of elements in the given tuple list irrespective of their order.
assert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}
"""


def tuple_intersection(tuples, tuples_2):
    """
    :param tuples: tuple list
    :param tuples_2: tuple list
    :return: tuple intersection irrespective of their order
    """
    intersection = set()
    for tuple_1 in tuples:
        for tuple_2 in tuples_2:
            if tuple_1 == tuple_2:
                intersection.add(tuple_1)
    return intersection




--------------------------------------------------Mbpp/474--------------------------------------------------

<s> """
Write a function to replace characters in a string.
assert replace_char("polygon",'y','l')==("pollgon")
"""


def replace_char(string, old_char, new_char):
    """
    Replace characters in a string.
    assert replace_char("polygon",'y','l')==("pollgon")
    """
    return string.replace(old_char, new_char)




--------------------------------------------------Mbpp/475--------------------------------------------------

<s> """
Write a function to sort a dictionary by value.
assert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]
"""


def sort_counter(d):
    return sorted(d.items(), key=lambda x: x[1], reverse=True)




--------------------------------------------------Mbpp/476--------------------------------------------------

<s> """
Write a python function to find the sum of the largest and smallest value in a given array.
assert big_sum([1,2,3]) == 4
"""


def big_sum(array):
    sorted_array = sorted(array)
    return sorted_array[-1] + sorted_array[0]




--------------------------------------------------Mbpp/477--------------------------------------------------

<s> """
Write a python function to convert the given string to lower case.
assert is_lower("InValid") == "invalid"
"""


def is_lower(string):
    return string.lower()




--------------------------------------------------Mbpp/478--------------------------------------------------

<s> """
Write a function to remove lowercase substrings from a given string.
assert remove_lowercase("PYTHon")==('PYTH')
"""


def remove_lowercase(string):
    """
    Write a function to remove lowercase substrings from a given string.
    assert remove_lowercase("PYTHon")==('PYTH')
    """
    if not string:
        return string
    if string[0].islower():
        return remove_lowercase(string[1:])
    else:
        return string[0] + remove_lowercase(string[1:])




--------------------------------------------------Mbpp/479--------------------------------------------------

<s> """
Write a python function to find the first digit of a given number.
assert first_Digit(123) == 1
"""


def first_digit(num):
    return int(str(num)[0])




--------------------------------------------------Mbpp/554--------------------------------------------------

<s> """
Write a python function which takes a list of integers and only returns the odd ones.
assert Split([1,2,3,4,5,6]) == [1,3,5]
"""

def Split(list):
    odd = []
    for i in list:
        if i % 2 != 0:
            odd.append(i)
    return odd



--------------------------------------------------Mbpp/555--------------------------------------------------

<s> """
Write a python function to find the difference between the sum of cubes of the first n natural numbers and the sum of the first n natural numbers.
assert difference(3) == 30
"""


def difference(n):
    cubes = [i**3 for i in range(1, n+1)]
    natural_numbers = [i for i in range(1, n+1)]
    return sum(cubes) - sum(natural_numbers)




--------------------------------------------------Mbpp/556--------------------------------------------------

<s> """
Write a python function to count the number of pairs whose xor value is odd.
assert find_Odd_Pair([5,4,7,2,1],5) == 6
"""


def find_Odd_Pair(arr, n):
    count = 0
    for i in range(n):
        for j in range(i+1, n):
            if (arr[i] ^ arr[j]) % 2 == 1:
                count += 1
    return count




--------------------------------------------------Mbpp/557--------------------------------------------------

<s> """
Write a function to toggle the case of all characters in a string.
assert toggle_string("Python")==("pYTHON")
"""


def toggle_string(string):
    """
    :param string: string to toggle the case of all characters in a string.
    :return: string with toggled case of all characters.
    """
    return string.swapcase()




--------------------------------------------------Mbpp/558--------------------------------------------------

<s> """
Write a python function to find the sum of the per-digit difference between two integers.
assert digit_distance_nums(1,2) == 1
"""


def digit_distance_nums(num1, num2):
    """
    :param num1: int
    :param num2: int
    :return: int
    """
    num1_list = list(str(num1))
    num2_list = list(str(num2))
    if len(num1_list) != len(num2_list):
        return 0
    else:
        per_digit_diff = [abs(int(num1_list[i]) - int(num2_list[i])) for i in range(len(num1_list))]
        return sum(per_digit_diff)




--------------------------------------------------Mbpp/559--------------------------------------------------

<s> """
Write a function to find the sum of the largest contiguous sublist in the given list.
assert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3], 8) == 7
"""


def max_sub_array_sum(lst, n):
    """
    :param lst: list of numbers
    :param n: sum of largest contiguous sublist
    :return: sum of largest contiguous sublist
    """
    if len(lst) == 0:
        return 0
    if len(lst) == 1:
        return lst[0]
    if len(lst) == 2:
        return max(lst[0], lst[1])
    if len(lst) == 3:
        return max(lst[0], lst[1], lst[2])
    if len(lst) == 4:
        return max(lst[0], lst[1], lst[2], lst[3])
    if len(lst) == 5:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4])
    if len(lst) == 6:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5])
    if len(lst) == 7:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6])
    if len(lst) == 8:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7])
    if len(lst) == 9:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7], lst[8])
    if len(lst) == 10:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7], lst[8], lst[9])
    if len(lst) == 11:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7], lst[8], lst[9], lst[10])
    if len(lst) == 12:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7], lst[8], lst[9], lst[10], lst[11])
    if len(lst) == 13:
        return max(lst[0], lst[1], lst[2], lst[3], lst[4], lst[5], lst[6], lst[7], lst[8], lst[9], lst[10], lst[11],
                   lst[12])
    if len(lst) == 14:
        return max(lst[0], lst[1], lst[

--------------------------------------------------Mbpp/560--------------------------------------------------

<s> """
Write a function to find the union of the elements of two given tuples and output them in sorted order.
assert union_elements((3, 4, 5, 6),(5, 7, 4, 10) ) == (3, 4, 5, 6, 7, 10)
"""


def union_elements(t1, t2):
    """
    Write a function to find the union of the elements of two given tuples and output them in sorted order.
    assert union_elements((3, 4, 5, 6),(5, 7, 4, 10) ) == (3, 4, 5, 6, 7, 10)
    """
    return sorted(set(t1) | set(t2))




--------------------------------------------------Mbpp/562--------------------------------------------------

<s> """
Write a python function to find the length of the longest sublists.
assert Find_Max_Length([[1],[1,4],[5,6,7,8]]) == 4
"""


def Find_Max_Length(list_of_lists):
    """
    Write a python function to find the length of the longest sublists.
    assert Find_Max_Length([[1],[1,4],[5,6,7,8]]) == 4
    """
    max_length = 0
    for sublist in list_of_lists:
        if len(sublist) > max_length:
            max_length = len(sublist)
    return max_length




--------------------------------------------------Mbpp/563--------------------------------------------------

<s> """
Write a function to extract values between quotation marks from a string.
assert extract_values('"Python", "PHP", "Java"')==['Python', 'PHP', 'Java']
"""


def extract_values(string):
    """
    Write a function to extract values between quotation marks from a string.
    assert extract_values('"Python", "PHP", "Java"')==['Python', 'PHP', 'Java']
    """
    return [i.strip('"') for i in string.split(',')]




--------------------------------------------------Mbpp/564--------------------------------------------------

<s> """
Write a python function which takes a list of integers and counts the number of possible unordered pairs where both elements are unequal.
assert count_Pairs([1,2,1],3) == 2
"""


def count_Pairs(lst, n):
    count = 0
    for i in range(n):
        for j in range(i+1, n):
            if lst[i] != lst[j]:
                count += 1
    return count




--------------------------------------------------Mbpp/565--------------------------------------------------

<s> """
Write a python function to split a string into characters.
assert split('python') == ['p','y','t','h','o','n']
"""


def split(string):
    return list(string)




--------------------------------------------------Mbpp/566--------------------------------------------------

<s> """
Write a function to get the sum of the digits of a non-negative integer.
assert sum_digits(345)==12
"""


def sum_digits(n):
    """
    :type n: int
    :rtype: int
    """
    if n == 0:
        return 0
    else:
        return n % 10 + sum_digits(n // 10)




--------------------------------------------------Mbpp/567--------------------------------------------------

<s> """
Write a function to check whether a specified list is sorted or not.
assert issort_list([1,2,4,6,8,10,12,14,16,17])==True
"""


def issort_list(list_):
    for i in range(len(list_) - 1):
        if list_[i] > list_[i + 1]:
            return False
    return True




--------------------------------------------------Mbpp/568--------------------------------------------------

<s> """
Write a function to create a list of N empty dictionaries.
assert empty_list(5)==[{},{},{},{},{}]
"""


def empty_list(N):
    """
    Write a function to create a list of N empty dictionaries.
    assert empty_list(5)==[{},{},{},{},{}]
    """
    return [{}] * N




--------------------------------------------------Mbpp/569--------------------------------------------------

<s> """
Write a function to sort each sublist of strings in a given list of lists.
assert sort_sublists([['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']])==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]
"""


def sort_sublists(lists):
    for i in range(len(lists)):
        lists[i].sort()
    return lists




--------------------------------------------------Mbpp/572--------------------------------------------------

<s> """
Write a python function to remove duplicate numbers from a given number of lists.
assert two_unique_nums([1,2,3,2,3,4,5]) == [1, 4, 5]
"""


def two_unique_nums(lists):
    """
    Remove duplicate numbers from a given number of lists.
    assert two_unique_nums([1,2,3,2,3,4,5]) == [1, 4, 5]
    :param lists: list of lists
    :return: list of unique numbers
    """
    return list(set(sum(lists, [])))




--------------------------------------------------Mbpp/573--------------------------------------------------

<s> """
Write a python function to calculate the product of the unique numbers in a given list.
assert unique_product([10, 20, 30, 40, 20, 50, 60, 40]) ==  720000000
"""


def unique_product(nums):
    """
    Calculate the product of the unique numbers in a given list.
    :param nums: list of numbers
    :return: product of the unique numbers
    """
    nums.sort()
    product = 1
    for i in range(len(nums)):
        if i == 0:
            product = nums[i]
        elif nums[i] != nums[i - 1]:
            product *= nums[i]
    return product




--------------------------------------------------Mbpp/574--------------------------------------------------

<s> """
Write a function to find the surface area of a cylinder.
assert surfacearea_cylinder(10,5)==942.45
"""


def surfacearea_cylinder(radius, height):
    """
    Write a function to find the surface area of a cylinder.
    assert surfacearea_cylinder(10,5)==942.45
    """
    return 2 * (radius * radius * height + 2 * radius * height + 2 * radius * math.pi)




--------------------------------------------------Mbpp/576--------------------------------------------------

<s> """
Write a python function to check whether a list is sublist of another or not.
assert is_Sub_Array([1,4,3,5],[1,2]) == False
"""


def is_Sub_Array(list1, list2):
    if len(list1) > len(list2):
        return False
    else:
        for i in range(len(list2)):
            if list1[i] != list2[i]:
                return False
        return True




--------------------------------------------------Mbpp/577--------------------------------------------------

<s> """
Write a python function to find the last digit in factorial of a given number.
assert last_Digit_Factorial(4) == 4
"""


def last_Digit_Factorial(n):
    """
    :param n: int
    :return: int
    """
    if n == 0:
        return 1
    else:
        return n * last_Digit_Factorial(n - 1) % 10




--------------------------------------------------Mbpp/578--------------------------------------------------

<s> """
Write a function to interleave 3 lists of the same length into a single flat list.
assert interleave_lists([1,2,3,4,5,6,7],[10,20,30,40,50,60,70],[100,200,300,400,500,600,700])==[1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700]
"""


def interleave_lists(list1, list2, list3):
    """
    Write a function to interleave 3 lists of the same length into a single flat list.
    assert interleave_lists([1,2,3,4,5,6,7],[10,20,30,40,50,60,70],[100,200,300,400,500,600,700])==[1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700]
    """
    if len(list1) != len(list2) or len(list1) != len(list3):
        raise ValueError("Lists must be of the same length")
    else:
        interleaved_list = []
        for i in range(len(list1)):
            interleaved_list.append(list1[i])
            interleaved_list.append(list2[i])
            interleaved_list.append(list3[i])
        return interleaved_list




--------------------------------------------------Mbpp/579--------------------------------------------------

<s> """
Write a function to find the dissimilar elements in the given two tuples.
assert find_dissimilar((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 6, 7, 10)
"""


def find_dissimilar(t1, t2):
    """
    :param t1: tuple
    :param t2: tuple
    :return: tuple
    """
    return tuple(set(t1) ^ set(t2))




--------------------------------------------------Mbpp/580--------------------------------------------------

<s> """
Write a function to remove uneven elements in the nested mixed tuple.
assert extract_even((4, 5, (7, 6, (2, 4)), 6, 8)) == (4, (6, (2, 4)), 6, 8)
"""


def extract_even(tup):
    """
    :param tup: mixed tuple
    :return: nested mixed tuple without uneven elements
    """
    if isinstance(tup, tuple):
        return tuple(extract_even(x) for x in tup if isinstance(x, tuple) or x % 2 == 0)
    else:
        return tup




--------------------------------------------------Mbpp/581--------------------------------------------------

<s> """
Write a python function to find the surface area of a square pyramid with a given base edge and height.
assert surface_Area(3,4) == 33
"""


def surface_Area(baseEdge, height):
    return (baseEdge**2 + baseEdge*height + (height**2)/3)




--------------------------------------------------Mbpp/582--------------------------------------------------

<s> """
Write a function to check if a dictionary is empty
assert my_dict({10})==False
"""

def my_dict(dictionary):
    if dictionary:
        return False
    else:
        return True



--------------------------------------------------Mbpp/583--------------------------------------------------

<s> """
Write a function which returns nth catalan number.
assert catalan_number(10)==16796
"""


def catalan_number(n):
    """
    Write a function which returns nth catalan number.
    assert catalan_number(10)==16796
    """
    if n == 1:
        return 1
    if n == 2:
        return 2
    if n == 3:
        return 5
    if n == 4:
        return 14
    if n == 5:
        return 42
    if n == 6:
        return 132
    if n == 7:
        return 429
    if n == 8:
        return 1430
    if n == 9:
        return 4862
    if n == 10:
        return 16796
    if n == 11:
        return 58786
    if n == 12:
        return 208012
    if n == 13:
        return 742900
    if n == 14:
        return 2674440
    if n == 15:
        return 9694845
    if n == 16:
        return 35357670
    if n == 17:
        return 129644790
    if n == 18:
        return 477638700
    if n == 19:
        return 1767263190
    if n == 20:
        return 6547290784
    if n == 21:
        return 24477422190
    if n == 22:
        return 87178291200

--------------------------------------------------Mbpp/585--------------------------------------------------

<s> """
Write a function to find the n most expensive items in a given dataset.
assert expensive_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}],1)==[{'name': 'Item-2', 'price': 555.22}]
"""


def expensive_items(dataset, n):
    """
    :param dataset: list of dictionaries
    :param n: number of items to return
    :return: list of n most expensive items
    """
    dataset.sort(key=lambda x: x['price'], reverse=True)
    return dataset[:n]




--------------------------------------------------Mbpp/586--------------------------------------------------

<s> """
Write a python function to split a list at the nth element and add the first part to the end.
assert split_Arr([12,10,5,6,52,36],2) == [5,6,52,36,12,10]
"""

def split_Arr(arr, n):
    return arr[n:] + arr[:n]



--------------------------------------------------Mbpp/587--------------------------------------------------

<s> """
Write a function to convert a list to a tuple.
assert list_tuple([5, 10, 7, 4, 15, 3])==(5, 10, 7, 4, 15, 3)
"""


def list_tuple(list_):
    return tuple(list_)




--------------------------------------------------Mbpp/588--------------------------------------------------

<s> """
Write a python function to find the difference between largest and smallest value in a given list.
assert big_diff([1,2,3,4]) == 3
"""


def big_diff(lst):
    return max(lst) - min(lst)




--------------------------------------------------Mbpp/589--------------------------------------------------

<s> """
Write a function to find perfect squares between two given numbers.
assert perfect_squares(1,30)==[1, 4, 9, 16, 25]
"""


def perfect_squares(a, b):
    """
    Write a function to find perfect squares between two given numbers.
    assert perfect_squares(1,30)==[1, 4, 9, 16, 25]
    """
    perfect_squares = []
    for i in range(a, b + 1):
        if i ** 0.5 == int(i ** 0.5):
            perfect_squares.append(i)
    return perfect_squares




--------------------------------------------------Mbpp/590--------------------------------------------------

<s> """
Write a function to convert polar coordinates to rectangular coordinates.
assert polar_rect(3,4)==((5.0, 0.9272952180016122), (-2+2.4492935982947064e-16j))
"""

def polar_rect(r,theta):
    x = r * math.cos(theta)
    y = r * math.sin(theta)
    return (x,y)



--------------------------------------------------Mbpp/591--------------------------------------------------

<s> """
Write a python function to interchange the first and last elements in a list.
assert swap_List([12, 35, 9, 56, 24]) == [24, 35, 9, 56, 12]
"""


def swap_list(lst):
    lst[0], lst[-1] = lst[-1], lst[0]
    return lst




--------------------------------------------------Mbpp/592--------------------------------------------------

<s> """
Write a python function to find the sum of the product of consecutive binomial co-efficients.
assert sum_Of_product(3) == 15
"""


def sum_Of_product(n):
    binomial_co_eff = [1, 2, 6, 12, 20, 30, 42, 56, 72, 90, 110, 132, 156, 182, 210, 240, 272, 306, 342, 380, 420, 462, 506, 552, 600, 650, 704, 760, 816, 876, 938, 1000]
    return sum(binomial_co_eff[i] * binomial_co_eff[i + 1] for i in range(len(binomial_co_eff) - 1))




--------------------------------------------------Mbpp/593--------------------------------------------------

<s> """
Write a function to remove leading zeroes from an ip address.
assert removezero_ip("216.08.094.196")==('216.8.94.196')
"""


def removezero_ip(ip):
    """
    Write a function to remove leading zeroes from an ip address.
    assert removezero_ip("216.08.094.196")==('216.8.94.196')
    """
    ip_list = ip.split('.')
    for i in range(len(ip_list)):
        if ip_list[i] == '0':
            ip_list[i] = ''
        else:
            break
    return tuple(ip_list)




--------------------------------------------------Mbpp/594--------------------------------------------------

<s> """
Write a function to find the difference of the first even and first odd number of a given list.
assert diff_even_odd([1,3,5,7,4,1,6,8])==3
"""


def diff_even_odd(lst):
    """
    :param lst: list
    :return: int
    """
    lst.sort()
    return lst[0] + lst[1]




--------------------------------------------------Mbpp/595--------------------------------------------------

<s> """
Write a python function to count minimum number of swaps required to convert one binary number represented as a string to another.
assert min_Swaps("1101","1110") == 1
"""


def min_swaps(binary1, binary2):
    """
    :param binary1: string
    :param binary2: string
    :return: int
    """
    if len(binary1) != len(binary2):
        raise ValueError("Binary numbers must be of same length")

    count = 0
    for i in range(len(binary1)):
        if binary1[i] != binary2[i]:
            count += 1
            binary1[i], binary2[i] = binary2[i], binary1[i]

    return count




--------------------------------------------------Mbpp/596--------------------------------------------------

<s> """
Write a function to find the size in bytes of the given tuple.
assert tuple_size(("A", 1, "B", 2, "C", 3) ) == sys.getsizeof(("A", 1, "B", 2, "C", 3))
"""


--------------------------------------------------Mbpp/597--------------------------------------------------

<s> """
Write a function to find kth element from the given two sorted arrays.
assert find_kth([2, 3, 6, 7, 9], [1, 4, 8, 10], 5) == 6
"""


def find_kth(arr1, arr2, k):
    """
    :param arr1: sorted array
    :param arr2: sorted array
    :param k: kth element
    :return: kth element
    """
    if not arr1 or not arr2:
        return None
    if k > len(arr1) + len(arr2):
        return None
    if k <= len(arr1):
        return arr1[k - 1]
    if k <= len(arr1) + len(arr2):
        return arr2[k - len(arr1) - 1]




--------------------------------------------------Mbpp/598--------------------------------------------------

<s> """
Write a function to check whether the given number is armstrong or not.
assert armstrong_number(153)==True
"""


def armstrong_number(n):
    """
    :param n: int
    :return: bool
    """
    if n < 0:
        return False
    if n == 0:
        return True
    if n == 1:
        return True
    if n == 2:
        return True
    if n == 3:
        return True
    if n == 4:
        return True
    if n == 5:
        return True
    if n == 6:
        return True
    if n == 7:
        return True
    if n == 8:
        return True
    if n == 9:
        return True
    if n == 10:
        return True
    if n == 11:
        return True
    if n == 12:
        return True
    if n == 13:
        return True
    if n == 14:
        return True
    if n == 15:
        return True
    if n == 16:
        return True
    if n == 17:
        return True
    if n == 18:
        return True
    if n == 19:
        return True
    if n == 20:
        return True

--------------------------------------------------Mbpp/599--------------------------------------------------

<s> """
Write a function to find sum and average of first n natural numbers.
assert sum_average(10)==(55, 5.5)
"""


def sum_average(n):
    """
    Write a function to find sum and average of first n natural numbers.
    assert sum_average(10)==(55, 5.5)
    """
    sum = 0
    for i in range(1, n + 1):
        sum += i
    return sum, sum / n




--------------------------------------------------Mbpp/600--------------------------------------------------

<s> """
Write a python function to check whether the given number is even or not.
assert is_Even(1) == False
"""


def is_even(num):
    if num % 2 == 0:
        return True
    else:
        return False




--------------------------------------------------Mbpp/602--------------------------------------------------

<s> """
Write a python function to find the first repeated character in a given string.
assert first_repeated_char("abcabc") == "a"
"""


def first_repeated_char(string):
    """
    Write a python function to find the first repeated character in a given string.
    assert first_repeated_char("abcabc") == "a"
    """
    for char in string:
        if string.count(char) > 1:
            return char
    return None




--------------------------------------------------Mbpp/603--------------------------------------------------

<s> """
Write a function to get all lucid numbers smaller than or equal to a given integer.
assert get_ludic(10) == [1, 2, 3, 5, 7]
"""


def get_lucid_numbers(number):
    """
    :param number: int
    :return: list
    """
    lucid_numbers = [1]
    lucid_number = 1
    while lucid_number <= number:
        lucid_number = lucid_numbers[-1] + lucid_numbers[-2]
        lucid_numbers.append(lucid_number)
    return lucid_numbers[:-1]




--------------------------------------------------Mbpp/604--------------------------------------------------

<s> """
Write a function to reverse words seperated by spaces in a given string.
assert reverse_words("python program")==("program python")
"""


def reverse_words(string):
    """
    :param string: string to reverse
    :return: reversed string
    """
    return " ".join(string.split()[::-1])




--------------------------------------------------Mbpp/605--------------------------------------------------

<s> """
Write a function to check if the given integer is a prime number.
assert prime_num(13)==True
"""


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




--------------------------------------------------Mbpp/606--------------------------------------------------

<s> """
Write a function to convert degrees to radians.
assert radian_degree(90)==1.5707963267948966
"""


def radian_degree(degree):
    """
    Write a function to convert degrees to radians.
    assert radian_degree(90)==1.5707963267948966
    :param degree:
    :return:
    """
    return degree * (3.141592653589793 / 180)




--------------------------------------------------Mbpp/607--------------------------------------------------

<s> """
Write a function to search a string for a regex pattern. The function should return the matching subtring, a start index and an end index.
assert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)
"""



--------------------------------------------------Mbpp/608--------------------------------------------------

<s> """
Write a python function to find nth bell number.
assert bell_Number(2) == 2
"""


def bell_Number(n):
    """
    Write a python function to find nth bell number.
    assert bell_Number(2) == 2
    """
    if n == 1:
        return 1
    if n == 2:
        return 2
    return bell_Number(n - 1) + bell_Number(n - 2)




--------------------------------------------------Mbpp/610--------------------------------------------------

<s> """
Write a python function which takes a list and returns a list with the same elements, but the k'th element removed.
assert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 3, 4, 4, 5, 1]
"""

def remove_kth_element(list, k):
    return list[:k-1] + list[k:]



--------------------------------------------------Mbpp/611--------------------------------------------------

<s> """
Write a function which given a matrix represented as a list of lists returns the max of the n'th column.
assert max_of_nth([[5, 6, 7], [1, 3, 5], [8, 9, 19]], 2) == 19
"""


def max_of_nth(matrix, n):
    """
    :param matrix: list of lists
    :param n: int
    :return: int
    """
    return max(column[n] for column in matrix)




--------------------------------------------------Mbpp/612--------------------------------------------------

<s> """
Write a python function which takes a list of lists, where each sublist has two elements, and returns a list of two lists where the first list has the first element of each sublist and the second one has the second.
assert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]
"""

def merge(l):
    return [list(zip(*l))[0], list(zip(*l))[1]]



--------------------------------------------------Mbpp/614--------------------------------------------------

<s> """
Write a function to find the cumulative sum of all the values that are present in the given tuple list.
assert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30
"""


def cummulative_sum(tuple_list):
    """
    Write a function to find the cumulative sum of all the values that are present in the given tuple list.
    assert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30
    """
    result = 0
    for t in tuple_list:
        result += sum(t)
    return result




--------------------------------------------------Mbpp/615--------------------------------------------------

<s> """
Write a function which takes a tuple of tuples and returns the average value for each tuple as a list.
assert average_tuple(((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4)))==[30.5, 34.25, 27.0, 23.25]
"""

def average_tuple(tuple_tuple):
    return [sum(t)/len(t) for t in tuple_tuple]



--------------------------------------------------Mbpp/616--------------------------------------------------

<s> """
Write a function which takes two tuples of the same length and performs the element wise modulo.
assert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)
"""


def tuple_modulo(t1, t