Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to copy a list from a singleton tuple.

### Response:

Output:
def lcopy(xs):
  return xs[:]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the area of a trapezium.

### Response:

Output:
def area_trapezium(base1,base2,height):
 area = 0.5 * (base1 + base2) * height
 return area


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find sum of all prime divisors of a given number.

### Response:

Output:
def Sum(N):
    SumOfPrimeDivisors = [0]*(N + 1)
    for i in range(2,N + 1) :
        if (SumOfPrimeDivisors[i] == 0) :
            for j in range(i,N + 1,i) :
                SumOfPrimeDivisors[j] += i
    return SumOfPrimeDivisors[N]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check if a triangle of positive area is possible with the given angles.

### Response:

Output:
def is_triangleexists(a,b,c):
    if(a != 0 and b != 0 and c != 0 and (a + b + c)== 180):
        if((a + b)>= c or (b + c)>= a or (a + c)>= b):
            return True
        else:
            return False
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find sum of inverse of divisors.

### Response:

Output:
def Sum_of_Inverse_Divisors(N,Sum):
    ans = float(Sum)*1.0 /float(N);
    return round(ans,2);


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to remove negative numbers from a list.

### Response:

Output:
def remove_negs(num_list):
    for item in num_list:
        if item < 0:
           num_list.remove(item)
    return num_list


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find sum of odd factors of a number.

### Response:

Output:
import math
def sum_of_odd_Factors(n):
    res = 1
    while n % 2 == 0:
        n = n // 2
    for i in range(3,int(math.sqrt(n) + 1)):
        count = 0
        curr_sum = 1
        curr_term = 1
        while n % i == 0:
            count+=1
            n = n // i
            curr_term *= i
            curr_sum += curr_term
        res *= curr_sum
    if n >= 2:
        res *= (1 + n)
    return res


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm.

### Response:

Output:
import heapq as hq
def raw_heap(rawheap):
  hq.heapify(rawheap)
  return rawheap


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check for even parity of a given number.

### Response:

Output:
def check_Even_Parity(x):
    parity = 0
    while (x != 0):
        x = x & (x - 1)
        parity += 1
    if (parity % 2 == 0):
        return True
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find minimum adjacent swaps required to sort binary array.

### Response:

Output:
def find_Min_Swaps(arr,n) :
    noOfZeroes = [0] * n
    count = 0
    noOfZeroes[n - 1] = 1 - arr[n - 1]
    for i in range(n-2,-1,-1) :
        noOfZeroes[i] = noOfZeroes[i + 1]
        if (arr[i] == 0) :
            noOfZeroes[i] = noOfZeroes[i] + 1
    for i in range(0,n) :
        if (arr[i] == 1) :
            count = count + noOfZeroes[i]
    return count


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to list out the list of given strings individually using map function.

### Response:

Output:
def listify_list(list1):
  result = list(map(list,list1))
  return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to count number of lists in a given list of lists and square the count.

### Response:

Output:
def count_list(input_list):
    return (len(input_list))**2


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to generate all sublists of a given list.

### Response:

Output:
from itertools import combinations
def sub_lists(my_list):
	subs = []
	for i in range(0, len(my_list)+1):
	  temp = [list(x) for x in combinations(my_list, i)]
	  if len(temp)>0:
	    subs.extend(temp)
	return subs


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check whether the given string is ending with only alphanumeric characters or not using regex.

### Response:

Output:
import re
regex = '[a-zA-z0-9]$'
def check_alphanumeric(string):
	if(re.search(regex, string)):
		return ("Accept")
	else:
		return ("Discard")


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find all anagrams of a string in a given list of strings using lambda function.

### Response:

Output:
from collections import Counter
def anagram_lambda(texts,str):
  result = list(filter(lambda x: (Counter(str) == Counter(x)), texts))
  return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the occurrences of n most common words in a given text.

### Response:

Output:
from collections import Counter
import re
def n_common_words(text,n):
  words = re.findall('\w+',text)
  n_common_words= Counter(words).most_common(n)
  return list(n_common_words)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the length of the longest sub-sequence such that elements in the subsequences are consecutive integers.

