Input: 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.

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


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

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

assert is_Word_Present("machine learning","machine") == True
assert is_Word_Present("easy","fun") == False
assert is_Word_Present("python language","code") == False


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

Answer:
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: Write a python function to check whether an array can be sorted or not by picking only the corner elements.

Answer:
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: Write a function where a string will start with a specific number.

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

assert match_num('5-2345861')==True
assert match_num('6-2345861')==False
assert match_num('78910')==False


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

Answer:
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

assert smallest_multiple(13)==360360
assert smallest_multiple(2)==2
assert smallest_multiple(1)==1


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

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


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

Answer:
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;

assert count_Unset_Bits(2) == 1
assert count_Unset_Bits(5) == 4
assert count_Unset_Bits(14) == 17


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

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

assert even_num(13.5)==False
assert even_num(0)==True
assert even_num(-9)==False


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

Answer:
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))

assert sum_of_square(4) == 70
assert sum_of_square(5) == 252
assert sum_of_square(2) == 6


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

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

assert extract_date("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/") == [('2016', '09', '02')]
assert extract_date("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/") == [('2020', '11', '03')]
assert extract_date("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms") == [('2020', '12', '29')]


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

Answer:
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: Write a function to find the fixed point in the given array.

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


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

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

assert previous_palindrome(99)==88
assert previous_palindrome(1221)==1111
assert previous_palindrome(120)==111


Input: Write a function to validate a gregorian date.

Answer:
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

assert check_date(11,11,2002)==True
assert check_date(13,11,2002)==False
assert check_date('11','11','2002')==True


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

Answer:
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: Write a function to find ln, m lobb number.

Answer:
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))

assert int(lobb_num(5, 3)) == 35
assert int(lobb_num(3, 2)) == 5
assert int(lobb_num(4, 2)) == 20


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

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

assert end_num('abcdef')==False
assert end_num('abcdef7')==True
assert end_num('abc')==False


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

Answer:
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

assert is_Two_Alter("abab") == True
assert is_Two_Alter("aaaa") == False
assert is_Two_Alter("xyz") == False


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

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


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

Answer:
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: Write a function to find the sequences of one upper case letter followed by lower case letters.

Answer:
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!')

assert text_uppercase_lowercase("AaBbGg")==('Found a match!')
assert text_uppercase_lowercase("aA")==('Not matched!')
assert text_uppercase_lowercase("PYTHON")==('Not matched!')


Input: Write a function to count coin change.

Answer:
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: Write a python function to multiply all items in the list.

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

assert multiply_list([1,-2,3]) == -6
assert multiply_list([1,2,3,4]) == 24
assert multiply_list([3,1,2,3]) == 18


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

Answer:
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: Write a function to perform chunking of tuples each of size n.

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


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

Answer:
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: Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.

Answer:
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))

assert super_seq("AGGTAB", "GXTXAYB", 6, 7) == 9
assert super_seq("feek", "eke", 4, 3) == 5
assert super_seq("PARRT", "RTA", 5, 3) == 6


Input: Write a function to find maximum of two numbers.

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

assert max_of_two(10,20)==20
assert max_of_two(19,15)==19
assert max_of_two(-10,-20)==-10


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

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


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

Answer:
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))

assert rencontres_number(7, 2) == 924
assert rencontres_number(3, 0) == 2
assert rencontres_number(3, 1) == 3


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

Answer:
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

assert (max_height(root)) == 3
assert (max_height(root1)) == 5
assert (max_height(root2)) == 4


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

Answer:
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: Write a function to count repeated items of a tuple.

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


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

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

assert text_match("msb") == 'Not matched!'
assert text_match("a0c") == 'Found a match!'
assert text_match("abbc") == 'Found a match!'


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

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

assert sum_series(7)==784
assert sum_series(5)==225
assert sum_series(15)==14400


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

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

assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises"])==['Python', 'Exercises', 'Practice', 'Solution']
assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","Java"])==['Python', 'Exercises', 'Practice', 'Solution', 'Java']
assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","C++","C","C++"])==['Python', 'Exercises', 'Practice', 'Solution','C++','C']


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

Answer:
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()

assert camel_to_snake('GoogleAssistant') == 'google_assistant'
assert camel_to_snake('ChromeCast') == 'chrome_cast'
assert camel_to_snake('QuadCore') == 'quad_core'


Input: Write a function to find the nth delannoy number.

Answer:
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)

assert dealnnoy_num(3, 4) == 129
assert dealnnoy_num(3, 3) == 63
assert dealnnoy_num(4, 5) == 681


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

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

assert series_sum(6)==91
assert series_sum(7)==140
assert series_sum(12)==650


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

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


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

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

assert max_char("hello world")==('l')
assert max_char("hello ")==('l')
assert max_char("python pr")==('p')


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

Answer:
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: Write a function to sort a list of dictionaries using lambda function.

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

