test/MBPP.json

[
  {
    "question": "Write a python function to remove first and last occurrence of a given character from the string.\nYour code should pass the test:\nassert remove_Occ(\"hello\",\"l\") == \"heo\"\n",
    "test_list": [
      "assert remove_Occ(\"hello\",\"l\") == \"heo\"",
      "assert remove_Occ(\"abcda\",\"a\") == \"bcd\"",
      "assert remove_Occ(\"PHP\",\"P\") == \"H\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a given matrix in ascending order according to the sum of its rows.\nYour code should pass the test:\nassert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]])==[[1, 1, 1], [1, 2, 3], [2, 4, 5]]\n",
    "test_list": [
      "assert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]])==[[1, 1, 1], [1, 2, 3], [2, 4, 5]]",
      "assert sort_matrix([[1, 2, 3], [-2, 4, -5], [1, -1, 1]])==[[-2, 4, -5], [1, -1, 1], [1, 2, 3]]",
      "assert sort_matrix([[5,8,9],[6,4,3],[2,1,4]])==[[2, 1, 4], [6, 4, 3], [5, 8, 9]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count the most common words in a dictionary.\nYour code should pass the test:\nassert count_common(['red','green','black','pink','black','white','black','eyes','white','black','orange','pink','pink','red','red','white','orange','white',\"black\",'pink','green','green','pink','green','pink','white','orange',\"orange\",'red']) == [('pink', 6), ('black', 5), ('white', 5), ('red', 4)]\n",
    "test_list": [
      "assert count_common(['red','green','black','pink','black','white','black','eyes','white','black','orange','pink','pink','red','red','white','orange','white',\"black\",'pink','green','green','pink','green','pink','white','orange',\"orange\",'red']) == [('pink', 6), ('black', 5), ('white', 5), ('red', 4)]",
      "assert count_common(['one', 'two', 'three', 'four', 'five', 'one', 'two', 'one', 'three', 'one']) == [('one', 4), ('two', 2), ('three', 2), ('four', 1)]",
      "assert count_common(['Facebook', 'Apple', 'Amazon', 'Netflix', 'Google', 'Apple', 'Netflix', 'Amazon']) == [('Apple', 2), ('Amazon', 2), ('Netflix', 2), ('Facebook', 1)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the volume of a triangular prism.\nYour code should pass the test:\nassert find_Volume(10,8,6) == 240\n",
    "test_list": [
      "assert find_Volume(10,8,6) == 240",
      "assert find_Volume(3,2,2) == 6",
      "assert find_Volume(1,2,1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to split a string at lowercase letters.\nYour code should pass the test:\nassert split_lowerstring(\"AbCd\")==['bC','d']\n",
    "test_list": [
      "assert split_lowerstring(\"AbCd\")==['bC','d']",
      "assert split_lowerstring(\"Python\")==['y', 't', 'h', 'o', 'n']",
      "assert split_lowerstring(\"Programming\")==['r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'n', 'g']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find sequences of lowercase letters joined with an underscore.\nYour code should pass the test:\nassert text_lowercase_underscore(\"aab_cbbbc\")==('Found a match!')\n",
    "test_list": [
      "assert text_lowercase_underscore(\"aab_cbbbc\")==('Found a match!')",
      "assert text_lowercase_underscore(\"aab_Abbbc\")==('Not matched!')",
      "assert text_lowercase_underscore(\"Aaab_abbbc\")==('Not matched!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the perimeter of a square.\nYour code should pass the test:\nassert square_perimeter(10)==40\n",
    "test_list": [
      "assert square_perimeter(10)==40",
      "assert square_perimeter(5)==20",
      "assert square_perimeter(4)==16"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove characters from the first string which are present in the second string.\nYour code should pass the test:\nassert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'\n",
    "test_list": [
      "assert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'",
      "assert remove_dirty_chars(\"digitalindia\", \"talent\") == 'digiidi'",
      "assert remove_dirty_chars(\"exoticmiles\", \"toxic\") == 'emles' "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find whether a given array of integers contains any duplicate element.\nYour code should pass the test:\nassert test_duplicate(([1,2,3,4,5]))==False\n",
    "test_list": [
      "assert test_duplicate(([1,2,3,4,5]))==False",
      "assert test_duplicate(([1,2,3,4, 4]))==True",
      "assert test_duplicate([1,1,2,2,3,3,4,4,5])==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if the given number is woodball or not.\nYour code should pass the test:\nassert is_woodall(383) == True\n",
    "test_list": [
      "assert is_woodall(383) == True",
      "assert is_woodall(254) == False",
      "assert is_woodall(200) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find m number of multiples of n.\nYour code should pass the test:\nassert multiples_of_num(4,3)== [3,6,9,12]\n",
    "test_list": [
      "assert multiples_of_num(4,3)== [3,6,9,12]",
      "assert multiples_of_num(2,5)== [5,10]",
      "assert multiples_of_num(9,2)== [2,4,6,8,10,12,14,16,18]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the first duplicate element in a given array of integers.\nYour code should pass the test:\nassert find_first_duplicate(([1, 2, 3, 4, 4, 5]))==4\n",
    "test_list": [
      "assert find_first_duplicate(([1, 2, 3, 4, 4, 5]))==4",
      "assert find_first_duplicate([1, 2, 3, 4])==-1",
      "assert find_first_duplicate([1, 1, 2, 3, 3, 2, 2])==1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum sum of elements of list in a list of lists.\nYour code should pass the test:\nassert maximum_Sum([[1,2,3],[4,5,6],[10,11,12],[7,8,9]]) == 33\n",
    "test_list": [
      "assert maximum_Sum([[1,2,3],[4,5,6],[10,11,12],[7,8,9]]) == 33",
      "assert maximum_Sum([[0,1,1],[1,1,2],[3,2,1]]) == 6",
      "assert maximum_Sum([[0,1,3],[1,2,1],[9,8,2],[0,1,0],[6,4,8]]) == 19"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert the given binary number to its decimal equivalent.\nYour code should pass the test:\nassert binary_to_decimal(100) == 4\n",
    "test_list": [
      "assert binary_to_decimal(100) == 4",
      "assert binary_to_decimal(1011) == 11",
      "assert binary_to_decimal(1101101) == 109"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the product of non-repeated elements in a given array.\nYour code should pass the test:\nassert find_Product([1,1,2,3],4) == 6\n",
    "test_list": [
      "assert find_Product([1,1,2,3],4) == 6",
      "assert find_Product([1,2,3,1,1],5) == 6",
      "assert find_Product([1,1,4,5,6],5) == 120"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if the given tuple list has all k elements.\nYour code should pass the test:\nassert check_k_elements([(4, 4), (4, 4, 4), (4, 4), (4, 4, 4, 4), (4, )], 4) == True\n",
    "test_list": [
      "assert check_k_elements([(4, 4), (4, 4, 4), (4, 4), (4, 4, 4, 4), (4, )], 4) == True",
      "assert check_k_elements([(7, 7, 7), (7, 7)], 7) == True",
      "assert check_k_elements([(9, 9), (9, 9, 9, 9)], 7) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to remove all digits from a list of strings.\nYour code should pass the test:\nassert remove(['4words', '3letters', '4digits']) == ['words', 'letters', 'digits']\n",
    "test_list": [
      "assert remove(['4words', '3letters', '4digits']) == ['words', 'letters', 'digits']",
      "assert remove(['28Jan','12Jan','11Jan']) == ['Jan','Jan','Jan']",
      "assert remove(['wonder1','wonder2','wonder3']) == ['wonder','wonder','wonder']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find binomial co-efficient.\nYour code should pass the test:\nassert binomial_Coeff(5,2) == 10\n",
    "test_list": [
      "assert binomial_Coeff(5,2) == 10",
      "assert binomial_Coeff(4,3) == 4",
      "assert binomial_Coeff(3,2) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the element occurring odd number of times.\nYour code should pass the test:\nassert get_Odd_Occurrence([1,2,3,1,2,3,1],7) == 1\n",
    "test_list": [
      "assert get_Odd_Occurrence([1,2,3,1,2,3,1],7) == 1",
      "assert get_Odd_Occurrence([1,2,3,2,3,1,3],7) == 3",
      "assert get_Odd_Occurrence([2,3,5,4,5,2,4,3,5,2,4,4,2],13) == 5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count all the substrings starting and ending with same characters.\nYour code should pass the test:\nassert count_Substring_With_Equal_Ends(\"abc\") == 3\n",
    "test_list": [
      "assert count_Substring_With_Equal_Ends(\"abc\") == 3",
      "assert count_Substring_With_Equal_Ends(\"abcda\") == 6",
      "assert count_Substring_With_Equal_Ends(\"ab\") == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the top k integers that occur most frequently from given lists of sorted and distinct integers using heap queue algorithm.\nYour code should pass the test:\nassert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],3)==[5, 7, 1]\n",
    "test_list": [
      "assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],3)==[5, 7, 1]",
      "assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],1)==[1]",
      "assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],5)==[6, 5, 7, 8, 1]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the largest prime factor of a given number.\nYour code should pass the test:\nassert max_Prime_Factors(15) == 5\n",
    "test_list": [
      "assert max_Prime_Factors(15) == 5",
      "assert max_Prime_Factors(6) == 3",
      "assert max_Prime_Factors(2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to convert a decimal number to binary number.\nYour code should pass the test:\nassert decimal_To_Binary(10) == 1010\n",
    "test_list": [
      "assert decimal_To_Binary(10) == 1010",
      "assert decimal_To_Binary(1) == 1",
      "assert decimal_To_Binary(20) == 10100"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the missing number in a sorted array.\nYour code should pass the test:\nassert find_missing([1,2,3,5],4) == 4\n",
    "test_list": [
      "assert find_missing([1,2,3,5],4) == 4",
      "assert find_missing([1,3,4,5],4) == 2",
      "assert find_missing([1,2,3,5,6,7],5) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n-th rectangular number.\nYour code should pass the test:\nassert find_rect_num(4) == 20\n",
    "test_list": [
      "assert find_rect_num(4) == 20",
      "assert find_rect_num(5) == 30",
      "assert find_rect_num(6) == 42"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the nth digit in the proper fraction of two given numbers.\nYour code should pass the test:\nassert find_Nth_Digit(1,2,1) == 5\n",
    "test_list": [
      "assert find_Nth_Digit(1,2,1) == 5",
      "assert find_Nth_Digit(3,5,1) == 6",
      "assert find_Nth_Digit(5,6,5) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a given mixed list of integers and strings.\nYour code should pass the test:\nassert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']\n",
    "test_list": [
      "assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']",
      "assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']",
      "assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the division of first even and odd number of a given list.\nYour code should pass the test:\nassert div_even_odd([1,3,5,7,4,1,6,8])==4\n",
    "test_list": [
      "assert div_even_odd([1,3,5,7,4,1,6,8])==4",
      "assert div_even_odd([1,2,3,4,5,6,7,8,9,10])==2",
      "assert div_even_odd([1,5,7,9,10])==10"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if the letters of a given string can be rearranged so that two characters that are adjacent to each other are different.\nYour code should pass the test:\nassert rearange_string(\"aab\")==('aba')\n",
    "test_list": [
      "assert rearange_string(\"aab\")==('aba')",
      "assert rearange_string(\"aabb\")==('abab')",
      "assert rearange_string(\"abccdd\")==('cdabcd')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find frequency of the elements in a given list of lists using collections module.\nYour code should pass the test:\nassert freq_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]])==({2: 3, 1: 2, 5: 2, 3: 1, 4: 1, 6: 1, 7: 1, 9: 1})\n",
    "test_list": [
      "assert freq_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]])==({2: 3, 1: 2, 5: 2, 3: 1, 4: 1, 6: 1, 7: 1, 9: 1})",
      "assert freq_element([[1,2,3,4],[5,6,7,8],[9,10,11,12]])==({1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1, 12: 1})",
      "assert freq_element([[15,20,30,40],[80,90,100,110],[30,30,80,90]])==({30: 3, 80: 2, 90: 2, 15: 1, 20: 1, 40: 1, 100: 1, 110: 1})"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to filter even numbers using lambda function.\nYour code should pass the test:\nassert filter_evennumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[2, 4, 6, 8, 10]\n",
    "test_list": [
      "assert filter_evennumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[2, 4, 6, 8, 10]",
      "assert filter_evennumbers([10,20,45,67,84,93])==[10,20,84]",
      "assert filter_evennumbers([5,7,9,8,6,4,3])==[8,6,4]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of repeated elements in a given array.\nYour code should pass the test:\nassert find_Sum([1,2,3,1,1,4,5,6],8) == 3\n",
    "test_list": [
      "assert find_Sum([1,2,3,1,1,4,5,6],8) == 3",
      "assert find_Sum([1,2,3,1,1],5) == 3",
      "assert find_Sum([1,1,2],3) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find sequences of lowercase letters joined with an underscore using regex.\nYour code should pass the test:\nassert text_match(\"aab_cbbbc\") == 'Found a match!'\n",
    "test_list": [
      "assert text_match(\"aab_cbbbc\") == 'Found a match!'",
      "assert text_match(\"aab_Abbbc\") == 'Not matched!'",
      "assert text_match(\"Aaab_abbbc\") == 'Not matched!'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that matches a word at the beginning of a string.\nYour code should pass the test:\nassert text_match_string(\" python\")==('Not matched!')\n",
    "test_list": [
      "assert text_match_string(\" python\")==('Not matched!')",
      "assert text_match_string(\"python\")==('Found a match!')",
      "assert text_match_string(\"  lang\")==('Not matched!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the gcd of the given array elements.\nYour code should pass the test:\nassert get_gcd([2, 4, 6, 8, 16]) == 2\n",
    "test_list": [
      "assert get_gcd([2, 4, 6, 8, 16]) == 2",
      "assert get_gcd([1, 2, 3]) == 1",
      "assert get_gcd([2, 4, 6, 8]) == 2 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to determine whether all the numbers are different from each other are not.\nYour code should pass the test:\nassert test_distinct([1,5,7,9]) == True\n",
    "test_list": [
      "assert test_distinct([1,5,7,9]) == True",
      "assert test_distinct([2,4,5,5,7,9]) == False",
      "assert test_distinct([1,2,3]) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the last digit when factorial of a divides factorial of b.\nYour code should pass the test:\nassert compute_Last_Digit(2,4) == 2\n",
    "test_list": [
      "assert compute_Last_Digit(2,4) == 2",
      "assert compute_Last_Digit(6,8) == 6",
      "assert compute_Last_Digit(1,2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to set all odd bits of a given number.\nYour code should pass the test:\nassert odd_bit_set_number(10) == 15\n",
    "test_list": [
      "assert odd_bit_set_number(10) == 15",
      "assert odd_bit_set_number(20) == 21",
      "assert odd_bit_set_number(30) == 31"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract every first or specified element from a given two-dimensional list.\nYour code should pass the test:\nassert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]\n",
    "test_list": [
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]",
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],2)==[3, 6, 9]",
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],1)==[2,5,1]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the list with minimum length using lambda function.\nYour code should pass the test:\nassert min_length_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(1, [0])\n",
    "test_list": [
      "assert min_length_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(1, [0])",
      "assert min_length_list([[1,2,3,4,5],[1,2,3,4],[1,2,3],[1,2],[1]])==(1,[1])",
      "assert min_length_list([[3,4,5],[6,7,8,9],[10,11,12],[1,2]])==(2,[1,2])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to print check if the triangle is equilateral or not.\nYour code should pass the test:\nassert check_equilateral(6,8,12)==False \n",
    "test_list": [
      "assert check_equilateral(6,8,12)==False ",
      "assert check_equilateral(6,6,12)==False",
      "assert check_equilateral(6,6,6)==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to caluclate area of a parallelogram.\nYour code should pass the test:\nassert parallelogram_area(10,20)==200\n",
    "test_list": [
      "assert parallelogram_area(10,20)==200",
      "assert parallelogram_area(15,20)==300",
      "assert parallelogram_area(8,9)==72"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the first and last characters of a given string are equal or not.\nYour code should pass the test:\nassert check_Equality(\"abcda\") == \"Equal\"\n",
    "test_list": [
      "assert check_Equality(\"abcda\") == \"Equal\"",
      "assert check_Equality(\"ab\") == \"Not Equal\"",
      "assert check_Equality(\"mad\") == \"Not Equal\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort the given array by using counting sort.\nYour code should pass the test:\nassert counting_sort([1,23,4,5,6,7,8]) == [1, 4, 5, 6, 7, 8, 23]\n",
    "test_list": [
      "assert counting_sort([1,23,4,5,6,7,8]) == [1, 4, 5, 6, 7, 8, 23]",
      "assert counting_sort([12, 9, 28, 33, 69, 45]) == [9, 12, 28, 33, 45, 69]",
      "assert counting_sort([8, 4, 14, 3, 2, 1]) == [1, 2, 3, 4, 8, 14]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find t-nth term of geometric series.\nYour code should pass the test:\nassert tn_gp(1,5,2)==16\n",
    "test_list": [
      "assert tn_gp(1,5,2)==16",
      "assert tn_gp(1,5,4)==256",
      "assert tn_gp(2,6,3)==486"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check if a given number is one less than twice its reverse.\nYour code should pass the test:\nassert check(70) == False\n",
    "test_list": [
      "assert check(70) == False",
      "assert check(23) == False",
      "assert check(73) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the largest number that can be formed with the given digits.\nYour code should pass the test:\nassert find_Max_Num([1,2,3],3) == 321\n",
    "test_list": [
      "assert find_Max_Num([1,2,3],3) == 321",
      "assert find_Max_Num([4,5,6,1],4) == 6541",
      "assert find_Max_Num([1,2,3,9],4) == 9321"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given two integers have opposite sign or not.\nYour code should pass the test:\nassert opposite_Signs(1,-2) == True\n",
    "test_list": [
      "assert opposite_Signs(1,-2) == True",
      "assert opposite_Signs(3,2) == False",
      "assert opposite_Signs(-10,-10) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nth octagonal number.\nYour code should pass the test:\nassert is_octagonal(5) == 65\n",
    "test_list": [
      "assert is_octagonal(5) == 65",
      "assert is_octagonal(10) == 280",
      "assert is_octagonal(15) == 645"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum length of the subsequence with difference between adjacent elements for the given array.\nYour code should pass the test:\nassert max_len_sub([2, 5, 6, 3, 7, 6, 5, 8], 8) == 5\n",
    "test_list": [
      "assert max_len_sub([2, 5, 6, 3, 7, 6, 5, 8], 8) == 5",
      "assert max_len_sub([-2, -1, 5, -1, 4, 0, 3], 7) == 4",
      "assert max_len_sub([9, 11, 13, 15, 18], 5) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count number of substrings with the sum of digits equal to their length.\nYour code should pass the test:\nassert count_Substrings('112112',6) == 6\n",
    "test_list": [
      "assert count_Substrings('112112',6) == 6",
      "assert count_Substrings('111',3) == 6",
      "assert count_Substrings('1101112',7) == 12"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find smallest number in a list.\nYour code should pass the test:\nassert smallest_num([10, 20, 1, 45, 99]) == 1\n",
    "test_list": [
      "assert smallest_num([10, 20, 1, 45, 99]) == 1",
      "assert smallest_num([1, 2, 3]) == 1",
      "assert smallest_num([45, 46, 50, 60]) == 45"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum difference between available pairs in the given tuple list.\nYour code should pass the test:\nassert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7\n",
    "test_list": [
      "assert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7",
      "assert max_difference([(4, 6), (2, 17), (9, 13), (11, 12)]) == 15",
      "assert max_difference([(12, 35), (21, 27), (13, 23), (41, 22)]) == 23"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a list of tuples using lambda.\nYour code should pass the test:\nassert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])==[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]\n",
    "test_list": [
      "assert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])==[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]",
      "assert subject_marks([('Telugu',49),('Hindhi',54),('Social',33)])==([('Social',33),('Telugu',49),('Hindhi',54)])",
      "assert subject_marks([('Physics',96),('Chemistry',97),('Biology',45)])==([('Biology',45),('Physics',96),('Chemistry',97)])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function of recursion list sum.\nYour code should pass the test:\nassert recursive_list_sum(([1, 2, [3,4],[5,6]]))==21\n",
    "test_list": [
      "assert recursive_list_sum(([1, 2, [3,4],[5,6]]))==21",
      "assert recursive_list_sum(([7, 10, [15,14],[19,41]]))==106",
      "assert recursive_list_sum(([10, 20, [30,40],[50,60]]))==210"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count positive numbers in a list.\nYour code should pass the test:\nassert pos_count([1,-2,3,-4]) == 2\n",
    "test_list": [
      "assert pos_count([1,-2,3,-4]) == 2",
      "assert pos_count([3,4,5,-1]) == 3",
      "assert pos_count([1,2,3,4]) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the number of ways to partition a set of bell numbers.\nYour code should pass the test:\nassert bell_number(2)==2\n",
    "test_list": [
      "assert bell_number(2)==2",
      "assert bell_number(10)==115975",
      "assert bell_number(56)==6775685320645824322581483068371419745979053216268760300"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given array is monotonic or not.\nYour code should pass the test:\nassert is_Monotonic([6, 5, 4, 4]) == True\n",
    "test_list": [
      "assert is_Monotonic([6, 5, 4, 4]) == True",
      "assert is_Monotonic([1, 2, 2, 3]) == True",
      "assert is_Monotonic([1, 3, 2]) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether a list contains the given sublist or not.\nYour code should pass the test:\nassert is_sublist([2,4,3,5,7],[3,7])==False\n",
    "test_list": [
      "assert is_sublist([2,4,3,5,7],[3,7])==False",
      "assert is_sublist([2,4,3,5,7],[4,3])==True",
      "assert is_sublist([2,4,3,5,7],[1,6])==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find whether all the given tuples have equal length or not.\nYour code should pass the test:\nassert get_equal([(11, 22, 33), (44, 55, 66)], 3) == 'All tuples have same length'\n",
    "test_list": [
      "assert get_equal([(11, 22, 33), (44, 55, 66)], 3) == 'All tuples have same length'",
      "assert get_equal([(1, 2, 3), (4, 5, 6, 7)], 3) == 'All tuples do not have same length'",
      "assert get_equal([(1, 2), (3, 4)], 2) == 'All tuples have same length'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a list of elements using comb sort.\nYour code should pass the test:\nassert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]\n",
    "test_list": [
      "assert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]",
      "assert comb_sort([41, 32, 15, 19, 22]) == [15, 19, 22, 32, 41]",
      "assert comb_sort([99, 15, 13, 47]) == [13, 15, 47, 99]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given number can be represented as difference of two squares or not.\nYour code should pass the test:\nassert dif_Square(5) == True\n",
    "test_list": [
      "assert dif_Square(5) == True",
      "assert dif_Square(10) == False",
      "assert dif_Square(15) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to split the given string with multiple delimiters by using regex.\nYour code should pass the test:\nassert multiple_split('Forces of the \\ndarkness*are coming into the play.') == ['Forces of the ', 'darkness', 'are coming into the play.']\n",
    "test_list": [
      "assert multiple_split('Forces of the \\ndarkness*are coming into the play.') == ['Forces of the ', 'darkness', 'are coming into the play.']",
      "assert multiple_split('Mi Box runs on the \\n Latest android*which has google assistance and chromecast.') == ['Mi Box runs on the ', ' Latest android', 'which has google assistance and chromecast.']",
      "assert multiple_split('Certain services\\nare subjected to change*over the seperate subscriptions.') == ['Certain services', 'are subjected to change', 'over the seperate subscriptions.']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether it follows the sequence given in the patterns array.\nYour code should pass the test:\nassert is_samepatterns([\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"])==True \n",
    "test_list": [
      "assert is_samepatterns([\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"])==True ",
      "assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\",\"b\"])==False ",
      "assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\"])==False "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find tuples which have all elements divisible by k from the given list of tuples.\nYour code should pass the test:\nassert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == '[(6, 24, 12)]'\n",
    "test_list": [
      "assert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == '[(6, 24, 12)]'",
      "assert find_tuples([(5, 25, 30), (4, 2, 3), (7, 8, 9)], 5) == '[(5, 25, 30)]'",
      "assert find_tuples([(7, 9, 16), (8, 16, 4), (19, 17, 18)], 4) == '[(8, 16, 4)]'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of squares in a rectangle.\nYour code should pass the test:\nassert count_Squares(4,3) == 20\n",
    "test_list": [
      "assert count_Squares(4,3) == 20",
      "assert count_Squares(2,2) == 5",
      "assert count_Squares(1,1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the difference between sum of even and odd digits.\nYour code should pass the test:\nassert is_Diff (12345) == False\n",
    "test_list": [
      "assert is_Diff (12345) == False",
      "assert is_Diff(1212112) == True",
      "assert is_Diff(1212) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find number of integers with odd number of set bits.\nYour code should pass the test:\nassert count_With_Odd_SetBits(5) == 3\n",
    "test_list": [
      "assert count_With_Odd_SetBits(5) == 3",
      "assert count_With_Odd_SetBits(10) == 5",
      "assert count_With_Odd_SetBits(15) == 8"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the length of the word is odd or not.\nYour code should pass the test:\nassert word_len(\"Hadoop\") == False\n",
    "test_list": [
      "assert word_len(\"Hadoop\") == False",
      "assert word_len(\"great\") == True",
      "assert word_len(\"structure\") == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nth tetrahedral number.\nYour code should pass the test:\nassert tetrahedral_number(5) == 35.0\n",
    "test_list": [
      "assert tetrahedral_number(5) == 35.0",
      "assert tetrahedral_number(6) == 56.0",
      "assert tetrahedral_number(7) == 84.0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to zip the two given tuples.\nYour code should pass the test:\nassert zip_tuples((7, 8, 4, 5, 9, 10),(1, 5, 6) ) == [(7, 1), (8, 5), (4, 6), (5, 1), (9, 5), (10, 6)]\n",
    "test_list": [
      "assert zip_tuples((7, 8, 4, 5, 9, 10),(1, 5, 6) ) == [(7, 1), (8, 5), (4, 6), (5, 1), (9, 5), (10, 6)]",
      "assert zip_tuples((8, 9, 5, 6, 10, 11),(2, 6, 7) ) == [(8, 2), (9, 6), (5, 7), (6, 2), (10, 6), (11, 7)]",
      "assert zip_tuples((9, 10, 6, 7, 11, 12),(3, 7, 8) ) == [(9, 3), (10, 7), (6, 8), (7, 3), (11, 7), (12, 8)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the volume of a sphere.\nYour code should pass the test:\nassert volume_sphere(10)==4188.790204786391\n",
    "test_list": [
      "assert volume_sphere(10)==4188.790204786391",
      "assert volume_sphere(25)==65449.84694978735",
      "assert volume_sphere(20)==33510.32163829113"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the character made by adding all the characters of the given string.\nYour code should pass the test:\nassert get_Char(\"abc\") == \"f\"\n",
    "test_list": [
      "assert get_Char(\"abc\") == \"f\"",
      "assert get_Char(\"gfg\") == \"t\"",
      "assert get_Char(\"ab\") == \"c\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n-th number in newman conway sequence.\nYour code should pass the test:\nassert sequence(10) == 6\n",
    "test_list": [
      "assert sequence(10) == 6",
      "assert sequence(2) == 1",
      "assert sequence(3) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the surface area of a sphere.\nYour code should pass the test:\nassert surfacearea_sphere(10)==1256.6370614359173\n",
    "test_list": [
      "assert surfacearea_sphere(10)==1256.6370614359173",
      "assert surfacearea_sphere(15)==2827.4333882308138",
      "assert surfacearea_sphere(20)==5026.548245743669"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find nth centered hexagonal number.\nYour code should pass the test:\nassert centered_hexagonal_number(10) == 271\n",
    "test_list": [
      "assert centered_hexagonal_number(10) == 271",
      "assert centered_hexagonal_number(2) == 7",
      "assert centered_hexagonal_number(9) == 217"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to merge three dictionaries into a single expression.\nYour code should pass the test:\nassert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{ \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}\n",
    "test_list": [
      "assert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{ \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}",
      "assert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{\"L\":\"lavender\",\"B\":\"Blue\"})=={'W': 'White', 'P': 'Pink', 'B': 'Black', 'R': 'Red', 'G': 'Green', 'L': 'lavender'}",
      "assert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" },{\"L\":\"lavender\",\"B\":\"Blue\"},{ \"G\": \"Green\", \"W\": \"White\" })=={'B': 'Black', 'P': 'Pink', 'R': 'Red', 'G': 'Green', 'L': 'lavender', 'W': 'White'}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to get the frequency of the elements in a list.\nYour code should pass the test:\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}) \n",
    "test_list": [
      "assert 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}) ",
      "assert freq_count([1,2,3,4,3,2,4,1,3,1,4])==({1:3, 2:2,3:3,4:3}) ",
      "assert freq_count([5,6,7,4,9,10,4,5,6,7,9,5])==({10:1,5:3,6:2,7:2,4:2,9:2}) "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the closest smaller number than n.\nYour code should pass the test:\nassert closest_num(11) == 10\n",
    "test_list": [
      "assert closest_num(11) == 10",
      "assert closest_num(7) == 6",
      "assert closest_num(12) == 11"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the length of the longest word.\nYour code should pass the test:\nassert len_log([\"python\",\"PHP\",\"bigdata\"]) == 7\n",
    "test_list": [
      "assert len_log([\"python\",\"PHP\",\"bigdata\"]) == 7",
      "assert len_log([\"a\",\"ab\",\"abc\"]) == 3",
      "assert len_log([\"small\",\"big\",\"tall\"]) == 5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if a substring is present in a given list of string values.\nYour code should pass the test:\nassert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True\n",
    "test_list": [
      "assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True",
      "assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"abc\")==False",
      "assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ange\")==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the given number is undulating or not.\nYour code should pass the test:\nassert is_undulating(\"1212121\") == True\n",
    "test_list": [
      "assert is_undulating(\"1212121\") == True",
      "assert is_undulating(\"1991\") == False",
      "assert is_undulating(\"121\") == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the value of 'a' to the power 'b'.\nYour code should pass the test:\nassert power(3,4) == 81\n",
    "test_list": [
      "assert power(3,4) == 81",
      "assert power(2,3) == 8",
      "assert power(5,5) == 3125"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the index minimum value record from the given tuples.\nYour code should pass the test:\nassert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'\n",
    "test_list": [
      "assert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'",
      "assert index_minimum([('Yash', 185), ('Dawood', 125), ('Sanya', 175)]) == 'Dawood'",
      "assert index_minimum([('Sai', 345), ('Salman', 145), ('Ayesha', 96)]) == 'Ayesha'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the minimum length of sublist.\nYour code should pass the test:\nassert Find_Min_Length([[1],[1,2]]) == 1\n",
    "test_list": [
      "assert Find_Min_Length([[1],[1,2]]) == 1",
      "assert Find_Min_Length([[1,2],[1,2,3],[1,2,3,4]]) == 2",
      "assert Find_Min_Length([[3,3,3],[4,4,4,4]]) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the number of divisors of a given integer.\nYour code should pass the test:\nassert divisor(15) == 4 \n",
    "test_list": [
      "assert divisor(15) == 4 ",
      "assert divisor(12) == 6",
      "assert divisor(9) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find frequency count of list of lists.\nYour code should pass the test:\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}\n",
    "test_list": [
      "assert 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}",
      "assert frequency_lists([[1,2,3,4],[5,6,7,8],[9,10,11,12]])=={1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1,10:1,11:1,12:1}",
      "assert frequency_lists([[20,30,40,17],[18,16,14,13],[10,20,30,40]])=={20:2,30:2,40:2,17: 1,18:1, 16: 1,14: 1,13: 1, 10: 1}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to multiply all the numbers in a list and divide with the length of the list.\nYour code should pass the test:\nassert multiply_num((8, 2, 3, -1, 7))==-67.2\n",
    "test_list": [
      "assert multiply_num((8, 2, 3, -1, 7))==-67.2",
      "assert multiply_num((-10,-20,-30))==-2000.0",
      "assert multiply_num((19,15,18))==1710.0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert the given decimal number to its binary equivalent.\nYour code should pass the test:\nassert decimal_to_binary(8) == '1000'\n",
    "test_list": [
      "assert decimal_to_binary(8) == '1000'",
      "assert decimal_to_binary(18) == '10010'",
      "assert decimal_to_binary(7) == '111' "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the next smallest palindrome of a specified number.\nYour code should pass the test:\nassert next_smallest_palindrome(99)==101\n",
    "test_list": [
      "assert next_smallest_palindrome(99)==101",
      "assert next_smallest_palindrome(1221)==1331",
      "assert next_smallest_palindrome(120)==121"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the kth element in the given array.\nYour code should pass the test:\nassert kth_element([12,3,5,7,19], 5, 2) == 3\n",
    "test_list": [
      "assert kth_element([12,3,5,7,19], 5, 2) == 3",
      "assert kth_element([17,24,8,23], 4, 3) == 8",
      "assert kth_element([16,21,25,36,4], 5, 4) == 36"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert snake case string to camel case string.\nYour code should pass the test:\nassert snake_to_camel('python_program')=='PythonProgram'\n",
    "test_list": [
      "assert snake_to_camel('python_program')=='PythonProgram'",
      "assert snake_to_camel('python_language')==('PythonLanguage')",
      "assert snake_to_camel('programming_language')==('ProgrammingLanguage')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find eulerian number a(n, m).\nYour code should pass the test:\nassert eulerian_num(3, 1) == 4\n",
    "test_list": [
      "assert eulerian_num(3, 1) == 4",
      "assert eulerian_num(4, 1) == 11",
      "assert eulerian_num(5, 3) == 26"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort each sublist of strings in a given list of lists using lambda function.\nYour code should pass the test:\nassert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]))==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n",
    "test_list": [
      "assert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]))==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]",
      "assert sort_sublists(([\" red \",\"green\" ],[\"blue \",\" black\"],[\" orange\",\"brown\"]))==[[' red ', 'green'], [' black', 'blue '], [' orange', 'brown']]",
      "assert sort_sublists(([\"zilver\",\"gold\"], [\"magnesium\",\"aluminium\"], [\"steel\", \"bronze\"]))==[['gold', 'zilver'],['aluminium', 'magnesium'], ['bronze', 'steel']]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count true booleans in the given list.\nYour code should pass the test:\nassert count([True,False,True]) == 2\n",
    "test_list": [
      "assert count([True,False,True]) == 2",
      "assert count([False,False]) == 0",
      "assert count([True,True,True]) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to add the given list to the given tuples.\nYour code should pass the test:\nassert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)\n",
    "test_list": [
      "assert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)",
      "assert add_lists([6, 7, 8], (10, 11)) == (10, 11, 6, 7, 8)",
      "assert add_lists([7, 8, 9], (11, 12)) == (11, 12, 7, 8, 9)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count hexadecimal numbers for a given range.\nYour code should pass the test:\nassert count_Hexadecimal(10,15) == 6\n",
    "test_list": [
      "assert count_Hexadecimal(10,15) == 6",
      "assert count_Hexadecimal(2,4) == 0",
      "assert count_Hexadecimal(15,16) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to merge multiple sorted inputs into a single sorted iterator using heap queue algorithm.\nYour code should pass the test:\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]\n",
    "test_list": [
      "assert 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]",
      "assert merge_sorted_list([1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12])==[1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12]",
      "assert merge_sorted_list([18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1],[25, 35, 22, 85, 14, 65, 75, 25, 58],[12, 74, 9, 50, 61, 41])==[1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the count of rotations of a binary string with odd value.\nYour code should pass the test:\nassert odd_Equivalent(\"011001\",6) == 3\n",
    "test_list": [
      "assert odd_Equivalent(\"011001\",6) == 3",
      "assert odd_Equivalent(\"11011\",5) == 4",
      "assert odd_Equivalent(\"1010\",4) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the ranges that are missing from the given list with the given start range and end range values.\nYour code should pass the test:\nassert extract_missing([(6, 9), (15, 34), (48, 70)], 2, 100) == [(2, 6), (9, 100), (9, 15), (34, 100), (34, 48), (70, 100)]\n",
    "test_list": [
      "assert extract_missing([(6, 9), (15, 34), (48, 70)], 2, 100) == [(2, 6), (9, 100), (9, 15), (34, 100), (34, 48), (70, 100)]",
      "assert extract_missing([(7, 2), (15, 19), (38, 50)], 5, 60) == [(5, 7), (2, 60), (2, 15), (19, 60), (19, 38), (50, 60)]",
      "assert extract_missing([(7, 2), (15, 19), (38, 50)], 1, 52) == [(1, 7), (2, 52), (2, 15), (19, 52), (19, 38), (50, 52)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find common elements in given nested lists. * list item * list item * list item * list item\nYour code should pass the test:\nassert common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])==[18, 12]\n",
    "test_list": [
      "assert common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])==[18, 12]",
      "assert common_in_nested_lists([[12, 5, 23, 25, 45], [7, 11, 5, 23, 28], [1, 5, 8, 18, 23, 16]])==[5,23]",
      "assert common_in_nested_lists([[2, 3,4, 1], [4, 5], [6,4, 8],[4, 5], [6, 8,4]])==[4]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the perimeter of a cylinder.\nYour code should pass the test:\nassert perimeter(2,4) == 12\n",
    "test_list": [
      "assert perimeter(2,4) == 12",
      "assert perimeter(1,2) == 6",
      "assert perimeter(3,1) == 8"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if a string represents an integer or not.\nYour code should pass the test:\nassert check_integer(\"python\")==False\n",
    "test_list": [
      "assert check_integer(\"python\")==False",
      "assert check_integer(\"1\")==True",
      "assert check_integer(\"12345\")==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to assign frequency to each tuple in the given tuple list.\nYour code should pass the test:\nassert assign_freq([(6, 5, 8), (2, 7), (6, 5, 8), (6, 5, 8), (9, ), (2, 7)] ) == '[(6, 5, 8, 3), (2, 7, 2), (9, 1)]'\n",
    "test_list": [
      "assert assign_freq([(6, 5, 8), (2, 7), (6, 5, 8), (6, 5, 8), (9, ), (2, 7)] ) == '[(6, 5, 8, 3), (2, 7, 2), (9, 1)]'",
      "assert assign_freq([(4, 2, 4), (7, 1), (4, 8), (4, 2, 4), (9, 2), (7, 1)] ) == '[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]'",
      "assert assign_freq([(11, 13, 10), (17, 21), (4, 2, 3), (17, 21), (9, 2), (4, 2, 3)] ) == '[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether all dictionaries in a list are empty or not.\nYour code should pass the test:\nassert empty_dit([{},{},{}])==True\n",
    "test_list": [
      "assert empty_dit([{},{},{}])==True",
      "assert empty_dit([{1,2},{},{}])==False",
      "assert empty_dit({})==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert a given tuple of positive integers into an integer.\nYour code should pass the test:\nassert tuple_to_int((1,2,3))==123\n",
    "test_list": [
      "assert tuple_to_int((1,2,3))==123",
      "assert tuple_to_int((4,5,6))==456",
      "assert tuple_to_int((5,6,7))==567"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert all possible convertible elements in the list to float.\nYour code should pass the test:\nassert list_to_float( [(\"3\", \"4\"), (\"1\", \"26.45\"), (\"7.32\", \"8\"), (\"4\", \"8\")] ) == '[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]'\n",
    "test_list": [
      "assert list_to_float( [(\"3\", \"4\"), (\"1\", \"26.45\"), (\"7.32\", \"8\"), (\"4\", \"8\")] ) == '[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]'",
      "assert list_to_float( [(\"4\", \"4\"), (\"2\", \"27\"), (\"4.12\", \"9\"), (\"7\", \"11\")] ) == '[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]'",
      "assert list_to_float( [(\"6\", \"78\"), (\"5\", \"26.45\"), (\"1.33\", \"4\"), (\"82\", \"13\")] ) == '[(6.0, 78.0), (5.0, 26.45), (1.33, 4.0), (82.0, 13.0)]'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "[link text](https:// [link text](https:// [link text](a function to convert a string to a list.\nYour code should pass the test:\nassert string_to_list(\"python programming\")==['python','programming']\n",
    "test_list": [
      "assert string_to_list(\"python programming\")==['python','programming']",
      "assert string_to_list(\"lists tuples strings\")==['lists','tuples','strings']",
      "assert string_to_list(\"write a program\")==['write','a','program']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the element that appears only once in a sorted array.\nYour code should pass the test:\nassert search([1,1,2,2,3],5) == 3\n",
    "test_list": [
      "assert search([1,1,2,2,3],5) == 3",
      "assert search([1,1,3,3,4,4,5,5,7,7,8],11) == 8",
      "assert search([1,2,2,3,3,4,4],7) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum product from the pairs of tuples within a given list.\nYour code should pass the test:\nassert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==36\n",
    "test_list": [
      "assert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==36",
      "assert max_product_tuple([(10,20), (15,2), (5,10)] )==200",
      "assert max_product_tuple([(11,44), (10,15), (20,5), (12, 9)] )==484"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the triplet with sum of the given array\nYour code should pass the test:\nassert check_triplet([2, 7, 4, 0, 9, 5, 1, 3], 8, 6, 0) == True\n",
    "test_list": [
      "assert check_triplet([2, 7, 4, 0, 9, 5, 1, 3], 8, 6, 0) == True",
      "assert check_triplet([1, 4, 5, 6, 7, 8, 5, 9], 8, 6, 0) == False",
      "assert check_triplet([10, 4, 2, 3, 5], 5, 15, 0) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find n’th smart number.\nYour code should pass the test:\nassert smartNumber(1) == 30\n",
    "test_list": [
      "assert smartNumber(1) == 30",
      "assert smartNumber(50) == 273",
      "assert smartNumber(1000) == 2664"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sum all amicable numbers from 1 to a specified number.\nYour code should pass the test:\nassert amicable_numbers_sum(999)==504\n",
    "test_list": [
      "assert amicable_numbers_sum(999)==504",
      "assert amicable_numbers_sum(9999)==31626",
      "assert amicable_numbers_sum(99)==0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to get the angle of a complex number.\nYour code should pass the test:\nassert angle_complex(0,1j)==1.5707963267948966 \n",
    "test_list": [
      "assert angle_complex(0,1j)==1.5707963267948966 ",
      "assert angle_complex(2,1j)==0.4636476090008061",
      "assert angle_complex(0,2j)==1.5707963267948966"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.\nYour code should pass the test:\nassert find_length(\"11000010001\", 11) == 6\n",
    "test_list": [
      "assert find_length(\"11000010001\", 11) == 6",
      "assert find_length(\"10111\", 5) == 1",
      "assert find_length(\"11011101100101\", 14) == 2 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of common divisors of two given numbers.\nYour code should pass the test:\nassert sum(10,15) == 6\n",
    "test_list": [
      "assert sum(10,15) == 6",
      "assert sum(100,150) == 93",
      "assert sum(4,6) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to multiply two integers without using the * operator in python.\nYour code should pass the test:\nassert multiply_int(10,20)==200\n",
    "test_list": [
      "assert multiply_int(10,20)==200",
      "assert multiply_int(5,10)==50",
      "assert multiply_int(4,8)==32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to shortlist words that are longer than n from a given list of words.\nYour code should pass the test:\nassert long_words(3,\"python is a programming language\")==['python','programming','language']\n",
    "test_list": [
      "assert long_words(3,\"python is a programming language\")==['python','programming','language']",
      "assert long_words(2,\"writing a program\")==['writing','program']",
      "assert long_words(5,\"sorting list\")==['sorting']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate magic square.\nYour code should pass the test:\nassert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]])==True\n",
    "test_list": [
      "assert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]])==True",
      "assert magic_square_test([[2, 7, 6], [9, 5, 1], [4, 3, 8]])==True",
      "assert magic_square_test([[2, 7, 6], [9, 5, 1], [4, 3, 7]])==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the item with maximum frequency in a given list.\nYour code should pass the test:\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, 5)\n",
    "test_list": [
      "assert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2])==(2, 5)",
      "assert max_occurrences([2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18])==(8, 2)",
      "assert max_occurrences([10,20,20,30,40,90,80,50,30,20,50,10])==(20, 3)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to reverse only the vowels of a given string.\nYour code should pass the test:\nassert reverse_vowels(\"Python\") == \"Python\"\n",
    "test_list": [
      "assert reverse_vowels(\"Python\") == \"Python\"",
      "assert reverse_vowels(\"USA\") == \"ASU\"",
      "assert reverse_vowels(\"ab\") == \"ab\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert tuple to a string.\nYour code should pass the test:\nassert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's'))==(\"exercises\")\n",
    "test_list": [
      "assert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's'))==(\"exercises\")",
      "assert tup_string(('p','y','t','h','o','n'))==(\"python\")",
      "assert tup_string(('p','r','o','g','r','a','m'))==(\"program\")"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the sum of the negative numbers of a given list of numbers using lambda function.\nYour code should pass the test:\nassert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32\n",
    "test_list": [
      "assert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32",
      "assert sum_negativenum([10,15,-14,13,-18,12,-20])==-52",
      "assert sum_negativenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==-894"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the last element of given array is even or odd after performing an operation p times.\nYour code should pass the test:\nassert check_last([5,7,10],3,1) == \"ODD\"\n",
    "test_list": [
      "assert check_last([5,7,10],3,1) == \"ODD\"",
      "assert check_last([2,3],2,3) == \"EVEN\"",
      "assert check_last([1,2,3],3,1) == \"ODD\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nth hexagonal number.\nYour code should pass the test:\nassert hexagonal_num(10) == 190\n",
    "test_list": [
      "assert hexagonal_num(10) == 190",
      "assert hexagonal_num(5) == 45",
      "assert hexagonal_num(7) == 91"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate electricity bill.\nYour code should pass the test:\nassert cal_electbill(75)==246.25\n",
    "test_list": [
      "assert cal_electbill(75)==246.25",
      "assert cal_electbill(265)==1442.75",
      "assert cal_electbill(100)==327.5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the ration of zeroes in an array of integers.\nYour code should pass the test:\nassert zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.15\n",
    "test_list": [
      "assert zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.15",
      "assert zero_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.00",
      "assert zero_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.00"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.\nYour code should pass the test:\nassert is_Sum_Of_Powers_Of_Two(10) == True\n",
    "test_list": [
      "assert is_Sum_Of_Powers_Of_Two(10) == True",
      "assert is_Sum_Of_Powers_Of_Two(7) == False",
      "assert is_Sum_Of_Powers_Of_Two(14) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the circumference of a circle.\nYour code should pass the test:\nassert circle_circumference(10)==62.830000000000005\n",
    "test_list": [
      "assert circle_circumference(10)==62.830000000000005",
      "assert circle_circumference(5)==31.415000000000003",
      "assert circle_circumference(4)==25.132"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract elements that occur singly in the given tuple list.\nYour code should pass the test:\nassert extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)]) == [3, 4, 5, 7, 1]\n",
    "test_list": [
      "assert extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)]) == [3, 4, 5, 7, 1]",
      "assert extract_singly([(1, 2, 3), (4, 2, 3), (7, 8)]) == [1, 2, 3, 4, 7, 8]",
      "assert extract_singly([(7, 8, 9), (10, 11, 12), (10, 11)]) == [7, 8, 9, 10, 11, 12]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a list of elements using pancake sort.\nYour code should pass the test:\nassert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]\n",
    "test_list": [
      "assert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]",
      "assert pancake_sort([98, 12, 54, 36, 85]) == [12, 36, 54, 85, 98]",
      "assert pancake_sort([41, 42, 32, 12, 23]) == [12, 23, 32, 41, 42]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count the same pair in three given lists.\nYour code should pass the test:\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\n",
    "test_list": [
      "assert 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",
      "assert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==4",
      "assert count_samepair([1,2,3,4,2,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find number of lists present in the given tuple.\nYour code should pass the test:\nassert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2\n",
    "test_list": [
      "assert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2",
      "assert find_lists(([1, 2], [3, 4], [5, 6]))  == 3",
      "assert find_lists(([9, 8, 7, 6, 5, 4, 3, 2, 1])) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of absolute differences in all pairs of the given array.\nYour code should pass the test:\nassert sum_Pairs([1,8,9,15,16],5) == 74\n",
    "test_list": [
      "assert sum_Pairs([1,8,9,15,16],5) == 74",
      "assert sum_Pairs([1,2,3,4],4) == 10",
      "assert sum_Pairs([1,2,3,4,5,7,9,11,14],9) == 188"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum difference between any two elements in a given array.\nYour code should pass the test:\nassert max_Abs_Diff((2,1,5,3),4) == 4\n",
    "test_list": [
      "assert max_Abs_Diff((2,1,5,3),4) == 4",
      "assert max_Abs_Diff((9,3,2,5,1),5) == 8",
      "assert max_Abs_Diff((3,2,1),3) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the ascii value of total characters in a string.\nYour code should pass the test:\nassert ascii_value_string(\"python\")==112\n",
    "test_list": [
      "assert ascii_value_string(\"python\")==112",
      "assert ascii_value_string(\"Program\")==80",
      "assert ascii_value_string(\"Language\")==76"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum total path sum in the given triangle.\nYour code should pass the test:\nassert max_path_sum([[1, 0, 0], [4, 8, 0], [1, 5, 3]], 2, 2) == 14\n",
    "test_list": [
      "assert max_path_sum([[1, 0, 0], [4, 8, 0], [1, 5, 3]], 2, 2) == 14",
      "assert max_path_sum([[13, 0, 0], [7, 4, 0], [2, 4, 6]], 2, 2) == 24 ",
      "assert max_path_sum([[2, 0, 0], [11, 18, 0], [21, 25, 33]], 2, 2) == 53"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to divide a number into two parts such that the sum of digits is maximum.\nYour code should pass the test:\nassert sum_digits_twoparts(35)==17\n",
    "test_list": [
      "assert sum_digits_twoparts(35)==17",
      "assert sum_digits_twoparts(7)==7",
      "assert sum_digits_twoparts(100)==19"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the longest subsequence such that the difference between adjacents is one for the given array.\nYour code should pass the test:\nassert longest_subseq_with_diff_one([1, 2, 3, 4, 5, 3, 2], 7) == 6\n",
    "test_list": [
      "assert longest_subseq_with_diff_one([1, 2, 3, 4, 5, 3, 2], 7) == 6",
      "assert longest_subseq_with_diff_one([10, 9, 4, 5, 4, 8, 6], 7) == 3",
      "assert longest_subseq_with_diff_one([1, 2, 3, 2, 3, 7, 2, 1], 8) == 7"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find whether the given number is present in the infinite sequence or not.\nYour code should pass the test:\nassert does_Contain_B(1,7,3) == True\n",
    "test_list": [
      "assert does_Contain_B(1,7,3) == True",
      "assert does_Contain_B(1,-3,5) == False",
      "assert does_Contain_B(3,2,5) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given number is co-prime or not.\nYour code should pass the test:\nassert is_coprime(17,13) == True\n",
    "test_list": [
      "assert is_coprime(17,13) == True",
      "assert is_coprime(15,21) == False",
      "assert is_coprime(25,45) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort the given array by using merge sort.\nYour code should pass the test:\nassert merge_sort([3, 4, 2, 6, 5, 7, 1, 9]) == [1, 2, 3, 4, 5, 6, 7, 9]\n",
    "test_list": [
      "assert merge_sort([3, 4, 2, 6, 5, 7, 1, 9]) == [1, 2, 3, 4, 5, 6, 7, 9]",
      "assert merge_sort([7, 25, 45, 78, 11, 33, 19]) == [7, 11, 19, 25, 33, 45, 78]",
      "assert merge_sort([3, 1, 4, 9, 8]) == [1, 3, 4, 8, 9]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the vertex of a parabola.\nYour code should pass the test:\nassert parabola_vertex(5,3,2)==(-0.3, 1.55)\n",
    "test_list": [
      "assert parabola_vertex(5,3,2)==(-0.3, 1.55)",
      "assert parabola_vertex(9,8,4)==(-0.4444444444444444, 2.2222222222222223)",
      "assert parabola_vertex(2,4,6)==(-1.0, 4.0)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract every specified element from a given two dimensional list.\nYour code should pass the test:\nassert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]\n",
    "test_list": [
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]",
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],2)==[3, 6, 9]",
      "assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],3)==[2,2,5]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to toggle all even bits of a given number.\nYour code should pass the test:\nassert even_bit_toggle_number(10) == 0\n",
    "test_list": [
      "assert even_bit_toggle_number(10) == 0",
      "assert even_bit_toggle_number(20) == 30",
      "assert even_bit_toggle_number(30) == 20"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert a tuple of string values to a tuple of integer values.\nYour code should pass the test:\nassert tuple_int_str((('333', '33'), ('1416', '55')))==((333, 33), (1416, 55))\n",
    "test_list": [
      "assert tuple_int_str((('333', '33'), ('1416', '55')))==((333, 33), (1416, 55))",
      "assert tuple_int_str((('999', '99'), ('1000', '500')))==((999, 99), (1000, 500))",
      "assert tuple_int_str((('666', '66'), ('1500', '555')))==((666, 66), (1500, 555))"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to reflect the run-length encoding from a list.\nYour code should pass the test:\nassert encode_list([1,1,2,3,4,4.3,5,1])==[[2, 1], [1, 2], [1, 3], [1, 4], [1, 4.3], [1, 5], [1, 1]]\n",
    "test_list": [
      "assert encode_list([1,1,2,3,4,4.3,5,1])==[[2, 1], [1, 2], [1, 3], [1, 4], [1, 4.3], [1, 5], [1, 1]]",
      "assert encode_list('automatically')==[[1, 'a'], [1, 'u'], [1, 't'], [1, 'o'], [1, 'm'], [1, 'a'], [1, 't'], [1, 'i'], [1, 'c'], [1, 'a'], [2, 'l'], [1, 'y']]",
      "assert encode_list('python')==[[1, 'p'], [1, 'y'], [1, 't'], [1, 'h'], [1, 'o'], [1, 'n']]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find k number of operations required to make all elements equal.\nYour code should pass the test:\nassert min_Ops([2,2,2,2],4,3) == 0\n",
    "test_list": [
      "assert min_Ops([2,2,2,2],4,3) == 0",
      "assert min_Ops([4,2,6,8],4,3) == -1",
      "assert min_Ops([21,33,9,45,63],5,6) == 24"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to print the season for the given month and day.\nYour code should pass the test:\nassert month_season('January',4)==('winter')\n",
    "test_list": [
      "assert month_season('January',4)==('winter')",
      "assert month_season('October',28)==('autumn')",
      "assert month_season('June',6)==('spring')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find x and y that satisfies ax + by = n.\nYour code should pass the test:\nassert solution(2, 3, 7) == ('x = ', 2, ', y = ', 1)\n",
    "test_list": [
      "assert solution(2, 3, 7) == ('x = ', 2, ', y = ', 1)",
      "assert solution(4, 2, 7) == 'No solution'",
      "assert solution(1, 13, 17) == ('x = ', 4, ', y = ', 1)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove all elements from a given list present in another list.\nYour code should pass the test:\nassert remove_elements([1,2,3,4,5,6,7,8,9,10],[2,4,6,8])==[1, 3, 5, 7, 9, 10]\n",
    "test_list": [
      "assert remove_elements([1,2,3,4,5,6,7,8,9,10],[2,4,6,8])==[1, 3, 5, 7, 9, 10]",
      "assert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],[1, 3, 5, 7])==[2, 4, 6, 8, 9, 10]",
      "assert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],[5,7])==[1, 2, 3, 4, 6, 8, 9, 10]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the sum of the positive integers of n+(n-2)+(n-4)... (until n-x =< 0).\nYour code should pass the test:\nassert sum_series(6)==12\n",
    "test_list": [
      "assert sum_series(6)==12",
      "assert sum_series(10)==30",
      "assert sum_series(9)==25"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the area of a regular polygon.\nYour code should pass the test:\nassert area_polygon(4,20)==400.00000000000006\n",
    "test_list": [
      "assert area_polygon(4,20)==400.00000000000006",
      "assert area_polygon(10,15)==1731.1969896610804",
      "assert area_polygon(9,7)==302.90938549487214"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the sum of divisors are same or not.\nYour code should pass the test:\nassert areEquivalent(36,57) == False\n",
    "test_list": [
      "assert areEquivalent(36,57) == False",
      "assert areEquivalent(2,4) == False",
      "assert areEquivalent(23,47) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count characters at same position in a given string (lower and uppercase characters) as in english alphabet.\nYour code should pass the test:\nassert count_char_position(\"xbcefg\") == 2\n",
    "test_list": [
      "assert count_char_position(\"xbcefg\") == 2",
      "assert count_char_position(\"ABcED\") == 3",
      "assert count_char_position(\"AbgdeF\") == 5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the pairs with xor as an even number.\nYour code should pass the test:\nassert find_even_Pair([5,4,7,2,1],5) == 4\n",
    "test_list": [
      "assert find_even_Pair([5,4,7,2,1],5) == 4",
      "assert find_even_Pair([7,2,8,1,0,5,11],7) == 9",
      "assert find_even_Pair([1,2,3],3) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find smallest power of 2 greater than or equal to n.\nYour code should pass the test:\nassert next_Power_Of_2(0) == 1\n",
    "test_list": [
      "assert next_Power_Of_2(0) == 1",
      "assert next_Power_Of_2(5) == 8",
      "assert next_Power_Of_2(17) == 32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the frequency of a number in a given array.\nYour code should pass the test:\nassert frequency([1,2,3],4) == 0\n",
    "test_list": [
      "assert frequency([1,2,3],4) == 0",
      "assert frequency([1,2,2,3,3,3,4],3) == 3",
      "assert frequency([0,1,2,3,1,2],1) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the nth pell number.\nYour code should pass the test:\nassert get_pell(4) == 12\n",
    "test_list": [
      "assert get_pell(4) == 12",
      "assert get_pell(7) == 169",
      "assert get_pell(8) == 408"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find sum of the numbers in a list between the indices of a specified range.\nYour code should pass the test:\nassert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],8,10)==29\n",
    "test_list": [
      "assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],8,10)==29",
      "assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],5,7)==16",
      "assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],7,10)==38"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the perimeter of a pentagon.\nYour code should pass the test:\nassert perimeter_pentagon(5)==25\n",
    "test_list": [
      "assert perimeter_pentagon(5)==25",
      "assert perimeter_pentagon(10)==50",
      "assert perimeter_pentagon(15)==75"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the occurence of characters 'std' in the given string 1. list item 1. list item 1. list item 2. list item 2. list item 2. list item\nYour code should pass the test:\nassert count_occurance(\"letstdlenstdporstd\") == 3\n",
    "test_list": [
      "assert count_occurance(\"letstdlenstdporstd\") == 3",
      "assert count_occurance(\"truststdsolensporsd\") == 1",
      "assert count_occurance(\"makestdsostdworthit\") == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove everything except alphanumeric characters from a string.\nYour code should pass the test:\nassert remove_splchar('python  @#&^%$*program123')==('pythonprogram123')\n",
    "test_list": [
      "assert remove_splchar('python  @#&^%$*program123')==('pythonprogram123')",
      "assert remove_splchar('python %^$@!^&*()  programming24%$^^()    language')==('pythonprogramming24language')",
      "assert remove_splchar('python   ^%&^()(+_)(_^&67)                  program')==('python67program')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to group a sequence of key-value pairs into a dictionary of lists.\nYour code should pass the test:\nassert group_keyvalue([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])=={'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}\n",
    "test_list": [
      "assert group_keyvalue([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])=={'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}",
      "assert group_keyvalue([('python', 1), ('python', 2), ('python', 3), ('python', 4), ('python', 5)])=={'python': [1,2,3,4,5]}",
      "assert group_keyvalue([('yellow',100), ('blue', 200), ('yellow', 300), ('blue', 400), ('red', 100)])=={'yellow': [100, 300], 'blue': [200, 400], 'red': [100]}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to verify validity of a string of parentheses.\nYour code should pass the test:\nassert is_valid_parenthese(\"(){}[]\")==True\n",
    "test_list": [
      "assert is_valid_parenthese(\"(){}[]\")==True",
      "assert is_valid_parenthese(\"()[{)}\")==False",
      "assert is_valid_parenthese(\"()\")==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the perimeter of a triangle.\nYour code should pass the test:\nassert perimeter_triangle(10,20,30)==60\n",
    "test_list": [
      "assert perimeter_triangle(10,20,30)==60",
      "assert perimeter_triangle(3,4,5)==12",
      "assert perimeter_triangle(25,35,45)==105"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find two distinct numbers such that their lcm lies within the given range.\nYour code should pass the test:\nassert answer(3,8) == (3,6)\n",
    "test_list": [
      "assert answer(3,8) == (3,6)",
      "assert answer(2,6) == (2,4)",
      "assert answer(1,3) == (1,2)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to search some literals strings in a string.\nYour code should pass the test:\nassert string_literals(['language'],'python language')==('Matched!')\n",
    "test_list": [
      "assert string_literals(['language'],'python language')==('Matched!')",
      "assert string_literals(['program'],'python language')==('Not Matched!')",
      "assert string_literals(['python'],'programming language')==('Not Matched!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find if the given number is a keith number or not.\nYour code should pass the test:\nassert is_num_keith(14) == True\n",
    "test_list": [
      "assert is_num_keith(14) == True",
      "assert is_num_keith(12) == False",
      "assert is_num_keith(197) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate distance between two points using latitude and longitude.\nYour code should pass the test:\nassert distance_lat_long(23.5,67.5,25.5,69.5)==12179.372041317429\n",
    "test_list": [
      "assert distance_lat_long(23.5,67.5,25.5,69.5)==12179.372041317429",
      "assert distance_lat_long(10.5,20.5,30.5,40.5)==6069.397933300514",
      "assert distance_lat_long(10,20,30,40)==6783.751974994595"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the longest common prefix in the given set of strings.\nYour code should pass the test:\nassert common_prefix([\"tablets\", \"tables\", \"taxi\", \"tamarind\"], 4) == 'ta'\n",
    "test_list": [
      "assert common_prefix([\"tablets\", \"tables\", \"taxi\", \"tamarind\"], 4) == 'ta'",
      "assert common_prefix([\"apples\", \"ape\", \"april\"], 3) == 'ap'",
      "assert common_prefix([\"teens\", \"teenager\", \"teenmar\"], 3) == 'teen'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find uppercase, lowercase, special character and numeric values using regex.\nYour code should pass the test:\nassert find_character(\"ThisIsGeeksforGeeks\") == (['T', 'I', 'G', 'G'], ['h', 'i', 's', 's', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'e', 'e', 'k', 's'], [], [])\n",
    "test_list": [
      "assert find_character(\"ThisIsGeeksforGeeks\") == (['T', 'I', 'G', 'G'], ['h', 'i', 's', 's', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'e', 'e', 'k', 's'], [], [])",
      "assert find_character(\"Hithere2\") == (['H'], ['i', 't', 'h', 'e', 'r', 'e'], ['2'], [])",
      "assert find_character(\"HeyFolks32\") == (['H', 'F'], ['e', 'y', 'o', 'l', 'k', 's'], ['3', '2'], [])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count all the distinct pairs having a difference of k in any array.\nYour code should pass the test:\nassert count_pairs([1, 5, 3, 4, 2], 5, 3) == 2\n",
    "test_list": [
      "assert count_pairs([1, 5, 3, 4, 2], 5, 3) == 2",
      "assert count_pairs([8, 12, 16, 4, 0, 20], 6, 4) == 5",
      "assert count_pairs([2, 4, 1, 3, 4], 5, 2) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all the values in a list that are greater than a specified number.\nYour code should pass the test:\nassert greater_specificnum([220, 330, 500],200)==True\n",
    "test_list": [
      "assert greater_specificnum([220, 330, 500],200)==True",
      "assert greater_specificnum([12, 17, 21],20)==False",
      "assert greater_specificnum([1,2,3,4],10)==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the focus of a parabola.\nYour code should pass the test:\nassert parabola_focus(5,3,2)==(-0.3, 1.6)\n",
    "test_list": [
      "assert parabola_focus(5,3,2)==(-0.3, 1.6)",
      "assert parabola_focus(9,8,4)==(-0.4444444444444444, 2.25)",
      "assert parabola_focus(2,4,6)==(-1.0, 4.125)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to search some literals strings in a string by using regex.\nYour code should pass the test:\nassert check_literals('The quick brown fox jumps over the lazy dog.',['fox']) == 'Matched!'\n",
    "test_list": [
      "assert check_literals('The quick brown fox jumps over the lazy dog.',['fox']) == 'Matched!'",
      "assert check_literals('The quick brown fox jumps over the lazy dog.',['horse']) == 'Not Matched!'",
      "assert check_literals('The quick brown fox jumps over the lazy dog.',['lazy']) == 'Matched!'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the longest common subsequence for the given two sequences.\nYour code should pass the test:\nassert longest_common_subsequence(\"AGGTAB\" , \"GXTXAYB\", 6, 7) == 4\n",
    "test_list": [
      "assert longest_common_subsequence(\"AGGTAB\" , \"GXTXAYB\", 6, 7) == 4",
      "assert longest_common_subsequence(\"ABCDGH\" , \"AEDFHR\", 6, 6) == 3",
      "assert longest_common_subsequence(\"AXYT\" , \"AYZX\", 4, 4) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given number can be represented by product of two squares or not.\nYour code should pass the test:\nassert prod_Square(25) == False\n",
    "test_list": [
      "assert prod_Square(25) == False",
      "assert prod_Square(30) == False",
      "assert prod_Square(16) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first missing positive number.\nYour code should pass the test:\nassert first_Missing_Positive([1,2,3,-1,5],5) == 4\n",
    "test_list": [
      "assert first_Missing_Positive([1,2,3,-1,5],5) == 4",
      "assert first_Missing_Positive([0,-1,-2,1,5,8],6) == 2",
      "assert first_Missing_Positive([0,1,2,5,-8],5) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of integral co-ordinates that lie inside a square.\nYour code should pass the test:\nassert count_Intgral_Points(1,1,4,4) == 4\n",
    "test_list": [
      "assert count_Intgral_Points(1,1,4,4) == 4",
      "assert count_Intgral_Points(1,2,1,2) == 1",
      "assert count_Intgral_Points(4,2,6,4) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the given month name contains 30 days or not.\nYour code should pass the test:\nassert check_monthnumber(\"February\")==False\n",
    "test_list": [
      "assert check_monthnumber(\"February\")==False",
      "assert check_monthnumber(\"June\")==True",
      "assert check_monthnumber(\"April\")==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether a string has atleast one letter and one number.\nYour code should pass the test:\nassert check_String('thishasboth29') == True\n",
    "test_list": [
      "assert check_String('thishasboth29') == True",
      "assert check_String('python') == False",
      "assert check_String ('string') == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove the duplicates from the given tuple.\nYour code should pass the test:\nassert remove_tuple((1, 3, 5, 2, 3, 5, 1, 1, 3)) == (1, 2, 3, 5)\n",
    "test_list": [
      "assert remove_tuple((1, 3, 5, 2, 3, 5, 1, 1, 3)) == (1, 2, 3, 5)",
      "assert remove_tuple((2, 3, 4, 4, 5, 6, 6, 7, 8, 8)) == (2, 3, 4, 5, 6, 7, 8)",
      "assert remove_tuple((11, 12, 13, 11, 11, 12, 14, 13)) == (11, 12, 13, 14)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to convert octal number to decimal number.\nYour code should pass the test:\nassert octal_To_Decimal(25) == 21\n",
    "test_list": [
      "assert octal_To_Decimal(25) == 21",
      "assert octal_To_Decimal(30) == 24",
      "assert octal_To_Decimal(40) == 32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first position of an element in a sorted array.\nYour code should pass the test:\nassert first([1,2,3,4,5,6,6],6,6) == 5\n",
    "test_list": [
      "assert first([1,2,3,4,5,6,6],6,6) == 5",
      "assert first([1,2,2,2,3,2,2,4,2],2,9) == 1",
      "assert first([1,2,3],1,3) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove all the tuples with length k.\nYour code should pass the test:\nassert remove_tuples([(4, 5), (4, ), (8, 6, 7), (1, ), (3, 4, 6, 7)] , 1) == [(4, 5), (8, 6, 7), (3, 4, 6, 7)]\n",
    "test_list": [
      "assert remove_tuples([(4, 5), (4, ), (8, 6, 7), (1, ), (3, 4, 6, 7)] , 1) == [(4, 5), (8, 6, 7), (3, 4, 6, 7)]",
      "assert remove_tuples([(4, 5), (4,5), (6, 7), (1, 2, 3), (3, 4, 6, 7)] ,2) == [(1, 2, 3), (3, 4, 6, 7)]",
      "assert remove_tuples([(1, 4, 4), (4, 3), (8, 6, 7), (1, ), (3, 6, 7)] , 3) == [(4, 3), (1,)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform the exponentiation of the given two tuples.\nYour code should pass the test:\nassert find_exponentio((10, 4, 5, 6), (5, 6, 7, 5)) == (100000, 4096, 78125, 7776)\n",
    "test_list": [
      "assert find_exponentio((10, 4, 5, 6), (5, 6, 7, 5)) == (100000, 4096, 78125, 7776)",
      "assert find_exponentio((11, 5, 6, 7), (6, 7, 8, 6)) == (1771561, 78125, 1679616, 117649)",
      "assert find_exponentio((12, 6, 7, 8), (7, 8, 9, 7)) == (35831808, 1679616, 40353607, 2097152)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the largest triangle that can be inscribed in an ellipse.\nYour code should pass the test:\nassert largest_triangle(4,2)==10.392304845413264\n",
    "test_list": [
      "assert largest_triangle(4,2)==10.392304845413264",
      "assert largest_triangle(5,7)==4.639421805988064",
      "assert largest_triangle(9,1)==105.2220865598093"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find highest power of 2 less than or equal to given number.\nYour code should pass the test:\nassert highest_Power_of_2(10) == 8\n",
    "test_list": [
      "assert highest_Power_of_2(10) == 8",
      "assert highest_Power_of_2(19) == 16",
      "assert highest_Power_of_2(32) == 32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all index positions of the maximum values in a given list.\nYour code should pass the test:\nassert position_max([12,33,23,10,67,89,45,667,23,12,11,10,54])==[7]\n",
    "test_list": [
      "assert position_max([12,33,23,10,67,89,45,667,23,12,11,10,54])==[7]",
      "assert position_max([1,2,2,2,4,4,4,5,5,5,5])==[7,8,9,10]",
      "assert position_max([2,1,5,6,8,3,4,9,10,11,8,12])==[11]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the elements in a list are same or not.\nYour code should pass the test:\nassert chkList(['one','one','one']) == True\n",
    "test_list": [
      "assert chkList(['one','one','one']) == True",
      "assert chkList(['one','Two','Three']) == False",
      "assert chkList(['bigdata','python','Django']) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove even characters in a string.\nYour code should pass the test:\nassert remove_even(\"python\")==(\"pto\")\n",
    "test_list": [
      "assert remove_even(\"python\")==(\"pto\")",
      "assert remove_even(\"program\")==(\"porm\")",
      "assert remove_even(\"language\")==(\"lnug\")"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the hamming distance between given two integers.\nYour code should pass the test:\nassert hamming_Distance(4,8) == 2\n",
    "test_list": [
      "assert hamming_Distance(4,8) == 2",
      "assert hamming_Distance(2,4) == 2",
      "assert hamming_Distance(1,2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the occurrence of a given character in a string.\nYour code should pass the test:\nassert count(\"abcc\",\"c\") == 2\n",
    "test_list": [
      "assert count(\"abcc\",\"c\") == 2",
      "assert count(\"ababca\",\"a\") == 3",
      "assert count(\"mnmm0pm\",\"m\") == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the inversions of tuple elements in the given tuple list.\nYour code should pass the test:\nassert inversion_elements((7, 8, 9, 1, 10, 7)) == (-8, -9, -10, -2, -11, -8)\n",
    "test_list": [
      "assert inversion_elements((7, 8, 9, 1, 10, 7)) == (-8, -9, -10, -2, -11, -8)",
      "assert inversion_elements((2, 4, 5, 6, 1, 7)) == (-3, -5, -6, -7, -2, -8)",
      "assert inversion_elements((8, 9, 11, 14, 12, 13)) == (-9, -10, -12, -15, -13, -14)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform the adjacent element concatenation in the given tuples.\nYour code should pass the test:\nassert concatenate_elements((\"DSP \", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"UTS\")) == ('DSP IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL UTS')\n",
    "test_list": [
      "assert concatenate_elements((\"DSP \", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"UTS\")) == ('DSP IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL UTS')",
      "assert concatenate_elements((\"RES \", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"QESR\")) == ('RES IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL QESR')",
      "assert concatenate_elements((\"MSAM\", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"SKD\")) == ('MSAMIS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL SKD')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count the longest repeating subsequences such that the two subsequences don’t have same string characters at same positions.\nYour code should pass the test:\nassert find_longest_repeating_subseq(\"AABEBCDD\") == 3\n",
    "test_list": [
      "assert find_longest_repeating_subseq(\"AABEBCDD\") == 3",
      "assert find_longest_repeating_subseq(\"aabb\") == 2",
      "assert find_longest_repeating_subseq(\"aab\") == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check the given decimal with a precision of 2 by using regex.\nYour code should pass the test:\nassert is_decimal('123.11') == True\n",
    "test_list": [
      "assert is_decimal('123.11') == True",
      "assert is_decimal('0.21') == True",
      "assert is_decimal('123.1214') == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to delete the smallest element from the given heap and then insert a new item.\nYour code should pass the test:\nassert heap_replace( [25, 44, 68, 21, 39, 23, 89],21)==[21, 25, 23, 44, 39, 68, 89]\n",
    "test_list": [
      "assert heap_replace( [25, 44, 68, 21, 39, 23, 89],21)==[21, 25, 23, 44, 39, 68, 89]",
      "assert heap_replace([25, 44, 68, 21, 39, 23, 89],110)== [23, 25, 68, 44, 39, 110, 89]",
      "assert heap_replace([25, 44, 68, 21, 39, 23, 89],500)==[23, 25, 68, 44, 39, 500, 89]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check that the given string contains only a certain set of characters(in this case a-z, a-z and 0-9) by using regex.\nYour code should pass the test:\nassert is_allowed_specific_char(\"ABCDEFabcdef123450\") == True\n",
    "test_list": [
      "assert is_allowed_specific_char(\"ABCDEFabcdef123450\") == True",
      "assert is_allowed_specific_char(\"*&%@#!}{\") == False",
      "assert is_allowed_specific_char(\"HELLOhowareyou98765\") == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count numbers whose oth and nth bits are set.\nYour code should pass the test:\nassert count_Num(2) == 1\n",
    "test_list": [
      "assert count_Num(2) == 1",
      "assert count_Num(3) == 2",
      "assert count_Num(1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of fourth power of n natural numbers.\nYour code should pass the test:\nassert fourth_Power_Sum(2) == 17\n",
    "test_list": [
      "assert fourth_Power_Sum(2) == 17",
      "assert fourth_Power_Sum(4) == 354",
      "assert fourth_Power_Sum(6) == 2275"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform the concatenation of two string tuples.\nYour code should pass the test:\nassert concatenate_strings((\"Manjeet\", \"Nikhil\", \"Akshat\"), (\" Singh\", \" Meherwal\", \" Garg\")) == ('Manjeet Singh', 'Nikhil Meherwal', 'Akshat Garg')\n",
    "test_list": [
      "assert concatenate_strings((\"Manjeet\", \"Nikhil\", \"Akshat\"), (\" Singh\", \" Meherwal\", \" Garg\")) == ('Manjeet Singh', 'Nikhil Meherwal', 'Akshat Garg')",
      "assert concatenate_strings((\"Shaik\", \"Ayesha\", \"Sanya\"), (\" Dawood\", \" Begum\", \" Singh\")) == ('Shaik Dawood', 'Ayesha Begum', 'Sanya Singh')",
      "assert concatenate_strings((\"Harpreet\", \"Priyanka\", \"Muskan\"), (\"Kour\", \" Agarwal\", \"Sethi\")) == ('HarpreetKour', 'Priyanka Agarwal', 'MuskanSethi')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert radians to degrees.\nYour code should pass the test:\nassert degree_radian(90)==5156.620156177409\n",
    "test_list": [
      "assert degree_radian(90)==5156.620156177409",
      "assert degree_radian(60)==3437.746770784939",
      "assert degree_radian(120)==6875.493541569878"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to decode a run-length encoded given list.\nYour code should pass the test:\nassert decode_list([[2, 1], 2, 3, [2, 4], 5,1])==[1,1,2,3,4,4,5,1]\n",
    "test_list": [
      "assert decode_list([[2, 1], 2, 3, [2, 4], 5,1])==[1,1,2,3,4,4,5,1]",
      "assert decode_list(['a', 'u', 't', 'o', 'm', 'a', 't', 'i', 'c', 'a', [2, 'l'], 'y'])==['a', 'u', 't', 'o', 'm', 'a', 't', 'i', 'c', 'a', 'l', 'l', 'y']",
      "assert decode_list(['p', 'y', 't', 'h', 'o', 'n'])==['p', 'y', 't', 'h', 'o', 'n']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if a nested list is a subset of another nested list.\nYour code should pass the test:\nassert check_subset_list([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==False\n",
    "test_list": [
      "assert check_subset_list([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==False",
      "assert check_subset_list([[2, 3, 1], [4, 5], [6, 8]],[[4, 5], [6, 8]])==True",
      "assert check_subset_list([['a', 'b'], ['e'], ['c', 'd']],[['g']])==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first repeated character in a given string.\nYour code should pass the test:\nassert first_Repeated_Char(\"Google\") == \"o\"\n",
    "test_list": [
      "assert first_Repeated_Char(\"Google\") == \"o\"",
      "assert first_Repeated_Char(\"data\") == \"a\"",
      "assert first_Repeated_Char(\"python\") == '\\0'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the minimum operations required to make two numbers equal.\nYour code should pass the test:\nassert min_Operations(2,4) == 1\n",
    "test_list": [
      "assert min_Operations(2,4) == 1",
      "assert min_Operations(4,10) == 4",
      "assert min_Operations(1,4) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract maximum and minimum k elements in the given tuple.\nYour code should pass the test:\nassert extract_min_max((5, 20, 3, 7, 6, 8), 2) == (3, 5, 8, 20)\n",
    "test_list": [
      "assert extract_min_max((5, 20, 3, 7, 6, 8), 2) == (3, 5, 8, 20)",
      "assert extract_min_max((4, 5, 6, 1, 2, 7), 3) == (1, 2, 4, 5, 6, 7)",
      "assert extract_min_max((2, 3, 4, 8, 9, 11, 7), 4) == (2, 3, 4, 7, 8, 9, 11)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to replace maximum n occurrences of spaces, commas, or dots with a colon.\nYour code should pass the test:\nassert replace_max_specialchar('Python language, Programming language.',2)==('Python:language: Programming language.')\n",
    "test_list": [
      "assert replace_max_specialchar('Python language, Programming language.',2)==('Python:language: Programming language.')",
      "assert replace_max_specialchar('a b c,d e f',3)==('a:b:c:d e f')",
      "assert replace_max_specialchar('ram reshma,ram rahim',1)==('ram:reshma,ram rahim')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first even number in a given list of numbers.\nYour code should pass the test:\nassert first_even ([1, 3, 5, 7, 4, 1, 6, 8]) == 4\n",
    "test_list": [
      "assert first_even ([1, 3, 5, 7, 4, 1, 6, 8]) == 4",
      "assert first_even([2, 3, 4]) == 2",
      "assert first_even([5, 6, 7]) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if all the elements in tuple have same data type or not.\nYour code should pass the test:\nassert check_type((5, 6, 7, 3, 5, 6) ) == True\n",
    "test_list": [
      "assert check_type((5, 6, 7, 3, 5, 6) ) == True",
      "assert check_type((1, 2, \"4\") ) == False",
      "assert check_type((3, 2, 1, 4, 5) ) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check for majority element in the given sorted array.\nYour code should pass the test:\nassert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True\n",
    "test_list": [
      "assert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True",
      "assert is_majority([1, 1, 2, 4, 4, 4, 6, 6], 8, 4) == False",
      "assert is_majority([1, 1, 1, 2, 2], 5, 1) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count set bits of a given number.\nYour code should pass the test:\nassert count_Set_Bits(2) == 1\n",
    "test_list": [
      "assert count_Set_Bits(2) == 1",
      "assert count_Set_Bits(4) == 1",
      "assert count_Set_Bits(6) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the minimum element in a sorted and rotated array.\nYour code should pass the test:\nassert find_Min([1,2,3,4,5],0,4) == 1\n",
    "test_list": [
      "assert find_Min([1,2,3,4,5],0,4) == 1",
      "assert find_Min([4,6,8],0,2) == 4",
      "assert find_Min([2,3,5,7,9],0,4) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to remove the characters which have odd index values of a given string.\nYour code should pass the test:\nassert odd_values_string('abcdef') == 'ace'\n",
    "test_list": [
      "assert odd_values_string('abcdef') == 'ace'",
      "assert odd_values_string('python') == 'pto'",
      "assert odd_values_string('data') == 'dt'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find minimum of three numbers.\nYour code should pass the test:\nassert min_of_three(10,20,0)==0\n",
    "test_list": [
      "assert min_of_three(10,20,0)==0",
      "assert min_of_three(19,15,18)==15",
      "assert min_of_three(-10,-20,-30)==-30"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether all the bits are unset in the given range or not.\nYour code should pass the test:\nassert all_Bits_Set_In_The_Given_Range(4,1,2) == True\n",
    "test_list": [
      "assert all_Bits_Set_In_The_Given_Range(4,1,2) == True",
      "assert all_Bits_Set_In_The_Given_Range(17,2,4) == True",
      "assert all_Bits_Set_In_The_Given_Range(39,4,6) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to re-arrange the elements of the given array so that all negative elements appear before positive ones.\nYour code should pass the test:\nassert re_arrange_array([-1, 2, -3, 4, 5, 6, -7, 8, 9], 9) == [-1, -3, -7, 4, 5, 6, 2, 8, 9]\n",
    "test_list": [
      "assert re_arrange_array([-1, 2, -3, 4, 5, 6, -7, 8, 9], 9) == [-1, -3, -7, 4, 5, 6, 2, 8, 9]",
      "assert re_arrange_array([12, -14, -26, 13, 15], 5) == [-14, -26, 12, 13, 15]",
      "assert re_arrange_array([10, 24, 36, -42, -39, -78, 85], 7) == [-42, -39, -78, 10, 24, 36, 85]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to replace blank spaces with any character in a string.\nYour code should pass the test:\nassert replace_blank(\"hello people\",'@')==(\"hello@people\")\n",
    "test_list": [
      "assert replace_blank(\"hello people\",'@')==(\"hello@people\")",
      "assert replace_blank(\"python program language\",'$')==(\"python$program$language\")",
      "assert replace_blank(\"blank space\",\"-\")==(\"blank-space\")"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum sum in the given right triangle of numbers.\nYour code should pass the test:\nassert max_sum([[1], [2,1], [3,3,2]], 3) == 6\n",
    "test_list": [
      "assert max_sum([[1], [2,1], [3,3,2]], 3) == 6",
      "assert max_sum([[1], [1, 2], [4, 1, 12]], 3) == 15 ",
      "assert max_sum([[2], [3,2], [13,23,12]], 3) == 28"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to get the n largest items from a dataset.\nYour code should pass the test:\nassert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],2)==[100,90]\n",
    "test_list": [
      "assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],2)==[100,90]",
      "assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],5)==[100,90,80,70,60]",
      "assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],3)==[100,90,80]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the lateral surface area of a cylinder.\nYour code should pass the test:\nassert lateralsuface_cylinder(10,5)==314.15000000000003\n",
    "test_list": [
      "assert lateralsuface_cylinder(10,5)==314.15000000000003",
      "assert lateralsuface_cylinder(4,5)==125.66000000000001",
      "assert lateralsuface_cylinder(4,10)==251.32000000000002"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the volume of a cube.\nYour code should pass the test:\nassert volume_cube(3)==27\n",
    "test_list": [
      "assert volume_cube(3)==27",
      "assert volume_cube(2)==8",
      "assert volume_cube(5)==125"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to set all even bits of a given number.\nYour code should pass the test:\nassert even_bit_set_number(10) == 10\n",
    "test_list": [
      "assert even_bit_set_number(10) == 10",
      "assert even_bit_set_number(20) == 30",
      "assert even_bit_set_number(30) == 30"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the maximum number of equilateral triangles that can be formed within a given equilateral triangle.\nYour code should pass the test:\nassert No_of_Triangle(4,2) == 7\n",
    "test_list": [
      "assert No_of_Triangle(4,2) == 7",
      "assert No_of_Triangle(4,3) == 3",
      "assert No_of_Triangle(1,3) == -1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check the occurrences of records which occur similar times in the given tuples.\nYour code should pass the test:\nassert check_occurences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)] ) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}\n",
    "test_list": [
      "assert check_occurences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)] ) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}",
      "assert check_occurences([(4, 2), (2, 4), (3, 6), (6, 3), (7, 4)] ) == {(2, 4): 2, (3, 6): 2, (4, 7): 1}",
      "assert check_occurences([(13, 2), (11, 23), (12, 25), (25, 12), (16, 23)] ) == {(2, 13): 1, (11, 23): 1, (12, 25): 2, (16, 23): 1}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count number of non-empty substrings of a given string.\nYour code should pass the test:\nassert number_of_substrings(\"abc\") == 6\n",
    "test_list": [
      "assert number_of_substrings(\"abc\") == 6",
      "assert number_of_substrings(\"abcd\") == 10",
      "assert number_of_substrings(\"abcde\") == 15"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the number of possible sequences of length n such that each of the next element is greater than or equal to twice of the previous element but less than or equal to m.\nYour code should pass the test:\nassert get_total_number_of_sequences(10, 4) == 4\n",
    "test_list": [
      "assert get_total_number_of_sequences(10, 4) == 4",
      "assert get_total_number_of_sequences(5, 2) == 6",
      "assert get_total_number_of_sequences(16, 3) == 84"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to replace the last element of the list with another list.\nYour code should pass the test:\nassert replace_list([1, 3, 5, 7, 9, 10],[2, 4, 6, 8])==[1, 3, 5, 7, 9, 2, 4, 6, 8]\n",
    "test_list": [
      "assert replace_list([1, 3, 5, 7, 9, 10],[2, 4, 6, 8])==[1, 3, 5, 7, 9, 2, 4, 6, 8]",
      "assert replace_list([1,2,3,4,5],[5,6,7,8])==[1,2,3,4,5,6,7,8]",
      "assert replace_list([\"red\",\"blue\",\"green\"],[\"yellow\"])==[\"red\",\"blue\",\"yellow\"]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to generate a 3d array having each element as '*'.\nYour code should pass the test:\nassert array_3d(6,4,3)==[[['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']]]\n",
    "test_list": [
      "assert array_3d(6,4,3)==[[['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']]]",
      "assert array_3d(5,3,4)==[[['*', '*', '*', '*', '*'], ['*', '*', '*', '*','*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'],['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']]]",
      "assert array_3d(1,2,3)==[[['*'],['*']],[['*'],['*']],[['*'],['*']]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count total characters in a string.\nYour code should pass the test:\nassert count_charac(\"python programming\")==18\n",
    "test_list": [
      "assert count_charac(\"python programming\")==18",
      "assert count_charac(\"language\")==8",
      "assert count_charac(\"words\")==5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort the given list based on the occurrence of first element of tuples.\nYour code should pass the test:\nassert sort_on_occurence([(1, 'Jake'), (2, 'Bob'), (1, 'Cara')]) == [(1, 'Jake', 'Cara', 2), (2, 'Bob', 1)]\n",
    "test_list": [
      "assert sort_on_occurence([(1, 'Jake'), (2, 'Bob'), (1, 'Cara')]) == [(1, 'Jake', 'Cara', 2), (2, 'Bob', 1)]",
      "assert sort_on_occurence([('b', 'ball'), ('a', 'arm'), ('b', 'b'), ('a', 'ant')]) == [('b', 'ball', 'b', 2), ('a', 'arm', 'ant', 2)]",
      "assert sort_on_occurence([(2, 'Mark'), (3, 'Maze'), (2, 'Sara')]) == [(2, 'Mark', 'Sara', 2), (3, 'Maze', 1)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the next perfect square greater than a given number.\nYour code should pass the test:\nassert next_Perfect_Square(35) == 36\n",
    "test_list": [
      "assert next_Perfect_Square(35) == 36",
      "assert next_Perfect_Square(6) == 9",
      "assert next_Perfect_Square(9) == 16"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum sum of bi-tonic sub-sequence for the given array.\nYour code should pass the test:\nassert max_sum([1, 15, 51, 45, 33, 100, 12, 18, 9], 9) == 194\n",
    "test_list": [
      "assert max_sum([1, 15, 51, 45, 33, 100, 12, 18, 9], 9) == 194",
      "assert max_sum([80, 60, 30, 40, 20, 10], 6) == 210",
      "assert max_sum([2, 3 ,14, 16, 21, 23, 29, 30], 8) == 138"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function for computing square roots using the babylonian method.\nYour code should pass the test:\nassert babylonian_squareroot(10)==3.162277660168379\n",
    "test_list": [
      "assert babylonian_squareroot(10)==3.162277660168379",
      "assert babylonian_squareroot(2)==1.414213562373095",
      "assert babylonian_squareroot(9)==3.0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the longest palindromic subsequence in the given string.\nYour code should pass the test:\nassert lps(\"TENS FOR TENS\") == 5 \n",
    "test_list": [
      "assert lps(\"TENS FOR TENS\") == 5 ",
      "assert lps(\"CARDIO FOR CARDS\") == 7",
      "assert lps(\"PART OF THE JOURNEY IS PART\") == 9 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the harmonic sum of n-1.\nYour code should pass the test:\nassert harmonic_sum(7) == 2.5928571428571425\n",
    "test_list": [
      "assert harmonic_sum(7) == 2.5928571428571425",
      "assert harmonic_sum(4) == 2.083333333333333",
      "assert harmonic_sum(19) == 3.547739657143682"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the intersection of two arrays using lambda function.\nYour code should pass the test:\nassert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[1, 2, 4, 8, 9])==[1, 2, 8, 9]\n",
    "test_list": [
      "assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[1, 2, 4, 8, 9])==[1, 2, 8, 9]",
      "assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[3,5,7,9])==[3,5,7,9]",
      "assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[10,20,30,40])==[10]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the occcurences of an element in a tuple.\nYour code should pass the test:\nassert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),4) == 0\n",
    "test_list": [
      "assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),4) == 0",
      "assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),10) == 3",
      "assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),8) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to insert an element before each element of a list.\nYour code should pass the test:\nassert insert_element(['Red', 'Green', 'Black'] ,'c')==['c', 'Red', 'c', 'Green', 'c', 'Black'] \n",
    "test_list": [
      "assert insert_element(['Red', 'Green', 'Black'] ,'c')==['c', 'Red', 'c', 'Green', 'c', 'Black'] ",
      "assert insert_element(['python', 'java'] ,'program')==['program', 'python', 'program', 'java'] ",
      "assert insert_element(['happy', 'sad'] ,'laugh')==['laugh', 'happy', 'laugh', 'sad'] "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to convert complex numbers to polar coordinates.\nYour code should pass the test:\nassert convert(1) == (1.0, 0.0)\n",
    "test_list": [
      "assert convert(1) == (1.0, 0.0)",
      "assert convert(4) == (4.0,0.0)",
      "assert convert(5) == (5.0,0.0)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count integers from a given list.\nYour code should pass the test:\nassert count_integer([1,2,'abc',1.2]) == 2\n",
    "test_list": [
      "assert count_integer([1,2,'abc',1.2]) == 2",
      "assert count_integer([1,2,3]) == 3",
      "assert count_integer([1,1.2,4,5.1]) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all words starting with 'a' or 'e' in a given string.\nYour code should pass the test:\nassert words_ae(\"python programe\")==['ame']\n",
    "test_list": [
      "assert words_ae(\"python programe\")==['ame']",
      "assert words_ae(\"python programe language\")==['ame','anguage']",
      "assert words_ae(\"assert statement\")==['assert', 'atement']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to choose specified number of colours from three different colours and generate all the combinations with repetitions.\nYour code should pass the test:\nassert combinations_colors( [\"Red\",\"Green\",\"Blue\"],1)==[('Red',), ('Green',), ('Blue',)]\n",
    "test_list": [
      "assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],1)==[('Red',), ('Green',), ('Blue',)]",
      "assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],2)==[('Red', 'Red'), ('Red', 'Green'), ('Red', 'Blue'), ('Green', 'Green'), ('Green', 'Blue'), ('Blue', 'Blue')]",
      "assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],3)==[('Red', 'Red', 'Red'), ('Red', 'Red', 'Green'), ('Red', 'Red', 'Blue'), ('Red', 'Green', 'Green'), ('Red', 'Green', 'Blue'), ('Red', 'Blue', 'Blue'), ('Green', 'Green', 'Green'), ('Green', 'Green', 'Blue'), ('Green', 'Blue', 'Blue'), ('Blue', 'Blue', 'Blue')]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of prime numbers less than a given non-negative number.\nYour code should pass the test:\nassert count_Primes_nums(5) == 2\n",
    "test_list": [
      "assert count_Primes_nums(5) == 2",
      "assert count_Primes_nums(10) == 4",
      "assert count_Primes_nums(100) == 25"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to swap two numbers.\nYour code should pass the test:\nassert swap_numbers(10,20)==(20,10)\n",
    "test_list": [
      "assert swap_numbers(10,20)==(20,10)",
      "assert swap_numbers(15,17)==(17,15)",
      "assert swap_numbers(100,200)==(200,100)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find number of odd elements in the given list using lambda function.\nYour code should pass the test:\nassert count_odd([1, 2, 3, 5, 7, 8, 10])==4\n",
    "test_list": [
      "assert count_odd([1, 2, 3, 5, 7, 8, 10])==4",
      "assert count_odd([10,15,14,13,-18,12,-20])==2",
      "assert count_odd([1, 2, 4, 8, 9])==2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to maximize the given two tuples.\nYour code should pass the test:\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))\n",
    "test_list": [
      "assert 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))",
      "assert maximize_elements(((2, 4), (5, 6), (3, 10), (2, 11)), ((7, 8), (4, 10), (2, 2), (8, 4))) == ((7, 8), (5, 10), (3, 10), (8, 11))",
      "assert maximize_elements(((3, 5), (6, 7), (4, 11), (3, 12)), ((8, 9), (5, 11), (3, 3), (9, 5))) == ((8, 9), (6, 11), (4, 11), (9, 12))"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nth newman–shanks–williams prime number.\nYour code should pass the test:\nassert newman_prime(3) == 7 \n",
    "test_list": [
      "assert newman_prime(3) == 7 ",
      "assert newman_prime(4) == 17",
      "assert newman_prime(5) == 41"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform mathematical division operation across the given tuples.\nYour code should pass the test:\nassert division_elements((10, 4, 6, 9),(5, 2, 3, 3)) == (2, 2, 2, 3)\n",
    "test_list": [
      "assert division_elements((10, 4, 6, 9),(5, 2, 3, 3)) == (2, 2, 2, 3)",
      "assert division_elements((12, 6, 8, 16),(6, 3, 4, 4)) == (2, 2, 2, 4)",
      "assert division_elements((20, 14, 36, 18),(5, 7, 6, 9)) == (4, 2, 6, 2)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to split a given list into two parts where the length of the first part of the list is given.\nYour code should pass the test:\nassert split_two_parts([1,1,2,3,4,4,5,1],3)==([1, 1, 2], [3, 4, 4, 5, 1])\n",
    "test_list": [
      "assert split_two_parts([1,1,2,3,4,4,5,1],3)==([1, 1, 2], [3, 4, 4, 5, 1])",
      "assert split_two_parts(['a', 'b', 'c', 'd'],2)==(['a', 'b'], ['c', 'd'])",
      "assert split_two_parts(['p', 'y', 't', 'h', 'o', 'n'],4)==(['p', 'y', 't', 'h'], ['o', 'n'])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to merge two dictionaries.\nYour code should pass the test:\nassert merge_dict({'a': 100, 'b': 200},{'x': 300, 'y': 200})=={'x': 300, 'y': 200, 'a': 100, 'b': 200}\n",
    "test_list": [
      "assert merge_dict({'a': 100, 'b': 200},{'x': 300, 'y': 200})=={'x': 300, 'y': 200, 'a': 100, 'b': 200}",
      "assert merge_dict({'a':900,'b':900,'d':900},{'a':900,'b':900,'d':900})=={'a':900,'b':900,'d':900,'a':900,'b':900,'d':900}",
      "assert merge_dict({'a':10,'b':20},{'x':30,'y':40})=={'x':30,'y':40,'a':10,'b':20}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate a dog's age in dog's years.\nYour code should pass the test:\nassert dog_age(12)==61\n",
    "test_list": [
      "assert dog_age(12)==61",
      "assert dog_age(15)==73",
      "assert dog_age(24)==109"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to split a list for every nth element.\nYour code should pass the test:\nassert list_split(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'],3)==[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']] \n",
    "test_list": [
      "assert list_split(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'],3)==[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']] ",
      "assert list_split([1,2,3,4,5,6,7,8,9,10,11,12,13,14],3)==[[1,4,7,10,13], [2,5,8,11,14], [3,6,9,12]] ",
      "assert list_split(['python','java','C','C++','DBMS','SQL'],2)==[['python', 'C', 'DBMS'], ['java', 'C++', 'SQL']] "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the lateral surface area of a cube.\nYour code should pass the test:\nassert lateralsurface_cube(5)==100\n",
    "test_list": [
      "assert lateralsurface_cube(5)==100",
      "assert lateralsurface_cube(9)==324",
      "assert lateralsurface_cube(10)==400"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of squares of first n odd natural numbers.\nYour code should pass the test:\nassert square_Sum(2) == 10\n",
    "test_list": [
      "assert square_Sum(2) == 10",
      "assert square_Sum(3) == 35",
      "assert square_Sum(4) == 84"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n'th star number.\nYour code should pass the test:\nassert find_star_num(3) == 37\n",
    "test_list": [
      "assert find_star_num(3) == 37",
      "assert find_star_num(4) == 73",
      "assert find_star_num(5) == 121"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the ascii value of a character.\nYour code should pass the test:\nassert ascii_value('A')==65\n",
    "test_list": [
      "assert ascii_value('A')==65",
      "assert ascii_value('R')==82",
      "assert ascii_value('S')==83"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of even numbers at even positions.\nYour code should pass the test:\nassert sum_even_and_even_index([5, 6, 12, 1, 18, 8],6) == 30\n",
    "test_list": [
      "assert sum_even_and_even_index([5, 6, 12, 1, 18, 8],6) == 30",
      "assert sum_even_and_even_index([3, 20, 17, 9, 2, 10, 18, 13, 6, 18],10) == 26",
      "assert sum_even_and_even_index([5, 6, 12, 1],4) == 12"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of fifth power of first n even natural numbers.\nYour code should pass the test:\nassert even_Power_Sum(2) == 1056\n",
    "test_list": [
      "assert even_Power_Sum(2) == 1056",
      "assert even_Power_Sum(3) == 8832",
      "assert even_Power_Sum(1) == 32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perfom the rear element extraction from list of tuples records.\nYour code should pass the test:\nassert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]\n",
    "test_list": [
      "assert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]",
      "assert rear_extract([(1, 'Sai', 36), (2, 'Ayesha', 25), (3, 'Salman', 45)]) == [36, 25, 45]",
      "assert rear_extract([(1, 'Sudeep', 14), (2, 'Vandana', 36), (3, 'Dawood', 56)]) == [14, 36, 56]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to substract the contents of one tuple with corresponding index of other tuple.\nYour code should pass the test:\nassert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)\n",
    "test_list": [
      "assert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)",
      "assert substract_elements((11, 2, 3), (24, 45 ,16)) == (-13, -43, -13)",
      "assert substract_elements((7, 18, 9), (10, 11, 12)) == (-3, 7, -3)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find sum of even index binomial coefficients.\nYour code should pass the test:\nassert even_binomial_Coeff_Sum(4) == 8\n",
    "test_list": [
      "assert even_binomial_Coeff_Sum(4) == 8",
      "assert even_binomial_Coeff_Sum(6) == 32",
      "assert even_binomial_Coeff_Sum(2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the position of the last removed element from the given array.\nYour code should pass the test:\nassert get_Position([2,5,4],3,2) == 2\n",
    "test_list": [
      "assert get_Position([2,5,4],3,2) == 2",
      "assert get_Position([4,3],2,2) == 2",
      "assert get_Position([1,2,3,4],4,1) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the volume of a cylinder.\nYour code should pass the test:\nassert volume_cylinder(10,5)==1570.7500000000002\n",
    "test_list": [
      "assert volume_cylinder(10,5)==1570.7500000000002",
      "assert volume_cylinder(4,5)==251.32000000000002",
      "assert volume_cylinder(4,10)==502.64000000000004"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to filter a dictionary based on values.\nYour code should pass the test:\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}\n",
    "test_list": [
      "assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},170)=={'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}",
      "assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},180)=={ 'Alden Cantrell': 180, 'Pierre Cox': 190}",
      "assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},190)=={ 'Pierre Cox': 190}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the element count that occurs before the record in the given tuple.\nYour code should pass the test:\nassert count_first_elements((1, 5, 7, (4, 6), 10) ) == 3\n",
    "test_list": [
      "assert count_first_elements((1, 5, 7, (4, 6), 10) ) == 3",
      "assert count_first_elements((2, 9, (5, 7), 11) ) == 2",
      "assert count_first_elements((11, 15, 5, 8, (2, 3), 8) ) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nth decagonal number.\nYour code should pass the test:\nassert is_num_decagonal(3) == 27\n",
    "test_list": [
      "assert is_num_decagonal(3) == 27",
      "assert is_num_decagonal(7) == 175",
      "assert is_num_decagonal(10) == 370"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to search an element in the given array by using sequential search.\nYour code should pass the test:\nassert sequential_search([11,23,58,31,56,77,43,12,65,19],31) == (True, 3)\n",
    "test_list": [
      "assert sequential_search([11,23,58,31,56,77,43,12,65,19],31) == (True, 3)",
      "assert sequential_search([12, 32, 45, 62, 35, 47, 44, 61],61) == (True, 7)",
      "assert sequential_search([9, 10, 17, 19, 22, 39, 48, 56],48) == (True, 6)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check if the elements of a given list are unique or not.\nYour code should pass the test:\nassert all_unique([1,2,3]) == True\n",
    "test_list": [
      "assert all_unique([1,2,3]) == True",
      "assert all_unique([1,2,1,2]) == False",
      "assert all_unique([1,2,3,4,5]) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to substaract two lists using map and lambda function.\nYour code should pass the test:\nassert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]\n",
    "test_list": [
      "assert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]",
      "assert sub_list([1,2],[3,4])==[-2,-2]",
      "assert sub_list([90,120],[50,70])==[40,50]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the frequency of each digit is less than or equal to the digit itself.\nYour code should pass the test:\nassert validate(1234) == True\n",
    "test_list": [
      "assert validate(1234) == True",
      "assert validate(51241) == False",
      "assert validate(321) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether all items of a list are equal to a given string.\nYour code should pass the test:\nassert check_element([\"green\", \"orange\", \"black\", \"white\"],'blue')==False\n",
    "test_list": [
      "assert check_element([\"green\", \"orange\", \"black\", \"white\"],'blue')==False",
      "assert check_element([1,2,3,4],7)==False",
      "assert check_element([\"green\", \"green\", \"green\", \"green\"],'green')==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that matches a string that has an a followed by two to three 'b'.\nYour code should pass the test:\nassert text_match_two_three(\"ac\")==('Not matched!')\n",
    "test_list": [
      "assert text_match_two_three(\"ac\")==('Not matched!')",
      "assert text_match_two_three(\"dc\")==('Not matched!')",
      "assert text_match_two_three(\"abbbba\")==('Found a match!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the largest sum of contiguous array in the modified array which is formed by repeating the given array k times.\nYour code should pass the test:\nassert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 3) == 30\n",
    "test_list": [
      "assert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 3) == 30",
      "assert max_sub_array_sum_repeated([-1, 10, 20], 3, 2) == 59",
      "assert max_sub_array_sum_repeated([-1, -2, -3], 3, 3) == -1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of squares of first n even natural numbers.\nYour code should pass the test:\nassert square_Sum(2) == 20\n",
    "test_list": [
      "assert square_Sum(2) == 20",
      "assert square_Sum(3) == 56",
      "assert square_Sum(4) == 120"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count array elements having modular inverse under given prime number p equal to itself.\nYour code should pass the test:\nassert modular_inverse([ 1, 6, 4, 5 ], 4, 7) == 2\n",
    "test_list": [
      "assert modular_inverse([ 1, 6, 4, 5 ], 4, 7) == 2",
      "assert modular_inverse([1, 3, 8, 12, 12], 5, 13) == 3",
      "assert modular_inverse([2, 3, 4, 5], 4, 6) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to calculate the number of odd days in a given year.\nYour code should pass the test:\nassert odd_Days(100) == 5\n",
    "test_list": [
      "assert odd_Days(100) == 5",
      "assert odd_Days(50) ==6",
      "assert odd_Days(75) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the list of lists with maximum length.\nYour code should pass the test:\nassert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])\n",
    "test_list": [
      "assert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])",
      "assert max_length([[1], [5, 7], [10, 12, 14,15]])==(4, [10, 12, 14,15])",
      "assert max_length([[5], [15,20,25]])==(3, [15,20,25])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find out the number of ways of painting the fence such that at most 2 adjacent posts have the same color for the given fence with n posts and k colors.\nYour code should pass the test:\nassert count_no_of_ways(2, 4) == 16\n",
    "test_list": [
      "assert count_no_of_ways(2, 4) == 16",
      "assert count_no_of_ways(3, 2) == 6",
      "assert count_no_of_ways(4, 4) == 228"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find quotient of two numbers.\nYour code should pass the test:\nassert find(10,3) == 3\n",
    "test_list": [
      "assert find(10,3) == 3",
      "assert find(4,2) == 2",
      "assert find(20,5) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the third side of a right angled triangle.\nYour code should pass the test:\nassert otherside_rightangle(7,8)==10.63014581273465\n",
    "test_list": [
      "assert otherside_rightangle(7,8)==10.63014581273465",
      "assert otherside_rightangle(3,4)==5",
      "assert otherside_rightangle(7,15)==16.55294535724685"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum value in a given heterogeneous list.\nYour code should pass the test:\nassert max_val(['Python', 3, 2, 4, 5, 'version'])==5\n",
    "test_list": [
      "assert max_val(['Python', 3, 2, 4, 5, 'version'])==5",
      "assert max_val(['Python', 15, 20, 25])==25",
      "assert max_val(['Python', 30, 20, 40, 50, 'version'])==50"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to return the sum of all divisors of a number.\nYour code should pass the test:\nassert sum_div(8)==7\n",
    "test_list": [
      "assert sum_div(8)==7",
      "assert sum_div(12)==16",
      "assert sum_div(7)==1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count inversions in an array.\nYour code should pass the test:\nassert get_Inv_Count([1,20,6,4,5],5) == 5\n",
    "test_list": [
      "assert get_Inv_Count([1,20,6,4,5],5) == 5",
      "assert get_Inv_Count([1,2,1],3) == 1",
      "assert get_Inv_Count([1,2,5,6,1],5) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to flatten a given nested list structure.\nYour code should pass the test:\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]\n",
    "test_list": [
      "assert flatten_list([0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]])==[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]",
      "assert flatten_list([[10, 20], [40], [30, 56, 25], [10, 20], [33], [40]])==[10, 20, 40, 30, 56, 25, 10, 20, 33, 40]",
      "assert flatten_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]])==[1, 2, 3, 4, 5, 6, 10, 11, 12, 7, 8, 9]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the nested list elements which are present in another list.\nYour code should pass the test:\nassert intersection_nested_lists( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==[[12], [7, 11], [1, 5, 8]]\n",
    "test_list": [
      "assert intersection_nested_lists( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==[[12], [7, 11], [1, 5, 8]]",
      "assert intersection_nested_lists([[2, 3, 1], [4, 5], [6, 8]], [[4, 5], [6, 8]])==[[], []]",
      "assert intersection_nested_lists(['john','amal','joel','george'],[['john'],['jack','john','mary'],['howard','john'],['jude']])==[['john'], ['john'], ['john'], []]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the maximum aggregate from the list of tuples.\nYour code should pass the test:\nassert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)\n",
    "test_list": [
      "assert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)",
      "assert max_aggregate([('Juan Whelan',50),('Sabah Colley',48),('Peter Nichols',37),('Juan Whelan',22),('Sabah Colley',14)])==('Juan Whelan', 72)",
      "assert max_aggregate([('Juan Whelan',10),('Sabah Colley',20),('Peter Nichols',30),('Juan Whelan',40),('Sabah Colley',50)])==('Sabah Colley', 70)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the count of all binary sequences of length 2n such that sum of first n bits is same as sum of last n bits.\nYour code should pass the test:\nassert count_binary_seq(1) == 2.0\n",
    "test_list": [
      "assert count_binary_seq(1) == 2.0",
      "assert count_binary_seq(2) == 6.0",
      "assert count_binary_seq(3) == 20.0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the depth of a dictionary.\nYour code should pass the test:\nassert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4\n",
    "test_list": [
      "assert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4",
      "assert dict_depth({'a':1, 'b': {'c':'python'}})==2",
      "assert dict_depth({1: 'Sun', 2: {3: {4:'Mon'}}})==3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the most significant bit number which is also a set bit.\nYour code should pass the test:\nassert set_Bit_Number(6) == 4\n",
    "test_list": [
      "assert set_Bit_Number(6) == 4",
      "assert set_Bit_Number(10) == 8",
      "assert set_Bit_Number(18) == 16"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the count of inversion of two types are same or not.\nYour code should pass the test:\nassert solve([1,0,2],3) == True\n",
    "test_list": [
      "assert solve([1,0,2],3) == True",
      "assert solve([1,2,0],3) == False",
      "assert solve([1,2,1],3) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find element at a given index after number of rotations.\nYour code should pass the test:\nassert find_Element([1,2,3,4,5],[[0,2],[0,3]],2,1) == 3\n",
    "test_list": [
      "assert find_Element([1,2,3,4,5],[[0,2],[0,3]],2,1) == 3",
      "assert find_Element([1,2,3,4],[[0,1],[0,2]],1,2) == 3",
      "assert find_Element([1,2,3,4,5,6],[[0,1],[0,2]],1,1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to match two words from a list of words starting with letter 'p'.\nYour code should pass the test:\nassert start_withp([\"Python PHP\", \"Java JavaScript\", \"c c++\"])==('Python', 'PHP')\n",
    "test_list": [
      "assert start_withp([\"Python PHP\", \"Java JavaScript\", \"c c++\"])==('Python', 'PHP')",
      "assert start_withp([\"Python Programming\",\"Java Programming\"])==('Python','Programming')",
      "assert start_withp([\"Pqrst Pqr\",\"qrstuv\"])==('Pqrst','Pqr')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum sum of increasing subsequence from prefix till ith index and also including a given kth element which is after i, i.e., k > i .\nYour code should pass the test:\nassert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11\n",
    "test_list": [
      "assert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11",
      "assert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 2, 5) == 7",
      "assert max_sum_increasing_subseq([11, 15, 19, 21, 26, 28, 31], 7, 2, 4) == 71"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to get a colon of a tuple.\nYour code should pass the test:\nassert colon_tuplex((\"HELLO\", 5, [], True) ,2,50)==(\"HELLO\", 5, [50], True) \n",
    "test_list": [
      "assert colon_tuplex((\"HELLO\", 5, [], True) ,2,50)==(\"HELLO\", 5, [50], True) ",
      "assert colon_tuplex((\"HELLO\", 5, [], True) ,2,100)==((\"HELLO\", 5, [100],True))",
      "assert colon_tuplex((\"HELLO\", 5, [], True) ,2,500)==(\"HELLO\", 5, [500], True)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the specified number of largest products from two given lists.\nYour code should pass the test:\nassert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]\n",
    "test_list": [
      "assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]",
      "assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],4)==[60, 54, 50, 48]",
      "assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],5)==[60, 54, 50, 48, 45]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum of two numbers.\nYour code should pass the test:\nassert maximum(5,10) == 10\n",
    "test_list": [
      "assert maximum(5,10) == 10",
      "assert maximum(-1,-2) == -1",
      "assert maximum(9,7) == 9"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert a given string to a tuple.\nYour code should pass the test:\nassert string_to_tuple(\"python 3.0\")==('p', 'y', 't', 'h', 'o', 'n', '3', '.', '0')\n",
    "test_list": [
      "assert string_to_tuple(\"python 3.0\")==('p', 'y', 't', 'h', 'o', 'n', '3', '.', '0')",
      "assert string_to_tuple(\"item1\")==('i', 't', 'e', 'm', '1')",
      "assert string_to_tuple(\"15.10\")==('1', '5', '.', '1', '0')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to set the left most unset bit.\nYour code should pass the test:\nassert set_left_most_unset_bit(10) == 14\n",
    "test_list": [
      "assert set_left_most_unset_bit(10) == 14",
      "assert set_left_most_unset_bit(12) == 14",
      "assert set_left_most_unset_bit(15) == 15"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the volume of a cone.\nYour code should pass the test:\nassert volume_cone(5,12)==314.15926535897927\n",
    "test_list": [
      "assert volume_cone(5,12)==314.15926535897927",
      "assert volume_cone(10,15)==1570.7963267948965",
      "assert volume_cone(19,17)==6426.651371693521"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to print positive numbers in a list.\nYour code should pass the test:\nassert pos_nos([-1,-2,1,2]) == 1,2\n",
    "test_list": [
      "assert pos_nos([-1,-2,1,2]) == 1,2",
      "assert pos_nos([3,4,-5]) == 3,4",
      "assert pos_nos([-2,-3,1]) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find out the maximum sum such that no two chosen numbers are adjacent for the given rectangular grid of dimension 2 x n.\nYour code should pass the test:\nassert max_sum_rectangular_grid([ [1, 4, 5], [2, 0, 0 ] ], 3) == 7\n",
    "test_list": [
      "assert max_sum_rectangular_grid([ [1, 4, 5], [2, 0, 0 ] ], 3) == 7",
      "assert max_sum_rectangular_grid([ [ 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10] ], 5) == 24",
      "assert max_sum_rectangular_grid([ [7, 9, 11, 15, 19], [21, 25, 28, 31, 32] ], 5) == 81"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first maximum length of even word.\nYour code should pass the test:\nassert find_Max_Len_Even(\"python language\") == \"language\"\n",
    "test_list": [
      "assert find_Max_Len_Even(\"python language\") == \"language\"",
      "assert find_Max_Len_Even(\"maximum even length\") == \"length\"",
      "assert find_Max_Len_Even(\"eve\") == \"-1\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the index of the last occurrence of a given number in a sorted array.\nYour code should pass the test:\nassert find_last_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 3\n",
    "test_list": [
      "assert find_last_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 3",
      "assert find_last_occurrence([2, 3, 5, 8, 6, 6, 8, 9, 9, 9], 9) == 9",
      "assert find_last_occurrence([2, 2, 1, 5, 6, 6, 6, 9, 9, 9], 6) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to reflect the modified run-length encoding from a list.\nYour code should pass the test:\nassert modified_encode([1,1,2,3,4,4,5,1])==[[2, 1], 2, 3, [2, 4], 5, 1]\n",
    "test_list": [
      "assert modified_encode([1,1,2,3,4,4,5,1])==[[2, 1], 2, 3, [2, 4], 5, 1]",
      "assert modified_encode('automatically')==['a', 'u', 't', 'o', 'm', 'a', 't', 'i', 'c', 'a', [2, 'l'], 'y']",
      "assert modified_encode('python')==['p', 'y', 't', 'h', 'o', 'n']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum volume of a cuboid with given sum of sides.\nYour code should pass the test:\nassert max_volume(8) == 18\n",
    "test_list": [
      "assert max_volume(8) == 18",
      "assert max_volume(4) == 2",
      "assert max_volume(1) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all five characters long word in the given string by using regex.\nYour code should pass the test:\nassert find_long_word('Please move back to strem') == ['strem']\n",
    "test_list": [
      "assert find_long_word('Please move back to strem') == ['strem']",
      "assert find_long_word('4K Ultra HD streaming player') == ['Ultra']",
      "assert find_long_word('Streaming Media Player') == ['Media']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the difference between the squared sum of first n natural numbers and the sum of squared first n natural numbers.\nYour code should pass the test:\nassert sum_difference(12)==5434\n",
    "test_list": [
      "assert sum_difference(12)==5434",
      "assert sum_difference(20)==41230",
      "assert sum_difference(54)==2151270"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the demlo number for the given number.\nYour code should pass the test:\nassert find_demlo(\"111111\") == '12345654321'\n",
    "test_list": [
      "assert find_demlo(\"111111\") == '12345654321'",
      "assert find_demlo(\"1111\") == '1234321'",
      "assert find_demlo(\"13333122222\") == '123456789101110987654321'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all index positions of the minimum values in a given list.\nYour code should pass the test:\nassert position_min([12,33,23,10,67,89,45,667,23,12,11,10,54])==[3,11]\n",
    "test_list": [
      "assert position_min([12,33,23,10,67,89,45,667,23,12,11,10,54])==[3,11]",
      "assert position_min([1,2,2,2,4,4,4,5,5,5,5])==[0]",
      "assert position_min([2,1,5,6,8,3,4,9,10,11,8,12])==[1]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to re-arrange the given array in alternating positive and negative items.\nYour code should pass the test:\nassert re_arrange([-5, -2, 5, 2, 4,\t7, 1, 8, 0, -8], 10) == [-5, 5, -2, 2, -8, 4, 7, 1, 8, 0]\n",
    "test_list": [
      "assert re_arrange([-5, -2, 5, 2, 4,\t7, 1, 8, 0, -8], 10) == [-5, 5, -2, 2, -8, 4, 7, 1, 8, 0]",
      "assert re_arrange([1, 2, 3, -4, -1, 4], 6) == [-4, 1, -1, 2, 3, 4]",
      "assert re_arrange([4, 7, 9, 77, -4, 5, -3, -9], 8) == [-4, 4, -3, 7, -9, 9, 77, 5]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the sum of alternate chains of tuples.\nYour code should pass the test:\nassert sum_of_alternates((5, 6, 3, 6, 10, 34)) == (46, 18)\n",
    "test_list": [
      "assert sum_of_alternates((5, 6, 3, 6, 10, 34)) == (46, 18)",
      "assert sum_of_alternates((1, 2, 3, 4, 5)) == (6, 9)",
      "assert sum_of_alternates((6, 7, 8, 9, 4, 5)) == (21, 18)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the minimum number of squares whose sum is equal to a given number.\nYour code should pass the test:\nassert get_Min_Squares(6) == 3\n",
    "test_list": [
      "assert get_Min_Squares(6) == 3",
      "assert get_Min_Squares(2) == 2",
      "assert get_Min_Squares(4) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to get the word with most number of occurrences in the given strings list.\nYour code should pass the test:\nassert most_occurrences([\"UTS is best for RTF\", \"RTF love UTS\", \"UTS is best\"] ) == 'UTS'\n",
    "test_list": [
      "assert most_occurrences([\"UTS is best for RTF\", \"RTF love UTS\", \"UTS is best\"] ) == 'UTS'",
      "assert most_occurrences([\"Its been a great year\", \"this year is so worse\", \"this year is okay\"] ) == 'year'",
      "assert most_occurrences([\"Families can be reunited\", \"people can be reunited\", \"Tasks can be achieved \"] ) == 'can'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to print check if the triangle is isosceles or not.\nYour code should pass the test:\nassert check_isosceles(6,8,12)==False \n",
    "test_list": [
      "assert check_isosceles(6,8,12)==False ",
      "assert check_isosceles(6,6,12)==True",
      "assert check_isosceles(6,16,20)==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to rotate a given list by specified number of items to the left direction.\nYour code should pass the test:\nassert rotate_left([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3,4)==[4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4]\n",
    "test_list": [
      "assert rotate_left([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3,4)==[4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4]",
      "assert rotate_left([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2,2)==[3, 4, 5, 6, 7, 8, 9, 10, 1, 2]",
      "assert rotate_left([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],5,2)==[6, 7, 8, 9, 10, 1, 2]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count negative numbers in a list.\nYour code should pass the test:\nassert neg_count([-1,-2,3,-4,-5]) == 4\n",
    "test_list": [
      "assert neg_count([-1,-2,3,-4,-5]) == 4",
      "assert neg_count([1,2,3]) == 0",
      "assert neg_count([1,2,-3,-10,20]) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all three, four, five characters long words in the given string by using regex.\nYour code should pass the test:\nassert find_char('For the four consumer complaints contact manager AKR reddy') == ['For', 'the', 'four', 'AKR', 'reddy']\n",
    "test_list": [
      "assert find_char('For the four consumer complaints contact manager AKR reddy') == ['For', 'the', 'four', 'AKR', 'reddy']",
      "assert find_char('Certain service are subject to change MSR') == ['are', 'MSR']",
      "assert find_char('Third party legal desclaimers') == ['Third', 'party', 'legal']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count unset bits of a given number.\nYour code should pass the test:\nassert count_unset_bits(2) == 1\n",
    "test_list": [
      "assert count_unset_bits(2) == 1",
      "assert count_unset_bits(4) == 2",
      "assert count_unset_bits(6) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count character frequency of a given string.\nYour code should pass the test:\nassert char_frequency('python')=={'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}\n",
    "test_list": [
      "assert char_frequency('python')=={'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}",
      "assert char_frequency('program')=={'p': 1, 'r': 2, 'o': 1, 'g': 1, 'a': 1, 'm': 1}",
      "assert char_frequency('language')=={'l': 1, 'a': 2, 'n': 1, 'g': 2, 'u': 1, 'e': 1}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to sort a list according to the second element in sublist.\nYour code should pass the test:\nassert Sort([['a', 10], ['b', 5], ['c', 20], ['d', 15]]) == [['b', 5], ['a', 10], ['d', 15], ['c', 20]]\n",
    "test_list": [
      "assert Sort([['a', 10], ['b', 5], ['c', 20], ['d', 15]]) == [['b', 5], ['a', 10], ['d', 15], ['c', 20]]",
      "assert Sort([['452', 10], ['256', 5], ['100', 20], ['135', 15]]) == [['256', 5], ['452', 10], ['135', 15], ['100', 20]]",
      "assert Sort([['rishi', 10], ['akhil', 5], ['ramya', 20], ['gaur', 15]]) == [['akhil', 5], ['rishi', 10], ['gaur', 15], ['ramya', 20]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the triangle is valid or not if sides are given.\nYour code should pass the test:\nassert check_Validity(1,2,3) == False\n",
    "test_list": [
      "assert check_Validity(1,2,3) == False",
      "assert check_Validity(2,3,5) == False",
      "assert check_Validity(7,10,5) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the sum of arithmetic progression.\nYour code should pass the test:\nassert ap_sum(1,5,2)==25\n",
    "test_list": [
      "assert ap_sum(1,5,2)==25",
      "assert ap_sum(2,6,4)==72",
      "assert ap_sum(1,4,5)==34"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the given month name contains 28 days or not.\nYour code should pass the test:\nassert check_monthnum(\"February\")==True\n",
    "test_list": [
      "assert check_monthnum(\"February\")==True",
      "assert check_monthnum(\"January\")==False",
      "assert check_monthnum(\"March\")==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that matches a word at the end of a string, with optional punctuation.\nYour code should pass the test:\nassert text_match_word(\"python.\")==('Found a match!')\n",
    "test_list": [
      "assert text_match_word(\"python.\")==('Found a match!')",
      "assert text_match_word(\"python.\")==('Found a match!')",
      "assert text_match_word(\"  lang  .\")==('Not matched!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of substrings with same first and last characters.\nYour code should pass the test:\nassert count_Substring_With_Equal_Ends('aba') == 4\n",
    "test_list": [
      "assert count_Substring_With_Equal_Ends('aba') == 4",
      "assert count_Substring_With_Equal_Ends('abcab') == 7",
      "assert count_Substring_With_Equal_Ends('abc') == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum occuring divisor in an interval.\nYour code should pass the test:\nassert find_Divisor(2,2) == 2\n",
    "test_list": [
      "assert find_Divisor(2,2) == 2",
      "assert find_Divisor(2,5) == 2",
      "assert find_Divisor(5,10) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of the three lowest positive numbers from a given list of numbers.\nYour code should pass the test:\nassert sum_three_smallest_nums([10,20,30,40,50,60,7]) == 37\n",
    "test_list": [
      "assert sum_three_smallest_nums([10,20,30,40,50,60,7]) == 37",
      "assert sum_three_smallest_nums([1,2,3,4,5]) == 6",
      "assert sum_three_smallest_nums([0,1,2,3,4,5]) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert the given set into ordered tuples.\nYour code should pass the test:\nassert set_to_tuple({1, 2, 3, 4, 5}) == (1, 2, 3, 4, 5)\n",
    "test_list": [
      "assert set_to_tuple({1, 2, 3, 4, 5}) == (1, 2, 3, 4, 5)",
      "assert set_to_tuple({6, 7, 8, 9, 10, 11}) == (6, 7, 8, 9, 10, 11)",
      "assert set_to_tuple({12, 13, 14, 15, 16}) == (12, 13, 14, 15, 16)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the smallest range that includes at-least one element from each of the given arrays.\nYour code should pass the test:\nassert find_minimum_range([[3, 6, 8, 10, 15], [1, 5, 12], [4, 8, 15, 16], [2, 6]]) == (4, 6)\n",
    "test_list": [
      "assert find_minimum_range([[3, 6, 8, 10, 15], [1, 5, 12], [4, 8, 15, 16], [2, 6]]) == (4, 6)",
      "assert find_minimum_range([[ 2, 3, 4, 8, 10, 15 ], [1, 5, 12], [7, 8, 15, 16], [3, 6]]) == (4, 7)",
      "assert find_minimum_range([[4, 7, 9, 11, 16], [2, 6, 13], [5, 9, 16, 17], [3, 7]]) == (5, 7)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the number of digits and letters in a string.\nYour code should pass the test:\nassert dig_let(\"python\")==(6,0)\n",
    "test_list": [
      "assert dig_let(\"python\")==(6,0)",
      "assert dig_let(\"program\")==(7,0)",
      "assert dig_let(\"python3.0\")==(6,2)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find number of elements with odd factors in a given range.\nYour code should pass the test:\nassert count_Odd_Squares(5,100) == 8\n",
    "test_list": [
      "assert count_Odd_Squares(5,100) == 8",
      "assert count_Odd_Squares(8,65) == 6",
      "assert count_Odd_Squares(2,5) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the difference between two consecutive numbers in a given list.\nYour code should pass the test:\nassert diff_consecutivenums([1, 1, 3, 4, 4, 5, 6, 7])==[0, 2, 1, 0, 1, 1, 1]\n",
    "test_list": [
      "assert diff_consecutivenums([1, 1, 3, 4, 4, 5, 6, 7])==[0, 2, 1, 0, 1, 1, 1]",
      "assert diff_consecutivenums([4, 5, 8, 9, 6, 10])==[1, 3, 1, -3, 4]",
      "assert diff_consecutivenums([0, 1, 2, 3, 4, 4, 4, 4, 5, 7])==[1, 1, 1, 1, 0, 0, 0, 1, 2]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find entringer number e(n, k).\nYour code should pass the test:\nassert zigzag(4, 3) == 5\n",
    "test_list": [
      "assert zigzag(4, 3) == 5",
      "assert zigzag(4, 2) == 4",
      "assert zigzag(3, 1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of squares in a rectangle.\nYour code should pass the test:\nassert count_Squares(4,3) == 20\n",
    "test_list": [
      "assert count_Squares(4,3) == 20",
      "assert count_Squares(1,2) == 2",
      "assert count_Squares(2,2) == 5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count sequences of given length having non-negative prefix sums that can be generated by given values.\nYour code should pass the test:\nassert find_ways(4) == 2\n",
    "test_list": [
      "assert find_ways(4) == 2",
      "assert find_ways(6) == 5",
      "assert find_ways(8) == 14"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given string is a binary string or not.\nYour code should pass the test:\nassert check(\"01010101010\") == \"Yes\"\n",
    "test_list": [
      "assert check(\"01010101010\") == \"Yes\"",
      "assert check(\"name0\") == \"No\"",
      "assert check(\"101\") == \"Yes\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to minimize the length of the string by removing occurrence of only one character.\nYour code should pass the test:\nassert minimum_Length(\"mnm\") == 1\n",
    "test_list": [
      "assert minimum_Length(\"mnm\") == 1",
      "assert minimum_Length(\"abcda\") == 3",
      "assert minimum_Length(\"abcb\") == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first element occurring k times in a given array.\nYour code should pass the test:\nassert first_Element([0,1,2,3,4,5],6,1) == 0\n",
    "test_list": [
      "assert first_Element([0,1,2,3,4,5],6,1) == 0",
      "assert first_Element([1,2,1,3,4],5,2) == 1",
      "assert first_Element([2,3,4,3,5,7,1,2,3,5],10,2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether all the characters in a given string are unique.\nYour code should pass the test:\nassert unique_Characters('aba') == False\n",
    "test_list": [
      "assert unique_Characters('aba') == False",
      "assert unique_Characters('abc') == True",
      "assert unique_Characters('abab') == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove a specified column from a given nested list.\nYour code should pass the test:\nassert remove_column([[1, 2, 3], [2, 4, 5], [1, 1, 1]],0)==[[2, 3], [4, 5], [1, 1]]\n",
    "test_list": [
      "assert remove_column([[1, 2, 3], [2, 4, 5], [1, 1, 1]],0)==[[2, 3], [4, 5], [1, 1]]",
      "assert remove_column([[1, 2, 3], [-2, 4, -5], [1, -1, 1]],2)==[[1, 2], [-2, 4], [1, -1]]",
      "assert remove_column([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]],0)==[[3], [7], [3], [15, 17], [7], [11]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find t-nth term of arithemetic progression.\nYour code should pass the test:\nassert tn_ap(1,5,2)==9\n",
    "test_list": [
      "assert tn_ap(1,5,2)==9",
      "assert tn_ap(2,6,4)==22",
      "assert tn_ap(1,4,5)==16"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of rectangles in a circle of radius r.\nYour code should pass the test:\nassert count_Rectangles(2) == 8\n",
    "test_list": [
      "assert count_Rectangles(2) == 8",
      "assert count_Rectangles(1) == 1",
      "assert count_Rectangles(0) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the third angle of a triangle using two angles.\nYour code should pass the test:\nassert find_angle(47,89)==44\n",
    "test_list": [
      "assert find_angle(47,89)==44",
      "assert find_angle(45,95)==40",
      "assert find_angle(50,40)==90"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum element of all the given tuple records.\nYour code should pass the test:\nassert find_max([(2, 4), (6, 7), (5, 1), (6, 10), (8, 7)]) == 10\n",
    "test_list": [
      "assert find_max([(2, 4), (6, 7), (5, 1), (6, 10), (8, 7)]) == 10",
      "assert find_max([(3, 5), (7, 8), (6, 2), (7, 11), (9, 8)]) == 11",
      "assert find_max([(4, 6), (8, 9), (7, 3), (8, 12), (10, 9)]) == 12"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find modulo division of two lists using map and lambda function.\nYour code should pass the test:\nassert moddiv_list([4,5,6],[1, 2, 3])==[0, 1, 0]\n",
    "test_list": [
      "assert moddiv_list([4,5,6],[1, 2, 3])==[0, 1, 0]",
      "assert moddiv_list([3,2],[1,4])==[0, 2]",
      "assert moddiv_list([90,120],[50,70])==[40, 50]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether one root of the quadratic equation is twice of the other or not.\nYour code should pass the test:\nassert Check_Solution(1,3,2) == \"Yes\"\n",
    "test_list": [
      "assert Check_Solution(1,3,2) == \"Yes\"",
      "assert Check_Solution(1,2,3) == \"No\"",
      "assert Check_Solution(1,-5,6) == \"No\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n’th carol number.\nYour code should pass the test:\nassert get_carol(2) == 7\n",
    "test_list": [
      "assert get_carol(2) == 7",
      "assert get_carol(4) == 223",
      "assert get_carol(5) == 959"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove empty lists from a given list of lists.\nYour code should pass the test:\nassert remove_empty([[], [], [], 'Red', 'Green', [1,2], 'Blue', [], []])==['Red', 'Green', [1, 2], 'Blue']\n",
    "test_list": [
      "assert remove_empty([[], [], [], 'Red', 'Green', [1,2], 'Blue', [], []])==['Red', 'Green', [1, 2], 'Blue']",
      "assert remove_empty([[], [], [],[],[], 'Green', [1,2], 'Blue', [], []])==[ 'Green', [1, 2], 'Blue']",
      "assert remove_empty([[], [], [], 'Python',[],[], 'programming', 'language',[],[],[], [], []])==['Python', 'programming', 'language']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the item with maximum occurrences in a given list.\nYour code should pass the test:\nassert max_occurrences([1,2,3,1,2,3,12,4,2]) ==  2\n",
    "test_list": [
      "assert max_occurrences([1,2,3,1,2,3,12,4,2]) ==  2",
      "assert max_occurrences([1,2,6,7,0,1,0,1,0]) == 1,0",
      "assert max_occurrences([1,2,3,1,2,4,1]) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to add the k elements to each element in the tuple.\nYour code should pass the test:\nassert add_K_element([(1, 3, 4), (2, 4, 6), (3, 8, 1)], 4) == [(5, 7, 8), (6, 8, 10), (7, 12, 5)]\n",
    "test_list": [
      "assert add_K_element([(1, 3, 4), (2, 4, 6), (3, 8, 1)], 4) == [(5, 7, 8), (6, 8, 10), (7, 12, 5)]",
      "assert add_K_element([(1, 2, 3), (4, 5, 6), (7, 8, 9)], 8) == [(9, 10, 11), (12, 13, 14), (15, 16, 17)]",
      "assert add_K_element([(11, 12, 13), (14, 15, 16), (17, 18, 19)], 9) == [(20, 21, 22), (23, 24, 25), (26, 27, 28)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the number of flips required to make the given binary string a sequence of alternate characters.\nYour code should pass the test:\nassert min_flip_to_make_string_alternate(\"0001010111\") == 2\n",
    "test_list": [
      "assert min_flip_to_make_string_alternate(\"0001010111\") == 2",
      "assert min_flip_to_make_string_alternate(\"001\") == 1",
      "assert min_flip_to_make_string_alternate(\"010111011\") == 2 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the number of digits of a given number.\nYour code should pass the test:\nassert count_Digit(12345) == 5\n",
    "test_list": [
      "assert count_Digit(12345) == 5",
      "assert count_Digit(11223305) == 8",
      "assert count_Digit(4123459) == 7"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the largest product of the pair of adjacent elements from a given list of integers.\nYour code should pass the test:\nassert adjacent_num_product([1,2,3,4,5,6]) == 30\n",
    "test_list": [
      "assert adjacent_num_product([1,2,3,4,5,6]) == 30",
      "assert adjacent_num_product([1,2,3,4,5]) == 20",
      "assert adjacent_num_product([2,3]) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if a binary tree is balanced or not.\nYour code should pass the test:\nassert is_tree_balanced(root) == False\n",
    "test_list": [
      "assert is_tree_balanced(root) == False",
      "assert is_tree_balanced(root1) == True",
      "assert is_tree_balanced(root2) == False "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to repeat the given tuple n times.\nYour code should pass the test:\nassert repeat_tuples((1, 3), 4) == ((1, 3), (1, 3), (1, 3), (1, 3))\n",
    "test_list": [
      "assert repeat_tuples((1, 3), 4) == ((1, 3), (1, 3), (1, 3), (1, 3))",
      "assert repeat_tuples((1, 2), 3) == ((1, 2), (1, 2), (1, 2))",
      "assert repeat_tuples((3, 4), 5) == ((3, 4), (3, 4), (3, 4), (3, 4), (3, 4))"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the lateral surface area of cuboid\nYour code should pass the test:\nassert lateralsurface_cuboid(8,5,6)==156\n",
    "test_list": [
      "assert lateralsurface_cuboid(8,5,6)==156",
      "assert lateralsurface_cuboid(7,9,10)==320",
      "assert lateralsurface_cuboid(10,20,30)==1800"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a tuple by its float element.\nYour code should pass the test:\nassert float_sort([('item1', '12.20'), ('item2', '15.10'), ('item3', '24.5')])==[('item3', '24.5'), ('item2', '15.10'), ('item1', '12.20')] \n",
    "test_list": [
      "assert float_sort([('item1', '12.20'), ('item2', '15.10'), ('item3', '24.5')])==[('item3', '24.5'), ('item2', '15.10'), ('item1', '12.20')] ",
      "assert float_sort([('item1', '15'), ('item2', '10'), ('item3', '20')])==[('item3', '20'), ('item1', '15'), ('item2', '10')] ",
      "assert float_sort([('item1', '5'), ('item2', '10'), ('item3', '14')])==[('item3', '14'), ('item2', '10'), ('item1', '5')] "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the smallest missing element in a sorted array.\nYour code should pass the test:\nassert smallest_missing([0, 1, 2, 3, 4, 5, 6], 0, 6) == 7\n",
    "test_list": [
      "assert smallest_missing([0, 1, 2, 3, 4, 5, 6], 0, 6) == 7",
      "assert smallest_missing([0, 1, 2, 6, 9, 11, 15], 0, 6) == 3",
      "assert smallest_missing([1, 2, 3, 4, 6, 9, 11, 15], 0, 7) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a given list of elements in ascending order using heap queue algorithm.\nYour code should pass the test:\nassert heap_assending([18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1])==[1, 2, 3, 4, 7, 8, 9, 9, 10, 14, 18]\n",
    "test_list": [
      "assert heap_assending([18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1])==[1, 2, 3, 4, 7, 8, 9, 9, 10, 14, 18]",
      "assert heap_assending([25, 35, 22, 85, 14, 65, 75, 25, 58])==[14, 22, 25, 25, 35, 58, 65, 75, 85]",
      "assert heap_assending([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the volume of a cuboid.\nYour code should pass the test:\nassert volume_cuboid(1,2,3)==6\n",
    "test_list": [
      "assert volume_cuboid(1,2,3)==6",
      "assert volume_cuboid(5,7,9)==315",
      "assert volume_cuboid(10,15,21)==3150"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to print all permutations of a given string including duplicates.\nYour code should pass the test:\nassert permute_string('ab')==['ab', 'ba']\n",
    "test_list": [
      "assert permute_string('ab')==['ab', 'ba']",
      "assert permute_string('abc')==['abc', 'bac', 'bca', 'acb', 'cab', 'cba']",
      "assert permute_string('abcd')==['abcd', 'bacd', 'bcad', 'bcda', 'acbd', 'cabd', 'cbad', 'cbda', 'acdb', 'cadb', 'cdab', 'cdba', 'abdc', 'badc', 'bdac', 'bdca', 'adbc', 'dabc', 'dbac', 'dbca', 'adcb', 'dacb', 'dcab', 'dcba']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to round the given number to the nearest multiple of a specific number.\nYour code should pass the test:\nassert round_num(4722,10)==4720\n",
    "test_list": [
      "assert round_num(4722,10)==4720",
      "assert round_num(1111,5)==1110",
      "assert round_num(219,2)==218"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove tuple elements that occur more than once and replace the duplicates with some custom value.\nYour code should pass the test:\nassert remove_replica((1, 1, 4, 4, 4, 5, 5, 6, 7, 7)) == (1, 'MSP', 4, 'MSP', 'MSP', 5, 'MSP', 6, 7, 'MSP')\n",
    "test_list": [
      "assert remove_replica((1, 1, 4, 4, 4, 5, 5, 6, 7, 7)) == (1, 'MSP', 4, 'MSP', 'MSP', 5, 'MSP', 6, 7, 'MSP')",
      "assert remove_replica((2, 3, 4, 4, 5, 6, 6, 7, 8, 9, 9)) == (2, 3, 4, 'MSP', 5, 6, 'MSP', 7, 8, 9, 'MSP')",
      "assert remove_replica((2, 2, 5, 4, 5, 7, 5, 6, 7, 7)) == (2, 'MSP', 5, 4, 'MSP', 7, 'MSP', 6, 'MSP', 'MSP')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to remove all occurrences of a character in a given string.\nYour code should pass the test:\nassert remove_Char(\"aba\",'a') == \"b\"\n",
    "test_list": [
      "assert remove_Char(\"aba\",'a') == \"b\"",
      "assert remove_Char(\"toggle\",'g') == \"tole\"",
      "assert remove_Char(\"aabbc\",'b') == \"aac\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to shift last element to first position in the given list.\nYour code should pass the test:\nassert move_first([1,2,3,4]) == [4,1,2,3]\n",
    "test_list": [
      "assert move_first([1,2,3,4]) == [4,1,2,3]",
      "assert move_first([0,1,2,3]) == [3,0,1,2]",
      "assert move_first([9,8,7,1]) == [1,9,8,7]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the surface area of a cuboid.\nYour code should pass the test:\nassert surfacearea_cuboid(1,2,3)==22\n",
    "test_list": [
      "assert surfacearea_cuboid(1,2,3)==22",
      "assert surfacearea_cuboid(5,7,9)==286",
      "assert surfacearea_cuboid(10,15,21)==1350"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to generate a two-dimensional array.\nYour code should pass the test:\nassert multi_list(3,4)==[[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]] \n",
    "test_list": [
      "assert multi_list(3,4)==[[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]] ",
      "assert multi_list(5,7)==[[0, 0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5, 6], [0, 2, 4, 6, 8, 10, 12], [0, 3, 6, 9, 12, 15, 18], [0, 4, 8, 12, 16, 20, 24]]",
      "assert multi_list(10,15)==[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28], [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42], [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56], [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70], [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84], [0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98], [0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112], [0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99, 108, 117, 126]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a list of lists by a given index of the inner list.\nYour code should pass the test:\nassert index_on_inner_list([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==[('Beau Turnbull', 94, 98), ('Brady Kent', 97, 96), ('Greyson Fulton', 98, 99), ('Wyatt Knott', 91, 94)]\n",
    "test_list": [
      "assert index_on_inner_list([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==[('Beau Turnbull', 94, 98), ('Brady Kent', 97, 96), ('Greyson Fulton', 98, 99), ('Wyatt Knott', 91, 94)]",
      "assert index_on_inner_list([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,1)==[('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98), ('Brady Kent', 97, 96), ('Greyson Fulton', 98, 99)]",
      "assert index_on_inner_list([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,2)==[('Wyatt Knott', 91, 94), ('Brady Kent', 97, 96), ('Beau Turnbull', 94, 98), ('Greyson Fulton', 98, 99)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the number of rotations in a circularly sorted array.\nYour code should pass the test:\nassert find_rotation_count([8, 9, 10, 1, 2, 3, 4, 5, 6, 7]) == 3\n",
    "test_list": [
      "assert find_rotation_count([8, 9, 10, 1, 2, 3, 4, 5, 6, 7]) == 3",
      "assert find_rotation_count([8, 9, 10,2, 5, 6]) == 3",
      "assert find_rotation_count([2, 5, 6, 8, 9, 10]) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to toggle all odd bits of a given number.\nYour code should pass the test:\nassert even_bit_toggle_number(10) == 15\n",
    "test_list": [
      "assert even_bit_toggle_number(10) == 15",
      "assert even_bit_toggle_number(20) == 1",
      "assert even_bit_toggle_number(30) == 11"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the frequency of the smallest value in a given array.\nYour code should pass the test:\nassert frequency_Of_Smallest(5,[1,2,3,4,3]) == 1\n",
    "test_list": [
      "assert frequency_Of_Smallest(5,[1,2,3,4,3]) == 1",
      "assert frequency_Of_Smallest(7,[3,1,2,5,6,2,3]) == 1",
      "assert frequency_Of_Smallest(7,[3,3,6,3,7,4,9]) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n'th perrin number using recursion.\nYour code should pass the test:\nassert get_perrin(9) == 12\n",
    "test_list": [
      "assert get_perrin(9) == 12",
      "assert get_perrin(4) == 2",
      "assert get_perrin(6) == 5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find out the minimum no of swaps required for bracket balancing in the given string.\nYour code should pass the test:\nassert swap_count(\"[]][][\") == 2\n",
    "test_list": [
      "assert swap_count(\"[]][][\") == 2",
      "assert swap_count(\"[[][]]\") == 0",
      "assert swap_count(\"[[][]]][\") == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the hexadecimal number is even or odd.\nYour code should pass the test:\nassert even_or_odd(\"AB3454D\") ==\"Odd\"\n",
    "test_list": [
      "assert even_or_odd(\"AB3454D\") ==\"Odd\"",
      "assert even_or_odd(\"ABC\") == \"Even\"",
      "assert even_or_odd(\"AAD\") == \"Odd\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the highest power of 2 that is less than or equal to n.\nYour code should pass the test:\nassert highest_Power_of_2(10) == 8\n",
    "test_list": [
      "assert highest_Power_of_2(10) == 8",
      "assert highest_Power_of_2(19) == 16",
      "assert highest_Power_of_2(32) == 32"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the n'th lucas number.\nYour code should pass the test:\nassert find_lucas(9) == 76\n",
    "test_list": [
      "assert find_lucas(9) == 76",
      "assert find_lucas(4) == 7",
      "assert find_lucas(3) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to insert a given string at the beginning of all items in a list.\nYour code should pass the test:\nassert add_string([1,2,3,4],'temp{0}')==['temp1', 'temp2', 'temp3', 'temp4']\n",
    "test_list": [
      "assert add_string([1,2,3,4],'temp{0}')==['temp1', 'temp2', 'temp3', 'temp4']",
      "assert add_string(['a','b','c','d'], 'python{0}')==[ 'pythona', 'pythonb', 'pythonc', 'pythond']",
      "assert add_string([5,6,7,8],'string{0}')==['string5', 'string6', 'string7', 'string8']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert more than one list to nested dictionary.\nYour code should pass the test:\nassert convert_list_dictionary([\"S001\", \"S002\", \"S003\", \"S004\"],[\"Adina Park\", \"Leyton Marsh\", \"Duncan Boyle\", \"Saim Richards\"] ,[85, 98, 89, 92])==[{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]\n",
    "test_list": [
      "assert convert_list_dictionary([\"S001\", \"S002\", \"S003\", \"S004\"],[\"Adina Park\", \"Leyton Marsh\", \"Duncan Boyle\", \"Saim Richards\"] ,[85, 98, 89, 92])==[{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]",
      "assert convert_list_dictionary([\"abc\",\"def\",\"ghi\",\"jkl\"],[\"python\",\"program\",\"language\",\"programs\"],[100,200,300,400])==[{'abc':{'python':100}},{'def':{'program':200}},{'ghi':{'language':300}},{'jkl':{'programs':400}}]",
      "assert convert_list_dictionary([\"A1\",\"A2\",\"A3\",\"A4\"],[\"java\",\"C\",\"C++\",\"DBMS\"],[10,20,30,40])==[{'A1':{'java':10}},{'A2':{'C':20}},{'A3':{'C++':30}},{'A4':{'DBMS':40}}]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum sum possible by using the given equation f(n) = max( (f(n/2) + f(n/3) + f(n/4) + f(n/5)), n).\nYour code should pass the test:\nassert get_max_sum(60) == 106\n",
    "test_list": [
      "assert get_max_sum(60) == 106",
      "assert get_max_sum(10) == 12",
      "assert get_max_sum(2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the list with maximum length using lambda function.\nYour code should pass the test:\nassert max_length_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])\n",
    "test_list": [
      "assert max_length_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])",
      "assert max_length_list([[1,2,3,4,5],[1,2,3,4],[1,2,3],[1,2],[1]])==(5,[1,2,3,4,5])",
      "assert max_length_list([[3,4,5],[6,7,8,9],[10,11,12]])==(4,[6,7,8,9])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if given tuple is distinct or not.\nYour code should pass the test:\nassert check_distinct((1, 4, 5, 6, 1, 4)) == False\n",
    "test_list": [
      "assert check_distinct((1, 4, 5, 6, 1, 4)) == False",
      "assert check_distinct((1, 4, 5, 6)) == True",
      "assert check_distinct((2, 3, 4, 5, 6)) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first non-repeated character in a given string.\nYour code should pass the test:\nassert first_non_repeating_character(\"abcabc\") == None\n",
    "test_list": [
      "assert first_non_repeating_character(\"abcabc\") == None",
      "assert first_non_repeating_character(\"abc\") == \"a\"",
      "assert first_non_repeating_character(\"ababc\") == \"c\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the given string starts and ends with the same character or not using regex.\nYour code should pass the test:\nassert check_char(\"abba\") == \"Valid\"\n",
    "test_list": [
      "assert check_char(\"abba\") == \"Valid\"",
      "assert check_char(\"a\") == \"Valid\"",
      "assert check_char(\"abcd\") == \"Invalid\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the median of three specific numbers.\nYour code should pass the test:\nassert median_numbers(25,55,65)==55.0\n",
    "test_list": [
      "assert median_numbers(25,55,65)==55.0",
      "assert median_numbers(20,10,30)==20.0",
      "assert median_numbers(15,45,75)==45.0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to compute the sum of digits of each number of a given list.\nYour code should pass the test:\nassert sum_of_digits([10,2,56])==14\n",
    "test_list": [
      "assert sum_of_digits([10,2,56])==14",
      "assert sum_of_digits([[10,20,4,5,'b',70,'a']])==19",
      "assert sum_of_digits([10,20,-4,5,-70])==19"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform the mathematical bitwise xor operation across the given tuples.\nYour code should pass the test:\nassert bitwise_xor((10, 4, 6, 9), (5, 2, 3, 3)) == (15, 6, 5, 10)\n",
    "test_list": [
      "assert bitwise_xor((10, 4, 6, 9), (5, 2, 3, 3)) == (15, 6, 5, 10)",
      "assert bitwise_xor((11, 5, 7, 10), (6, 3, 4, 4)) == (13, 6, 3, 14)",
      "assert bitwise_xor((12, 6, 8, 11), (7, 4, 5, 6)) == (11, 2, 13, 13)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the frequency of unique tuples in the given list order irrespective.\nYour code should pass the test:\nassert extract_freq([(3, 4), (1, 2), (4, 3), (5, 6)] ) == 3\n",
    "test_list": [
      "assert extract_freq([(3, 4), (1, 2), (4, 3), (5, 6)] ) == 3",
      "assert extract_freq([(4, 15), (2, 3), (5, 4), (6, 7)] ) == 4",
      "assert extract_freq([(5, 16), (2, 3), (6, 5), (6, 9)] ) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform index wise addition of tuple elements in the given two nested tuples.\nYour code should pass the test:\nassert add_nested_tuples(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((7, 10), (7, 14), (3, 10), (8, 13))\n",
    "test_list": [
      "assert add_nested_tuples(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((7, 10), (7, 14), (3, 10), (8, 13))",
      "assert add_nested_tuples(((2, 4), (5, 6), (3, 10), (2, 11)), ((7, 8), (4, 10), (2, 2), (8, 4))) == ((9, 12), (9, 16), (5, 12), (10, 15))",
      "assert add_nested_tuples(((3, 5), (6, 7), (4, 11), (3, 12)), ((8, 9), (5, 11), (3, 3), (9, 5))) == ((11, 14), (11, 18), (7, 14), (12, 17))"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to compute the value of ncr%p.\nYour code should pass the test:\nassert ncr_modp(10,2,13)==6\n",
    "test_list": [
      "assert ncr_modp(10,2,13)==6",
      "assert ncr_modp(15,12,43)==25",
      "assert ncr_modp(17,9,18)==10"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if a url is valid or not using regex.\nYour code should pass the test:\nassert is_valid_URL(\"https://www.google.com\") == True\n",
    "test_list": [
      "assert is_valid_URL(\"https://www.google.com\") == True",
      "assert is_valid_URL(\"https:/www.gmail.com\") == False",
      "assert is_valid_URL(\"https:// www.redit.com\") == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the minimum of two numbers.\nYour code should pass the test:\nassert minimum(1,2) == 1\n",
    "test_list": [
      "assert minimum(1,2) == 1",
      "assert minimum(-5,-4) == -5",
      "assert minimum(0,0) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether an element exists within a tuple.\nYour code should pass the test:\nassert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),'r')==True\n",
    "test_list": [
      "assert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),'r')==True",
      "assert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),'5')==False",
      "assert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\",\"e\"),3)==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the parity of a given number.\nYour code should pass the test:\nassert find_Parity(12) == \"Even Parity\"\n",
    "test_list": [
      "assert find_Parity(12) == \"Even Parity\"",
      "assert find_Parity(7) == \"Odd Parity\"",
      "assert find_Parity(10) == \"Even Parity\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to create the next bigger number by rearranging the digits of a given number.\nYour code should pass the test:\nassert rearrange_bigger(12)==21\n",
    "test_list": [
      "assert rearrange_bigger(12)==21",
      "assert rearrange_bigger(10)==False",
      "assert rearrange_bigger(102)==120"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find k number of pairs which consist of one element from the first array and one element from the second array.\nYour code should pass the test:\nassert k_smallest_pairs([1,3,7],[2,4,6],2)==[[1, 2], [1, 4]]\n",
    "test_list": [
      "assert k_smallest_pairs([1,3,7],[2,4,6],2)==[[1, 2], [1, 4]]",
      "assert k_smallest_pairs([1,3,7],[2,4,6],1)==[[1, 2]]",
      "assert k_smallest_pairs([1,3,7],[2,4,6],7)==[[1, 2], [1, 4], [3, 2], [1, 6], [3, 4], [3, 6], [7, 2]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the minimum product from the pairs of tuples within a given list.\nYour code should pass the test:\nassert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==8\n",
    "test_list": [
      "assert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==8",
      "assert min_product_tuple([(10,20), (15,2), (5,10)] )==30",
      "assert min_product_tuple([(11,44), (10,15), (20,5), (12, 9)] )==100"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the minimum value in a given heterogeneous list.\nYour code should pass the test:\nassert min_val(['Python', 3, 2, 4, 5, 'version'])==2\n",
    "test_list": [
      "assert min_val(['Python', 3, 2, 4, 5, 'version'])==2",
      "assert min_val(['Python', 15, 20, 25])==15",
      "assert min_val(['Python', 30, 20, 40, 50, 'version'])==20"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert the given snake case string to camel case string by using regex.\nYour code should pass the test:\nassert snake_to_camel('android_tv') == 'AndroidTv'\n",
    "test_list": [
      "assert snake_to_camel('android_tv') == 'AndroidTv'",
      "assert snake_to_camel('google_pixel') == 'GooglePixel'",
      "assert snake_to_camel('apple_watch') == 'AppleWatch'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to remove odd numbers from a given list.\nYour code should pass the test:\nassert remove_odd([1,2,3]) == [2]\n",
    "test_list": [
      "assert remove_odd([1,2,3]) == [2]",
      "assert remove_odd([2,4,6]) == [2,4,6]",
      "assert remove_odd([10,20,3]) == [10,20]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the nth element from a given list of tuples.\nYour code should pass the test:\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']\n",
    "test_list": [
      "assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']",
      "assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,2)==[99, 96, 94, 98]",
      "assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)],1)==[98, 97, 91, 94]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the value exists in a sequence or not.\nYour code should pass the test:\nassert overlapping([1,2,3,4,5],[6,7,8,9]) == False\n",
    "test_list": [
      "assert overlapping([1,2,3,4,5],[6,7,8,9]) == False",
      "assert overlapping([1,2,3],[4,5,6]) == False",
      "assert overlapping([1,4,5],[1,4,5]) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find a pair with highest product from a given array of integers.\nYour code should pass the test:\nassert max_Product([1,2,3,4,7,0,8,4]) == (7,8)\n",
    "test_list": [
      "assert max_Product([1,2,3,4,7,0,8,4]) == (7,8)",
      "assert max_Product([0,-1,-2,-4,5,0,-6]) == (-4,-6)",
      "assert max_Product([1,2,3]) == (2,3)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum sum we can make by dividing number in three parts recursively and summing them up together for the given number.\nYour code should pass the test:\nassert breakSum(12) == 13\n",
    "test_list": [
      "assert breakSum(12) == 13",
      "assert breakSum(24) == 27",
      "assert breakSum(23) == 23"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find common first element in given list of tuple.\nYour code should pass the test:\nassert group_tuples([('x', 'y'), ('x', 'z'), ('w', 't')]) == [('x', 'y', 'z'), ('w', 't')]\n",
    "test_list": [
      "assert group_tuples([('x', 'y'), ('x', 'z'), ('w', 't')]) == [('x', 'y', 'z'), ('w', 't')]",
      "assert group_tuples([('a', 'b'), ('a', 'c'), ('d', 'e')]) == [('a', 'b', 'c'), ('d', 'e')]",
      "assert group_tuples([('f', 'g'), ('f', 'g'), ('h', 'i')]) == [('f', 'g', 'g'), ('h', 'i')]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sublist having maximum length.\nYour code should pass the test:\nassert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']\n",
    "test_list": [
      "assert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']",
      "assert Find_Max([[1],[1,2],[1,2,3]]) == [1,2,3]",
      "assert Find_Max([[1,1],[1,2,3],[1,5,6,1]]) == [1,5,6,1]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to round every number of a given list of numbers and print the total sum multiplied by the length of the list.\nYour code should pass the test:\nassert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243\n",
    "test_list": [
      "assert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243",
      "assert round_and_sum([5,2,9,24.3,29])==345",
      "assert round_and_sum([25.0,56.7,89.2])==513"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the cube sum of first n even natural numbers.\nYour code should pass the test:\nassert cube_Sum(2) == 72\n",
    "test_list": [
      "assert cube_Sum(2) == 72",
      "assert cube_Sum(3) == 288",
      "assert cube_Sum(4) == 800"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to concatenate each element of tuple by the delimiter.\nYour code should pass the test:\nassert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\") ) == 'ID-is-4-UTS'\n",
    "test_list": [
      "assert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\") ) == 'ID-is-4-UTS'",
      "assert concatenate_tuple((\"QWE\", \"is\", 4, \"RTY\") ) == 'QWE-is-4-RTY'",
      "assert concatenate_tuple((\"ZEN\", \"is\", 4, \"OP\") ) == 'ZEN-is-4-OP'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the average of cubes of first n natural numbers.\nYour code should pass the test:\nassert find_Average_Of_Cube(2) == 4.5\n",
    "test_list": [
      "assert find_Average_Of_Cube(2) == 4.5",
      "assert find_Average_Of_Cube(3) == 12",
      "assert find_Average_Of_Cube(1) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to solve gold mine problem.\nYour code should pass the test:\nassert get_maxgold([[1, 3, 1, 5],[2, 2, 4, 1],[5, 0, 2, 3],[0, 6, 1, 2]],4,4)==16\n",
    "test_list": [
      "assert get_maxgold([[1, 3, 1, 5],[2, 2, 4, 1],[5, 0, 2, 3],[0, 6, 1, 2]],4,4)==16",
      "assert get_maxgold([[10,20],[30,40]],2,2)==70",
      "assert get_maxgold([[4,9],[3,7]],2,2)==13"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract only the rear index element of each string in the given tuple.\nYour code should pass the test:\nassert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']\n",
    "test_list": [
      "assert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']",
      "assert extract_rear(('Avenge', 'for', 'People') ) == ['e', 'r', 'e']",
      "assert extract_rear(('Gotta', 'get', 'go') ) == ['a', 't', 'o']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count the number of sublists containing a particular element.\nYour code should pass the test:\nassert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3\n",
    "test_list": [
      "assert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3",
      "assert count_element_in_list([['A', 'B'], ['A', 'C'], ['A', 'D', 'E'], ['B', 'C', 'D']],'A')==3",
      "assert count_element_in_list([['A', 'B'], ['A', 'C'], ['A', 'D', 'E'], ['B', 'C', 'D']],'E')==1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to filter odd numbers using lambda function.\nYour code should pass the test:\nassert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]\n",
    "test_list": [
      "assert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]",
      "assert filter_oddnumbers([10,20,45,67,84,93])==[45,67,93]",
      "assert filter_oddnumbers([5,7,9,8,6,4,3])==[5,7,9,3]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format by using regex.\nYour code should pass the test:\nassert change_date_format(\"2026-01-02\") == '02-01-2026'\n",
    "test_list": [
      "assert change_date_format(\"2026-01-02\") == '02-01-2026'",
      "assert change_date_format(\"2020-11-13\") == '13-11-2020'",
      "assert change_date_format(\"2021-04-26\") == '26-04-2021'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort the given array by using shell sort.\nYour code should pass the test:\nassert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]\n",
    "test_list": [
      "assert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]",
      "assert shell_sort([24, 22, 39, 34, 87, 73, 68]) == [22, 24, 34, 39, 68, 73, 87]",
      "assert shell_sort([32, 30, 16, 96, 82, 83, 74]) == [16, 30, 32, 74, 82, 83, 96]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract the elementwise and tuples from the given two tuples.\nYour code should pass the test:\nassert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)\n",
    "test_list": [
      "assert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)",
      "assert and_tuples((1, 2, 3, 4), (5, 6, 7, 8)) == (1, 2, 3, 0)",
      "assert and_tuples((8, 9, 11, 12), (7, 13, 14, 17)) == (0, 9, 10, 0)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the directrix of a parabola.\nYour code should pass the test:\nassert parabola_directrix(5,3,2)==-198\n",
    "test_list": [
      "assert parabola_directrix(5,3,2)==-198",
      "assert parabola_directrix(9,8,4)==-2336",
      "assert parabola_directrix(2,4,6)==-130"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that takes two lists and returns true if they have at least one common element.\nYour code should pass the test:\nassert common_element([1,2,3,4,5], [5,6,7,8,9])==True\n",
    "test_list": [
      "assert common_element([1,2,3,4,5], [5,6,7,8,9])==True",
      "assert common_element([1,2,3,4,5], [6,7,8,9])==None",
      "assert common_element(['a','b','c'], ['d','b','e'])==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the median of a trapezium.\nYour code should pass the test:\nassert median_trapezium(15,25,35)==20\n",
    "test_list": [
      "assert median_trapezium(15,25,35)==20",
      "assert median_trapezium(10,20,30)==15",
      "assert median_trapezium(6,9,4)==7.5"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the entered number is greater than the elements of the given array.\nYour code should pass the test:\nassert check_greater([1, 2, 3, 4, 5], 4) == 'No, entered number is less than those in the array'\n",
    "test_list": [
      "assert check_greater([1, 2, 3, 4, 5], 4) == 'No, entered number is less than those in the array'",
      "assert check_greater([2, 3, 4, 5, 6], 8) == 'Yes, the entered number is greater than those in the array'",
      "assert check_greater([9, 7, 4, 8, 6, 1], 11) == 'Yes, the entered number is greater than those in the array'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that matches a string that has an a followed by one or more b's.\nYour code should pass the test:\nassert text_match_one(\"ac\")==('Not matched!')\n",
    "test_list": [
      "assert text_match_one(\"ac\")==('Not matched!')",
      "assert text_match_one(\"dc\")==('Not matched!')",
      "assert text_match_one(\"abba\")==('Found a match!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the last digit of a given number.\nYour code should pass the test:\nassert last_Digit(123) == 3\n",
    "test_list": [
      "assert last_Digit(123) == 3",
      "assert last_Digit(25) == 5",
      "assert last_Digit(30) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to print negative numbers in a list.\nYour code should pass the test:\nassert neg_nos([-1,4,5,-6]) == -1,-6\n",
    "test_list": [
      "assert neg_nos([-1,4,5,-6]) == -1,-6",
      "assert neg_nos([-1,-2,3,4]) == -1,-2",
      "assert neg_nos([-7,-6,8,9]) == -7,-6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove odd characters in a string.\nYour code should pass the test:\nassert remove_odd(\"python\")==(\"yhn\")\n",
    "test_list": [
      "assert remove_odd(\"python\")==(\"yhn\")",
      "assert remove_odd(\"program\")==(\"rga\")",
      "assert remove_odd(\"language\")==(\"agae\")"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to count bidirectional tuple pairs.\nYour code should pass the test:\nassert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '3'\n",
    "test_list": [
      "assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '3'",
      "assert count_bidirectional([(5, 6), (1, 3), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '2'",
      "assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 2), (6, 5), (2, 1)] ) == '4'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert a list of multiple integers into a single integer.\nYour code should pass the test:\nassert multiple_to_single([11, 33, 50])==113350\n",
    "test_list": [
      "assert multiple_to_single([11, 33, 50])==113350",
      "assert multiple_to_single([-1,2,3,4,5,6])==-123456",
      "assert multiple_to_single([10,15,20,25])==10152025"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all adverbs and their positions in a given sentence.\nYour code should pass the test:\nassert find_adverb_position(\"clearly!! we can see the sky\")==(0, 7, 'clearly')\n",
    "test_list": [
      "assert find_adverb_position(\"clearly!! we can see the sky\")==(0, 7, 'clearly')",
      "assert find_adverb_position(\"seriously!! there are many roses\")==(0, 9, 'seriously')",
      "assert find_adverb_position(\"unfortunately!! sita is going to home\")==(0, 13, 'unfortunately')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the surface area of a cube.\nYour code should pass the test:\nassert surfacearea_cube(5)==150\n",
    "test_list": [
      "assert surfacearea_cube(5)==150",
      "assert surfacearea_cube(3)==54",
      "assert surfacearea_cube(10)==600"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the ration of positive numbers in an array of integers.\nYour code should pass the test:\nassert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54\n",
    "test_list": [
      "assert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54",
      "assert positive_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.69",
      "assert positive_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.56"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the largest negative number from the given list.\nYour code should pass the test:\nassert largest_neg([1,2,3,-4,-6]) == -6\n",
    "test_list": [
      "assert largest_neg([1,2,3,-4,-6]) == -6",
      "assert largest_neg([1,2,3,-8,-9]) == -9",
      "assert largest_neg([1,2,3,4,-1]) == -1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to trim each tuple by k in the given tuple list.\nYour code should pass the test:\nassert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1),(9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 2) == '[(2,), (9,), (2,), (2,)]'\n",
    "test_list": [
      "assert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1),(9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 2) == '[(2,), (9,), (2,), (2,)]'",
      "assert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1), (9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 1) == '[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]'",
      "assert trim_tuple([(7, 8, 4, 9), (11, 8, 12, 4),(4, 1, 7, 8), (3, 6, 9, 7)], 1) == '[(8, 4), (8, 12), (1, 7), (6, 9)]'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to perform index wise multiplication of tuple elements in the given two tuples.\nYour code should pass the test:\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))\n",
    "test_list": [
      "assert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))",
      "assert index_multiplication(((2, 4), (5, 6), (3, 10), (2, 11)),((7, 8), (4, 10), (2, 2), (8, 4)) ) == ((14, 32), (20, 60), (6, 20), (16, 44))",
      "assert index_multiplication(((3, 5), (6, 7), (4, 11), (3, 12)),((8, 9), (5, 11), (3, 3), (9, 5)) ) == ((24, 45), (30, 77), (12, 33), (27, 60))"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the occurence of all elements of list in a tuple.\nYour code should pass the test:\nassert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3\n",
    "test_list": [
      "assert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3",
      "assert count_Occurrence((1, 2, 3, 1, 4, 6, 7, 1, 4),[1, 4, 7]) == 6",
      "assert count_Occurrence((1,2,3,4,5,6),[1,2]) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find cubes of individual elements in a list using lambda function.\nYour code should pass the test:\nassert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n",
    "test_list": [
      "assert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]",
      "assert cube_nums([10,20,30])==([1000, 8000, 27000])",
      "assert cube_nums([12,15])==([1728, 3375])"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the sum of perrin numbers.\nYour code should pass the test:\nassert cal_sum(9) == 49\n",
    "test_list": [
      "assert cal_sum(9) == 49",
      "assert cal_sum(10) == 66",
      "assert cal_sum(11) == 88"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the triangle is valid or not if 3 points are given.\nYour code should pass the test:\nassert check_Triangle(1,5,2,5,4,6) == 'Yes'\n",
    "test_list": [
      "assert check_Triangle(1,5,2,5,4,6) == 'Yes'",
      "assert check_Triangle(1,1,1,4,1,5) == 'No'",
      "assert check_Triangle(1,1,1,1,1,1) == 'No'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract specified size of strings from a give list of string values.\nYour code should pass the test:\nassert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']\n",
    "test_list": [
      "assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']",
      "assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,6)==['Python']",
      "assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,9)==['exercises']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove all whitespaces from the given string using regex.\nYour code should pass the test:\nassert remove_whitespaces(' Google    Flutter ') == 'GoogleFlutter'\n",
    "test_list": [
      "assert remove_whitespaces(' Google    Flutter ') == 'GoogleFlutter'",
      "assert remove_whitespaces(' Google    Dart ') == 'GoogleDart'",
      "assert remove_whitespaces(' iOS    Swift ') == 'iOSSwift'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that gives loss amount if the given amount has loss else return none.\nYour code should pass the test:\nassert loss_amount(1500,1200)==None\n",
    "test_list": [
      "assert loss_amount(1500,1200)==None",
      "assert loss_amount(100,200)==100",
      "assert loss_amount(2000,5000)==3000"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of even factors of a number.\nYour code should pass the test:\nassert sumofFactors(18) == 26\n",
    "test_list": [
      "assert sumofFactors(18) == 26",
      "assert sumofFactors(30) == 48",
      "assert sumofFactors(6) == 8"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function that matches a word containing 'z'.\nYour code should pass the test:\nassert text_match_wordz(\"pythonz.\")==('Found a match!')\n",
    "test_list": [
      "assert text_match_wordz(\"pythonz.\")==('Found a match!')",
      "assert text_match_wordz(\"xyz.\")==('Found a match!')",
      "assert text_match_wordz(\"  lang  .\")==('Not matched!')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check whether the given month number contains 31 days or not.\nYour code should pass the test:\nassert check_monthnumb_number(5)==True\n",
    "test_list": [
      "assert check_monthnumb_number(5)==True",
      "assert check_monthnumb_number(2)==False",
      "assert check_monthnumb_number(6)==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to reverse strings in a given list of string values.\nYour code should pass the test:\nassert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']\n",
    "test_list": [
      "assert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']",
      "assert reverse_string_list(['john','amal','joel','george'])==['nhoj','lama','leoj','egroeg']",
      "assert reverse_string_list(['jack','john','mary'])==['kcaj','nhoj','yram']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sublist having minimum length.\nYour code should pass the test:\nassert Find_Min([[1],[1,2],[1,2,3]]) == [1]\n",
    "test_list": [
      "assert Find_Min([[1],[1,2],[1,2,3]]) == [1]",
      "assert Find_Min([[1,1],[1,1,1],[1,2,7,8]]) == [1,1]",
      "assert Find_Min([['x'],['x','y'],['x','y','z']]) == ['x']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the area of a rectangle.\nYour code should pass the test:\nassert rectangle_area(10,20)==200\n",
    "test_list": [
      "assert rectangle_area(10,20)==200",
      "assert rectangle_area(10,5)==50",
      "assert rectangle_area(4,2)==8"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove uppercase substrings from a given string by using regex.\nYour code should pass the test:\nassert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'\n",
    "test_list": [
      "assert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'",
      "assert remove_uppercase('wAtchTheinTernEtrAdIo') == 'wtchheinerntrdo'",
      "assert remove_uppercase('VoicESeaRchAndreComMendaTionS') == 'oiceachndreomendaion'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to get the first element of each sublist.\nYour code should pass the test:\nassert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]\n",
    "test_list": [
      "assert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]",
      "assert Extract([[1,2,3],[4, 5]]) == [1,4]",
      "assert Extract([[9,8,1],[1,2]]) == [9,1]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to count the upper case characters in a given string.\nYour code should pass the test:\nassert upper_ctr('PYthon') == 1\n",
    "test_list": [
      "assert upper_ctr('PYthon') == 1",
      "assert upper_ctr('BigData') == 1",
      "assert upper_ctr('program') == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find all possible combinations of the elements of a given list.\nYour code should pass the test:\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']]\n",
    "test_list": [
      "assert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]",
      "assert combinations_list(['red', 'green', 'blue', 'white', 'black', 'orange'])==[[], ['red'], ['green'], ['green', 'red'], ['blue'], ['blue', 'red'], ['blue', 'green'], ['blue', 'green', 'red'], ['white'], ['white', 'red'], ['white', 'green'], ['white', 'green', 'red'], ['white', 'blue'], ['white', 'blue', 'red'], ['white', 'blue', 'green'], ['white', 'blue', 'green', 'red'], ['black'], ['black', 'red'], ['black', 'green'], ['black', 'green', 'red'], ['black', 'blue'], ['black', 'blue', 'red'], ['black', 'blue', 'green'], ['black', 'blue', 'green', 'red'], ['black', 'white'], ['black', 'white', 'red'], ['black', 'white', 'green'], ['black', 'white', 'green', 'red'], ['black', 'white', 'blue'], ['black', 'white', 'blue', 'red'], ['black', 'white', 'blue', 'green'], ['black', 'white', 'blue', 'green', 'red'], ['orange'], ['orange', 'red'], ['orange', 'green'], ['orange', 'green', 'red'], ['orange', 'blue'], ['orange', 'blue', 'red'], ['orange', 'blue', 'green'], ['orange', 'blue', 'green', 'red'], ['orange', 'white'], ['orange', 'white', 'red'], ['orange', 'white', 'green'], ['orange', 'white', 'green', 'red'], ['orange', 'white', 'blue'], ['orange', 'white', 'blue', 'red'], ['orange', 'white', 'blue', 'green'], ['orange', 'white', 'blue', 'green', 'red'], ['orange', 'black'], ['orange', 'black', 'red'], ['orange', 'black', 'green'], ['orange', 'black', 'green', 'red'], ['orange', 'black', 'blue'], ['orange', 'black', 'blue', 'red'], ['orange', 'black', 'blue', 'green'], ['orange', 'black', 'blue', 'green', 'red'], ['orange', 'black', 'white'], ['orange', 'black', 'white', 'red'], ['orange', 'black', 'white', 'green'], ['orange', 'black', 'white', 'green', 'red'], ['orange', 'black', 'white', 'blue'], ['orange', 'black', 'white', 'blue', 'red'], ['orange', 'black', 'white', 'blue', 'green'], ['orange', 'black', 'white', 'blue', 'green', 'red']]",
      "assert combinations_list(['red', 'green', 'black', 'orange'])==[[], ['red'], ['green'], ['green', 'red'], ['black'], ['black', 'red'], ['black', 'green'], ['black', 'green', 'red'], ['orange'], ['orange', 'red'], ['orange', 'green'], ['orange', 'green', 'red'], ['orange', 'black'], ['orange', 'black', 'red'], ['orange', 'black', 'green'], ['orange', 'black', 'green', 'red']]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum product subarray of the given array.\nYour code should pass the test:\nassert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112\n",
    "test_list": [
      "assert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112",
      "assert max_subarray_product([6, -3, -10, 0, 2]) == 180 ",
      "assert max_subarray_product([-2, -40, 0, -2, -3]) == 80"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if all values are same in a dictionary.\nYour code should pass the test:\nassert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},10)==False\n",
    "test_list": [
      "assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},10)==False",
      "assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},12)==True",
      "assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},5)==False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to drop empty items from a given dictionary.\nYour code should pass the test:\nassert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}\n",
    "test_list": [
      "assert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}",
      "assert drop_empty({'c1': 'Red', 'c2': None, 'c3':None})=={'c1': 'Red'}",
      "assert drop_empty({'c1': None, 'c2': 'Green', 'c3':None})=={ 'c2': 'Green'}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the peak element in the given array.\nYour code should pass the test:\nassert find_peak([1, 3, 20, 4, 1, 0], 6) == 2\n",
    "test_list": [
      "assert find_peak([1, 3, 20, 4, 1, 0], 6) == 2",
      "assert find_peak([2, 3, 4, 5, 6], 5) == 4",
      "assert find_peak([8, 9, 11, 12, 14, 15], 6) == 5 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to convert decimal number to octal number.\nYour code should pass the test:\nassert decimal_to_Octal(10) == 12\n",
    "test_list": [
      "assert decimal_to_Octal(10) == 12",
      "assert decimal_to_Octal(2) == 2",
      "assert decimal_to_Octal(33) == 41"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum product formed by multiplying numbers of an increasing subsequence of that array.\nYour code should pass the test:\nassert max_product([3, 100, 4, 5, 150, 6], 6) == 45000 \n",
    "test_list": [
      "assert max_product([3, 100, 4, 5, 150, 6], 6) == 45000 ",
      "assert max_product([4, 42, 55, 68, 80], 5) == 50265600",
      "assert max_product([10, 22, 9, 33, 21, 50, 41, 60], 8) == 21780000 "
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the maximum profit earned from a maximum of k stock transactions\nYour code should pass the test:\nassert max_profit([1, 5, 2, 3, 7, 6, 4, 5], 3) == 10\n",
    "test_list": [
      "assert max_profit([1, 5, 2, 3, 7, 6, 4, 5], 3) == 10",
      "assert max_profit([2, 4, 7, 5, 4, 3, 5], 2) == 7",
      "assert max_profit([10, 6, 8, 4, 2], 2) == 2"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the pairwise addition of the elements of the given tuples.\nYour code should pass the test:\nassert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)\n",
    "test_list": [
      "assert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)",
      "assert add_pairwise((2, 6, 8, 9, 11)) == (8, 14, 17, 20)",
      "assert add_pairwise((3, 7, 9, 10, 12)) == (10, 16, 19, 22)"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find remainder of array multiplication divided by n.\nYour code should pass the test:\nassert find_remainder([ 100, 10, 5, 25, 35, 14 ],6,11) ==9\n",
    "test_list": [
      "assert find_remainder([ 100, 10, 5, 25, 35, 14 ],6,11) ==9",
      "assert find_remainder([1,1,1],3,1) == 0",
      "assert find_remainder([1,2,1],3,2) == 0"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to check whether the given list contains consecutive numbers or not.\nYour code should pass the test:\nassert check_Consecutive([1,2,3,4,5]) == True\n",
    "test_list": [
      "assert check_Consecutive([1,2,3,4,5]) == True",
      "assert check_Consecutive([1,2,3,5,6]) == False",
      "assert check_Consecutive([1,2,1]) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the tuple intersection of elements in the given tuple list irrespective of their order.\nYour code should pass the test:\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)}\n",
    "test_list": [
      "assert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}",
      "assert tuple_intersection([(4, 1), (7, 4), (11, 13), (17, 14)] , [(1, 4), (7, 4), (16, 12), (10, 13)]) == {(4, 7), (1, 4)}",
      "assert tuple_intersection([(2, 1), (3, 2), (1, 3), (1, 4)] , [(11, 2), (2, 3), (6, 2), (1, 3)]) == {(1, 3), (2, 3)}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to replace characters in a string.\nYour code should pass the test:\nassert replace_char(\"polygon\",'y','l')==(\"pollgon\")\n",
    "test_list": [
      "assert replace_char(\"polygon\",'y','l')==(\"pollgon\")",
      "assert replace_char(\"character\",'c','a')==(\"aharaater\")",
      "assert replace_char(\"python\",'l','a')==(\"python\")"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort counter by value.\nYour code should pass the test:\nassert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]\n",
    "test_list": [
      "assert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]",
      "assert sort_counter({'Math':400, 'Physics':300, 'Chemistry':250})==[('Math', 400), ('Physics', 300), ('Chemistry', 250)]",
      "assert sort_counter({'Math':900, 'Physics':1000, 'Chemistry':1250})==[('Chemistry', 1250), ('Physics', 1000), ('Math', 900)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the sum of the largest and smallest value in a given array.\nYour code should pass the test:\nassert big_sum([1,2,3]) == 4\n",
    "test_list": [
      "assert big_sum([1,2,3]) == 4",
      "assert big_sum([-1,2,3,4]) == 3",
      "assert big_sum([2,3,6]) == 8"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to convert the given string to lower case.\nYour code should pass the test:\nassert is_lower(\"InValid\") == \"invalid\"\n",
    "test_list": [
      "assert is_lower(\"InValid\") == \"invalid\"",
      "assert is_lower(\"TruE\") == \"true\"",
      "assert is_lower(\"SenTenCE\") == \"sentence\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove lowercase substrings from a given string.\nYour code should pass the test:\nassert remove_lowercase(\"PYTHon\")==('PYTH')\n",
    "test_list": [
      "assert remove_lowercase(\"PYTHon\")==('PYTH')",
      "assert remove_lowercase(\"FInD\")==('FID')",
      "assert remove_lowercase(\"STRinG\")==('STRG')"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first digit of a given number.\nYour code should pass the test:\nassert first_Digit(123) == 1\n",
    "test_list": [
      "assert first_Digit(123) == 1",
      "assert first_Digit(456) == 4",
      "assert first_Digit(12) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the maximum occurring character in a given string.\nYour code should pass the test:\nassert get_max_occuring_char(\"data\") == \"a\"\n",
    "test_list": [
      "assert get_max_occuring_char(\"data\") == \"a\"",
      "assert get_max_occuring_char(\"create\") == \"e\"",
      "assert get_max_occuring_char(\"brilliant girl\") == \"i\""
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to determine if there is a subset of the given set with sum equal to the given sum.\nYour code should pass the test:\nassert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 9) == True\n",
    "test_list": [
      "assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 9) == True",
      "assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 30) == False",
      "assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 15) == True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find sequences of one upper case letter followed by lower case letters in the given string by using regex.\nYour code should pass the test:\nassert match(\"Geeks\") == 'Yes'\n",
    "test_list": [
      "assert match(\"Geeks\") == 'Yes'",
      "assert match(\"geeksforGeeks\") == 'Yes'",
      "assert match(\"geeks\") == 'No'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the first natural number whose factorial is divisible by x.\nYour code should pass the test:\nassert first_Factorial_Divisible_Number(10) == 5\n",
    "test_list": [
      "assert first_Factorial_Divisible_Number(10) == 5",
      "assert first_Factorial_Divisible_Number(15) == 5",
      "assert first_Factorial_Divisible_Number(5) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove the matching tuples from the given two tuples.\nYour code should pass the test:\nassert remove_matching_tuple([('Hello', 'dude'), ('How', 'are'), ('you', '?')], [('Hello', 'dude'), ('How', 'are')]) == [('you', '?')]\n",
    "test_list": [
      "assert remove_matching_tuple([('Hello', 'dude'), ('How', 'are'), ('you', '?')], [('Hello', 'dude'), ('How', 'are')]) == [('you', '?')]",
      "assert remove_matching_tuple([('Part', 'of'), ('the', 'journey'), ('is ', 'end')], [('Journey', 'the'), ('is', 'end')]) == [('Part', 'of'), ('the', 'journey'), ('is ', 'end')]",
      "assert remove_matching_tuple([('Its', 'been'), ('a', 'long'), ('day', 'without')], [('a', 'long'), ('my', 'friend')]) == [('Its', 'been'), ('day', 'without')]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the largest palindromic number in the given array.\nYour code should pass the test:\nassert largest_palindrome([1, 232, 54545, 999991], 4) == 54545\n",
    "test_list": [
      "assert largest_palindrome([1, 232, 54545, 999991], 4) == 54545",
      "assert largest_palindrome([1, 2, 3, 4, 5, 50], 6) == 5",
      "assert largest_palindrome([1, 3, 7, 9, 45], 5)  == 9"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to compute binomial probability for the given number.\nYour code should pass the test:\nassert binomial_probability(10, 5, 1.0/3) == 0.13656454808718185\n",
    "test_list": [
      "assert binomial_probability(10, 5, 1.0/3) == 0.13656454808718185",
      "assert binomial_probability(11, 6, 2.0/4) == 0.2255859375",
      "assert binomial_probability(12, 7, 3.0/5) == 0.227030335488"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to sort a list of tuples in increasing order by the last element in each tuple.\nYour code should pass the test:\nassert sort_tuple([(1, 3), (3, 2), (2, 1)] ) == [(2, 1), (3, 2), (1, 3)]\n",
    "test_list": [
      "assert sort_tuple([(1, 3), (3, 2), (2, 1)] ) == [(2, 1), (3, 2), (1, 3)]",
      "assert sort_tuple([(2, 4), (3, 3), (1, 1)] ) == [(1, 1), (3, 3), (2, 4)]",
      "assert sort_tuple([(3, 9), (6, 7), (4, 3)] ) == [(4, 3), (6, 7), (3, 9)]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the area of a pentagon.\nYour code should pass the test:\nassert area_pentagon(5)==43.01193501472417\n",
    "test_list": [
      "assert area_pentagon(5)==43.01193501472417",
      "assert area_pentagon(10)==172.0477400588967",
      "assert area_pentagon(15)==387.10741513251753"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the frequency of the largest value in a given array.\nYour code should pass the test:\nassert frequency_Of_Largest(5,[1,2,3,4,4]) == 2\n",
    "test_list": [
      "assert frequency_Of_Largest(5,[1,2,3,4,4]) == 2",
      "assert frequency_Of_Largest(3,[5,6,5]) == 1",
      "assert frequency_Of_Largest(4,[2,7,7,7]) == 3"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to extract all the pairs which are symmetric in the given tuple list.\nYour code should pass the test:\nassert extract_symmetric([(6, 7), (2, 3), (7, 6), (9, 8), (10, 2), (8, 9)] ) == {(8, 9), (6, 7)}\n",
    "test_list": [
      "assert extract_symmetric([(6, 7), (2, 3), (7, 6), (9, 8), (10, 2), (8, 9)] ) == {(8, 9), (6, 7)}",
      "assert extract_symmetric([(7, 8), (3, 4), (8, 7), (10, 9), (11, 3), (9, 10)] ) == {(9, 10), (7, 8)}",
      "assert extract_symmetric([(8, 9), (4, 5), (9, 8), (11, 10), (12, 4), (10, 11)] ) == {(8, 9), (10, 11)}"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the sum of geometric progression series.\nYour code should pass the test:\nassert sum_gp(1,5,2)==31\n",
    "test_list": [
      "assert sum_gp(1,5,2)==31",
      "assert sum_gp(1,5,4)==341",
      "assert sum_gp(2,6,3)==728"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to search an element in the given array by using binary search.\nYour code should pass the test:\nassert binary_search([1,2,3,5,8], 6) == False\n",
    "test_list": [
      "assert binary_search([1,2,3,5,8], 6) == False",
      "assert binary_search([7, 8, 9, 10, 13], 10) == True",
      "assert binary_search([11, 13, 14, 19, 22, 36], 23) == False"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate a grid of hexagon coordinates where function returns a list of lists containing 6 tuples of x, y point coordinates.\nYour code should pass the test:\nassert calculate_polygons(1,1, 4, 4, 3)==[[(-5.0, -4.196152422706632), (-5.0, -0.7320508075688767), (-2.0, 1.0), (1.0, -0.7320508075688767), (1.0, -4.196152422706632), (-2.0, -5.928203230275509), (-5.0, -4.196152422706632)], [(1.0, -4.196152422706632), (1.0, -0.7320508075688767), (4.0, 1.0), (7.0, -0.7320508075688767), (7.0, -4.196152422706632), (4.0, -5.928203230275509), (1.0, -4.196152422706632)], [(7.0, -4.196152422706632), (7.0, -0.7320508075688767), (10.0, 1.0), (13.0, -0.7320508075688767), (13.0, -4.196152422706632), (10.0, -5.928203230275509), (7.0, -4.196152422706632)], [(-2.0, 1.0000000000000004), (-2.0, 4.464101615137755), (1.0, 6.196152422706632), (4.0, 4.464101615137755), (4.0, 1.0000000000000004), (1.0, -0.7320508075688767), (-2.0, 1.0000000000000004)], [(4.0, 1.0000000000000004), (4.0, 4.464101615137755), (7.0, 6.196152422706632), (10.0, 4.464101615137755), (10.0, 1.0000000000000004), (7.0, -0.7320508075688767), (4.0, 1.0000000000000004)], [(-5.0, 6.196152422706632), (-5.0, 9.660254037844387), (-2.0, 11.392304845413264), (1.0, 9.660254037844387), (1.0, 6.196152422706632), (-2.0, 4.464101615137755), (-5.0, 6.196152422706632)], [(1.0, 6.196152422706632), (1.0, 9.660254037844387), (4.0, 11.392304845413264), (7.0, 9.660254037844387), (7.0, 6.196152422706632), (4.0, 4.464101615137755), (1.0, 6.196152422706632)], [(7.0, 6.196152422706632), (7.0, 9.660254037844387), (10.0, 11.392304845413264), (13.0, 9.660254037844387), (13.0, 6.196152422706632), (10.0, 4.464101615137755), (7.0, 6.196152422706632)], [(-2.0, 11.392304845413264), (-2.0, 14.85640646055102), (1.0, 16.588457268119896), (4.0, 14.85640646055102), (4.0, 11.392304845413264), (1.0, 9.660254037844387), (-2.0, 11.392304845413264)], [(4.0, 11.392304845413264), (4.0, 14.85640646055102), (7.0, 16.588457268119896), (10.0, 14.85640646055102), (10.0, 11.392304845413264), (7.0, 9.660254037844387), (4.0, 11.392304845413264)]]\n",
    "test_list": [
      "assert calculate_polygons(1,1, 4, 4, 3)==[[(-5.0, -4.196152422706632), (-5.0, -0.7320508075688767), (-2.0, 1.0), (1.0, -0.7320508075688767), (1.0, -4.196152422706632), (-2.0, -5.928203230275509), (-5.0, -4.196152422706632)], [(1.0, -4.196152422706632), (1.0, -0.7320508075688767), (4.0, 1.0), (7.0, -0.7320508075688767), (7.0, -4.196152422706632), (4.0, -5.928203230275509), (1.0, -4.196152422706632)], [(7.0, -4.196152422706632), (7.0, -0.7320508075688767), (10.0, 1.0), (13.0, -0.7320508075688767), (13.0, -4.196152422706632), (10.0, -5.928203230275509), (7.0, -4.196152422706632)], [(-2.0, 1.0000000000000004), (-2.0, 4.464101615137755), (1.0, 6.196152422706632), (4.0, 4.464101615137755), (4.0, 1.0000000000000004), (1.0, -0.7320508075688767), (-2.0, 1.0000000000000004)], [(4.0, 1.0000000000000004), (4.0, 4.464101615137755), (7.0, 6.196152422706632), (10.0, 4.464101615137755), (10.0, 1.0000000000000004), (7.0, -0.7320508075688767), (4.0, 1.0000000000000004)], [(-5.0, 6.196152422706632), (-5.0, 9.660254037844387), (-2.0, 11.392304845413264), (1.0, 9.660254037844387), (1.0, 6.196152422706632), (-2.0, 4.464101615137755), (-5.0, 6.196152422706632)], [(1.0, 6.196152422706632), (1.0, 9.660254037844387), (4.0, 11.392304845413264), (7.0, 9.660254037844387), (7.0, 6.196152422706632), (4.0, 4.464101615137755), (1.0, 6.196152422706632)], [(7.0, 6.196152422706632), (7.0, 9.660254037844387), (10.0, 11.392304845413264), (13.0, 9.660254037844387), (13.0, 6.196152422706632), (10.0, 4.464101615137755), (7.0, 6.196152422706632)], [(-2.0, 11.392304845413264), (-2.0, 14.85640646055102), (1.0, 16.588457268119896), (4.0, 14.85640646055102), (4.0, 11.392304845413264), (1.0, 9.660254037844387), (-2.0, 11.392304845413264)], [(4.0, 11.392304845413264), (4.0, 14.85640646055102), (7.0, 16.588457268119896), (10.0, 14.85640646055102), (10.0, 11.392304845413264), (7.0, 9.660254037844387), (4.0, 11.392304845413264)]]",
      "assert calculate_polygons(5,4,7,9,8)==[[(-11.0, -9.856406460551018), (-11.0, -0.6188021535170058), (-3.0, 4.0), (5.0, -0.6188021535170058), (5.0, -9.856406460551018), (-3.0, -14.475208614068023), (-11.0, -9.856406460551018)], [(5.0, -9.856406460551018), (5.0, -0.6188021535170058), (13.0, 4.0), (21.0, -0.6188021535170058), (21.0, -9.856406460551018), (13.0, -14.475208614068023), (5.0, -9.856406460551018)], [(21.0, -9.856406460551018), (21.0, -0.6188021535170058), (29.0, 4.0), (37.0, -0.6188021535170058), (37.0, -9.856406460551018), (29.0, -14.475208614068023), (21.0, -9.856406460551018)], [(-3.0, 4.0), (-3.0, 13.237604307034012), (5.0, 17.856406460551018), (13.0, 13.237604307034012), (13.0, 4.0), (5.0, -0.6188021535170058), (-3.0, 4.0)], [(13.0, 4.0), (13.0, 13.237604307034012), (21.0, 17.856406460551018), (29.0, 13.237604307034012), (29.0, 4.0), (21.0, -0.6188021535170058), (13.0, 4.0)], [(-11.0, 17.856406460551018), (-11.0, 27.09401076758503), (-3.0, 31.712812921102035), (5.0, 27.09401076758503), (5.0, 17.856406460551018), (-3.0, 13.237604307034012), (-11.0, 17.856406460551018)], [(5.0, 17.856406460551018), (5.0, 27.09401076758503), (13.0, 31.712812921102035), (21.0, 27.09401076758503), (21.0, 17.856406460551018), (13.0, 13.237604307034012), (5.0, 17.856406460551018)], [(21.0, 17.856406460551018), (21.0, 27.09401076758503), (29.0, 31.712812921102035), (37.0, 27.09401076758503), (37.0, 17.856406460551018), (29.0, 13.237604307034012), (21.0, 17.856406460551018)], [(-3.0, 31.712812921102035), (-3.0, 40.95041722813605), (5.0, 45.569219381653056), (13.0, 40.95041722813605), (13.0, 31.712812921102035), (5.0, 27.09401076758503), (-3.0, 31.712812921102035)], [(13.0, 31.712812921102035), (13.0, 40.95041722813605), (21.0, 45.569219381653056), (29.0, 40.95041722813605), (29.0, 31.712812921102035), (21.0, 27.09401076758503), (13.0, 31.712812921102035)]]",
      "assert calculate_polygons(9,6,4,3,2)==[[(5.0, 2.5358983848622456), (5.0, 4.8452994616207485), (7.0, 6.0), (9.0, 4.8452994616207485), (9.0, 2.5358983848622456), (7.0, 1.3811978464829942), (5.0, 2.5358983848622456)], [(7.0, 6.0), (7.0, 8.309401076758503), (9.0, 9.464101615137753), (11.0, 8.309401076758503), (11.0, 6.0), (9.0, 4.8452994616207485), (7.0, 6.0)]]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to convert the given binary tuple to integer.\nYour code should pass the test:\nassert binary_to_integer((1, 1, 0, 1, 0, 0, 1)) == '105'\n",
    "test_list": [
      "assert binary_to_integer((1, 1, 0, 1, 0, 0, 1)) == '105'",
      "assert binary_to_integer((0, 1, 1, 0, 0, 1, 0, 1)) == '101'",
      "assert binary_to_integer((1, 1, 0, 1, 0, 1)) == '53'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove lowercase substrings from a given string by using regex.\nYour code should pass the test:\nassert remove_lowercase('KDeoALOklOOHserfLoAJSIskdsf') == 'KDALOOOHLAJSI'\n",
    "test_list": [
      "assert remove_lowercase('KDeoALOklOOHserfLoAJSIskdsf') == 'KDALOOOHLAJSI'",
      "assert remove_lowercase('ProducTnamEstreAmIngMediAplAYer') == 'PTEAIMAAY'",
      "assert remove_lowercase('maNufacTuredbYSheZenTechNolOGIes') == 'NTYSZTNOGI'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the smallest integers from a given list of numbers using heap queue algorithm.\nYour code should pass the test:\nassert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],3)==[14, 22, 25] \n",
    "test_list": [
      "assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],3)==[14, 22, 25] ",
      "assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],2)==[14, 22]",
      "assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 22, 58],5)==[14, 22, 22, 25, 35]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the surface area of a cone.\nYour code should pass the test:\nassert surfacearea_cone(5,12)==282.7433388230814\n",
    "test_list": [
      "assert surfacearea_cone(5,12)==282.7433388230814",
      "assert surfacearea_cone(10,15)==880.5179353159282",
      "assert surfacearea_cone(19,17)==2655.923961165254"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find gcd of two positive integers.\nYour code should pass the test:\nassert gcd(12, 17) == 1\n",
    "test_list": [
      "assert gcd(12, 17) == 1",
      "assert gcd(4,6) == 2",
      "assert gcd(2,9) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the diameter of a circle.\nYour code should pass the test:\nassert diameter_circle(10)==20\n",
    "test_list": [
      "assert diameter_circle(10)==20",
      "assert diameter_circle(40)==80",
      "assert diameter_circle(15)==30"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to concatenate all elements of the given list into a string.\nYour code should pass the test:\nassert concatenate_elements(['hello','there','have','a','rocky','day'] ) == '  hello there have a rocky day'\n",
    "test_list": [
      "assert concatenate_elements(['hello','there','have','a','rocky','day'] ) == '  hello there have a rocky day'",
      "assert concatenate_elements([ 'Hi', 'there', 'How','are', 'you'] ) == '  Hi there How are you'",
      "assert concatenate_elements([ 'Part', 'of', 'the','journey', 'is', 'end'] ) == '  Part of the journey is end'"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find common divisor between two numbers in a given pair.\nYour code should pass the test:\nassert num_comm_div(2,4) == 2\n",
    "test_list": [
      "assert num_comm_div(2,4) == 2",
      "assert num_comm_div(2,8) == 2",
      "assert num_comm_div(12,24) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find remainder of two numbers.\nYour code should pass the test:\nassert find(3,3) == 0\n",
    "test_list": [
      "assert find(3,3) == 0",
      "assert find(10,3) == 1",
      "assert find(16,5) == 1"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to add consecutive numbers of a given list.\nYour code should pass the test:\nassert add_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[2, 4, 7, 8, 9, 11, 13]\n",
    "test_list": [
      "assert add_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[2, 4, 7, 8, 9, 11, 13]",
      "assert add_consecutive_nums([4, 5, 8, 9, 6, 10])==[9, 13, 17, 15, 16]",
      "assert add_consecutive_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[3, 5, 7, 9, 11, 13, 15, 17, 19]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the cube sum of first n natural numbers.\nYour code should pass the test:\nassert sum_Of_Series(5) == 225\n",
    "test_list": [
      "assert sum_Of_Series(5) == 225",
      "assert sum_Of_Series(2) == 9",
      "assert sum_Of_Series(3) == 36"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to move all zeroes to the end of the given array.\nYour code should pass the test:\nassert re_order([6, 0, 8, 2, 3, 0, 4, 0, 1]) == [6, 8, 2, 3, 4, 1, 0, 0, 0]\n",
    "test_list": [
      "assert re_order([6, 0, 8, 2, 3, 0, 4, 0, 1]) == [6, 8, 2, 3, 4, 1, 0, 0, 0]",
      "assert re_order([4, 0, 2, 7, 0, 9, 0, 12, 0]) == [4, 2, 7, 9, 12, 0, 0, 0, 0]",
      "assert re_order([3, 11, 0, 74, 14, 0, 1, 0, 2]) == [3, 11, 74, 14, 1, 2, 0, 0, 0]"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to calculate the permutation coefficient of given p(n, k).\nYour code should pass the test:\nassert permutation_coefficient(10, 2) == 90\n",
    "test_list": [
      "assert permutation_coefficient(10, 2) == 90",
      "assert permutation_coefficient(10, 3) == 720",
      "assert permutation_coefficient(10, 1) == 10"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to remove specific words from a given list.\nYour code should pass the test:\nassert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['white', 'orange'])==['red', 'green', 'blue', 'black']\n",
    "test_list": [
      "assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['white', 'orange'])==['red', 'green', 'blue', 'black']",
      "assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['black', 'orange'])==['red', 'green', 'blue', 'white']",
      "assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['blue', 'white'])==['red', 'green', 'black', 'orange']"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to check if the common elements between two given lists are in the same order or not.\nYour code should pass the test:\nassert same_order([\"red\",\"green\",\"black\",\"orange\"],[\"red\",\"pink\",\"green\",\"white\",\"black\"])==True\n",
    "test_list": [
      "assert same_order([\"red\",\"green\",\"black\",\"orange\"],[\"red\",\"pink\",\"green\",\"white\",\"black\"])==True",
      "assert same_order([\"red\",\"pink\",\"green\",\"white\",\"black\"],[\"white\",\"orange\",\"pink\",\"black\"])==False",
      "assert same_order([\"red\",\"green\",\"black\",\"orange\"],[\"red\",\"pink\",\"green\",\"white\",\"black\"])==True"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a python function to find the average of odd numbers till a given odd number.\nYour code should pass the test:\nassert average_Odd(9) == 5\n",
    "test_list": [
      "assert average_Odd(9) == 5",
      "assert average_Odd(5) == 3",
      "assert average_Odd(11) == 6"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  },
  {
    "question": "Write a function to find the number of subsequences having product smaller than k for the given non negative array.\nYour code should pass the test:\nassert no_of_subsequences([1,2,3,4], 10) == 11\n",
    "test_list": [
      "assert no_of_subsequences([1,2,3,4], 10) == 11",
      "assert no_of_subsequences([4,8,7,2], 50) == 9",
      "assert no_of_subsequences([5,6,7,8], 15) == 4"
    ],
    "test_time_limit": 1,
    "test_method": "function",
    "prefix": "Here is the completed code:\n```python"
  }
]