### Response:

Output:
def find_longest_conseq_subseq(arr, n):
	ans = 0
	count = 0
	arr.sort()
	v = []
	v.append(arr[0])
	for i in range(1, n):
		if (arr[i] != arr[i - 1]):
			v.append(arr[i])
	for i in range(len(v)):
		if (i > 0 and v[i] == v[i - 1] + 1):
			count += 1
		else:
			count = 1
		ans = max(ans, count)
	return ans


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find palindromes in a given list of strings using lambda function.

### Response:

Output:
def palindrome_lambda(texts):
  result = list(filter(lambda x: (x == "".join(reversed(x))), texts))
  return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to print n-times a list using map function.

### Response:

Output:
def ntimes_list(nums,n):
    result = map(lambda x:n*x, nums)
    return list(result)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check whether the given month name contains 31 days or not.

### Response:

Output:
def check_monthnumb(monthname2):
  if(monthname2=="January" or monthname2=="March"or monthname2=="May" or monthname2=="July" or monthname2=="Augest" or monthname2=="October" or monthname2=="December"):
    return True
  else:
    return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to add a minimum number such that the sum of array becomes even.

### Response:

Output:
def min_Num(arr,n):
    odd = 0
    for i in range(n):
        if (arr[i] % 2):
            odd += 1
    if (odd % 2):
        return 1
    return 2


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the length of the last word in a given string.

### Response:

Output:
def length_Of_Last_Word(a):
    l = 0
    x = a.strip()
    for i in range(len(x)):
        if x[i] == " ":
            l = 0
        else:
            l += 1
    return l


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to remove sublists from a given list of lists, which are outside a given range.

### Response:

Output:
def remove_list_range(list1, leftrange, rigthrange):
   result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)]
   return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function.

### Response:

Output:
def sum_positivenum(nums):
  sum_positivenum = list(filter(lambda nums:nums>0,nums))
  return sum(sum_positivenum)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the given strings are rotations of each other or not.

### Response:

Output:
def are_Rotations(string1,string2):
    size1 = len(string1)
    size2 = len(string2)
    temp = ''
    if size1 != size2:
        return False
    temp = string1 + string1
    if (temp.count(string2)> 0):
        return True
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check if a nested list is a subset of another nested list.

### Response:

Output:
def check_subset(list1,list2):
    return all(map(list1.__contains__,list2))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to solve the fibonacci sequence using recursion.

### Response:

Output:
def fibonacci(n):
  if n == 1 or n == 2:
    return 1
  else:
    return (fibonacci(n - 1) + (fibonacci(n - 2)))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check if the string is a concatenation of another string.

### Response:

Output:
def check_Concat(str1,str2):
    N = len(str1)
    M = len(str2)
    if (N % M != 0):
        return False
    for i in range(N):
        if (str1[i] != str2[i % M]):
            return False
    return True


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the minimum difference in the tuple pairs of given tuples.

### Response:

Output:
def min_difference(test_list):
  temp = [abs(b - a) for a, b in test_list]
  res = min(temp)
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find lcm of two positive integers.

### Response:

Output:
def lcm(x, y):
   if x > y:
       z = x
   else:
       z = y
   while(True):
       if((z % x == 0) and (z % y == 0)):
           lcm = z
           break
       z += 1
   return lcm


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to sort the given string.

### Response:

Output:
def sort_String(str) :
    str = ''.join(sorted(str))
    return (str)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check if the given tuple contains only k elements.

### Response:

Output:
def check_tuples(test_tuple, K):
  res = all(ele in K for ele in test_tuple)
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function that matches a string that has an 'a' followed by anything, ending in 'b' by using regex.

### Response:

Output:
import re
def text_match(text):
  patterns = 'a.*?b$'
  if re.search(patterns,  text):
    return ('Found a match!')
  else:
    return ('Not matched!')


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find number of solutions in quadratic equation.