assert sorted_models([{'make':'Nokia', 'model':216, 'color':'Black'}, {'make':'Mi Max', 'model':2, 'color':'Gold'}, {'make':'Samsung', 'model': 7, 'color':'Blue'}])==[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': 2, 'color': 'Gold'}]
assert sorted_models([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])==([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])
assert sorted_models([{'make':'micromax','model':40,'color':'grey'},{'make':'poco','model':60,'color':'blue'}])==([{'make':'poco','model':60,'color':'blue'},{'make':'micromax','model':40,'color':'grey'}])


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

Answer:
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: Write a function to count the elements in a list until an element is a tuple.

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


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

Answer:
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: Write a function to combine two given sorted lists using heapq module.

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


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

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

assert num_position("there are 70 flats in this apartment")==10
assert num_position("every adult have 32 teeth")==17
assert num_position("isha has 79 chocolates in her bag")==9


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

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


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

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

assert most_common_elem('lkseropewdssafsdfafkpwe',3)==[('s', 4), ('e', 3), ('f', 3)]
assert most_common_elem('lkseropewdssafsdfafkpwe',2)==[('s', 4), ('e', 3)]
assert most_common_elem('lkseropewdssafsdfafkpwe',7)==[('s', 4), ('e', 3), ('f', 3), ('k', 2), ('p', 2), ('w', 2), ('d', 2)]


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

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


Input: Write a function to get an item of a tuple.

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


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

Answer:
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: Write a function to display sign of the chinese zodiac for given year.

Answer:
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

assert chinese_zodiac(1997)==('Ox')
assert chinese_zodiac(1998)==('Tiger')
assert chinese_zodiac(1994)==('Dog')


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

Answer:
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: Write a function to compute the value of ncr mod p.

Answer:
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: Write a python function to find the minimun number of subsets with distinct elements.

Answer:
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: Write a function that gives profit amount if the given amount has profit else return none.

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

assert profit_amount(1500,1200)==300
assert profit_amount(100,200)==None
assert profit_amount(2000,5000)==None


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

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

assert is_abundant(12)==True
assert is_abundant(13)==False
assert is_abundant(9)==False


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

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

assert split_list("LearnToBuildAnythingWithGoogle") == ['Learn', 'To', 'Build', 'Anything', 'With', 'Google']
assert split_list("ApmlifyingTheBlack+DeveloperCommunity") == ['Apmlifying', 'The', 'Black+', 'Developer', 'Community']
assert split_list("UpdateInTheGoEcoSystem") == ['Update', 'In', 'The', 'Go', 'Eco', 'System']


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

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

assert get_First_Set_Bit_Pos(12) == 3
assert get_First_Set_Bit_Pos(18) == 2
assert get_First_Set_Bit_Pos(16) == 5


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

Answer:
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

assert int_to_roman(1)==("I")
assert int_to_roman(50)==("L")
assert int_to_roman(4)==("IV")


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

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


Input: Write a function to solve tiling problem.

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

assert get_noOfways(4)==3
assert get_noOfways(3)==2
assert get_noOfways(5)==5


Input: Write a function to convert a roman numeral to an integer.

Answer:
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

assert roman_to_int('MMMCMLXXXVI')==3986
assert roman_to_int('MMMM')==4000
assert roman_to_int('C')==100


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

Answer:
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)))

assert sum_Even(2,5) == 6
assert sum_Even(3,8) == 18
assert sum_Even(4,6) == 10


Input: Write a function to calculate the discriminant value.

Answer:
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)

assert discriminant_value(4,8,2)==("Two solutions",32)
assert discriminant_value(5,7,9)==("no real solution",-131)
assert discriminant_value(0,0,9)==("one solution",0)


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

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

assert word_len("program") == False
assert word_len("solution") == True
assert word_len("data") == True


Input: Write a function to convert camel case string to snake case string.

Answer:
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()

assert camel_to_snake('PythonProgram')==('python_program')
assert camel_to_snake('pythonLanguage')==('python_language')
assert camel_to_snake('ProgrammingLanguage')==('programming_language')


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

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


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

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

assert check("SEEquoiaL") == 'accepted'
assert check('program') == "not accepted"
assert check('fine') == "not accepted"


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

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

assert floor_Max(11,10,9) == 9
assert floor_Max(5,7,4) == 2
assert floor_Max(2,2,1) == 1


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

Answer:
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: Write a function to find minimum of two numbers.

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

assert min_of_two(10,20)==10
assert min_of_two(19,15)==15
assert min_of_two(-10,-20)==-20


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

Answer:
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]

assert maximum_segments(7, 5, 2, 5) == 2
assert maximum_segments(17, 2, 1, 3) == 17
assert maximum_segments(18, 16, 3, 6) == 6


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

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


Input: Write a python function to left rotate the string.

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

assert left_rotate("python",2) == "thonpy"
assert left_rotate("bigdata",3 ) == "databig"
assert left_rotate("hadoop",1 ) == "adooph"


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

Answer:
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]