evalplus/evalplus_results/mbpp/home--aiscuser--fhw--model_weights--deepseek-coder-6.7b-instruct_vllm_temp_0.0.raw.jsonl

{"task_id": "Mbpp/2", "solution": "def similar_elements(list1, list2):\n    return set(list1)).intersection(set(list2))\n\n# Test the function\nassert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == set((4, 5))"}
{"task_id": "Mbpp/3", "solution": "def is_not_prime(n):\n    if n <= 1:\n        return True\n    elif n <= 3:\n        return False\n    elif n % 2 == 0 or n % 3 == 0:\n        return True\n    i = 5\n    while i * i <= n:\n        if n % i == 0 or n % (i + 2) == 0:\n            return True\n        i += 6\n    return False\n\n# Test cases\nassert is_not_prime(2) == False\nassert is_not_prime(3) == False\nassert is_not_prime(4) == True\nassert is_not_prime(9) == True\nassert is_not_prime(15) == True\nassert is_not_prime(21) == True\nassert is_not_prime(25) == True\nassert is_not_prime(27) == True\nassert is_not_prime(31) == False"}
{"task_id": "Mbpp/4", "solution": "import heapq\n\ndef heap_queue_largest(nums, n):\n    return heapq.nlargest(n, nums)\n\n# Test the function\nassert heap_queue_largest([25, 35, 22, 85, 14, 65, 75, 22, 58], 3) == [85, 75, 65]"}
{"task_id": "Mbpp/6", "solution": "def differ_At_One_Bit_Pos(x, y):\n    return bin(x ^ y).count('1') == 1\n\n# Test cases"}
{"task_id": "Mbpp/7", "solution": "def find_char_long(s):\n    return [word for word in s.split() if len(word) >= 4]\n\nassert set(find_char_long('Please move back to stream')) == set(['Please', 'move', 'back', 'stream'])"}
{"task_id": "Mbpp/8", "solution": "def square_nums(nums):\n    return [num ** 2 for num in nums]\n\nassert square_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"}
{"task_id": "Mbpp/9", "solution": "def find_Rotations(s: str) -> int:\n    n = len(s)\n    for i in range(1, n):\n        if s[i:] + s[:i] == s:\n            return i\n    return n\n\n# Test cases\nassert find_Rotations(\"aaaa\") == 1\nassert find_Rotations(\"abcde\") == 5\nassert find_Rotations(\"abcd\") == 4\nassert find_Rotations(\"aaaab\") == 1\nassert find_Rotations(\"baab\") == 2"}
{"task_id": "Mbpp/11", "solution": "def remove_Occ(s, ch):\n    first_occurrence = s.find(ch)\n    if first_occurrence != -1:\n        last_occurrence = s.rfind(ch)\n        return s[:first_occurrence] + s[last_occurrence+1:]\n    return s\n\n# Test the function\nassert remove_Occ(\"hello\",\"l\") == \"heo\""}
{"task_id": "Mbpp/12", "solution": "def sort_matrix(matrix):\n    return sorted(matrix, key=sum)\n\n# Test the function\nassert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]]) == [[1, 1, 1], [1, 2, 3], [2, 4, 5]]"}
{"task_id": "Mbpp/14", "solution": "def find_Volume(base, height, length):\n    # calculate the volume of a triangular prism\n    volume = (base * height * length) // 2\n    return volume\n\n# test the function\nassert find_Volume(10,8,6) == 240"}
{"task_id": "Mbpp/16", "solution": "def text_lowercase_underscore(s):\n    # Split the string into words\n    words = s.split(\"_\")\n\n    # Check if all words are lowercase\n    for word in words:\n        if not word.islower():\n            return False\n\n    # If all words are lowercase, return True\n    return True\n\n# Test the function\nassert text_lowercase_underscore(\"aab_cbbbc\") == True"}
{"task_id": "Mbpp/17", "solution": "def square_perimeter(side_length):\n    return 4 * side_length\n\n# Test the function\nassert square_perimeter(10) == 40"}
{"task_id": "Mbpp/18", "solution": "def remove_dirty_chars(s1, s2):\n    return ''.join([char for char in s1 if char not in s2])\n\n# Test the function\nassert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'"}
{"task_id": "Mbpp/19", "solution": "def test_duplicate(arr):\n    return len(arr) != len(set(arr))\n\n# Test cases"}
{"task_id": "Mbpp/20", "solution": "def is_woodall(n):\n    # A number is a Woodall number if it is a power of 2 minus 1\n    # So, we just need to check if n is a power of 2\n    if n <= 0:\n        return False\n    while n % 2 == 0:\n        n = n // 2\n    return n == 1\n\n# Test the function\nassert is_woodall(383) == True"}
{"task_id": "Mbpp/56", "solution": "def check(n):\n    # Convert the number to string to reverse it\n    str_n = str(n)\n    # Reverse the string\n    reversed_str_n = str_n[::-1]\n    # Convert the reversed string back to integer\n    reversed_n = int(reversed_str_n)\n    # Check if the number is one less than twice its reverse\n    return n == (2 * reversed_n) - 1\n\n# Test the function\nassert check(70) == False"}
{"task_id": "Mbpp/57", "solution": "def find_Max_Num(lst):\n    # Convert each element in the list to string\n    str_lst = [str(i) for i in lst]\n    # Sort the list in descending order\n    str_lst.sort(reverse=True)\n    # Join the elements in the list to form a string and convert it to integer\n    max_num = int(''.join(str_lst))\n    return max_num\n\n# Test the function\nassert find_Max_Num([1,2,3]) == 321"}
{"task_id": "Mbpp/58", "solution": "def opposite_Signs(num1, num2):\n    return (num1 ^ num2) < 0\n\n# Test the function\nassert opposite_Signs(1,-2) == True"}
{"task_id": "Mbpp/59", "solution": "def nth_octagonal(n):\n    return n*(3*n-2)\n\ndef is_octagonal(n):\n    return nth_octagonal(n)\n\n# Test cases\nassert is_octagonal(1) == 1\nassert is_octagonal(2) == 8\nassert is_octagonal(3) == 19\nassert is_octagonal(4) == 33\nassert is_octagonal(5) == 50"}
{"task_id": "Mbpp/61", "solution": "def count_Substrings(s):\n    count = 0\n    for length in range(1, len(s) + 1):\n        for start in range(0, len(s)):\n            if start + length > len(s):\n                break\n            substring = s[start:start + length]\n            if sum(int(digit) for digit in substring) == length:\n                count += 1\n    return count\n\n# Test the function\nassert count_Substrings('112112') == 6"}
{"task_id": "Mbpp/62", "solution": "def smallest_num(lst):\n    return min(lst)\n\n# Test the function\nassert smallest_num([10, 20, 1, 45, 99]) == 1"}
{"task_id": "Mbpp/63", "solution": "def max_difference(tuples):\n    max_diff = 0\n    for i in range(len(tuples)):\n        for j in range(i+1, len(tuples)):\n            diff = abs(tuples[i][0] - tuples[j][1])\n            if diff > max_diff:\n                max_diff = diff\n    return max_diff\n\n# Test the function\nassert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7"}
{"task_id": "Mbpp/64", "solution": "def sort_tuples(tuples):\n    return sorted(tuples, key=lambda x: x[1])\n\ndef test_sort_tuples():\n    assert sort_tuples([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]) == [('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]\n    print(\"All tests pass\")\n\ntest_sort_tuples()"}
{"task_id": "Mbpp/65", "solution": "def recursive_list_sum(lst):\n    total = 0\n    for element in lst:\n        if type(element) is list:\n            total += recursive_list_sum(element)\n        else:\n            total += element\n    return total\n\n# Test the function\nassert recursive_list_sum([1, 2, [3,4],[5,6]]) == 21"}
{"task_id": "Mbpp/66", "solution": "def pos_count(lst):\n    count = 0\n    for num in lst:\n        if num > 0:\n            count += 1\n    return count\n\n# Test the function\nassert pos_count([1,-2,3,-4]) == 2"}
{"task_id": "Mbpp/67", "solution": "def bell_number(n):\n    bell = [[0 for i in range(n+1)] for j in range(n+1)]\n    bell[0][0] = 1\n    for i in range(1, n+1):\n        bell[i][0] = bell[i-1][i-1]\n        for j in range(1, i+1):\n            bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n    return bell[n][0]\n\n# Test the function\nassert bell_number(2)==2"}
{"task_id": "Mbpp/68", "solution": "def is_Monotonic(arr):\n    return all(arr[i] <= arr[i + 1] for i in range(len(arr) - 1)) or all(arr[i] >= arr[i + 1] for i in range(len(arr) - 1))\n\n# Test cases"}
{"task_id": "Mbpp/69", "solution": "def is_sublist(main_list, sublist):\n    return sublist in main_list\n\n# Test cases"}
{"task_id": "Mbpp/70", "solution": "def get_equal(tuples):\n    length = len(tuples[0])\n    for t in tuples:\n        if len(t) != length:\n            return False\n    return True\n\n# Test the function\nassert get_equal([(11, 22, 33), (44, 55, 66)]) == True"}
{"task_id": "Mbpp/71", "solution": "def comb_sort(lst):\n    gap = len(lst)\n    shrink = 1.3\n    sorted = False\n\n    while not sorted:\n        gap = int(gap / shrink)\n        if gap <= 1:\n            gap = 1\n            sorted = True\n        i = 0\n        while i + gap < len(lst):\n            if lst[i] > lst[i + gap]:\n                lst[i], lst[i + gap] = lst[i + gap], lst[i]\n            i += 1\n    return lst\n\n# Test the function\nassert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]"}
{"task_id": "Mbpp/72", "solution": "def dif_Square(n):\n    i = 0\n    while i*i <= n:\n        j = 0\n        while j*j <= n:\n            if i*i - j*j == n:\n                return True\n            j += 1\n        i += 1\n    return False\n\n# Test cases"}
{"task_id": "Mbpp/74", "solution": "def is_samepatterns(patterns1, patterns2):\n    return patterns1 == patterns2\n\n# Test the function"}
{"task_id": "Mbpp/75", "solution": "def find_tuples(tuples_list, k):\n    result = []\n    for tup in tuples_list:\n        if all(i % k == 0 for i in tup):\n            result.append(tup)\n    return result\n\n# Test the function\nassert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == [(6, 24, 12)]"}
{"task_id": "Mbpp/77", "solution": "def is_divisible_by_11(n):\n    return n % 11 == 0\n\n# Test cases\nassert is_divisible_by_11(12345) == False"}
{"task_id": "Mbpp/79", "solution": "def word_len(word):\n    return len(word) % 2 == 1\n\n# Test cases\nassert word_len(\"Hadoop\") == False"}
{"task_id": "Mbpp/80", "solution": "def tetrahedral_number(n):\n    return n * (n + 1) * (n + 2) // 6\n\n# Test the function\nassert tetrahedral_number(5) == 35"}
{"task_id": "Mbpp/82", "solution": "import math\n\ndef volume_sphere(radius):\n    return (4/3) * math.pi * radius**3\n\nassert math.isclose(volume_sphere(10), 4188.790204786391, rel_tol=0.001)"}
{"task_id": "Mbpp/84", "solution": "def newman_conway(n):\n    if n == 1:\n        return \"1\"\n    if n == 2:\n        return \"1 1\"\n    sequence = [1, 1]\n    for i in range(2, n):\n        sequence.append(sequence[sequence[i-1]-1] + sequence[i-sequence[i-1]])\n    return ' '.join(map(str, sequence))\n\ndef sequence(n):\n    return int(newman_conway(n).split()[-1])\n\n# Test the function\nassert sequence(10) == 6"}
{"task_id": "Mbpp/85", "solution": "import math\n\ndef surfacearea_sphere(radius):\n    return 4 * math.pi * radius ** 2\n\n# Test the function\nassert math.isclose(surfacearea_sphere(10), 1256.6370614359173, rel_tol=0.001)"}
{"task_id": "Mbpp/86", "solution": "def centered_hexagonal_number(n):\n    return n*(7*n-5)//2 + 1\n\n# Test the function\nassert centered_hexagonal_number(10) == 271"}
{"task_id": "Mbpp/87", "solution": "def merge_dictionaries_three(dict1, dict2, dict3):\n    merged_dict = {**dict1, **dict2, **dict3}\n    return merged_dict\n\n# Test the function\ndict1 = { \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }\ndict2 = { \"G\": \"Green\", \"W\": \"White\" }\ndict3 = { \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" }\n\nassert merge_dictionaries_three(dict1, dict2, dict3)=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}"}
{"task_id": "Mbpp/88", "solution": "def freq_count(lst):\n    freqs = {}\n    for item in lst:\n        if item in freqs:\n            freqs[item] += 1\n        else:\n            freqs[item] = 1\n    return freqs\n\n# Test the function\nassert freq_count([10,10,10,10,20,20,20,20,40,40,50,50,30])==({10: 4, 20: 4, 40: 2, 50: 2, 30: 1})"}
{"task_id": "Mbpp/89", "solution": "def closest_num(n):\n    # Convert the number to a string\n    num_str = str(n)\n    # Split the string into a list of characters\n    num_list = list(num_str)\n    # Iterate over the list from the end to the beginning\n    for i in range(len(num_list) - 1, -1, -1):\n        # If the current digit is greater than the next one\n        if num_list[i] > num_list[i - 1]:\n            # Decrease the next digit by 1\n            num_list[i - 1] = str(int(num_list[i - 1]) - 1)\n            # Set the current digit to 9\n            num_list[i] = '9'\n    # If the first digit is 0, remove it\n    if num_list[0] == '0':\n        num_list = num_list[1:]\n    # Join the list back into a string\n    result_str = ''.join(num_list)\n    # Convert the string back to an integer\n    result = int(result_str)\n    return result\n\n# Test the function\nassert closest_num(11) == 10"}
{"task_id": "Mbpp/90", "solution": "def len_longest_word(words):\n    return max(len(word) for word in words)\n\nassert len_longest_word([\"python\",\"PHP\",\"bigdata\"]) == 7"}
{"task_id": "Mbpp/91", "solution": "def find_substring(lst, substr):\n    for item in lst:\n        if substr in item:\n            return True\n    return False\n\n# Test the function\nassert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True"}
{"task_id": "Mbpp/92", "solution": "def is_undulating(n):\n    n = str(n)\n    if len(n) < 3:\n        return False\n    diff1 = int(n[1]) - int(n[0])\n    for i in range(2, len(n)):\n        diff = int(n[i]) - int(n[i-1])\n        if diff != diff1:\n            return False\n        diff1 = diff\n    return True\n\n# Test cases"}
{"task_id": "Mbpp/93", "solution": "def power(a, b):\n    return a ** b\n\n# Test the function\nassert power(3, 4) == 81"}
{"task_id": "Mbpp/94", "solution": "def index_minimum(lst):\n    return min(lst, key=lambda x: x[1])[0]\n\nassert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'"}
{"task_id": "Mbpp/95", "solution": "def Find_Min_Length(lst):\n    return min(len(sub_lst) for sub_lst in lst)\n\n# Test the function\nassert Find_Min_Length([[1],[1,2]]) == 1"}
{"task_id": "Mbpp/96", "solution": "def divisor(n):\n    count = 0\n    for i in range(1, n + 1):\n        if n % i == 0:\n            count += 1\n    return count\n\nassert divisor(15) == 4"}
{"task_id": "Mbpp/97", "solution": "def flatten(lst):\n    return [item for sublist in lst for item in sublist]\n\ndef frequency_lists(lst):\n    flattened_list = flatten(lst)\n    frequency_dict = {}\n    for i in flattened_list:\n        if i in frequency_dict:\n            frequency_dict[i] += 1\n        else:\n            frequency_dict[i] = 1\n    return frequency_dict\n\n# Test the function\nassert frequency_lists([[1, 2, 3, 2], [4, 5, 6, 2], [7, 8, 9, 5]])=={1: 1, 2: 3, 3: 1, 4: 1, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1}"}
{"task_id": "Mbpp/98", "solution": "def multiply_num(lst):\n    if len(lst) == 0:\n        return 0\n    product = 1\n    for num in lst:\n        product *= num\n    return product / len(lst)\n\nimport math\nassert math.isclose(multiply_num((8, 2, 3, -1, 7)), -67.2, rel_tol=0.001)"}
{"task_id": "Mbpp/99", "solution": "def decimal_to_binary(n):\n    return bin(n).replace(\"0b\", \"\")\n\n# Test the function\nassert decimal_to_binary(8) == '1000'"}
{"task_id": "Mbpp/100", "solution": "def next_smallest_palindrome(n):\n    while True:\n        n += 1\n        if str(n) == str(n)[::-1]:  # Check if the number is a palindrome\n            return n\n\n# Test the function\nassert next_smallest_palindrome(99) == 101"}
{"task_id": "Mbpp/101", "solution": "def kth_element(arr, k):\n    \"\"\"\n    This function takes in a list and an integer k as arguments.\n    It returns the kth element in the list using 1-based indexing.\n    \"\"\"\n    return arr[k-1]\n\n# Test the function\nassert kth_element([12,3,5,7,19], 2) == 3"}
{"task_id": "Mbpp/102", "solution": "def snake_to_camel(snake_str):\n    components = snake_str.split('_')\n    return ''.join(x.title() for x in components)\n\nassert snake_to_camel('python_program') == 'PythonProgram'"}
{"task_id": "Mbpp/103", "solution": "def eulerian_num(n, m):\n    if m == 0 or m == n:\n        return 1\n    if n == 0:\n        return 0\n    return eulerian_num(n - 1, m) + eulerian_num(n, m - 1)\n\n# Test cases\nassert eulerian_num(3, 1) == 4"}
{"task_id": "Mbpp/104", "solution": "def sort_sublists(lst):\n    return [sorted(sublist) for sublist in lst]\n\n# Test the function\nassert sort_sublists([[\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]]) == [['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]"}
{"task_id": "Mbpp/105", "solution": "def count(lst):\n    return sum(lst)\n\nassert count([True, False, True]) == 2"}
{"task_id": "Mbpp/106", "solution": "def add_lists(lst, tpl):\n    return tpl + tuple(lst)\n\n# Test the function\nassert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)"}
{"task_id": "Mbpp/108", "solution": "def merge_sorted_list(list1, list2, list3):\n    # Merge the lists\n    merged_list = list1 + list2 + list3\n    # Sort the merged list\n    merged_list.sort()\n    return merged_list\n\n# Test the function\nassert merge_sorted_list([25, 24, 15, 4, 5, 29, 110],[19, 20, 11, 56, 25, 233, 154],[24, 26, 54, 48])==[4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233]"}
{"task_id": "Mbpp/109", "solution": "def odd_Equivalent(binary_string, rotations):\n    # Create a list to store the binary strings after each rotation\n    rotated_strings = []\n\n    # Perform the rotations\n    for _ in range(rotations):\n        binary_string = binary_string[-1:] + binary_string[:-1]\n        rotated_strings.append(binary_string)\n\n    # Count the number of odd equivalent binary strings\n    count = 0\n    for string in rotated_strings:\n        if int(string, 2) % 2 != 0:\n            count += 1\n\n    return count\n\n# Test the function\nassert odd_Equivalent(\"011001\", 6) == 3"}
{"task_id": "Mbpp/111", "solution": "def common_in_nested_lists(nested_lists):\n    # Convert the first list to a set\n    common_set = set(nested_lists[0])\n\n    # Iterate over the rest of the lists\n    for lst in nested_lists[1:]:\n        # Update the common set with the intersection of the current list and the common set\n        common_set = common_set.intersection(set(lst))\n\n    # Convert the common set back to a list and return it\n    return list(common_set)\n\n# Test the function\nassert set(common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])) == set([18, 12])"}
{"task_id": "Mbpp/113", "solution": "def check_integer(s):\n    try:\n        int(s)\n        return True\n    except ValueError:\n        return False\n\n# Test cases"}
{"task_id": "Mbpp/116", "solution": "def tuple_to_int(tup):\n    return int(''.join(map(str, tup)))\n\n# Test the function\nassert tuple_to_int((1,2,3))==123"}
{"task_id": "Mbpp/118", "solution": "def string_to_list(s):\n    return s.split(\" \")\n\n# Test the function\nassert string_to_list(\"python programming\") == ['python','programming']"}
{"task_id": "Mbpp/119", "solution": "def search(nums):\n    left, right = 0, len(nums) - 1\n    while left < right:\n        mid = (left + right) // 2\n        if nums[mid] == nums[mid ^ 1]:\n            left = mid + 1\n        else:\n            right = mid\n    return nums[left]\n\nassert search([1,1,2,2,3]) == 3"}
{"task_id": "Mbpp/120", "solution": "def max_product_tuple(lst):\n    max_product = float('-inf')\n    for tup in lst:\n        product = abs(tup[0] * tup[1])\n        if product > max_product:\n            max_product = product\n    return max_product\n\n# Test the function\nassert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)]) == 36"}
{"task_id": "Mbpp/123", "solution": "def d(n):\n    \"\"\"\n    Function to calculate the sum of proper divisors of a number\n    \"\"\"\n    sum = 1\n    i = 2\n    while i * i <= n:\n        if n % i:\n            i += 1\n        else:\n            if i * (n // i) == n:\n                sum = sum + i + n//i\n            else:\n                sum = sum + i\n            i += 1\n    return sum\n\ndef amicable_numbers_sum(limit):\n    \"\"\"\n    Function to calculate the sum of all amicable numbers up to a specified limit\n    \"\"\"\n    sum = 0\n    for i in range(1, limit):\n        if d(d(i)) == i and d(i) != i:\n            sum += i\n    return sum\n\n# Test the function\nassert amicable_numbers_sum(999) == 504"}
{"task_id": "Mbpp/124", "solution": "import cmath\nimport math\n\ndef angle_complex(z):\n    \"\"\"\n    This function calculates the angle of a complex number.\n    \"\"\"\n    return cmath.phase(z)\n\n# Testing the function\nassert math.isclose(angle_complex(0+1j), 1.5707963267948966, rel_tol=0.001)"}
{"task_id": "Mbpp/125", "solution": "def find_length(binary_string):\n    max_diff = 0\n    count_zero = 0\n    count_one = 0\n\n    for char in binary_string:\n        if char == '0':\n            count_zero += 1\n        else:\n            count_one += 1\n        diff = count_one - count_zero\n        if diff > max_diff:\n            max_diff = diff\n    return max_diff\n\n# Test the function\nassert find_length(\"11000010001\") == 6"}
{"task_id": "Mbpp/126", "solution": "def sum_common_divisors(num1, num2):\n    def get_divisors(n):\n        divisors = [1]\n        for i in range(2, n // 2 + 1):\n            if n % i == 0:\n                divisors.append(i)\n        divisors.append(n)\n        return divisors\n\n    return sum(set(get_divisors(num1)) & set(get_divisors(num2)))\n\n# Test the function\nassert sum_common_divisors(10, 15) == 6"}
{"task_id": "Mbpp/127", "solution": "def multiply_int(a, b):\n    return a * b\n\n# Test the function\nassert multiply_int(10, 20) == 200"}
{"task_id": "Mbpp/128", "solution": "def long_words(n, sentence):\n    words = sentence.split()\n    long_words = [word for word in words if len(word) > n]\n    return long_words\n\n# Test the function\nassert long_words(3, \"python is a programming language\") == ['python','programming','language']"}
{"task_id": "Mbpp/129", "solution": "def magic_square_test(matrix):\n    # Get the size of the matrix\n    size = len(matrix)\n\n    # Calculate the sum of the first row\n    magic_constant = sum(matrix[0])\n\n    # Check rows\n    for row in matrix:\n        if sum(row) != magic_constant:\n            return False\n\n    # Check columns\n    for i in range(size):\n        if sum(row[i] for row in matrix) != magic_constant:\n            return False\n\n    # Check diagonals\n    if sum(matrix[i][i] for i in range(size)) != magic_constant:\n        return False\n    if sum(matrix[i][size - i - 1] for i in range(size)) != magic_constant:\n        return False\n\n    # If all checks pass, the matrix is a magic square\n    return True\n\n# Test the function\nassert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]]) == True"}
{"task_id": "Mbpp/130", "solution": "def max_occurrences(lst):\n    # Create a dictionary to store the frequency of each item\n    freq_dict = {}\n    for item in lst:\n        if item in freq_dict:\n            freq_dict[item] += 1\n        else:\n            freq_dict[item] = 1\n\n    # Find the item with maximum frequency\n    max_freq_item = max(freq_dict, key=freq_dict.get)\n    return max_freq_item\n\n# Test the function\nassert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2])==2"}
{"task_id": "Mbpp/131", "solution": "def reverse_vowels(s):\n    vowels = \"aeiouAEIOU\"\n    vowels_in_s = [c for c in s if c in vowels]\n    return \"\".join(vowels_in_s[::-1] + [c for c in s if c not in vowels])\n\n# Test cases\nassert reverse_vowels(\"Python\") == \"Ptyhon\"\nassert reverse_vowels(\"Jupyter\") == \"Jeupytr\"\nassert reverse_vowels(\"Data Science\") == \"Dita Scenec\""}
{"task_id": "Mbpp/132", "solution": "def tup_string(tup):\n    return ''.join(tup)\n\n# Test the function\nassert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's')) == \"exercises\""}
{"task_id": "Mbpp/133", "solution": "def sum_negativenum(numbers):\n    return sum(num for num in numbers if num < 0)\n\n# Test the function\nassert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17]) == -32"}
{"task_id": "Mbpp/135", "solution": "def hexagonal_num(n):\n    return n*(2*n-1)\n\n# Test the function\nassert hexagonal_num(10) == 190"}
{"task_id": "Mbpp/137", "solution": "def zero_count(arr):\n    zero_count = arr.count(0)\n    non_zero_count = len(arr) - zero_count\n    return zero_count / non_zero_count\n\nimport math\nassert math.isclose(zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8]), 0.181818, rel_tol=0.001)"}
{"task_id": "Mbpp/138", "solution": "def is_Sum_Of_Powers_Of_Two(n):\n    if n < 0:\n        return False\n    while n > 0:\n        if n % 2 == 1:\n            n -= 1\n        else:\n            n /= 2\n    return n == 0\n\n# Test cases"}
{"task_id": "Mbpp/139", "solution": "import math\n\ndef circle_circumference(radius):\n    return 2 * math.pi * radius\n\n# Testing the function\nassert math.isclose(circle_circumference(10), 62.830000000000005, rel_tol=0.001)"}
{"task_id": "Mbpp/140", "solution": "def extract_singly(lst):\n    result = []\n    for sublist in lst:\n        for item in sublist:\n            result.append(item)\n    return result\n\nassert set(extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)])) == set([3, 4, 5, 7, 1])"}
{"task_id": "Mbpp/141", "solution": "def pancake_sort(lst):\n    for i in range(len(lst), 0, -1):\n        max_idx = lst.index(max(lst[:i]))\n        if max_idx != i - 1:\n            if max_idx != 0:\n                lst[:i] = lst[max_idx::-1] + lst[i:]\n            lst[:i] = lst[i - 1::-1] + lst[i:]\n    return lst\n\nassert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]"}
{"task_id": "Mbpp/142", "solution": "def count_samepair(list1, list2, list3):\n    count = 0\n    for i in range(len(list1)):\n        if list1[i] == list2[i] == list3[i]:\n            count += 1\n    return count\n\n# Test the function\nassert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,9],[2,1,3,1,2,6,7,9]) == 3"}
{"task_id": "Mbpp/145", "solution": "def max_Abs_Diff(arr):\n    return max(abs(a - b) for a, b in zip(arr, arr[1:]))\n\n# Test the function\nassert max_Abs_Diff((2,1,5,3)) == 4"}
{"task_id": "Mbpp/160", "solution": "def find_solution(a, b, n):\n    for x in range(n+1):\n        for y in range(n+1):\n            if a*x + b*y == n:\n                return (x, y)\n    return None\n\n# Test cases"}
{"task_id": "Mbpp/161", "solution": "def remove_elements(lst1, lst2):\n    return [i for i in lst1 if i not in lst2]\n\nassert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 4, 6, 8]) == [1, 3, 5, 7, 9, 10]"}
{"task_id": "Mbpp/162", "solution": "def sum_series(n):\n    total = 0\n    while n > 0:\n        total += n\n        n -= 2\n    return total\n\n# Test the function\nassert sum_series(6) == 12"}
{"task_id": "Mbpp/165", "solution": "def count_char_position(s):\n    s = s.lower()\n    return sum(1 for i in range(len(s)) if s[i] == chr(97 + i))\n\n# Test cases\nassert count_char_position(\"xbcefg\") == 2\nassert count_char_position(\"abcde\") == 5\nassert count_char_position(\"Xbcefg\") == 2\nassert count_char_position(\"\") == 0\nassert count_char_position(\"abcd\") == 4"}
{"task_id": "Mbpp/166", "solution": "def find_even_pair(lst):\n    count = 0\n    for i in range(len(lst)):\n        for j in range(i+1, len(lst)):\n            if lst[i] ^ lst[j] % 2 == 0:\n                count += 1\n    return count\n\n# Test the function\nassert find_even_pair([5, 4, 7, 2, 1]) == 4"}
{"task_id": "Mbpp/167", "solution": "def next_power_of_2(n):\n    if n <= 0:\n        return 1\n    else:\n        return 2 ** (n - 1).bit_length()\n\n# Test cases\nassert next_power_of_2(0) == 1\nassert next_power_of_2(1) == 2\nassert next_power_of_2(2) == 4\nassert next_power_of_2(3) == 8\nassert next_power_of_2(4) == 8\nassert next_power_of_2(5) == 16\nassert next_power_of_2(6) == 16\nassert next_power_of_2(7) == 32\nassert next_power_of_2(8) == 32\nassert next_power_of_2(9) == 64\nassert next_power_of_2(10) == 64"}
{"task_id": "Mbpp/168", "solution": "def frequency(lst, num):\n    return lst.count(num)\n\n# Test cases"}
{"task_id": "Mbpp/170", "solution": "def sum_range_list(lst, start, end):\n    return sum(lst[start:end+1])\n\n# Test the function\nassert sum_range_list([2,1,5,6,8,3,4,9,10,11,8,12], 8, 10) == 29"}
{"task_id": "Mbpp/171", "solution": "def perimeter_pentagon(side_length):\n    return 5 * side_length\n\n# Test the function\nassert perimeter_pentagon(5) == 25"}
{"task_id": "Mbpp/172", "solution": "def count_occurance(s):\n    return s.count('std')\n\n# Test the function\nassert count_occurance(\"letstdlenstdporstd\") == 3"}
{"task_id": "Mbpp/222", "solution": "def check_type(tup):\n    return all(isinstance(x, type(tup[0])) for x in tup)\n\n# Test cases"}
{"task_id": "Mbpp/223", "solution": "def is_majority(arr, n, elm):\n    count = arr.count(elm)\n    if count > n / 2:\n        return True\n    else:\n        return False\n\n# Test the function\nassert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True"}
{"task_id": "Mbpp/224", "solution": "def count_Set_Bits(n):\n    return bin(n).count('1')\n\n# Test the function\nassert count_Set_Bits(2) == 1"}
{"task_id": "Mbpp/226", "solution": "def odd_values_string(s):\n    return s[::2]\n\nassert odd_values_string('abcdef') == 'ace'"}
{"task_id": "Mbpp/227", "solution": "def min_of_three(a, b, c):\n    return min(a, b, c)\n\n# Test the function\nassert min_of_three(10,20,0)==0"}
{"task_id": "Mbpp/230", "solution": "def replace_blank(s, c):\n    return s.replace(' ', c)\n\n# Test the function\nassert replace_blank(\"hello people\",'@')==(\"hello@people\")"}
{"task_id": "Mbpp/232", "solution": "def larg_num(lst, n):\n    # Sort the list in descending order\n    lst.sort(reverse=True)\n    # Return the first n elements\n    return lst[:n]\n\n# Test the function\nassert set(larg_num([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100], 2)) == set([100, 90])"}
{"task_id": "Mbpp/233", "solution": "import math\n\ndef lateral_surface_cylinder(radius, height):\n    return 2 * math.pi * radius * height\n\n# Test the function\nassert math.isclose(lateral_surface_cylinder(10,5), 314.15000000000003, rel_tol=0.001)"}
{"task_id": "Mbpp/234", "solution": "def volume_cube(side_length):\n    \"\"\"\n    This function calculates the volume of a cube given its side length.\n    \"\"\"\n    return side_length ** 3\n\n# Test the function\nassert volume_cube(3) == 27"}
{"task_id": "Mbpp/235", "solution": "def even_bit_set_number(n):\n    binary = bin(n)[2:]  # Convert to binary and remove '0b' prefix\n    binary = '0' + binary  # Add leading zero to make it 1-indexed\n    binary = list(binary)  # Convert to list for easy manipulation\n\n    for i in range(0, len(binary), 2):  # Go through every even index\n        binary[i] = '1'  # Set bit to 1\n\n    return int(''.join(binary), 2)  # Convert back to integer and return\n\n# Test the function\nassert even_bit_set_number(10) == 10"}
{"task_id": "Mbpp/237", "solution": "def check_occurences(lst):\n    count_dict = {}\n    for tup in lst:\n        if tup in count_dict:\n            count_dict[tup] += 1\n        else:\n            count_dict[tup] = 1\n    return count_dict\n\n# Test the function\nassert check_occurences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)]) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}"}
{"task_id": "Mbpp/238", "solution": "def number_of_substrings(s):\n    n = len(s)\n    return n * (n + 1) // 2\n\n# Test the function\nassert number_of_substrings(\"abc\") == 6"}
{"task_id": "Mbpp/239", "solution": "def get_total_number_of_sequences(m, n):\n    # Initialize a list to store the sequences\n    sequences = [[[i]] for i in range(1, min(m, n) + 1)]\n\n    # Iterate over the length of the sequences\n    for j in range(1, n):\n        # Iterate over the possible starting numbers\n        for i in range(1, m + 1):\n            # Iterate over the sequences of length j\n            for seq in sequences[j - 1]:\n                # If the last number in the sequence is less than i, add a new sequence\n                if seq[-1] < i:\n                    sequences[j].append(seq + [i])\n\n    # Return the total number of sequences\n    return len(sequences[-1])\n\n# Test the function\nassert get_total_number_of_sequences(10, 4) == 4"}
{"task_id": "Mbpp/240", "solution": "def replace_list(list1, list2):\n    list1[-1:] = list2\n    return list1\n\n# Test the function\nassert replace_list([1, 3, 5, 7, 9, 10],[2, 4, 6, 8])==[1, 3, 5, 7, 9, 2, 4, 6, 8]"}
{"task_id": "Mbpp/242", "solution": "def count_charac(string):\n    return len(string)\n\n# Test the function\nassert count_charac(\"python programming\") == 18"}
{"task_id": "Mbpp/244", "solution": "def next_Perfect_Square(n):\n    # Calculate the square root of the given number\n    root = n ** 0.5\n\n    # If the square root is not an integer, increment it by 1\n    if not root.is_integer():\n        root = int(root) + 1\n    else:\n        root = int(root)\n\n    # Return the square of the root\n    return root ** 2\n\n# Test the function\nassert next_Perfect_Square(35) == 36"}
{"task_id": "Mbpp/245", "solution": "def max_sum(arr):\n    n = len(arr)\n    if n < 3:\n        return sum(arr)\n\n    # Initialize variables\n    inc = [0]*n\n    dec = [0]*n\n\n    # Calculate increasing subsequence values\n    for i in range(1, n):\n        for j in range(i):\n            if arr[i] > arr[j] and inc[i] < inc[j] + arr[i]:\n                inc[i] = inc[j] + arr[i]\n        if inc[i] == 0:\n            inc[i] = arr[i]\n\n    # Calculate decreasing subsequence values\n    for i in range(n-2, -1, -1):\n        for j in range(n-1, i, -1):\n            if arr[i] > arr[j] and dec[i] < dec[j] + arr[i]:\n                dec[i] = dec[j] + arr[i]\n        if dec[i] == 0:\n            dec[i] = arr[i]\n\n    # Find maximum sum of bitonic subsequence\n    bitonic = [0]*n\n    for i in range(n):\n        bitonic[i] = inc[i] + dec[i] - arr[i]\n\n    return max(bitonic)\n\n# Test the function\nassert max_sum([1, 15, 51, 45, 33, 100, 12, 18, 9]) == 194"}
{"task_id": "Mbpp/247", "solution": "def lps(s):\n    n = len(s)\n    dp = [[0]*n for _ in range(n)]\n    for i in range(n-1, -1, -1):\n        dp[i][i] = 1\n        for j in range(i+1, n):\n            if s[i] == s[j]:\n                dp[i][j] = 2 + dp[i+1][j-1]\n            else:\n                dp[i][j] = max(dp[i+1][j], dp[i][j-1])\n    return dp[0][n-1]\n\nassert lps(\"TENS FOR TENS\") == 5"}
{"task_id": "Mbpp/250", "solution": "def count_X(tup, elem):\n    return tup.count(elem)\n\n# Test the function\nassert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2), 4) == 0"}
{"task_id": "Mbpp/251", "solution": "def insert_element(lst, element):\n    result = []\n    for i in lst:\n        result.extend([element, i])\n    return result\n\n# Test the function\nassert insert_element(['Red', 'Green', 'Black'], 'c') == ['c', 'Red', 'c', 'Green', 'c', 'Black']"}
{"task_id": "Mbpp/252", "solution": "import cmath\n\ndef convert(complex_num):\n    \"\"\"\n    This function converts a complex number to polar coordinates.\n    \"\"\"\n    # Convert the complex number to polar coordinates using cmath.polar\n    r, phi = cmath.polar(complex_num)\n    # Return the polar coordinates as a tuple\n    return (r, phi)\n\n# Test the function\nassert convert(1) == (1.0, 0.0)"}
{"task_id": "Mbpp/253", "solution": "def count_integer(lst):\n    return sum(1 for i in lst if isinstance(i, int))\n\n# Test the function\nassert count_integer([1,2,'abc',1.2]) == 2"}
{"task_id": "Mbpp/255", "solution": "from itertools import product\n\ndef combinations_colors(lst, n):\n    return list(product(*([lst]*n)))\n\n# Test the function"}
{"task_id": "Mbpp/256", "solution": "def count_Primes_nums(n):\n    if n < 2:\n        return 0\n    primes = [True] * n\n    p = 2\n    while p * p <= n:\n        if primes[p]:\n            for i in range(p * p, n, p):\n                primes[i] = False\n        p += 1\n    return sum(primes) - 2  # subtract 2 to exclude 0 and 1\n\n# Test the function\nassert count_Primes_nums(5) == 2"}
{"task_id": "Mbpp/257", "solution": "def swap_numbers(a, b):\n    return b, a\n\n# Test the function\nassert swap_numbers(10,20)==(20,10)"}
{"task_id": "Mbpp/259", "solution": "def maximize_elements(t1, t2):\n    return tuple(max(a, b) for a, b in zip(t1, t2))\n\n# Test the function\nassert maximize_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((6, 7), (4, 9), (2, 9), (7, 10))"}
{"task_id": "Mbpp/260", "solution": "def newman_prime(n):\n    def is_prime(num):\n        if num < 2:\n            return False\n        for i in range(2, int(num**0.5) + 1):\n            if num % i == 0:\n                return False\n        return True\n\n    count = 0\n    num = 2\n    while True:\n        if is_prime(num):\n            count += 1\n            if count == n:\n                return num\n        num += 1\n\n# Test the function\nassert newman_prime(3) == 7"}
{"task_id": "Mbpp/261", "solution": "def division_elements(t1, t2):\n    return tuple(map(lambda x, y: x / y, t1, t2))\n\nassert division_elements((10, 4, 6, 9),(5, 2, 3, 3)) == (2, 2, 2, 3)"}
{"task_id": "Mbpp/262", "solution": "def split_two_parts(lst, L):\n    return (lst[:L], lst[L:])\n\n# Test the function\nassert split_two_parts([1,1,2,3,4,4,5,1],3)==([1, 1, 2], [3, 4, 4, 5, 1])"}
{"task_id": "Mbpp/264", "solution": "def dog_age(human_years):\n    if human_years <= 2:\n        return human_years * 10.5\n    else:\n        return 21 + (human_years - 2) * 4\n\n# Test the function\nassert dog_age(12) == 61"}
{"task_id": "Mbpp/265", "solution": "def list_split(lst, n):\n    return [lst[i:i + n] for i in range(0, len(lst), n)]\n\n# Test the function"}
{"task_id": "Mbpp/266", "solution": "def lateralsurface_cube(side_length):\n    return 4 * side_length ** 2\n\n# Test the function\nassert lateralsurface_cube(5) == 100"}
{"task_id": "Mbpp/267", "solution": "def square_Sum(n):\n    sum = 0\n    for i in range(1, 2*n, 2):\n        sum += i*i\n    return sum\n\n# Test the function\nassert square_Sum(2) == 10"}
{"task_id": "Mbpp/268", "solution": "def find_star_num(n):\n    return n*(7*n - 5)//2\n\n# Test the function\nassert find_star_num(3) == 37"}
{"task_id": "Mbpp/269", "solution": "def ascii_value(char):\n    return ord(char)\n\n# Test the function\nassert ascii_value('A') == 65"}
{"task_id": "Mbpp/270", "solution": "def sum_even_and_even_index(lst):\n    return sum(val for idx, val in enumerate(lst) if idx % 2 == 0 and val % 2 == 0)\n\n# Test the function\nassert sum_even_and_even_index([5, 6, 12, 1, 18, 8]) == 30"}
{"task_id": "Mbpp/271", "solution": "def even_Power_Sum(n):\n    sum = 0\n    for i in range(2, 2*n+1, 2):\n        sum += i**5\n    return sum\n\n# Test the function\nassert even_Power_Sum(2) == 1056"}
{"task_id": "Mbpp/272", "solution": "def rear_extract(lst):\n    return [i[-1] for i in lst]\n\n# Testing the function\nassert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]"}
{"task_id": "Mbpp/273", "solution": "def substract_elements(t1, t2):\n    return tuple(x1 - x2 for x1, x2 in zip(t1, t2))\n\n# Test the function\nassert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)"}
{"task_id": "Mbpp/274", "solution": "def even_binomial_Coeff_Sum(n):\n    # Initialize the sum to 0\n    sum = 0\n    # Loop through the range of n\n    for i in range(n+1):\n        # Check if the index is even\n        if i % 2 == 0:\n            # Calculate the binomial coefficient and add it to the sum\n            sum += binomial_coefficient(n, i)\n    return sum\n\ndef binomial_coefficient(n, k):\n    # Calculate the binomial coefficient using the formula nCk = n! / [(n-k)! * k!]\n    return factorial(n) / (factorial(n-k) * factorial(k))\n\ndef factorial(n):\n    # Calculate the factorial of a number using a loop\n    if n == 0:\n        return 1\n    else:\n        fact = 1\n        for i in range(1, n+1):\n            fact *= i\n        return fact\n\n# Test the function\nassert even_binomial_Coeff_Sum(4) == 8"}
{"task_id": "Mbpp/276", "solution": "import math\n\ndef volume_cylinder(radius, height):\n    return math.pi * radius**2 * height\n\n# Test the function\nassert math.isclose(volume_cylinder(10,5), 1570.7963267948966, rel_tol=0.001)"}
{"task_id": "Mbpp/277", "solution": "def dict_filter(d, n):\n    return {k: v for k, v in d.items() if v >= n}\n\n# Test the function\nassert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},170)=={'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}"}
{"task_id": "Mbpp/278", "solution": "def count_first_elements(tup):\n    count = 0\n    for i in tup:\n        if isinstance(i, tuple):\n            break\n        count += 1\n    return count\n\n# Test the function\nassert count_first_elements((1, 5, 7, (4, 6), 10)) == 3"}
{"task_id": "Mbpp/279", "solution": "def is_num_decagonal(n):\n    return n*(7*n-5)//2\n\n# Test the function\nassert is_num_decagonal(3) == 27"}
{"task_id": "Mbpp/280", "solution": "def sequential_search(array, element):\n    for i in range(len(array)):\n        if array[i] == element:\n            return (True, i)\n    return (False, -1)\n\n# Test the function"}
{"task_id": "Mbpp/281", "solution": "def all_unique(lst):\n    return len(lst) == len(set(lst))\n\n# Test cases"}
{"task_id": "Mbpp/282", "solution": "def sub_list(list1, list2):\n    return [a - b for a, b in zip(list1, list2)]\n\n# Test the function\nassert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]"}
{"task_id": "Mbpp/283", "solution": "def validate(n):\n    # Convert the integer to a string to easily access each digit\n    str_n = str(n)\n    # Iterate over each digit in the string representation of the integer\n    for digit in str_n:\n        # Count the number of times the digit appears in the string representation of the integer\n        count = str_n.count(digit)\n        # If the count is greater than the digit itself, return False\n        if count > int(digit):\n            return False\n    # If we've gone through all the digits without finding a count that's greater than the digit, return True\n    return True\n\n# Test the function with the provided examples"}
{"task_id": "Mbpp/284", "solution": "def check_element(lst, elm):\n    return all(i == elm for i in lst)\n\n# Test the function"}
{"task_id": "Mbpp/285", "solution": "import re\n\ndef text_match_two_three(text):\n    pattern = 'ab{2,3}'\n    if re.search(pattern, text):\n        return True\n    else:\n        return False\n\n# Test cases"}
{"task_id": "Mbpp/286", "solution": "def max_sub_array_sum_repeated(arr, k, n):\n    # Calculate the sum of the array\n    total_sum = sum(arr)\n\n    # Calculate the sum of the array repeated k times\n    repeated_sum = total_sum * k\n\n    # Calculate the maximum subarray sum using Kadane's algorithm\n    max_sum = current_sum = repeated_sum\n    for i in range(n):\n        current_sum = max(arr[i], current_sum + arr[i])\n        max_sum = max(max_sum, current_sum)\n\n    return max_sum\n\n# Test the function\nassert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 4) == 30"}
{"task_id": "Mbpp/287", "solution": "def square_Sum(n):\n    sum = 0\n    for i in range(1, n+1):\n        sum += i*i\n    return sum*2\n\n# Test the function\nassert square_Sum(2) == 20"}
{"task_id": "Mbpp/290", "solution": "def max_length(lst):\n    max_len = max(len(sub_lst) for sub_lst in lst)\n    max_sub_lst = [sub_lst for sub_lst in lst if len(sub_lst) == max_len]\n    return max_len, max_sub_lst[0]\n\n# Test the function\nassert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])"}
{"task_id": "Mbpp/292", "solution": "def find(num1, num2):\n    return num1 // num2\n\n# Test the function\nassert find(10, 3) == 3"}
{"task_id": "Mbpp/293", "solution": "import math\n\ndef otherside_rightangle(base, height):\n    \"\"\"\n    This function calculates the length of the third side of a right-angled triangle.\n    It takes two arguments: base and height of the right-angled triangle.\n    It returns the length of the third side.\n    \"\"\"\n    return math.sqrt(base**2 + height**2)\n\n# Test the function\nassert otherside_rightangle(7, 8) == 10.63014581273465"}
{"task_id": "Mbpp/294", "solution": "def max_val(lst):\n    max_value = None\n    for item in lst:\n        if isinstance(item, int) or isinstance(item, float):\n            if max_value is None or item > max_value:\n                max_value = item\n    return max_value\n\n# Test the function\nassert max_val(['Python', 3, 2, 4, 5, 'version'])==5"}
{"task_id": "Mbpp/296", "solution": "def get_Inv_Count(arr):\n    inv_count = 0\n    for i in range(len(arr)):\n        for j in range(i + 1, len(arr)):\n            if arr[i] > arr[j]:\n                inv_count += 1\n    return inv_count\n\n# Test the function\nassert get_Inv_Count([1,20,6,4,5]) == 5"}
{"task_id": "Mbpp/297", "solution": "def flatten_list(nested_list):\n    flat_list = []\n    for i in nested_list:\n        if isinstance(i, list):\n            flat_list.extend(flatten_list(i))\n        else:\n            flat_list.append(i)\n    return flat_list\n\n# Test the function\nassert 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]"}
{"task_id": "Mbpp/299", "solution": "def max_aggregate(lst):\n    # Create a dictionary to store the sum of scores for each name\n    scores = {}\n    for name, score in lst:\n        if name in scores:\n            scores[name] += score\n        else:\n            scores[name] = score\n\n    # Find the name with the maximum score\n    max_score = max(scores.values())\n    max_name = [name for name, score in scores.items() if score == max_score][0]\n\n    return (max_name, max_score)\n\n# Test the function\nassert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)"}
{"task_id": "Mbpp/300", "solution": "def count_binary_seq(n):\n    # Initialize a list to store the count of binary sequences\n    # for each possible sum of the first n bits\n    counts = [0] * (2*n + 1)\n\n    # Initialize the count of binary sequences for n=0\n    counts[0] = 1\n\n    # Iterate over each bit position from 0 to 2n-1\n    for _ in range(2*n):\n        # Iterate over each possible sum of the first n bits\n        for j in range(2*n, -1, -1):\n            # Update the count of binary sequences for the next bit position\n            counts[j] = counts[j] * 2 + (counts[j-1] if j > 0 else 0)\n\n    # Return the count of binary sequences where the sum of the first n bits is the same as the sum of the last n bits\n    return counts[n]\n\n# Test the function\nassert math.isclose(count_binary_seq(1), 2.0, rel_tol=0.001)"}
{"task_id": "Mbpp/301", "solution": "def dict_depth(d):\n    if not isinstance(d, dict) or not d:\n        return 1\n    return 1 + max(dict_depth(v) for v in d.values())\n\n# Test cases\nassert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4\nassert dict_depth({'a':1, 'b': {'c': {'d': {'e': {}}}}})==5\nassert dict_depth({'a':1, 'b': {'c': {'d': {'e': {'f': {}}}}} })==6\nassert dict_depth({'a':1})==1\nassert dict_depth({})==1"}
{"task_id": "Mbpp/305", "solution": "def start_withp(words_list):\n    for words in words_list:\n        for word in words.split():\n            if word.lower().startswith('p'):\n                return word,\n\nassert start_withp([\"Python PHP\", \"Java JavaScript\", \"c c++\"])==('Python', 'PHP')"}
{"task_id": "Mbpp/306", "solution": "def max_sum_increasing_subseq(arr, n, k, i):\n    # Initialize the dp array with the given array values\n    dp = arr[:]\n    # Initialize the max_sum variable with the value at the kth index\n    max_sum = arr[k]\n    # Iterate over the array from the (i+1)th index to the end\n    for j in range(i+1, n):\n        # Iterate over the array from the 0th index to the (i-1)th index\n        for x in range(0, i):\n            # If the current element is greater than the (i-1)th element and the sum of the dp[x] and the current element is greater than the dp[j]\n            if arr[j] > arr[x] and dp[x] + arr[j] > dp[j]:\n                # Update the dp[j] with the new sum\n                dp[j] = dp[x] + arr[j]\n        # Update the max_sum with the maximum of the current max_sum and the dp[j]\n        max_sum = max(max_sum, dp[j])\n    # Return the max_sum\n    return max_sum\n\n# Test the function\nassert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11"}
{"task_id": "Mbpp/308", "solution": "def large_product(list1, list2, n):\n    products = [(x * y) for x in list1 for y in list2]\n    products.sort(reverse=True)\n    return products[:n]\n\n# Test the function\nassert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]"}
{"task_id": "Mbpp/309", "solution": "def maximum(num1, num2):\n    if num1 > num2:\n        return num1\n    else:\n        return num2\n\n# Test the function\nassert maximum(5,10) == 10"}
{"task_id": "Mbpp/310", "solution": "def string_to_tuple(s):\n    return tuple(s)\n\n# Test the function\nassert string_to_tuple(\"python 3.0\") == ('p', 'y', 't', 'h', 'o', 'n', ' ', '3', '.', '0')"}
{"task_id": "Mbpp/311", "solution": "def set_left_most_unset_bit(n):\n    if n == 0:\n        return 1\n    if n % 2 == 1:\n        return n\n    else:\n        return n + 1\n\n# Test the function\nassert set_left_most_unset_bit(10) == 14"}
{"task_id": "Mbpp/312", "solution": "import math\n\ndef volume_cone(radius, height):\n    return (1/3) * math.pi * radius**2 * height\n\n# Test the function\nassert math.isclose(volume_cone(5,12), 314.15926535897927, rel_tol=0.001)"}
{"task_id": "Mbpp/388", "solution": "def highest_Power_of_2(n):\n    i = 0\n    while 2 ** i <= n:\n        i += 1\n    return 2 ** (i - 1)\n\n# Test the function\nassert highest_Power_of_2(10) == 8"}
{"task_id": "Mbpp/389", "solution": "def find_lucas(n):\n    if n == 0:\n        return 2\n    if n == 1:\n        return 1\n    lucas_numbers = [2, 1]\n    for i in range(2, n + 1):\n        lucas_numbers.append(lucas_numbers[i - 1] + lucas_numbers[i - 2])\n    return lucas_numbers[n]\n\n# Test the function\nassert find_lucas(9) == 76"}
{"task_id": "Mbpp/390", "solution": "def add_string(lst, fmt_str):\n    return [fmt_str.format(i) for i in lst]\n\n# Test the function\nassert add_string([1,2,3,4],'temp{0}')==['temp1', 'temp2', 'temp3', 'temp4']"}
{"task_id": "Mbpp/391", "solution": "def convert_list_dictionary(keys, names, values):\n    result = []\n    for i in range(len(keys)):\n        temp_dict = {keys[i]: {names[i]: values[i]}}\n        result.append(temp_dict)\n    return result\n\n# Test the function\nkeys = [\"S001\", \"S002\", \"S003\", \"S004\"]\nnames = [\"Adina Park\", \"Leyton Marsh\", \"Duncan Boyle\", \"Saim Richards\"]\nvalues = [85, 98, 89, 92]\n\nassert convert_list_dictionary(keys, names, values) == [{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]"}
{"task_id": "Mbpp/392", "solution": "def get_max_sum(n):\n    if n <= 1:\n        return n\n    else:\n        return max(get_max_sum(n/2) + get_max_sum(n/3) + get_max_sum(n/4) + get_max_sum(n/5), n)\n\nassert get_max_sum(60) == 106"}
{"task_id": "Mbpp/394", "solution": "def check_distinct(tup):\n    return len(tup) == len(set(tup))\n\n# Test the function\nassert check_distinct((1, 4, 5, 6, 1, 4)) == False"}
{"task_id": "Mbpp/395", "solution": "def first_non_repeating_character(s):\n    char_count = {}\n    for char in s:\n        if char in char_count:\n            char_count[char] += 1\n        else:\n            char_count[char] = 1\n    for char in s:\n        if char_count[char] == 1:\n            return char\n    return None\n\n# Test cases\nassert first_non_repeating_character(\"abcabc\") == None\nassert first_non_repeating_character(\"aabbcc\") == None\nassert first_non_repeating_character(\"aabbccd\") == 'd'\nassert first_non_repeating_character(\"\") == None"}
{"task_id": "Mbpp/397", "solution": "def median_numbers(a, b, c):\n    \"\"\"\n    This function takes three numbers as input and returns their median.\n    \"\"\"\n    # Sort the numbers\n    numbers = sorted([a, b, c])\n    \n    # Return the middle number\n    return numbers[1]\n\n# Test the function\nassert median_numbers(25, 55, 65) == 55.0"}
{"task_id": "Mbpp/398", "solution": "def sum_of_digits(lst):\n    return [sum(int(digit) for digit in str(num)) for num in lst]\n\n# Test the function\nassert sum_of_digits([10,2,56]) == [1, 2, 11]"}
{"task_id": "Mbpp/404", "solution": "def minimum(a, b):\n    if a < b:\n        return a\n    else:\n        return b\n\n# Test the function\nassert minimum(1, 2) == 1"}
{"task_id": "Mbpp/405", "solution": "def check_tuplex(tuplex, element):\n    return element in tuplex\n\n# Test the function\nassert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),'r')==True"}
{"task_id": "Mbpp/406", "solution": "def find_Parity(n):\n    return n % 2 != 0\n\n# Test cases\nassert find_Parity(12) == False\nassert find_Parity(11) == True\nassert find_Parity(0) == False\nassert find_Parity(-11) == True\nassert find_Parity(-12) == False"}
{"task_id": "Mbpp/409", "solution": "def min_product_tuple(lst):\n    return min(x*y for x, y in lst)\n\n# Test the function\nassert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)]) == 8"}
{"task_id": "Mbpp/410", "solution": "def min_val(lst):\n    # Filter out non-numeric values and find the minimum\n    min_val = min([i for i in lst if isinstance(i, (int, float))])\n    return min_val\n\n# Test the function\nassert min_val(['Python', 3, 2, 4, 5, 'version']) == 2"}
{"task_id": "Mbpp/412", "solution": "def remove_odd(numbers):\n    return [num for num in numbers if num % 2 == 0]\n\nassert remove_odd([1,2,3]) == [2]"}
{"task_id": "Mbpp/413", "solution": "def extract_nth_element(lst, n):\n    return [x[n] for x in lst]\n\n# Test the function\nassert 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']"}
{"task_id": "Mbpp/414", "solution": "def overlapping(seq1, seq2):\n    for i in seq1:\n        if i in seq2:\n            return True\n    return False\n\n# Test cases"}
{"task_id": "Mbpp/415", "solution": "def max_Product(arr):\n    arr.sort()\n    return (arr[-1], arr[-2]) if arr[-1] * arr[-2] > arr[0] * arr[1] else (arr[0], arr[1])\n\n# Test the function\nassert max_Product([1,2,3,4,7,0,8,4]) == (7,8)"}
{"task_id": "Mbpp/418", "solution": "def Find_Max(lst):\n    max_len = max(len(sublist) for sublist in lst)\n    for sublist in lst:\n        if len(sublist) == max_len:\n            return sublist\n\n# Test the function\nassert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']"}
{"task_id": "Mbpp/419", "solution": "def round_and_sum(numbers):\n    rounded_numbers = [round(num) for num in numbers]\n    total_sum = sum(rounded_numbers)\n    result = total_sum * len(rounded_numbers)\n    return result\n\n# Test the function\nassert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243"}
{"task_id": "Mbpp/420", "solution": "def cube_Sum(n):\n    sum = 0\n    for i in range(1, n+1):\n        sum += i*2*i\n    return sum\n\n# Test the function\nassert cube_Sum(2) == 72"}
{"task_id": "Mbpp/421", "solution": "def concatenate_tuple(tup):\n    return '-'.join(str(i) for i in tup)\n\n# Test the function\nassert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\")) == 'ID-is-4-UTS'"}
{"task_id": "Mbpp/422", "solution": "def find_Average_Of_Cube(n):\n    sum_of_cubes = sum([i**3 for i in range(1, n+1)])\n    average = sum_of_cubes / n\n    return average\n\n# Test the function\nassert find_Average_Of_Cube(2) == 4.5"}
{"task_id": "Mbpp/424", "solution": "def extract_rear(tup):\n    return [s[-1] for s in tup]\n\nassert extract_rear(('Mers', 'for', 'Vers')) == ['s', 'r', 's']"}
{"task_id": "Mbpp/425", "solution": "def count_element_in_list(lst, element):\n    count = 0\n    for sublist in lst:\n        if element in sublist:\n            count += 1\n    return count\n\n# Test the function\nassert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]], 1) == 3"}
{"task_id": "Mbpp/426", "solution": "def filter_oddnumbers(numbers):\n    return [num for num in numbers if num % 2 == 0]\n\nassert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [2, 4, 6, 8, 10]"}
{"task_id": "Mbpp/427", "solution": "def change_date_format(date):\n    # Split the date into year, month, and day\n    year, month, day = date.split('-')\n    # Return the date in the desired format\n    return '{}-{}-{}'.format(day, month, year)\n\n# Test the function\nassert change_date_format(\"2026-01-02\") == '02-01-2026'"}
{"task_id": "Mbpp/428", "solution": "def shell_sort(arr):\n    n = len(arr)\n    gap = n//2\n\n    while gap > 0:\n        for i in range(gap,n):\n            temp = arr[i]\n            j = i\n            while  j >= gap and arr[j-gap] >temp:\n                arr[j] = arr[j-gap]\n                j -= gap\n            arr[j] = temp\n        gap //= 2\n    return arr\n\nassert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]"}
{"task_id": "Mbpp/429", "solution": "def and_tuples(t1, t2):\n    return tuple(x & y for x, y in zip(t1, t2))\n\n# Test the function\nassert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)"}
{"task_id": "Mbpp/430", "solution": "def parabola_directrix(a, h, k):\n    \"\"\"\n    Function to find the directrix of a parabola.\n    The directrix of a parabola is the line that is perpendicular to the x-axis and intersects the parabola at its vertex.\n    The equation of a parabola is y = a*(x-h)^2 + k.\n    The equation of the directrix is x = h.\n    The function takes three parameters: a, h, and k.\n    It returns the y-coordinate of the directrix.\n    \"\"\"\n    return a * (h - h) ** 2 + k\n\n# Test the function\nassert parabola_directrix(5, 3, 2) == -198"}
{"task_id": "Mbpp/432", "solution": "def median_trapezium(a, b, c):\n    \"\"\"\n    This function calculates the median length of a trapezium.\n    The median of a trapezium is the length of the line segment that divides the trapezium into two equal parts.\n    The lengths of the parallel sides of the trapezium are given by a, b, and c.\n    The median is calculated as (a+b+c)/2.\n    \"\"\"\n    return (a + b + c) / 2\n\n# Test the function\nassert median_trapezium(15, 25, 35) == 20"}
{"task_id": "Mbpp/433", "solution": "def check_greater(arr, num):\n    for i in arr:\n        if i <= num:\n            return False\n    return True\n\n# Test the function"}
{"task_id": "Mbpp/435", "solution": "def last_Digit(n):\n    return n % 10\n\n# Test the function\nassert last_Digit(123) == 3"}
{"task_id": "Mbpp/436", "solution": "def neg_nos(lst):\n    return [num for num in lst if num < 0]\n\nassert neg_nos([-1,4,5,-6]) == [-1,-6]"}
{"task_id": "Mbpp/437", "solution": "def remove_odd(s):\n    return s[::2]\n\nassert remove_odd(\"python\") == \"yhn\""}
{"task_id": "Mbpp/439", "solution": "def multiple_to_single(nums):\n    return int(''.join(map(str, nums)))\n\n# Test the function\nassert multiple_to_single([11, 33, 50])==113350"}
{"task_id": "Mbpp/440", "solution": "import nltk\nfrom nltk.tokenize import word_tokenize\nfrom nltk.corpus import stopwords\n\nnltk.download('punkt')\nnltk.download('averaged_perceptron_tagger')\nnltk.download('stopwords')\n\ndef find_adverb_position(sentence):\n    stop_words = set(stopwords.words('english'))\n    words = word_tokenize(sentence)\n    pos_tags = nltk.pos_tag(words)\n\n    for i in range(len(pos_tags)):\n        word, tag = pos_tags[i]\n        if tag in ['RB', 'RBR', 'RBS', 'WRB'] and word not in stop_words:\n            return i, i+1, word\n\n    return None\n\n# Test the function\nassert find_adverb_position(\"clearly!! we can see the sky\")==(0, 7, 'clearly')"}
{"task_id": "Mbpp/441", "solution": "def surfacearea_cube(side_length):\n    return 6 * side_length ** 2\n\n# Test the function\nassert surfacearea_cube(5) == 150"}
{"task_id": "Mbpp/445", "solution": "def index_multiplication(tuples):\n    tuple1, tuple2 = tuples\n    result = []\n    for i in range(len(tuple1)):\n        result.append(tuple(a*b for a, b in zip(tuple1[i], tuple2[i])))\n    return tuple(result)\n\n# Test the function\nassert 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))"}
{"task_id": "Mbpp/446", "solution": "def count_Occurrence(tup, lst):\n    count = 0\n    for element in lst:\n        count += tup.count(element)\n    return count\n\n# Test the function\nassert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b']) == 3"}
{"task_id": "Mbpp/447", "solution": "def cube_nums(nums):\n    return [num**3 for num in nums]\n\nassert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]"}
{"task_id": "Mbpp/448", "solution": "def cal_sum(n):\n    # Initialize the first three Perrin numbers\n    perrin = [3, 0, 2]\n    \n    # Calculate the rest of the Perrin numbers\n    for i in range(3, n):\n        perrin.append(perrin[i-2] + perrin[i-1] + 1)\n    \n    # Return the sum of the first n Perrin numbers\n    return sum(perrin[:n])\n\n# Test the function\nassert cal_sum(9) == 49"}
{"task_id": "Mbpp/450", "solution": "def extract_string(lst, size):\n    return [s for s in lst if len(s) == size]\n\n# Test the function\nassert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'], 8) == ['practice', 'solution']"}
{"task_id": "Mbpp/451", "solution": "def remove_whitespaces(input_string):\n    return input_string.replace(\" \", \"\")\n\n# Test the function\nassert remove_whitespaces(' Google    Flutter ') == 'GoogleFlutter'"}
{"task_id": "Mbpp/453", "solution": "def sumofFactors(n):\n    sum = 0\n    for i in range(1, n+1):\n        if n % i == 0 and i % 2 == 0:\n            sum += i\n    return sum\n\n# Test the function\nassert sumofFactors(18) == 26"}
{"task_id": "Mbpp/454", "solution": "import re\n\ndef text_match_wordz(text):\n    pattern = r'\\b\\w*z\\w*\\b'\n    if re.search(pattern, text):\n        return True\n    else:\n        return False\n\n# Test the function"}
{"task_id": "Mbpp/455", "solution": "def check_month_number(month_number):\n    # Months with 31 days: January, March, May, July, August, October, December\n    thirty_one_days_months = [1, 3, 5, 7, 8, 10, 12]\n    if month_number in thirty_one_days_months:\n        return True\n    else:\n        return False\n\n# Test the function\nassert check_month_number(5) == True"}
{"task_id": "Mbpp/456", "solution": "def reverse_string_list(lst):\n    return [s[::-1] for s in lst]\n\nassert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black']) == ['deR', 'neerG', 'eulB', 'etihW', 'kcalB']"}
{"task_id": "Mbpp/457", "solution": "def Find_Min(lst):\n    return min(lst, key=len)\n\n# Testing the function\nassert Find_Min([[1],[1,2],[1,2,3]]) == [1]"}
{"task_id": "Mbpp/458", "solution": "def rectangle_area(length, width):\n    \"\"\"\n    This function calculates the area of a rectangle.\n    \"\"\"\n    return length * width\n\n# Test the function\nassert rectangle_area(10,20)==200, \"Test case 1 failed\"\n"}
{"task_id": "Mbpp/459", "solution": "def remove_uppercase(s):\n    return ''.join([c for c in s if not c.isupper()])\n\n# Test the function\nassert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'"}
{"task_id": "Mbpp/460", "solution": "def Extract(lst):\n    return [sublist[0] for sublist in lst]\n\n# Test the function\nassert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]"}
{"task_id": "Mbpp/462", "solution": "from itertools import chain, combinations\n\ndef combinations_list(lst):\n    return list(chain(*[combinations(lst, i) for i in range(len(lst) + 1)]))\n\nassert 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']]"}
{"task_id": "Mbpp/463", "solution": "def max_subarray_product(nums):\n    if not nums:\n        return 0\n\n    max_product = min_product = result = nums[0]\n\n    for i in range(1, len(nums)):\n        if nums[i] < 0:\n            max_product, min_product = min_product, max_product\n\n        max_product = max(nums[i], max_product * nums[i])\n        min_product = min(nums[i], min_product * nums[i])\n\n        result = max(result, max_product)\n\n    return result\n\nassert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112"}
{"task_id": "Mbpp/465", "solution": "def drop_empty(d):\n    return {k: v for k, v in d.items() if v is not None}\n\nassert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}"}
{"task_id": "Mbpp/468", "solution": "def max_product(arr):\n    n = len(arr)\n    if n < 2:\n        return None\n\n    max_ending_here = max_ending_so_far = arr[0]\n    for i in range(1, n):\n        if arr[i] < 0:\n            max_ending_here, max_ending_so_far = max_ending_so_far, max_ending_here\n        max_ending_here = max(arr[i], max_ending_here * arr[i])\n        max_ending_so_far = max(max_ending_so_far, max_ending_here)\n\n    return max_ending_so_far\n\n# Test cases\nassert max_product([3, 100, 4, 5, 150, 6]) == 3000"}
{"task_id": "Mbpp/470", "solution": "def add_pairwise(tup):\n    return tuple(tup[i] + tup[i + 1] for i in range(len(tup) - 1))\n\n# Test the function\nassert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)"}
{"task_id": "Mbpp/471", "solution": "def find_remainder(arr, n):\n    product = 1\n    for num in arr:\n        product = (product * num) % n\n    return product\n\n# Test the function\nassert find_remainder([100, 10, 5, 25, 35, 14], 11) == 9"}
{"task_id": "Mbpp/472", "solution": "def check_Consecutive(lst):\n    return sorted(lst) == list(range(min(lst), max(lst)+1))\n\n# Test the function\nassert check_Consecutive([1,2,3,4,5]) == True"}
{"task_id": "Mbpp/473", "solution": "def tuple_intersection(tuples1, tuples2):\n    # Convert tuples to sets and find intersection\n    set1 = set(tuples1)\n    set2 = set(tuples2)\n    intersection = set1 & set2\n\n    # Convert sets back to tuples and return\n    return set(intersection)\n\n# Test the function\nassert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}"}
{"task_id": "Mbpp/474", "solution": "def replace_char(s, old_char, new_char):\n    return s.replace(old_char, new_char)\n\n# Test the function\nassert replace_char(\"polygon\",'y','l')==(\"pollgon\")"}
{"task_id": "Mbpp/475", "solution": "def sort_dict_by_value(d):\n    return sorted(d.items(), key=lambda x: x[1], reverse=True)\n\nassert sort_dict_by_value({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]"}
{"task_id": "Mbpp/476", "solution": "def big_sum(arr):\n    return max(arr) + min(arr)\n\n# Test the function\nassert big_sum([1,2,3]) == 4"}
{"task_id": "Mbpp/477", "solution": "def to_lower(s):\n    return s.lower()\n\nassert to_lower(\"InValid\") == \"invalid\""}
{"task_id": "Mbpp/478", "solution": "def remove_lowercase(s):\n    return ''.join([c for c in s if c.isupper()])\n\n# Test the function\nassert remove_lowercase(\"PYTHon\") == \"PYTH\""}
{"task_id": "Mbpp/479", "solution": "def first_Digit(n):\n    while n >= 10:\n        n /= 10\n    return int(n)\n\n# Test cases\nassert first_Digit(123) == 1\nassert first_Digit(456) == 4\nassert first_Digit(789) == 7\nassert first_Digit(1000) == 1\nassert first_Digit(9876543210) == 9"}
{"task_id": "Mbpp/554", "solution": "def get_odd_numbers(numbers):\n    return [num for num in numbers if num % 2 != 0]\n\nassert get_odd_numbers([1,2,3,4,5,6]) == [1,3,5]"}
{"task_id": "Mbpp/555", "solution": "def difference(n):\n    sum_of_cubes = sum([i**3 for i in range(1, n+1)])\n    sum_of_numbers = sum([i for i in range(1, n+1)])\n    return sum_of_cubes - sum_of_numbers\n\n# Test the function\nassert difference(3) == 30"}
{"task_id": "Mbpp/556", "solution": "def find_Odd_Pair(arr, n):\n    # Initialize count of odd pairs\n    odd_count = 0\n\n    # Traverse through all pairs of arr[i] and arr[j]\n    for i in range(0, n):\n        for j in range(i + 1, n):\n\n            # If XOR of arr[i] and arr[j] is odd\n            if (arr[i] ^ arr[j]) & 1:\n                odd_count += 1\n\n    return odd_count\n\n# Test the function\nassert find_Odd_Pair([5, 4, 7, 2, 1], 5) == 6"}
{"task_id": "Mbpp/557", "solution": "def toggle_string(s):\n    return s.swapcase()\n\nassert toggle_string(\"Python\") == \"pYTHON\""}
{"task_id": "Mbpp/558", "solution": "def digit_distance_nums(num1, num2):\n    # Convert numbers to strings to easily access digits\n    num1, num2 = str(num1), str(num2)\n    # Initialize sum of digit differences\n    sum_diff = 0\n    # Iterate over each digit in the numbers\n    for digit1, digit2 in zip(num1, num2):\n        # Add the absolute difference between the digits to the sum\n        sum_diff += abs(int(digit1) - int(digit2))\n    return sum_diff\n\n# Test the function\nassert digit_distance_nums(1,2) == 1"}
{"task_id": "Mbpp/559", "solution": "def max_sub_array_sum(lst, n):\n    max_sum = 0\n    for i in range(n):\n        for j in range(i+1, n+1):\n            sub_array_sum = sum(lst[i:j])\n            if sub_array_sum > max_sum:\n                max_sum = sub_array_sum\n    return max_sum\n\n# Test the function\nassert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3], 8) == 7"}
{"task_id": "Mbpp/560", "solution": "def union_elements(t1, t2):\n    return tuple(sorted(set(t1 + t2)))\n\n# Test the function\nassert union_elements((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 4, 5, 6, 7, 10)"}
{"task_id": "Mbpp/562", "solution": "def Find_Max_Length(lst):\n    return max(len(sublist) for sublist in lst)\n\n# Test the function\nassert Find_Max_Length([[1],[1,4],[5,6,7,8]]) == 4"}
{"task_id": "Mbpp/563", "solution": "import re\n\ndef extract_values(s):\n    return re.findall(r'\"([^\"]*)\"', s)\n\n# Test the function\nassert extract_values('\"Python\", \"PHP\", \"Java\"') == ['Python', 'PHP', 'Java']"}
{"task_id": "Mbpp/564", "solution": "def count_Pairs(lst, n):\n    count = 0\n    for i in range(n):\n        for j in range(i+1, n):\n            if lst[i] != lst[j]:\n                count += 1\n    return count\n\n# Test the function\nassert count_Pairs([1,2,1],3) == 2"}
{"task_id": "Mbpp/565", "solution": "def split_string(s):\n    return list(s)\n\nassert split_string('python') == ['p','y','t','h','o','n']"}
{"task_id": "Mbpp/566", "solution": "def sum_digits(n):\n    return sum(int(digit) for digit in str(n))\n\n# Test the function\nassert sum_digits(345) == 12"}
{"task_id": "Mbpp/567", "solution": "def is_sorted_list(lst):\n    return all(lst[i] <= lst[i + 1] for i in range(len(lst) - 1))\n\n# Test the function\nassert is_sorted_list([1,2,4,6,8,10,12,14,16,17]) == True"}
{"task_id": "Mbpp/568", "solution": "def empty_list(n):\n    return [{} for _ in range(n)]\n\n# Test the function\nassert empty_list(5) == [{},{},{},{},{}]"}
{"task_id": "Mbpp/569", "solution": "def sort_sublists(lst):\n    return [sorted(sublist) for sublist in lst]\n\n# Test the function\nassert sort_sublists([['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']])==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]"}
{"task_id": "Mbpp/572", "solution": "def two_unique_nums(lst):\n    unique_nums = []\n    for num in lst:\n        if num not in unique_nums:\n            unique_nums.append(num)\n    return unique_nums\n\nassert two_unique_nums([1,2,3,2,3,4,5]) == [1, 4, 5]"}
{"task_id": "Mbpp/573", "solution": "def unique_product(lst):\n    unique_nums = set(lst)\n    product = 1\n    for num in unique_nums:\n        product *= num\n    return product\n\n# Test the function\nassert unique_product([10, 20, 30, 40, 20, 50, 60, 40]) == 720000000"}
{"task_id": "Mbpp/576", "solution": "def is_Sub_Array(main_list, sub_list):\n    return sub_list in main_list\n\n# Test cases"}
{"task_id": "Mbpp/577", "solution": "def last_Digit_Factorial(n):\n    if n == 0:\n        return 1\n    else:\n        last_digit = 1\n        for i in range(1, n + 1):\n            last_digit *= i\n            while last_digit % 10 == 0:\n                last_digit //= 10\n            last_digit %= 10\n        return last_digit\n\n# Test cases"}
{"task_id": "Mbpp/578", "solution": "def interleave_lists(list1, list2, list3):\n    return [val for pair in zip(list1, list2, list3) for val in pair]\n\n# Test the function\nassert 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]"}
{"task_id": "Mbpp/579", "solution": "def find_dissimilar(t1, t2):\n    return tuple(set(t1).symmetric_difference(set(t2)))\n\nassert find_dissimilar((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 6, 7, 10)"}
{"task_id": "Mbpp/580", "solution": "def extract_even(tup):\n    result = []\n    for item in tup:\n        if isinstance(item, tuple):\n            new_item = extract_even(item)\n            if new_item:\n                result.append(new_item)\n        elif item % 2 == 0:\n            result.append(item)\n    return tuple(result)\n\nassert extract_even((4, 5, (7, 6, (2, 4)), 6, 8)) == (4, (6, (2, 4)), 6, 8)"}
{"task_id": "Mbpp/581", "solution": "def surface_Area(base_edge, height):\n    # Calculate the surface area of a square pyramid\n    # Formula: A = 1/3 * base_area * height + 1/2 * base_perimeter * height\n    base_area = base_edge ** 2\n    base_perimeter = 4 * base_edge\n    surface_area = 1/3 * base_area * height + 1/2 * base_perimeter * height\n    return surface_area\n\n# Test the function\nassert surface_Area(3,4) == 33"}
{"task_id": "Mbpp/583", "solution": "def catalan_number(n):\n    if n <= 1:\n        return 1\n\n    catalan = [0 for _ in range(n+1)]\n    catalan[0] = 1\n    catalan[1] = 1\n\n    for i in range(2, n+1):\n        for j in range(i):\n            catalan[i] += catalan[j] * catalan[i-j-1]\n\n    return catalan[n]\n\n# Test the function\nassert catalan_number(10) == 16796"}
{"task_id": "Mbpp/585", "solution": "def expensive_items(dataset, n):\n    # Sort the dataset by price in descending order\n    sorted_dataset = sorted(dataset, key=lambda x: x['price'], reverse=True)\n    # Return the first n items from the sorted dataset\n    return sorted_dataset[:n]\n\n# Test the function\nassert expensive_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}],1)==[{'name': 'Item-2', 'price': 555.22}]"}
{"task_id": "Mbpp/586", "solution": "def split_Arr(arr, n):\n    return arr[n:] + arr[:n]\n\n# Test the function\nassert split_Arr([12,10,5,6,52,36],2) == [5,6,52,36,12,10]"}
{"task_id": "Mbpp/587", "solution": "def list_tuple(lst):\n    return tuple(lst)\n\n# Test the function\nassert list_tuple([5, 10, 7, 4, 15, 3])==(5, 10, 7, 4, 15, 3)"}
{"task_id": "Mbpp/588", "solution": "def big_diff(lst):\n    if lst:\n        return max(lst) - min(lst)\n    else:\n        return 0\n\n# Test cases\nassert big_diff([1,2,3,4]) == 3\nassert big_diff([10,20,30,40]) == 30\nassert big_diff([15,12,13,10]) == 3\nassert big_diff([100,200,300,400]) == 300\nassert big_diff([10,10,10,10]) == 0"}
{"task_id": "Mbpp/589", "solution": "def perfect_squares(start, end):\n    return [i**2 for i in range(int(start**0.5), int(end**0.5)+1)]\n\n# Test the function\nassert perfect_squares(1,30)==[1, 4, 9, 16, 25]"}
{"task_id": "Mbpp/590", "solution": "import cmath\n\ndef polar_rect(r, theta):\n    x = r * cmath.cos(theta)\n    y = r * cmath.sin(theta)\n    return (x.real, y.real)\n\n# Testing the function\nassert polar_rect(3,4)==((5.0, 0.9272952180016122))"}
{"task_id": "Mbpp/591", "solution": "def swap_List(lst):\n    # Swap first and last elements\n    lst[0], lst[-1] = lst[-1], lst[0]\n    return lst\n\n# Test the function\nassert swap_List([12, 35, 9, 56, 24]) == [24, 35, 9, 56, 12]"}
{"task_id": "Mbpp/592", "solution": "import math\n\ndef sum_Of_product(n):\n    sum_product = 0\n    for i in range(1, n):\n        sum_product += math.comb(n, i) * math.comb(n, i+1)\n    return sum_product\n\n# Test the function\nassert sum_Of_product(3) == 15"}
{"task_id": "Mbpp/593", "solution": "def removezero_ip(ip):\n    ip_parts = ip.split('.')\n    ip_parts = [str(int(part)) for part in ip_parts]\n    return '.'.join(ip_parts)\n\n# Test the function\nassert removezero_ip(\"216.08.094.196\") == '216.8.94.196'"}
{"task_id": "Mbpp/594", "solution": "def diff_even_odd(lst):\n    even = next((x for x in lst if x % 2 == 0), None)\n    odd = next((x for x in lst if x % 2 != 0), None)\n    return even - odd if even and odd else None\n\n# Test the function\nassert diff_even_odd([1,3,5,7,4,1,6,8]) == 3"}
{"task_id": "Mbpp/596", "solution": "import sys\n\ndef tuple_size(t):\n    return sys.getsizeof(t)\n\n# Testing the function"}
{"task_id": "Mbpp/597", "solution": "def find_kth(nums1, nums2, k):\n    \"\"\"\n    Find kth element from the given two sorted arrays.\n    \"\"\"\n    # Merge the two sorted arrays\n    merged = sorted(nums1 + nums2)\n    # Return the kth element\n    return merged[k - 1]\n\n# Test the function\nassert find_kth([2, 3, 6, 7, 9], [1, 4, 8, 10], 5) == 6"}
{"task_id": "Mbpp/598", "solution": "def armstrong_number(num):\n    # Convert the number to string to find its length (number of digits)\n    num_str = str(num)\n    num_len = len(num_str)\n\n    # Calculate the sum of the digits raised to the power of the number of digits\n    sum_of_powers = sum(int(digit)**num_len for digit in num_str)\n\n    # If the sum is equal to the original number, it's an Armstrong number\n    return sum_of_powers == num\n\n# Test the function\nassert armstrong_number(153) == True"}
{"task_id": "Mbpp/599", "solution": "def sum_average(n):\n    # calculate sum of first n natural numbers\n    total_sum = n * (n + 1) // 2\n    # calculate average of first n natural numbers\n    avg = total_sum / n\n    return (total_sum, avg)\n\n# test the function\nassert sum_average(10) == (55, 5.5)"}
{"task_id": "Mbpp/600", "solution": "def is_Even(n):\n    return n % 2 == 0\n\n# Test cases\nassert is_Even(1) == False\nassert is_Even(2) == True\nassert is_Even(0) == True\nassert is_Even(-1) == False\nassert is_Even(-2) == True"}
{"task_id": "Mbpp/602", "solution": "def first_repeated_char(string):\n    char_count = {}\n    for char in string:\n        if char in char_count:\n            return char\n        else:\n            char_count[char] = 1\n    return None\n\n# Test cases\nassert first_repeated_char(\"abcabc\") == \"a\"\nassert first_repeated_char(\"abcd\") == None\nassert first_repeated_char(\"aabbcc\") == \"a\"\nassert first_repeated_char(\"abcabcabc\") == \"a\"\nassert first_repeated_char(\"abcdabcd\") == \"a\""}
{"task_id": "Mbpp/603", "solution": "def get_ludic(n):\n    def is_prime(num):\n        if num < 2:\n            return False\n        for i in range(2, int(num**0.5) + 1):\n            if num % i == 0:\n                return False\n        return True\n\n    ludic_numbers = []\n    for i in range(1, n+1):\n        if is_prime(i):\n            ludic_numbers.append(i)\n    return ludic_numbers\n\nassert get_ludic(10) == [1, 2, 3, 5, 7]"}
{"task_id": "Mbpp/604", "solution": "def reverse_words(s):\n    words = s.split(' ')\n    reversed_words = ' '.join(reversed(words))\n    return reversed_words\n\n# Test the function\nassert reverse_words(\"python program\") == \"program python\""}
{"task_id": "Mbpp/605", "solution": "def prime_num(n):\n    if n <= 1:\n        return False\n    elif n <= 3:\n        return True\n    elif n % 2 == 0 or n % 3 == 0:\n        return False\n    i = 5\n    while i * i <= n:\n        if n % i == 0 or n % (i + 2) == 0:\n            return False\n        i += 6\n    return True\n\n# Test cases\nassert prime_num(13) == True"}
{"task_id": "Mbpp/606", "solution": "import math\n\ndef degree_to_radian(degree):\n    return degree * (math.pi / 180)\n\n# Test the function\nassert degree_to_radian(90) == math.pi/2"}
{"task_id": "Mbpp/607", "solution": "import re\n\ndef find_literals(text, pattern):\n    match = re.search(pattern, text)\n    if match:\n        return match.group(), match.start(), match.end()\n    return None, None, None\n\n# Test the function\nassert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)"}
{"task_id": "Mbpp/608", "solution": "def bell_Number(n):\n    bell = [[0 for i in range(n+1)] for j in range(n+1)]\n    bell[0][0] = 1\n    for i in range(1, n+1):\n        bell[i][0] = bell[i-1][i-1]\n        for j in range(1, i+1):\n            bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n    return bell[n][0]\n\n# Testing the function\nassert bell_Number(2) == 2"}
{"task_id": "Mbpp/610", "solution": "def remove_kth_element(lst, k):\n    del lst[k]\n    return lst\n\n# Test the function\nassert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 2, 3, 4, 4, 5, 1]"}
{"task_id": "Mbpp/611", "solution": "def max_of_nth(matrix, n):\n    return max(row[n] for row in matrix)\n\n# Test the function\nassert max_of_nth([[5, 6, 7], [1, 3, 5], [8, 9, 19]], 2) == 19"}
{"task_id": "Mbpp/612", "solution": "def merge(lst):\n    return [[sub[i] for sub in lst] for i in range(2)]\n\n# Test the function\nassert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]"}
{"task_id": "Mbpp/614", "solution": "def cummulative_sum(tuples):\n    total = 0\n    for t in tuples:\n        total += sum(t)\n    return total\n\n# Test the function\nassert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30"}
{"task_id": "Mbpp/615", "solution": "def average_tuple(tuples):\n    averages = []\n    for t in tuples:\n        averages.append(sum(t)/len(t))\n    return averages\n\n# Test the function\nassert 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]"}
{"task_id": "Mbpp/616", "solution": "def tuple_modulo(t1, t2):\n    return tuple(map(lambda x, y: x % y, t1, t2))\n\n# Test the function\nassert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)"}
{"task_id": "Mbpp/618", "solution": "def div_list(list1, list2):\n    return [a / b for a, b in zip(list1, list2)]\n\n# Test the function\nassert div_list([4,5,6],[1, 2, 3])==[4.0,2.5,2.0]"}
{"task_id": "Mbpp/619", "solution": "def move_num(s):\n    nums = [i for i in s if i.isdigit()]\n    letters = [i for i in s if not i.isdigit()]\n    return ''.join(letters + nums)\n\n# Test the function\nassert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'"}
{"task_id": "Mbpp/620", "solution": "def largest_subset(lst):\n    if not lst:\n        return 0\n\n    lst.sort()\n    dp = [1] * len(lst)\n    max_len = 1\n\n    for i in range(1, len(lst)):\n        for j in range(i):\n            if lst[i] % lst[j] == 0 and dp[i] < dp[j] + 1:\n                dp[i] = dp[j] + 1\n                max_len = max(max_len, dp[i])\n\n    return max_len\n\nassert largest_subset([1, 3, 6, 13, 17, 18]) == 4"}
{"task_id": "Mbpp/622", "solution": "def get_median(list1, list2, n):\n    merged_list = sorted(list1 + list2)\n    if n % 2 == 0:\n        median = (merged_list[n//2] + merged_list[n//2 - 1]) / 2\n    else:\n        median = merged_list[n//2]\n    return median\n\n# Test the function\nassert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0"}
{"task_id": "Mbpp/623", "solution": "def nth_nums(nums, n):\n    return [num ** n for num in nums]\n\n# Test the function\nassert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"}
{"task_id": "Mbpp/624", "solution": "def convert_to_upper(s):\n    return s.upper()\n\nassert convert_to_upper(\"person\") == \"PERSON\""}
{"task_id": "Mbpp/626", "solution": "import math\n\ndef largest_triangle_in_semicircle(radius):\n    if radius <= 0:\n        return None\n    else:\n        # The area of the largest triangle that can be inscribed in a semicircle is a right-angled triangle with hypotenuse equal to the diameter of the semicircle.\n        # The area of a right-angled triangle is 1/2 * base * height.\n        # In this case, the base and height are equal to the diameter of the semicircle.\n        diameter = 2 * radius\n        area = 0.5 * diameter * diameter\n        return area\n\n# Test cases"}
{"task_id": "Mbpp/628", "solution": "def replace_spaces(s):\n    return s.replace(' ', '%20')\n\nassert replace_spaces(\"My Name is Dawood\") == 'My%20Name%20is%20Dawood'"}
{"task_id": "Mbpp/629", "solution": "def find_even_numbers(numbers):\n    return [num for num in numbers if num % 2 == 0]\n\nassert find_even_numbers([1,2,3,4,5]) == [2,4]"}
{"task_id": "Mbpp/630", "solution": "def get_coordinates(coordinate):\n    x, y = coordinate\n    adjacent_coordinates = []\n    for i in range(-1, 2):\n        for j in range(-1, 2):\n            if not (i == 0 and j == 0):\n                adjacent_coordinates.append([x + i, y + j])\n    return adjacent_coordinates\n\nassert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]"}
{"task_id": "Mbpp/631", "solution": "def replace_spaces(s):\n    return s.replace(' ', '_')\n\nassert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'"}
{"task_id": "Mbpp/632", "solution": "def move_zero(lst):\n    # Count the number of zeros in the list\n    num_zeros = lst.count(0)\n    \n    # Remove all zeros from the list\n    lst = [num for num in lst if num != 0]\n    \n    # Extend the list with the number of zeros\n    lst.extend([0]*num_zeros)\n    \n    return lst\n\n# Test the function\nassert move_zero([1,0,2,0,3,4]) == [1,2,3,4,0,0]"}
{"task_id": "Mbpp/633", "solution": "def pair_xor_sum(lst, n):\n    sum = 0\n    for i in range(n):\n        for j in range(i + 1, n):\n            sum += lst[i] ^ lst[j]\n    return sum\n\n# Test the function\nassert pair_xor_sum([5,9,7,6],4) == 47"}
{"task_id": "Mbpp/635", "solution": "def heap_sort(lst):\n    def heapify(n, i):\n        largest = i\n        l = 2 * i + 1\n        r = 2 * i + 2\n\n        if l < n and lst[i] < lst[l]:\n            largest = l\n\n        if r < n and lst[largest] < lst[r]:\n            largest = r\n\n        if largest != i:\n            lst[i], lst[largest] = lst[largest], lst[i]\n            heapify(n, largest)\n\n    n = len(lst)\n\n    for i in range(n, -1, -1):\n        heapify(n, i)\n\n    for i in range(n-1, 0, -1):\n        lst[i], lst[0] = lst[0], lst[i]\n        heapify(i, 0)\n\n    return lst\n\nassert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"}
{"task_id": "Mbpp/637", "solution": "def noprofit_noloss(sell_price, cost_price):\n    return sell_price != cost_price\n\n# Test the function\nassert noprofit_noloss(1500,1200)==False"}
{"task_id": "Mbpp/638", "solution": "def wind_chill(velocity, temperature):\n    \"\"\"\n    Calculate the wind chill index given the wind velocity in km/h and a temperature in celsius.\n    \"\"\"\n    # Formula for wind chill index\n    wct_index = 13.12 + 0.6215*temperature - 11.37*(velocity**0.16) + 0.3965*temperature*(velocity**0.16)\n    # Round to the next integer\n    return round(wct_index + 0.5)\n\n# Test the function\nassert wind_chill(120,35)==40"}
{"task_id": "Mbpp/639", "solution": "def sum_names(names):\n    return sum(len(name) for name in names if name[0].isupper())\n\n# Test the function\nassert sum_names(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith']) == 16"}
{"task_id": "Mbpp/641", "solution": "def is_nonagonal(n):\n    return n * (7 * n - 5) // 2\n\n# Test the function\nassert is_nonagonal(10) == 325"}
{"task_id": "Mbpp/643", "solution": "import re\n\ndef text_match_wordz_middle(text):\n    # Regular expression pattern to match words containing 'z' except at the start and end\n    pattern = r'\\b\\w*z\\w*\\b'\n    # Find all matches in the text\n    matches = re.findall(pattern, text)\n    # Check if any match is found\n    if matches:\n        # Check if each match is a word containing 'z' except at the start and end\n        for match in matches:\n            if match != 'z' and match[0] != 'z' and match[-1] != 'z':\n                return True\n    return False\n\n# Test cases"}
{"task_id": "Mbpp/644", "solution": "def reverse_Array_Upto_K(arr, k):\n    # Reverse the first k elements\n    arr[:k] = arr[:k][::-1]\n    return arr\n\n# Test the function\nassert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6], 4) == [4, 3, 2, 1, 5, 6]"}
{"task_id": "Mbpp/720", "solution": "def add_dict_to_tuple(tup, dic):\n    return tup + (dic,)\n\n# Test the function\nassert add_dict_to_tuple((4, 5, 6), {\"MSAM\" : 1, \"is\" : 2, \"best\" : 3} ) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3})"}
{"task_id": "Mbpp/721", "solution": "def maxAverageOfPath(matrix):\n    n = len(matrix)\n    dp = [[0]*n for _ in range(n)]\n    dp[0][0] = matrix[0][0]\n\n    for i in range(1, n):\n        dp[i][0] = dp[i-1][0] + matrix[i][0]\n        dp[0][i] = dp[0][i-1] + matrix[0][i]\n\n    for i in range(1, n):\n        for j in range(1, n):\n            dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + matrix[i][j]\n\n    return dp[-1][-1] / ((n-1) * 2)\n\nassert maxAverageOfPath([[1, 2, 3], [6, 5, 4], [7, 3, 9]]) == 5.2"}
{"task_id": "Mbpp/722", "solution": "def filter_data(students, min_height, min_weight):\n    return {name: data for name, data in students.items() if data[0] >= min_height and data[1] >= min_weight}\n\n# Test the function\nstudents = {'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)}\nmin_height = 6.0\nmin_weight = 70"}
{"task_id": "Mbpp/723", "solution": "def count_same_pair(list1, list2):\n    if len(list1) != len(list2):\n        raise ValueError(\"Both lists must have the same length\")\n    return sum(1 for a, b in zip(list1, list2) if a == b)\n\n# Test the function"}
{"task_id": "Mbpp/724", "solution": "def power_base_sum(base, power):\n    return sum(int(digit) for digit in str(base ** power))\n\n# Test the function\nassert power_base_sum(2,100)==115"}
{"task_id": "Mbpp/725", "solution": "import re\n\ndef extract_quotation(s):\n    return re.findall(r'\"([^\"]*)\"', s)\n\n# Test the function\nassert extract_quotation('Cortex \"A53\" Based \"multi\" tasking \"Processor\"') == ['A53', 'multi', 'Processor']"}
{"task_id": "Mbpp/726", "solution": "def multiply_elements(t):\n    return tuple(t[i] * t[i + 1] for i in range(len(t) - 1))\n\n# Test the function\nassert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80)"}
{"task_id": "Mbpp/728", "solution": "def sum_list(list1, list2):\n    return [a + b for a, b in zip(list1, list2)]\n\n# Test the function\nassert sum_list([10,20,30],[15,25,35])==[25,45,65]"}
{"task_id": "Mbpp/730", "solution": "def consecutive_duplicates(lst):\n    return [lst[i] for i in range(len(lst)) if i == 0 or lst[i] != lst[i-1]]\n\n# Test the function\nassert consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4 ])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4]"}
{"task_id": "Mbpp/731", "solution": "import math\n\ndef lateralsurface_cone(r, h):\n    return math.pi * r * math.sqrt(r**2 + h**2)\n\n# Test the function\nassert lateralsurface_cone(5, 12) == 204.20352248333654"}
{"task_id": "Mbpp/732", "solution": "def replace_specialchar(s):\n    s = s.replace(' ', ':')\n    s = s.replace(',', ':')\n    s = s.replace('.', ':')\n    return s\n\n# Test the function\nassert replace_specialchar('Python language, Programming language.') == 'Python:language::Programming:language:'"}
{"task_id": "Mbpp/733", "solution": "def find_first_occurrence(arr, target):\n    left, right = 0, len(arr) - 1\n    result = -1\n    while left <= right:\n        mid = left + (right - left) // 2\n        if arr[mid] == target:\n            result = mid\n            right = mid - 1\n        elif arr[mid] < target:\n            left = mid + 1\n        else:\n            right = mid - 1\n    return result\n\n# Test the function\nassert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1"}
{"task_id": "Mbpp/734", "solution": "def sum_Of_Subarray_Prod(lst):\n    n = len(lst)\n    prod = 0\n    for i in range(n):\n        for j in range(i+1, n+1):\n            sublist = lst[i:j]\n            product = 1\n            for num in sublist:\n                product *= num\n            prod += product\n    return prod\n\n# Test cases\nassert sum_Of_Subarray_Prod([1,2,3]) == 20"}
{"task_id": "Mbpp/735", "solution": "def toggle_middle_bits(n):\n    # Convert the number to binary and store it as a string\n    binary = bin(n)[2:]\n\n    # Toggle bits of the number except the first and the last bit\n    for i in range(1, len(binary) - 1):\n        if binary[i] == '1':\n            binary = binary[:i] + '0' + binary[i+1:]\n        else:\n            binary = binary[:i] + '1' + binary[i+1:]\n\n    # Convert the binary string back to an integer\n    return int(binary, 2)\n\n# Test the function\nassert toggle_middle_bits(9) == 15"}
{"task_id": "Mbpp/736", "solution": "def left_insertion(arr, val):\n    for i in range(len(arr)):\n        if arr[i] >= val:\n            return i\n    return len(arr)\n\n# Test the function\nassert left_insertion([1,2,4,5], 6) == 4"}
{"task_id": "Mbpp/737", "solution": "import re\n\ndef check_str(s):\n    return bool(re.match(r'^[aeiou]', s, re.IGNORECASE))\n\n# Test cases\nassert check_str(\"annie\") == True\nassert check_str(\"banana\") == False\nassert check_str(\"Elephant\") == True\nassert check_str(\"Dog\") == False"}
{"task_id": "Mbpp/739", "solution": "import math\n\ndef find_Index(n):\n    # The nth triangular number is given by the formula n*(n+1)/2\n    # We can rearrange this to solve for n: n = (sqrt(8*T + 1) - 1) / 2, where T is the triangular number\n    # We want to find the smallest such n that is greater than or equal to n\n    # So we can use the math.ceil function to round up to the nearest integer\n    return math.ceil((math.sqrt(8 * 10 ** (n-1) + 1) - 1) / 2)\n\n# Test the function\nassert find_Index(2) == 4"}
{"task_id": "Mbpp/740", "solution": "def tuple_to_dict(tup):\n    return {tup[i]: tup[i + 1] for i in range(0, len(tup), 2)}\n\n# Test the function\nassert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5}"}
{"task_id": "Mbpp/741", "solution": "def all_Characters_Same(s):\n    return len(set(s)) <= 1\n\n# Test cases"}
{"task_id": "Mbpp/742", "solution": "import math\n\ndef area_tetrahedron(edge_length):\n    # The formula to calculate the area of a tetrahedron is sqrt(3) * edge_length ** 2\n    return math.sqrt(3) * edge_length ** 2\n\n# Test the function\nassert area_tetrahedron(3) == 15.588457268119894"}
{"task_id": "Mbpp/743", "solution": "def rotate_right(lst, k):\n    # Calculate the effective rotation\n    k = k % len(lst)\n    # Use slicing to rotate the list\n    return lst[-k:] + lst[:-k]\n\n# Test the function\nassert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]"}
{"task_id": "Mbpp/744", "solution": "def check_none(tup):\n    return None in tup\n\n# Test the function\nassert check_none((10, 4, 5, 6, None)) == True"}
{"task_id": "Mbpp/745", "solution": "def divisible_by_digits(startnum, endnum):\n    result = []\n    for num in range(startnum, endnum+1):\n        if all(digit != 0 and num % digit == 0 for digit in map(int, str(num))):\n            result.append(num)\n    return result\n\nassert divisible_by_digits(1,22)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]"}
{"task_id": "Mbpp/748", "solution": "def capital_words_spaces(s):\n    return ' '.join(s.split())\n\n# Test cases\nassert capital_words_spaces(\"Python\") == 'Python'\nassert capital_words_spaces(\"HelloWorld\") == 'Hello World'\nassert capital_words_spaces(\"CapitalAfterSpace\") == 'Capital After Space'\nassert capital_words_spaces(\"Allcaps\") == 'Allcaps'\nassert capital_words_spaces(\"\") == ''\n"}
{"task_id": "Mbpp/749", "solution": "def sort_numeric_strings(lst):\n    return sorted(int(i) for i in lst)\n\nassert sort_numeric_strings(['4', '12', '45', '7', '0', '100', '200', '-12', '-500']) == [-500, -12, 0, 4, 7, 12, 45, 100, 200]"}
{"task_id": "Mbpp/750", "solution": "def add_tuple(lst, tup):\n    return lst + list(tup)\n\n# Test the function\nassert add_tuple([5, 6, 7], (9, 10)) == [5, 6, 7, 9, 10]"}
{"task_id": "Mbpp/751", "solution": "def check_min_heap(arr):\n    n = len(arr)\n\n    # Iterate from the parent nodes to the root node\n    for i in range(int(n/2)):\n        # If left child is greater than parent\n        if arr[i] > arr[2 * i + 1]:\n            return False\n\n        # If right child exists and is greater than parent\n        if 2 * i + 2 < n and arr[i] > arr[2 * i + 2]:\n            return False\n\n    return True\n\n# Test cases"}
{"task_id": "Mbpp/752", "solution": "def jacobsthal_num(n):\n    if n == 0:\n        return 0\n    elif n == 1:\n        return 1\n    else:\n        return 2 * jacobsthal_num(n - 1) + jacobsthal_num(n - 2)\n\n# Test the function\nassert jacobsthal_num(5) == 11"}
{"task_id": "Mbpp/753", "solution": "def min_k(records, k):\n    # Sort the records by the second element of each tuple\n    sorted_records = sorted(records, key=lambda x: x[1])\n    # Return the first k records\n    return sorted_records[:k]\n\n# Test cases\nassert min_k([('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)], 2) == [('Akash', 2), ('Akshat', 4)]"}
{"task_id": "Mbpp/754", "solution": "def extract_index_list(l1, l2, l3):\n    common_elements = []\n    for i in range(len(l1)):\n        if l1[i] == l2[i] == l3[i]:\n            common_elements.append(l1[i])\n    return common_elements\n\n# Test the function\nassert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 7]"}
{"task_id": "Mbpp/755", "solution": "def second_smallest(numbers):\n    m1, m2 = float('inf'), float('inf')\n    for x in numbers:\n        if x <= m1:\n            m1, m2 = x, m1\n        elif x < m2:\n            m2 = x\n    return m2\n\n# Test the function\nassert second_smallest([1, 2, -8, -2, 0, -2]) == -2"}
{"task_id": "Mbpp/757", "solution": "def count_reverse_pairs(lst):\n    count = 0\n    for i in range(len(lst)):\n        for j in range(i+1, len(lst)):\n            if lst[i] == lst[j][::-1]:\n                count += 1\n    return count\n\n# Test the function\nassert count_reverse_pairs([\"julia\", \"best\", \"tseb\", \"for\", \"ailuj\"]) == 2"}
{"task_id": "Mbpp/758", "solution": "def unique_sublists(lst):\n    count_dict = {}\n    for sublist in lst:\n        tuple_sublist = tuple(sublist)\n        if tuple_sublist in count_dict:\n            count_dict[tuple_sublist] += 1\n        else:\n            count_dict[tuple_sublist] = 1\n    return count_dict\n\n# Test the function\nassert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]]) == {(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1}"}
{"task_id": "Mbpp/759", "solution": "def is_decimal(s):\n    try:\n        float(s)\n    except ValueError:\n        return False\n    else:\n        parts = s.split('.')\n        if len(parts) == 2 and len(parts[1]) == 2:\n            return True\n        else:\n            return False\n\n# Test cases"}
{"task_id": "Mbpp/760", "solution": "def unique_Element(lst):\n    return len(set(lst)) <= 1\n\n# Test cases"}
{"task_id": "Mbpp/762", "solution": "def check_monthnumber_number(month_number):\n    # Months with 30 days: 4, 6, 9, 11\n    if month_number in [4, 6, 9, 11]:\n        return True\n    else:\n        return False\n\n# Test cases\nassert check_monthnumber_number(6) == True\nassert check_monthnumber_number(7) == False\nassert check_monthnumber_number(9) == True\nassert check_monthnumber_number(12) == False"}
{"task_id": "Mbpp/763", "solution": "def find_min_diff(arr, n):\n    arr = sorted(arr)\n    min_diff = float('inf')\n    for i in range(1, n):\n        diff = arr[i] - arr[i-1]\n        min_diff = min(min_diff, diff)\n    return min_diff\n\n# Test the function\nassert find_min_diff((1,5,3,19,18,25),6) == 1"}
{"task_id": "Mbpp/764", "solution": "def number_ctr(s):\n    return sum(c.isdigit() for c in s)\n\n# Test the function\nassert number_ctr('program2bedone') == 1"}
{"task_id": "Mbpp/765", "solution": "def is_polite(n):\n    def is_power_of_two(n):\n        return (n and (not(n & (n - 1))))\n\n    def find_next_power_of_two(n):\n        count = 0\n        while (n):\n            n >>= 1\n            count += 1\n        return count\n\n    if (is_power_of_two(n)):\n        return n << 1\n    else:\n        p = 1 << find_next_power_of_two(n)\n        q = p >> 1\n        if (n == (p + q - 1)):\n            return p\n        else:\n            return p + q\n\nassert is_polite(7) == 11"}
{"task_id": "Mbpp/766", "solution": "def pair_wise(lst):\n    return [(lst[i], lst[i + 1]) for i in range(len(lst) - 1)]\n\n# Test the function\nassert pair_wise([1,1,2,3,3,4,4,5])==[(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)]"}
{"task_id": "Mbpp/767", "solution": "def get_pairs_count(lst, total):\n    count = 0\n    length = len(lst)\n    for i in range(0, length):\n        for j in range(i+1, length):\n            if lst[i] + lst[j] == total:\n                count += 1\n    return count\n\n# Test the function\nassert get_pairs_count([1,1,1,1],2) == 6"}
{"task_id": "Mbpp/769", "solution": "def Diff(li1, li2): \n    return [i for i in li1+li2 if i not in li1 or i not in li2] \n\n# Test the function\nassert (Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35]) == [10, 20, 30, 15])"}
{"task_id": "Mbpp/770", "solution": "def odd_num_sum(n):\n    sum = 0\n    for i in range(1, 2*n, 2):\n        sum += i**4\n    return sum\n\n# Test the function\nassert odd_num_sum(2) == 82"}
{"task_id": "Mbpp/771", "solution": "def check_expression(expr):\n    stack = []\n    brackets = {'(': ')', '{': '}', '[': ']'}\n    for bracket in expr:\n        if bracket in brackets:\n            stack.append(bracket)\n        elif len(stack) == 0 or brackets[stack.pop()] != bracket:\n            return False\n    return len(stack) == 0\n\n# Test cases"}
{"task_id": "Mbpp/772", "solution": "def remove_length(s, k):\n    words = s.split()\n    words = [word for word in words if len(word) != k]\n    return ' '.join(words)\n\n# Test the function\nassert remove_length('The person is most value tet', 3) == 'person is most value'"}
{"task_id": "Mbpp/773", "solution": "def occurrence_substring(s, sub):\n    pos = s.find(sub)\n    if pos != -1:\n        return (sub, pos, pos+len(sub))\n    else:\n        return None\n\n# Test the function"}
{"task_id": "Mbpp/775", "solution": "def odd_position(lst):\n    return all(el % 2 != 0 for i, el in enumerate(lst) if i % 2 != 0)\n\n# Test the function\nassert odd_position([2,1,4,3,6,7,6,3]) == True"}
{"task_id": "Mbpp/777", "solution": "def find_sum(lst):\n    return sum(set(lst))\n\n# Test the function\nassert find_sum([1,2,3,1,1,4,5,6]) == 21"}
{"task_id": "Mbpp/778", "solution": "def pack_consecutive_duplicates(lst):\n    result = []\n    i = 0\n    while i < len(lst):\n        start = i\n        while i < len(lst) - 1 and lst[i] == lst[i + 1]:\n            i += 1\n        result.append(lst[start:i+1])\n        i += 1\n    return result\n\n# Test the function\nassert pack_consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]) == [[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]]"}
{"task_id": "Mbpp/780", "solution": "from itertools import combinations\n\ndef find_combinations(tuples):\n    result = []\n    for i in range(2, len(tuples)+1):\n        for combination in combinations(tuples, i):\n            result.append(tuple(sum(x) for x in zip(*combination)))\n    return result\n\nassert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)]"}
{"task_id": "Mbpp/781", "solution": "def count_divisors(n):\n    count = 0\n    for i in range(1, n + 1):\n        if n % i == 0:\n            count += 1\n    return count % 2 == 0\n\n# Test the function\nassert count_divisors(10)"}
{"task_id": "Mbpp/782", "solution": "def odd_length_sum(arr):\n    n = len(arr)\n    res = 0\n    for i in range(n):\n        res += ((i+1)*(n-i)+1)//2*arr[i]\n    return res\n\n# Test cases\nassert odd_length_sum([1,2,4]) == 14"}
{"task_id": "Mbpp/784", "solution": "def mul_even_odd(lst):\n    even_product = 1\n    odd_product = 1\n    for num in lst:\n        if num % 2 == 0:\n            even_product *= num\n        else:\n            odd_product *= num\n    return even_product, odd_product\n\n# Test the function\neven_product, odd_product = mul_even_odd([1,3,5,7,4,1,6,8])\nassert even_product == 4\nassert odd_product == 1680"}
{"task_id": "Mbpp/785", "solution": "def tuple_str_int(tup_str):\n    # Remove parentheses and split by comma\n    str_list = tup_str[1:-1].split(',')\n    # Convert each string to integer and return as tuple\n    return tuple(map(int, str_list))\n\n# Test the function\nassert tuple_str_int(\"(7, 8, 9)\") == (7, 8, 9)"}
{"task_id": "Mbpp/786", "solution": "def right_insertion(arr, target):\n    for i in range(len(arr)):\n        if arr[i] > target:\n            return i\n    return len(arr)\n\n# Test cases\nassert right_insertion([1,2,4,5], 6) == 4"}
{"task_id": "Mbpp/787", "solution": "import re\n\ndef text_match_three(text):\n    pattern = 'abbb'\n    if re.search(pattern, text):\n        return True\n    else:\n        return False\n\n# Test cases"}
{"task_id": "Mbpp/788", "solution": "def new_tuple(lst, string):\n    return tuple(lst + [string])\n\n# Test the function\nassert new_tuple([\"WEB\", \"is\"], \"best\") == ('WEB', 'is', 'best')"}
{"task_id": "Mbpp/790", "solution": "def even_position(lst):\n    for i in range(0, len(lst), 2):\n        if lst[i] % 2 != 0:\n            return False\n    return True\n\n# Test cases"}
{"task_id": "Mbpp/791", "solution": "def remove_nested(tup):\n    return tuple(i for i in tup if not isinstance(i, tuple))\n\n# Test the function\nassert remove_nested((1, 5, 7, (4, 6), 10)) == (1, 5, 7, 10)"}
{"task_id": "Mbpp/792", "solution": "def count_list(lst):\n    return len(lst)\n\n# Test the function\nassert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]]) == 4"}
{"task_id": "Mbpp/793", "solution": "def last(arr, target):\n    try:\n        return len(arr) - 1 - arr[::-1].index(target)\n    except ValueError:\n        return -1\n\n# Test cases"}
{"task_id": "Mbpp/794", "solution": "import re\n\ndef text_starta_endb(text):\n    pattern = 'a.*b$'\n    if re.search(pattern, text):\n        return True\n    else:\n        return False\n\n# Test cases\nassert text_starta_endb(\"aabbbb\") == True\nassert text_starta_endb(\"ababab\") == False\nassert text_starta_endb(\"a\") == False\nassert text_starta_endb(\"b\") == False\nassert text_starta_endb(\"ab\") == True"}
{"task_id": "Mbpp/796", "solution": "def return_sum(dictionary):\n    return sum(dictionary.values())\n\n# Test the function\nassert return_sum({'a': 100, 'b':200, 'c':300}) == 600"}
{"task_id": "Mbpp/797", "solution": "def sum_in_range(l, r):\n    return sum(i for i in range(l, r+1) if i % 2 != 0)\n\n# Test the function\nassert sum_in_range(2,5) == 8"}
{"task_id": "Mbpp/798", "solution": "def _sum(arr):\n    return sum(arr)\n\n# Test the function\nassert _sum([1, 2, 3]) == 6"}
{"task_id": "Mbpp/799", "solution": "def left_rotate(n, d):\n    \"\"\"\n    Function to rotate left bits of a number by d bits.\n    \"\"\"\n    # In n<<d, last d bits are 0. To put first 32-d bits of n at last, do bitwise or of n<<d and n>>(32-d)\n    return (n << d)|(n >> (32 - d))\n\n# Test the function\nassert left_rotate(16, 2) == 64"}
{"task_id": "Mbpp/800", "solution": "def remove_all_spaces(input_string):\n    return input_string.replace(' ', '')\n\n# Test the function\nassert remove_all_spaces('python  program') == 'pythonprogram'"}
{"task_id": "Mbpp/801", "solution": "def test_three_equal(a, b, c):\n    if a == b and b == c:\n        return 3\n    elif a == b or a == c or b == c:\n        return 2\n    else:\n        return 0\n\n# Test cases"}
{"task_id": "Mbpp/803", "solution": "def is_perfect_square(n):\n    if n < 0:\n        return False\n    if n == 0 or n == 1:\n        return True\n    x = n // 2\n    seen = set([x])\n    while x * x != n:\n        x = (x + (n // x)) // 2\n        if x in seen:\n            return False\n        seen.add(x)\n    return True\n\n# Test cases\nassert not is_perfect_square(10)"}
{"task_id": "Mbpp/804", "solution": "def is_product_even(lst):\n    product = 1\n    for num in lst:\n        product *= num\n    return product % 2 == 0\n\n# Test the function\nassert is_product_even([1, 2, 3]) == False"}
{"task_id": "Mbpp/805", "solution": "def max_sum_list(lst):\n    return max(lst, key=sum)\n\n# Test the function\nassert max_sum_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]]) == [10, 11, 12]"}
{"task_id": "Mbpp/806", "solution": "def max_run_uppercase(s):\n    max_length = 0\n    current_length = 0\n    for char in s:\n        if char.isupper():\n            current_length += 1\n            max_length = max(max_length, current_length)\n        else:\n            current_length = 0\n    return max_length\n\n# Test the function\nassert max_run_uppercase('GeMKSForGERksISBESt') == 5"}
{"task_id": "Mbpp/807", "solution": "def first_odd(numbers):\n    for num in numbers:\n        if num % 2 != 0:\n            return num\n    return None\n\n# Test cases\nassert first_odd([1,3,5]) == 1\nassert first_odd([2,4,6]) == None\nassert first_odd([2,4,1,6,7]) == 1\nassert first_odd([4,6,8]) == None"}
{"task_id": "Mbpp/808", "solution": "def check_K(tup, k):\n    return k in tup\n\n# Test the function\nassert check_K((10, 4, 5, 6, 8), 6) == True"}
{"task_id": "Mbpp/809", "solution": "def check_smaller(t1, t2):\n    return all(x < y for x, y in zip(t1, t2))\n\n# Test the function"}