### Response:

Output:
def Check_Solution(a,b,c) :
    if ((b*b) - (4*a*c)) > 0 :
        return ("2 solutions")
    elif ((b*b) - (4*a*c)) == 0 :
        return ("1 solution")
    else :
        return ("No solutions")


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the sum of first even and odd number of a given list.

### Response:

Output:
def sum_even_odd(list1):
    first_even = next((el for el in list1 if el%2==0),-1)
    first_odd = next((el for el in list1 if el%2!=0),-1)
    return (first_even+first_odd)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to caluclate perimeter of a parallelogram.

### Response:

Output:
def parallelogram_perimeter(b,h):
  perimeter=2*(b*h)
  return perimeter


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find numbers divisible by m and n from a list of numbers using lambda function.

### Response:

Output:
def div_of_nums(nums,m,n):
 result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums))
 return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether all the bits are within a given range or not.

### Response:

Output:
def all_Bits_Set_In_The_Given_Range(n,l,r):
    num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1)
    new_num = n & num
    if (num == new_num):
        return True
    return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the two given strings are isomorphic to each other or not.

### Response:

Output:
def is_Isomorphic(str1,str2):
    dict_str1 = {}
    dict_str2 = {}
    for i, value in enumerate(str1):
        dict_str1[value] = dict_str1.get(value,[]) + [i]
    for j, value in enumerate(str2):
        dict_str2[value] = dict_str2.get(value,[]) + [j]
    if sorted(dict_str1.values()) == sorted(dict_str2.values()):
        return True
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to add all the numbers in a list and divide it with the length of the list.

### Response:

Output:
def sum_num(numbers):
    total = 0
    for x in numbers:
        total += x
    return total/len(numbers)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the given number is odd or not using bitwise operator.

### Response:

Output:
def is_odd(n) :
    if (n^1 == n-1) :
        return True;
    else :
        return False;


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to substract the elements of the given nested tuples.

### Response:

Output:
def substract_elements(test_tup1, test_tup2):
  res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
   for tup1, tup2 in zip(test_tup1, test_tup2))
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to reverse each list in a given list of lists.

### Response:

Output:
def reverse_list_lists(lists):
    for l in lists:
        l.sort(reverse = True)
    return lists


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the index of an extra element present in one sorted array.

### Response:

Output:
def find_Extra(arr1,arr2,n) :
    for i in range(0, n) :
        if (arr1[i] != arr2[i]) :
            return i
    return n


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the given two numbers have same number of digits or not.

### Response:

Output:
def same_Length(A,B):
    while (A > 0 and B > 0):
        A = A / 10;
        B = B / 10;
    if (A == 0 and B == 0):
        return True;
    return False;


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to remove multiple spaces in a string.

### Response:

Output:
import re
def remove_spaces(text):
 return (re.sub(' +',' ',text))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to get the last element of each sublist.

### Response:

Output:
def Extract(lst):
    return [item[-1] for item in lst]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert the given string of float type into tuple.

### Response:

Output:
def float_to_tuple(test_str):
  res = tuple(map(float, test_str.split(', ')))
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the maximum sum of subsequences of given array with no adjacent elements.

### Response:

Output:
def max_sum_subseq(A):
    n = len(A)
    if n == 1:
        return A[0]
    look_up = [None] * n
    look_up[0] = A[0]
    look_up[1] = max(A[0], A[1])
    for i in range(2, n):
        look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
        look_up[i] = max(look_up[i], A[i])
    return look_up[n - 1]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to sort a list in increasing order by the last element in each tuple from a given list of non-empty tuples.

### Response:

Output:
def last(n):
   return n[-1]
def sort_list_last(tuples):
  return sorted(tuples, key=last)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the word is present in a given sentence or not.

### Response:

Output:
def is_Word_Present(sentence,word):
    s = sentence.split(" ")
    for i in s:
        if (i == word):
            return True
    return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to extract specified number of elements from a given list, which follow each other continuously.

### Response:

Output:
from itertools import groupby
def extract_elements(numbers, n):
    result = [i for i, j in groupby(numbers) if len(list(j)) == n]
    return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether an array can be sorted or not by picking only the corner elements.

### Response:

Output:
def check(arr,n):
    g = 0
    for i in range(1,n):
        if (arr[i] - arr[i - 1] > 0 and g == 1):
            return False
        if (arr[i] - arr[i] < 0):
            g = 1
    return True


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function where a string will start with a specific number.

### Response:

Output:
import re
def match_num(string):
    text = re.compile(r"^5")
    if text.match(string):
        return True
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the smallest multiple of the first n numbers.

### Response:

Output:
def smallest_multiple(n):
    if (n<=2):
      return n
    i = n * 2
    factors = [number  for number in range(n, 1, -1) if number * 2 > n]
    while True:
        for a in factors:
            if i % a != 0:
                i += n
                break
            if (a == factors[-1] and i % a == 0):
                return i


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to combine two dictionaries by adding values for common keys.

### Response:

Output:
from collections import Counter
def add_dict(d1,d2):
   add_dict = Counter(d1) + Counter(d2)
   return add_dict


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to count the total unset bits from 1 to n.

### Response:

Output:
def count_Unset_Bits(n) :
    cnt = 0;
    for i in range(1,n + 1) :
        temp = i;
        while (temp) :
            if (temp % 2 == 0) :
                cnt += 1;
            temp = temp // 2;
    return cnt;


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to return true if the given number is even else return false.

### Response:

Output:
def even_num(x):
  if x%2==0:
     return True
  else:
    return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the sum of squares of binomial co-efficients.

### Response:

Output:
def factorial(start,end):
    res = 1
    for i in range(start,end + 1):
        res *= i
    return res
def sum_of_square(n):
   return int(factorial(n + 1, 2 * n)  /factorial(1, n))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to extract year, month and date from a url by using regex.

### Response:

Output:
import re
def extract_date(url):
        return re.findall(r'/(\d{4})/(\d{1,2})/(\d{1,2})/', url)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to print the first n lucky numbers.

### Response:

Output:
def lucky_num(n):
 List=range(-1,n*n+9,2)
 i=2
 while List[i:]:List=sorted(set(List)-set(List[List[i]::List[i]]));i+=1
 return List[1:n+1]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the fixed point in the given array.

### Response:

Output:
def find_fixed_point(arr, n):
	for i in range(n):
		if arr[i] is i:
			return i
	return -1


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the previous palindrome of a specified number.

### Response:

Output:
def previous_palindrome(num):
    for x in range(num-1,0,-1):
        if str(x) == str(x)[::-1]:
            return x


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to validate a gregorian date.

### Response:

Output:
import datetime
def check_date(m, d, y):
    try:
        m, d, y = map(int, (m, d, y))
        datetime.date(y, m, d)
        return True
    except ValueError:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to compute maximum product of three numbers of a given array of integers using heap queue algorithm.

### Response:

Output:
def maximum_product(nums):
    import heapq
    a, b = heapq.nlargest(3, nums), heapq.nsmallest(2, nums)
    return max(a[0] * a[1] * a[2], a[0] * b[0] * b[1])


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find ln, m lobb number.

### Response:

Output:
def binomial_coeff(n, k):
	C = [[0 for j in range(k + 1)]
			for i in range(n + 1)]
	for i in range(0, n + 1):
		for j in range(0, min(i, k) + 1):
			if (j == 0 or j == i):
				C[i][j] = 1
			else:
				C[i][j] = (C[i - 1][j - 1]
							+ C[i - 1][j])
	return C[n][k]
def lobb_num(n, m):
	return (((2 * m + 1) *
		binomial_coeff(2 * n, m + n))
					/ (m + n + 1))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check for a number at the end of a string.

### Response:

Output:
import re
def end_num(string):
    text = re.compile(r".*[0-9]$")
    if text.match(string):
        return True
    else:
        return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the given string is made up of two alternating characters or not.

### Response:

Output:
def is_Two_Alter(s):
    for i in range (len( s) - 2) :
        if (s[i] != s[i + 2]) :
            return False
    if (s[0] == s[1]):
        return False
    return True


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to rearrange positive and negative numbers in a given array using lambda function.

### Response:

Output:
def rearrange_numbs(array_nums):
  result = sorted(array_nums, key = lambda i: 0 if i == 0 else -1 / i)
  return result


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find if there is a triplet in the array whose sum is equal to a given value.

### Response:

Output:
def find_triplet_array(A, arr_size, sum):
	for i in range( 0, arr_size-2):
		for j in range(i + 1, arr_size-1):
			for k in range(j + 1, arr_size):
				if A[i] + A[j] + A[k] == sum:
					return  A[i],A[j],A[k]
					return True
	return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the sequences of one upper case letter followed by lower case letters.

### Response:

Output:
import re
def text_uppercase_lowercase(text):
        patterns = '[A-Z]+[a-z]+$'
        if re.search(patterns, text):
                return 'Found a match!'
        else:
                return ('Not matched!')


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to count coin change.

### Response:

Output:
def coin_change(S, m, n):
    table = [[0 for x in range(m)] for x in range(n+1)]
    for i in range(m):
        table[0][i] = 1
    for i in range(1, n+1):
        for j in range(m):
            x = table[i - S[j]][j] if i-S[j] >= 0 else 0
            y = table[i][j-1] if j >= 1 else 0
            table[i][j] = x + y
    return table[n][m-1]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to multiply all items in the list.

### Response:

Output:
def multiply_list(items):
    tot = 1
    for x in items:
        tot *= x
    return tot


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to remove all tuples with all none values in the given tuple list.

### Response:

Output:
def remove_tuple(test_list):
  res = [sub for sub in test_list if not all(ele == None for ele in sub)]
  return (str(res))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to perform chunking of tuples each of size n.

### Response:

Output:
def chunk_tuples(test_tup, N):
  res = [test_tup[i : i + N] for i in range(0, len(test_tup), N)]
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find a pair with the highest product from a given array of integers.

### Response:

Output:
def max_product(arr):
    arr_len = len(arr)
    if (arr_len < 2):
        return None
    x = arr[0]; y = arr[1]
    for i in range(0, arr_len):
        for j in range(i + 1, arr_len):
            if (arr[i] * arr[j] > x * y):
                x = arr[i]; y = arr[j]
    return x,y


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.

### Response:

Output:
def super_seq(X, Y, m, n):
	if (not m):
		return n
	if (not n):
		return m
	if (X[m - 1] == Y[n - 1]):
		return 1 + super_seq(X, Y, m - 1, n - 1)
	return 1 + min(super_seq(X, Y, m - 1, n),	super_seq(X, Y, m, n - 1))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find maximum of two numbers.

### Response:

Output:
def max_of_two( x, y ):
    if x > y:
        return x
    return y


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to calculate the product of all the numbers of a given tuple.

### Response:

Output:
def mutiple_tuple(nums):
    temp = list(nums)
    product = 1
    for x in temp:
        product *= x
    return product


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find n-th rencontres number.

### Response:

Output:
def binomial_coeffi(n, k):
	if (k == 0 or k == n):
		return 1
	return (binomial_coeffi(n - 1, k - 1)
		+ binomial_coeffi(n - 1, k))
def rencontres_number(n, m):
	if (n == 0 and m == 0):
		return 1
	if (n == 1 and m == 0):
		return 0
	if (m == 0):
		return ((n - 1) * (rencontres_number(n - 1, 0)+ rencontres_number(n - 2, 0)))
	return (binomial_coeffi(n, m) * rencontres_number(n - m, 0))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to calculate the height of the given binary tree.

### Response:

Output:
class Node:
	def __init__(self, data):
		self.data = data
		self.left = None
		self.right = None
def max_height(node):
	if node is None:
		return 0 ;
	else :
		left_height = max_height(node.left)
		right_height = max_height(node.right)
		if (left_height > right_height):
			return left_height+1
		else:
			return right_height+1


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.

### Response:

Output:
import re
def change_date_format(dt):
        return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\\3-\\2-\\1', dt)
        return change_date_format(dt)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to count repeated items of a tuple.

### Response:

Output:
def count_tuplex(tuplex,value):
  count = tuplex.count(value)
  return count


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function that matches a string that has an a followed by zero or more b's by using regex.

### Response:

Output:
import re
def text_match(text):
        patterns = 'ab*?'
        if re.search(patterns,  text):
                return ('Found a match!')
        else:
                return ('Not matched!')


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to calculate the sum of series 1³+2³+3³+….+n³.

### Response:

Output:
import math
def sum_series(number):
 total = 0
 total = math.pow((number * (number + 1)) /2, 2)
 return total


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to remove duplicate words from a given list of strings.

### Response:

Output:
def remove_duplic_list(l):
    temp = []
    for x in l:
        if x not in temp:
            temp.append(x)
    return temp


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert camel case string to snake case string by using regex.

### Response:

Output:
import re
def camel_to_snake(text):
  str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
  return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the nth delannoy number.

### Response:

Output:
def dealnnoy_num(n, m):
	if (m == 0 or n == 0) :
		return 1
	return dealnnoy_num(m - 1, n) + dealnnoy_num(m - 1, n - 1) + dealnnoy_num(m, n - 1)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to calculate the sum of series 1²+2²+3²+….+n².

### Response:

Output:
def series_sum(number):
 total = 0
 total = (number * (number + 1) * (2 * number + 1)) / 6
 return total


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to re-arrange the given tuples based on the given ordered list.

### Response:

Output:
def re_arrange_tuples(test_list, ord_list):
  temp = dict(test_list)
  res = [(key, temp[key]) for key in ord_list]
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to count the most common character in a given string.

### Response:

Output:
from collections import Counter
def max_char(str1):
    temp = Counter(str1)
    max_char = max(temp, key = temp.get)
    return max_char


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find three closest elements from three sorted arrays.

### Response:

Output:
import sys

def find_closet(A, B, C, p, q, r):
	diff = sys.maxsize
	res_i = 0
	res_j = 0
	res_k = 0
	i = 0
	j = 0
	k = 0
	while(i < p and j < q and k < r):
		minimum = min(A[i], min(B[j], C[k]))
		maximum = max(A[i], max(B[j], C[k]));
		if maximum-minimum < diff:
			res_i = i
			res_j = j
			res_k = k
			diff = maximum - minimum;
		if diff == 0:
			break
		if A[i] == minimum:
			i = i+1
		elif B[j] == minimum:
			j = j+1
		else:
			k = k+1
	return A[res_i],B[res_j],C[res_k]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to sort a list of dictionaries using lambda function.

### Response:

Output:
def sorted_models(models):
 sorted_models = sorted(models, key = lambda x: x['color'])
 return sorted_models


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to sort the given array by using heap sort.

### Response:

Output:
def heap_sort(arr):
    heapify(arr)
    end = len(arr) - 1
    while end > 0:
        arr[end], arr[0] = arr[0], arr[end]
        shift_down(arr, 0, end - 1)
        end -= 1
    return arr

def heapify(arr):
    start = len(arr) // 2
    while start >= 0:
        shift_down(arr, start, len(arr) - 1)
        start -= 1
def shift_down(arr, start, end):
    root = start
    while root * 2 + 1 <= end:
        child = root * 2 + 1
        if child + 1 <= end and arr[child] < arr[child + 1]:
            child += 1
        if child <= end and arr[root] < arr[child]:
            arr[root], arr[child] = arr[child], arr[root]
            root = child
        else:
            return


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to count the elements in a list until an element is a tuple.

### Response:

Output:
def count_elim(num):
  count_elim = 0
  for n in num:
    if isinstance(n, tuple):
        break
    count_elim += 1
  return count_elim


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to check if any list element is present in the given list.

### Response:

Output:
def check_element(test_tup, check_list):
  res = False
  for ele in check_list:
    if ele in test_tup:
      res = True
      break
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to combine two given sorted lists using heapq module.

### Response:

Output:
from heapq import merge
def combine_lists(num1,num2):
  combine_lists=list(merge(num1, num2))
  return combine_lists


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to separate and print the numbers and their position of a given string.

### Response:

Output:
import re
def num_position(text):
 for m in re.finditer("\d+", text):
    return m.start()


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert the given tuples into set.

### Response:

Output:
def tuple_to_set(t):
  s = set(t)
  return (s)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the most common elements and their counts of a specified text.

### Response:

Output:
from collections import Counter
def most_common_elem(s,a):
  most_common_elem=Counter(s).most_common(a)
  return most_common_elem


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the length of the shortest word.

### Response:

Output:
def len_log(list1):
    min=len(list1[0])
    for i in list1:
        if len(i)<min:
            min=len(i)
    return min


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to get an item of a tuple.

### Response:

Output:
def get_item(tup1,index):
  item = tup1[index]
  return item


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to sort the given tuple list basis the total digits in tuple.

### Response:

Output:
def count_digs(tup):
  return sum([len(str(ele)) for ele in tup ])
def sort_list(test_list):
  test_list.sort(key = count_digs)
  return (str(test_list))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to display sign of the chinese zodiac for given year.

### Response:

Output:
def chinese_zodiac(year):
 if (year - 2000) % 12 == 0:
     sign = 'Dragon'
 elif (year - 2000) % 12 == 1:
     sign = 'Snake'
 elif (year - 2000) % 12 == 2:
     sign = 'Horse'
 elif (year - 2000) % 12 == 3:
     sign = 'sheep'
 elif (year - 2000) % 12 == 4:
     sign = 'Monkey'
 elif (year - 2000) % 12 == 5:
     sign = 'Rooster'
 elif (year - 2000) % 12 == 6:
     sign = 'Dog'
 elif (year - 2000) % 12 == 7:
     sign = 'Pig'
 elif (year - 2000) % 12 == 8:
     sign = 'Rat'
 elif (year - 2000) % 12 == 9:
     sign = 'Ox'
 elif (year - 2000) % 12 == 10:
     sign = 'Tiger'
 else:
     sign = 'Hare'
 return sign


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the maximum of similar indices in two lists of tuples.

### Response:

Output:
def max_similar_indices(test_list1, test_list2):
  res = [(max(x[0], y[0]), max(x[1], y[1]))
   for x, y in zip(test_list1, test_list2)]
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to compute the value of ncr mod p.

### Response:

Output:
def nCr_mod_p(n, r, p):
	if (r > n- r):
		r = n - r
	C = [0 for i in range(r + 1)]
	C[0] = 1
	for i in range(1, n + 1):
		for j in range(min(i, r), 0, -1):
			C[j] = (C[j] + C[j-1]) % p
	return C[r]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the minimun number of subsets with distinct elements.

### Response:

Output:
def subset(ar, n):
    res = 0
    ar.sort()
    for i in range(0, n) :
        count = 1
        for i in range(n - 1):
            if ar[i] == ar[i + 1]:
                count+=1
            else:
                break
        res = max(res, count)
    return res


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function that gives profit amount if the given amount has profit else return none.

### Response:

Output:
def profit_amount(actual_cost,sale_amount):
 if(actual_cost > sale_amount):
    amount = actual_cost - sale_amount
    return amount
 else:
    return None


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find out, if the given number is abundant.

### Response:

Output:
def is_abundant(n):
    fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
    return fctrsum > n


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to split the given string at uppercase letters by using regex.

### Response:

Output:
import re
def split_list(text):
  return (re.findall('[A-Z][^A-Z]*', text))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to get the position of rightmost set bit.

### Response:

Output:
import math
def get_First_Set_Bit_Pos(n):
     return math.log2(n&-n)+1


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert an integer into a roman numeral.

### Response:

Output:
def int_to_roman( num):
        val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
        syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
        roman_num = ''
        i = 0
        while  num > 0:
            for _ in range(num // val[i]):
                roman_num += syb[i]
                num -= val[i]
            i += 1
        return roman_num


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the average of a list.

### Response:

Output:
def Average(lst):
    return sum(lst) / len(lst)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to solve tiling problem.

### Response:

Output:
def get_noOfways(n):
    if (n == 0):
        return 0;
    if (n == 1):
        return 1;
    return get_noOfways(n - 1) + get_noOfways(n - 2);


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert a roman numeral to an integer.

### Response:

Output:
def roman_to_int(s):
        rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
        int_val = 0
        for i in range(len(s)):
            if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]:
                int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]]
            else:
                int_val += rom_val[s[i]]
        return int_val


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find the sum of all even natural numbers within the range l and r.

### Response:

Output:
def sum_Natural(n):
    sum = (n * (n + 1))
    return int(sum)
def sum_Even(l,r):
    return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to calculate the discriminant value.

### Response:

Output:
def discriminant_value(x,y,z):
    discriminant = (y**2) - (4*x*z)
    if discriminant > 0:
        return ("Two solutions",discriminant)
    elif discriminant == 0:
        return ("one solution",discriminant)
    elif discriminant < 0:
        return ("no real solution",discriminant)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to check whether the length of the word is even or not.

### Response:

Output:
def word_len(s):
    s = s.split(' ')
    for word in s:
        if len(word)%2==0:
            return True
        else:
          return False


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to convert camel case string to snake case string.

### Response:

Output:
def camel_to_snake(text):
        import re
        str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to remove an empty tuple from a list of tuples.

### Response:

Output:
def remove_empty(tuple1): #L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')]
   tuple1 = [t for t in tuple1 if t]
   return tuple1


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to accept the strings which contains all vowels.

### Response:

Output:
def check(string):
  if len(set(string).intersection("AEIOUaeiou"))>=5:
    return ('accepted')
  else:
    return ("not accepted")


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to find maximum possible value for the given periodic function.

### Response:

Output:
def floor_Max(A,B,N):
    x = min(B - 1,N)
    return (A*x) // B


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to join the tuples if they have similar initial elements.

### Response:

Output:
def join_tuples(test_list):
  res = []
  for sub in test_list:
    if res and res[-1][0] == sub[0]:
      res[-1].extend(sub[1:])
    else:
      res.append([ele for ele in sub])
  res = list(map(tuple, res))
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find minimum of two numbers.

### Response:

Output:
def min_of_two( x, y ):
    if x < y:
        return x
    return y


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the maximum number of segments of lengths a, b and c that can be formed from n.

### Response:

Output:
def maximum_segments(n, a, b, c) :
	dp = [-1] * (n + 10)
	dp[0] = 0
	for i in range(0, n) :
		if (dp[i] != -1) :
			if(i + a <= n ):
				dp[i + a] = max(dp[i] + 1,
							dp[i + a])
			if(i + b <= n ):
				dp[i + b] = max(dp[i] + 1,
							dp[i + b])
			if(i + c <= n ):
				dp[i + c] = max(dp[i] + 1,
							dp[i + c])
	return dp[n]


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to concatenate the given two tuples to a nested tuple.

### Response:

Output:
def concatenate_nested(test_tup1, test_tup2):
  res = test_tup1 + test_tup2
  return (res)


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a python function to left rotate the string.

### Response:

Output:
def left_rotate(s,d):
    tmp = s[d : ] + s[0 : d]
    return tmp


Input:
Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
Write a function to find the minimum total path sum in the given triangle.

### Response:

Output:
def min_sum_path(A):
	memo = [None] * len(A)
	n = len(A) - 1
	for i in range(len(A[n])):
		memo[i] = A[n][i]
	for i in range(len(A) - 2, -1,-1):
		for j in range( len(A[i])):
			memo[j] = A[i][j] + min(memo[j],
									memo[j + 1])
	return memo[0]