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

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


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

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


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

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


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

Write a function to find maximum of two numbers.


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

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


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

Write a function to find n-th rencontres number.


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

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root1 = Node(1);
root1.left = Node(2);
root1.right = Node(3);
root1.left.left = Node(4);
root1.right.left = Node(5);
root1.right.right = Node(6);
root1.right.right.right= Node(7);
root1.right.right.right.right = Node(8)
root2 = Node(1)
root2.left = Node(2)
root2.right = Node(3)
root2.left.left = Node(4)
root2.left.right = Node(5)
root2.left.left.left = Node(6)
root2.left.left.right = Node(7)

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


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)

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


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

Write a function to count repeated items of a tuple.


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!'

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


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

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


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']

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


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'

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


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

Write a function to find the nth delannoy number.


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

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


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

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


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')

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


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]

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


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'}]

Write a function to sort a list of dictionaries using lambda function.


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

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


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

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


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

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


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

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


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

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


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

Write a function to convert the given tuples into set.


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)]

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


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

assert len_log(["win","lose","great"]) == 3

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


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

Write a function to get an item of a tuple.


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

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


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')

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


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)

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


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]

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


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

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


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

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


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

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


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']

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


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

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


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

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


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

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


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

Write a function to solve tiling problem.


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

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


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

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


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(5,7,9)==("no real solution",-131)

Write a function to calculate the discriminant value.


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

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


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

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


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

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


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

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

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


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

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


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)

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


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

Write a function to find minimum of two numbers.


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

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


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

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


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"

Write a python function to left rotate the string.


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]

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


assert remove_Occ("hellolloll","l") == "helollol"

def remove_Occ(s,ch):
    for i in range(len(s)):
        if (s[i] == ch):
            s = s[0 : i] + s[i + 1:]
            break
    for i in range(len(s) - 1,-1,-1):
        if (s[i] == ch):
            s = s[0 : i] + s[i + 1:]
            break
    return s

assert remove_Occ("hello","l") == "heo"
assert remove_Occ("abcda","a") == "bcd"
assert remove_Occ("PHP","P") == "H"

Write a python function to remove first and last occurrence of a given character from the string.


def sort_matrix(M):
    result = sorted(M, key=sum)
    return result

Write a function to sort a given matrix in ascending order according to the sum of its rows.


from collections import Counter
def count_common(words):
  word_counts = Counter(words)
  top_four = word_counts.most_common(4)
  return (top_four)

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)]

Write a function to count the most common words in a dictionary.


def find_Volume(l,b,h) :
    return ((l * b * h) / 2)

assert find_Volume(10,8,6) == 240
assert find_Volume(3,2,2) == 6
assert find_Volume(1,2,1) == 1

Write a python function to find the volume of a triangular prism.


import re
def split_lowerstring(text):
 return (re.findall('[a-z][^a-z]*', text))

assert split_lowerstring("Python")==['y', 't', 'h', 'o', 'n']

assert split_lowerstring("Programming")==['r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'n', 'g']

Write a function to split a string at lowercase letters.


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

assert text_lowercase_underscore("aab_cbbbc")==('Found a match!')

Write a function to find sequences of lowercase letters joined with an underscore.


def square_perimeter(a):
  perimeter=4*a
  return perimeter

assert square_perimeter(10)==40
assert square_perimeter(5)==20
assert square_perimeter(4)==16

Write a function to find the perimeter of a square.


NO_OF_CHARS = 256
def str_to_list(string):
	temp = []
	for x in string:
		temp.append(x)
	return temp
def lst_to_string(List):
	return ''.join(List)
def get_char_count_array(string):
	count = [0] * NO_OF_CHARS
	for i in string:
		count[ord(i)] += 1
	return count
def remove_dirty_chars(string, second_string):
	count = get_char_count_array(second_string)
	ip_ind = 0
	res_ind = 0
	temp = ''
	str_list = str_to_list(string)
	while ip_ind != len(str_list):
		temp = str_list[ip_ind]
		if count[ord(temp)] == 0:
			str_list[res_ind] = str_list[ip_ind]
			res_ind += 1
		ip_ind+=1
	return lst_to_string(str_list[0:res_ind])

assert remove_dirty_chars("probasscurve", "pros") == 'bacuve'

assert remove_dirty_chars("digitalindia", "talent") == 'digiidi'

assert remove_dirty_chars("exoticmiles", "toxic") == 'emles'

Write a function to remove characters from the first string which are present in the second string.


def test_duplicate(arraynums):
    nums_set = set(arraynums)
    return len(arraynums) != len(nums_set)

Write a function to find whether a given array of integers contains any duplicate element.


assert is_woodall(32212254719) == True
assert is_woodall(32212254718) == False
assert is_woodall(159) == True

def is_woodall(x):
	if (x % 2 == 0):
		return False
	if (x == 1):
		return True
	x = x + 1
	p = 0
	while (x % 2 == 0):
		x = x/2
		p = p + 1
		if (p == x):
			return True
	return False

assert is_woodall(383) == True
assert is_woodall(254) == False
assert is_woodall(200) == False

Write a function to check if the given number is woodball or not.


def multiples_of_num(m,n):
    multiples_of_num= list(range(n,(m+1)*n, n))
    return list(multiples_of_num)

Write a function to find m number of multiples of n.


def find_first_duplicate(nums):
    num_set = set()
    no_duplicate = -1

    for i in range(len(nums)):

        if nums[i] in num_set:
            return nums[i]
        else:
            num_set.add(nums[i])

    return no_duplicate

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

Write a function to find the first duplicate element in a given array of integers.


def maximum_Sum(list1):
    maxi = -100000
    for x in list1:
        sum = 0
        for y in x:
            sum+= y
        maxi = max(sum,maxi)
    return maxi

Write a python function to find the maximum sum of elements of list in a list of lists.


def binary_to_decimal(binary):
    binary1 = binary
    decimal, i, n = 0, 0, 0
    while(binary != 0):
        dec = binary % 10
        decimal = decimal + dec * pow(2, i)
        binary = binary//10
        i += 1
    return (decimal)

assert binary_to_decimal(1101101) == 109

Write a function to convert the given binary number to its decimal equivalent.


def find_Product(arr,n):
    arr.sort()
    prod = 1
    for i in range(0,n,1):
        if (arr[i - 1] != arr[i]):
            prod = prod * arr[i]
    return prod;

Write a python function to find the product of non-repeated elements in a given array.


def check_k_elements(test_list, K):
  res = True
  for tup in test_list:
    for ele in tup:
      if ele != K:
        res = False
  return (res)

assert check_k_elements([(7, 7, 7), (7, 7)], 7) == True

assert check_k_elements([(9, 9), (9, 9, 9, 9)], 7) == False

Write a function to check if the given tuple list has all k elements.


import re
def remove(list):
    pattern = '[0-9]'
    list = [re.sub(pattern, '', i) for i in list]
    return 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']

Write a python function to remove all digits from a list of strings.


def binomial_Coeff(n,k):
    if k > n :
       return 0
    if k==0 or k ==n :
        return 1
    return binomial_Coeff(n-1,k-1) + binomial_Coeff(n-1,k)

assert binomial_Coeff(5,2) == 10
assert binomial_Coeff(4,3) == 4
assert binomial_Coeff(3,2) == 3

Write a python function to find binomial co-efficient.


def get_Odd_Occurrence(arr,arr_size):
    for i in range(0,arr_size):
        count = 0
        for j in range(0,arr_size):
            if arr[i] == arr[j]:
                count+=1
        if (count % 2 != 0):
            return arr[i]
    return -1

Write a python function to find the element occurring odd number of times.


def check_Equality(s):
    return (ord(s[0]) == ord(s[len(s) - 1]));
def count_Substring_With_Equal_Ends(s):
    result = 0;
    n = len(s);
    for i in range(n):
        for j in range(1,n-i+1):
            if (check_Equality(s[i:i+j])):
                result+=1;
    return result;

assert count_Substring_With_Equal_Ends("abc") == 3

assert count_Substring_With_Equal_Ends("abcda") == 6

assert count_Substring_With_Equal_Ends("ab") == 2

Write a python function to count all the substrings starting and ending with same characters.


def func(nums, k):
    import collections
    d = collections.defaultdict(int)
    for row in nums:
        for i in row:
            d[i] += 1
    temp = []
    import heapq
    for key, v in d.items():
        if len(temp) < k:
            temp.append((v, key))
            if len(temp) == k:
                heapq.heapify(temp)
        else:
            if v > temp[0][0]:
                heapq.heappop(temp)
                heapq.heappush(temp, (v, key))
    result = []
    while temp:
        v, key = heapq.heappop(temp)
        result.append(key)
    return result

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.


import math
def max_Prime_Factors (n):
    maxPrime = -1
    while n%2 == 0:
        maxPrime = 2
        n >>= 1
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i == 0:
            maxPrime = i
            n = n / i
    if n > 2:
        maxPrime = n
    return int(maxPrime)

assert max_Prime_Factors(15) == 5
assert max_Prime_Factors(6) == 3
assert max_Prime_Factors(2) == 2

Write a python function to find the largest prime factor of a given number.


def decimal_To_Binary(N):
    B_Number = 0
    cnt = 0
    while (N != 0):
        rem = N % 2
        c = pow(10,cnt)
        B_Number += rem*c
        N //= 2
        cnt += 1
    return B_Number

assert decimal_To_Binary(10) == 1010
assert decimal_To_Binary(1) == 1
assert decimal_To_Binary(20) == 10100

Write a python function to convert a decimal number to binary number.


def find_missing(ar,N):
    l = 0
    r = N - 1
    while (l <= r):
        mid = (l + r) / 2
        mid= int (mid)
        if (ar[mid] != mid + 1 and ar[mid - 1] == mid):
            return (mid + 1)
        elif (ar[mid] != mid + 1):
            r = mid - 1
        else:
            l = mid + 1
    return (-1)

Write a python function to find the missing number in a sorted array.


def find_rect_num(n):
  return n*(n + 1)

assert find_rect_num(4) == 20
assert find_rect_num(5) == 30
assert find_rect_num(6) == 42

Write a function to find the n-th rectangular number.


def find_Nth_Digit(p,q,N) :
    while (N > 0) :
        N -= 1;
        p *= 10;
        res = p // q;
        p %= q;
    return res;

assert find_Nth_Digit(1,2,1) == 5
assert find_Nth_Digit(3,5,1) == 6
assert find_Nth_Digit(5,6,5) == 3

Write a python function to find the nth digit in the proper fraction of two given numbers.


def sort_mixed_list(mixed_list):
    int_part = sorted([i for i in mixed_list if type(i) is int])
    str_part = sorted([i for i in mixed_list if type(i) is str])
    return int_part + str_part

assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']

Write a function to sort a given mixed list of integers and strings.


def div_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)

Write a function to find the division of first even and odd number of a given list.


import heapq
from collections import Counter
def rearange_string(S):
    ctr = Counter(S)
    heap = [(-value, key) for key, value in ctr.items()]
    heapq.heapify(heap)
    if (-heap[0][0]) * 2 > len(S) + 1:
        return ""
    ans = []
    while len(heap) >= 2:
        nct1, char1 = heapq.heappop(heap)
        nct2, char2 = heapq.heappop(heap)
        ans.extend([char1, char2])
        if nct1 + 1: heapq.heappush(heap, (nct1 + 1, char1))
        if nct2 + 1: heapq.heappush(heap, (nct2 + 1, char2))
    return "".join(ans) + (heap[0][1] if heap else "")

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.


from collections import Counter
from itertools import chain
def freq_element(nums):
  result = Counter(chain.from_iterable(nums))
  return result

Write a function to find frequency of the elements in a given list of lists using collections module.


def filter_evennumbers(nums):
 even_nums = list(filter(lambda x: x%2 == 0, nums))
 return even_nums

Write a function to filter even numbers using lambda function.


def find_Sum(arr,n):
    return sum([x for x in arr if arr.count(x) > 1])

Write a python function to find the sum of repeated elements in a given array.


assert text_match("aab-cbbbc") == 'Not matched!'

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

assert text_match("aab_cbbbc") == 'Found a match!'

assert text_match("aab_Abbbc") == 'Not matched!'

assert text_match("Aaab_abbbc") == 'Not matched!'

Write a function to find sequences of lowercase letters joined with an underscore using regex.


assert text_match_string("foo")==('Found a match!')

import re
def text_match_string(text):
        patterns = '^\w+'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return 'Not matched!'

assert text_match_string(" python")==('Not matched!')

assert text_match_string("python")==('Found a match!')

assert text_match_string("  lang")==('Not matched!')

Write a function that matches a word at the beginning of a string.


def find_gcd(x, y):
	while(y):
		x, y = y, x % y
	return x
def get_gcd(l):
  num1 = l[0]
  num2 = l[1]
  gcd = find_gcd(num1, num2)
  for i in range(2, len(l)):
    gcd = find_gcd(gcd, l[i])
  return gcd

Write a function to find the gcd of the given array elements.


def test_distinct(data):
  if len(data) == len(set(data)):
    return True
  else:
    return False;

assert test_distinct([2,4,5,5,7,9]) == False

Write a python function to determine whether all the numbers are different from each other are not.


assert compute_Last_Digit(1021,1024) == 4

def compute_Last_Digit(A,B):
    variable = 1
    if (A == B):
        return 1
    elif ((B - A) >= 5):
        return 0
    else:
        for i in range(A + 1,B + 1):
            variable = (variable * (i % 10)) % 10
        return variable % 10

assert compute_Last_Digit(2,4) == 2
assert compute_Last_Digit(6,8) == 6
assert compute_Last_Digit(1,2) == 2

Write a python function to find the last digit when factorial of a divides factorial of b.


def odd_bit_set_number(n):
    count = 0;res = 0;temp = n
    while temp > 0:
        if count % 2 == 0:
            res |= (1 << count)
        count += 1
        temp >>= 1
    return (n | res)

assert odd_bit_set_number(10) == 15
assert odd_bit_set_number(20) == 21
assert odd_bit_set_number(30) == 31

Write a python function to set all odd bits of a given number.


def specified_element(nums, N):
    result = [i[N] for i in nums]
    return result

Write a function to extract every first or specified element from a given two-dimensional list.


def min_length_list(input_list):
    min_length = min(len(x) for x in input_list )
    min_list = min(input_list, key = lambda i: len(i))
    return(min_length, min_list)

Write a function to find the list with minimum length using lambda function.


def check_equilateral(x,y,z):
  if x == y == z:
	   return True
  else:
     return False

Write a function to print check if the triangle is equilateral or not.


def parallelogram_area(b,h):
  area=b*h
  return area

assert parallelogram_area(10,20)==200
assert parallelogram_area(15,20)==300
assert parallelogram_area(8,9)==72

Write a function to caluclate area of a parallelogram.


def check_Equality(str):
  if (str[0] == str[-1]):
    return ("Equal")
  else:
    return ("Not Equal")

assert check_Equality("abcda") == "Equal"

assert check_Equality("ab") == "Not Equal"

assert check_Equality("mad") == "Not Equal"

Write a python function to check whether the first and last characters of a given string are equal or not.


def counting_sort(my_list):
    max_value = 0
    for i in range(len(my_list)):
        if my_list[i] > max_value:
            max_value = my_list[i]
    buckets = [0] * (max_value + 1)
    for i in my_list:
        buckets[i] += 1
    i = 0
    for j in range(max_value + 1):
         for a in range(buckets[j]):
             my_list[i] = j
             i += 1
    return my_list

Write a function to sort the given array by using counting sort.


import math
def tn_gp(a,n,r):
  tn = a * (math.pow(r, n - 1))
  return tn

Write a function to find t-nth term of geometric series.


def rev(num):
    rev_num = 0
    while (num > 0):
        rev_num = (rev_num * 10 + num % 10)
        num = num // 10
    return rev_num
def check(n):
    return (2 * rev(n) == n + 1)

assert check(70) == False
assert check(23) == False
assert check(73) == True

Write a python function to check if a given number is one less than twice its reverse.


def find_Max_Num(arr,n) :
    arr.sort(reverse = True)
    num = arr[0]
    for i in range(1,n) :
        num = num * 10 + arr[i]
    return num

Write a python function to find the largest number that can be formed with the given digits.


def opposite_Signs(x,y):
    return ((x ^ y) < 0);

assert opposite_Signs(1,-2) == True
assert opposite_Signs(3,2) == False
assert opposite_Signs(-10,-10) == False

Write a python function to check whether the given two integers have opposite sign or not.


def is_octagonal(n):
	return 3 * n * n - 2 * n

assert is_octagonal(5) == 65
assert is_octagonal(10) == 280
assert is_octagonal(15) == 645

Write a function to find the nth octagonal number.


def max_len_sub( arr, n):
	mls=[]
	max = 0
	for i in range(n):
		mls.append(1)
	for i in range(n):
		for j in range(i):
			if (abs(arr[i] - arr[j]) <= 1 and mls[i] < mls[j] + 1):
				mls[i] = mls[j] + 1
	for i in range(n):
		if (max < mls[i]):
			max = mls[i]
	return max

Write a function to find the maximum length of the subsequence with difference between adjacent elements for the given array.


from collections import defaultdict
def count_Substrings(s,n):
    count,sum = 0,0
    mp = defaultdict(lambda : 0)
    mp[0] += 1
    for i in range(n):
        sum += ord(s[i]) - ord('0')
        count += mp[sum - (i + 1)]
        mp[sum - (i + 1)] += 1
    return count

assert count_Substrings('112112',6) == 6

assert count_Substrings('1101112',7) == 12

Write a python function to count number of substrings with the sum of digits equal to their length.


Write a python function to find smallest number in a list.


def max_difference(test_list):
  temp = [abs(b - a) for a, b in test_list]
  res = max(temp)
  return (res)

Write a function to find the maximum difference between available pairs in the given tuple list.


def subject_marks(subjectmarks):
#subject_marks = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])
 subjectmarks.sort(key = lambda x: x[1])
 return subjectmarks

assert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])==[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]

Write a function to sort a list of tuples using lambda.


def recursive_list_sum(data_list):
	total = 0
	for element in data_list:
		if type(element) == type([]):
			total = total + recursive_list_sum(element)
		else:
			total = total + element
	return total

Write a function of recursion list sum.


def pos_count(list):
  pos_count= 0
  for num in list:
    if num >= 0:
      pos_count += 1
  return pos_count

Write a python function to count positive numbers in a list.


def bell_number(n):
    bell = [[0 for i in range(n+1)] for j in range(n+1)]
    bell[0][0] = 1
    for i in range(1, n+1):
        bell[i][0] = bell[i-1][i-1]
        for j in range(1, i+1):
            bell[i][j] = bell[i-1][j-1] + bell[i][j-1]
    return bell[n][0]

Write a function to find the number of ways to partition a set of bell numbers.


def is_Monotonic(A):
    return (all(A[i] <= A[i + 1] for i in range(len(A) - 1)) or
            all(A[i] >= A[i + 1] for i in range(len(A) - 1)))

assert is_Monotonic([6, 5, 4, 4]) == True

assert is_Monotonic([1, 2, 2, 3]) == True

Write a python function to check whether the given array is monotonic or not.


def is_sublist(l, s):
	sub_set = False
	if s == []:
		sub_set = True
	elif s == l:
		sub_set = True
	elif len(s) > len(l):
		sub_set = False
	else:
		for i in range(len(l)):
			if l[i] == s[0]:
				n = 1
				while (n < len(s)) and (l[i+n] == s[n]):
					n += 1
				if n == len(s):
					sub_set = True
	return sub_set

Write a function to check whether a list contains the given sublist or not.


def find_equal_tuple(Input, k):
  flag = 1
  for tuple in Input:
    if len(tuple) != k:
      flag = 0
      break
  return flag
def get_equal(Input, k):
  if find_equal_tuple(Input, k) == 1:
    return ("All tuples have same length")
  else:
    return ("All tuples do not have same length")

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'

Write a function to find whether all the given tuples have equal length or not.


def comb_sort(nums):
    shrink_fact = 1.3
    gaps = len(nums)
    swapped = True
    i = 0
    while gaps > 1 or swapped:
        gaps = int(float(gaps) / shrink_fact)
        swapped = False
        i = 0
        while gaps + i < len(nums):
            if nums[i] > nums[i+gaps]:
                nums[i], nums[i+gaps] = nums[i+gaps], nums[i]
                swapped = True
            i += 1
    return nums

Write a function to sort a list of elements using comb sort.


def dif_Square(n):
    if (n % 4 != 2):
        return True
    return False

assert dif_Square(5) == True
assert dif_Square(10) == False
assert dif_Square(15) == True

Write a python function to check whether the given number can be represented as difference of two squares or not.


import re
def multiple_split(text):
  return (re.split('; |, |\*|\n',text))

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.']

Write a function to split the given string with multiple delimiters by using regex.


def is_samepatterns(colors, patterns):
    if len(colors) != len(patterns):
        return False
    sdict = {}
    pset = set()
    sset = set()
    for i in range(len(patterns)):
        pset.add(patterns[i])
        sset.add(colors[i])
        if patterns[i] not in sdict.keys():
            sdict[patterns[i]] = []

        keys = sdict[patterns[i]]
        keys.append(colors[i])
        sdict[patterns[i]] = keys

    if len(pset) != len(sset):
        return False

    for values in sdict.values():

        for i in range(len(values) - 1):
            if values[i] != values[i+1]:
                return False

    return True

assert is_samepatterns(["red","green","green"], ["a", "b", "b"])==True

Write a function to check whether it follows the sequence given in the patterns array.


def find_tuples(test_list, K):
  res = [sub for sub in test_list if all(ele % K == 0 for ele in sub)]
  return (str(res))

Write a function to find tuples which have all elements divisible by k from the given list of tuples.


def count_Squares(m,n):
    if(n < m):
        temp = m
        m = n
        n = temp
    return ((m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2))

assert count_Squares(4,3) == 20
assert count_Squares(2,2) == 5
assert count_Squares(1,1) == 1

Write a python function to count the number of squares in a rectangle.


def is_Diff(n):
    return (n % 11 == 0)

assert is_Diff (12345) == False
assert is_Diff(1212112) == True
assert is_Diff(1212) == False

Write a python function to find the difference between sum of even and odd digits.


def count_With_Odd_SetBits(n):
    if (n % 2 != 0):
        return (n + 1) / 2
    count = bin(n).count('1')
    ans = n / 2
    if (count % 2 != 0):
        ans += 1
    return ans

assert count_With_Odd_SetBits(5) == 3
assert count_With_Odd_SetBits(10) == 5
assert count_With_Odd_SetBits(15) == 8

Write a python function to find number of integers with odd number of set bits.


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

assert word_len("Hadoop") == False
assert word_len("great") == True
assert word_len("structure") == True

Write a python function to check whether the length of the word is odd or not.


def tetrahedral_number(n):
	return (n * (n + 1) * (n + 2)) / 6

assert tetrahedral_number(5) == 35.0
assert tetrahedral_number(6) == 56.0
assert tetrahedral_number(7) == 84.0

Write a function to find the nth tetrahedral number.


def zip_tuples(test_tup1, test_tup2):
  res = []
  for i, j in enumerate(test_tup1):
    res.append((j, test_tup2[i % len(test_tup2)]))
  return (res)

Write a function to zip the two given tuples.


import math
def volume_sphere(r):
  volume=(4/3)*math.pi*r*r*r
  return volume

Write a function to find the volume of a sphere.


def get_Char(strr):
    summ = 0
    for i in range(len(strr)):
        summ += (ord(strr[i]) - ord('a') + 1)
    if (summ % 26 == 0):
        return ord('z')
    else:
        summ = summ % 26
        return chr(ord('a') + summ - 1)

assert get_Char("abc") == "f"
assert get_Char("gfg") == "t"
assert get_Char("ab") == "c"

Write a python function to find the character made by adding all the characters of the given string.


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

assert sequence(10) == 6
assert sequence(2) == 1
assert sequence(3) == 2

Write a function to find the n-th number in newman conway sequence.


import math
def surfacearea_sphere(r):
  surfacearea=4*math.pi*r*r
  return surfacearea

Write a function to find the surface area of a sphere.


def centered_hexagonal_number(n):
  return 3 * n * (n - 1) + 1

assert centered_hexagonal_number(10) == 271

assert centered_hexagonal_number(2) == 7

assert centered_hexagonal_number(9) == 217

Write a function to find nth centered hexagonal number.


import collections as ct
def merge_dictionaries_three(dict1,dict2, dict3):
    merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
    return merged_dict

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'}

Write a function to merge three dictionaries into a single expression.


import collections
def freq_count(list1):
  freq_count= collections.Counter(list1)
  return freq_count

Write a function to get the frequency of the elements in a list.


assert closest_num(11) == 10
assert closest_num(7) == 6
assert closest_num(12) == 11

Write a function to find the closest smaller number than n.


def len_log(list1):
    max=len(list1[0])
    for i in list1:
        if len(i)>max:
            max=len(i)
    return max

assert len_log(["python","PHP","bigdata"]) == 7

assert len_log(["small","big","tall"]) == 5

Write a python function to find the length of the longest word.


def find_substring(str1, sub_str):
   if any(sub_str in s for s in str1):
       return True
   return False

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

Write a function to check if a substring is present in a given list of string values.


def is_undulating(n):
	if (len(n) <= 2):
		return False
	for i in range(2, len(n)):
		if (n[i - 2] != n[i]):
			return False
	return True

assert is_undulating("1212121") == True
assert is_undulating("1991") == False
assert is_undulating("121") == True

Write a function to check whether the given number is undulating or not.


def power(a,b):
	if b==0:
		return 1
	elif a==0:
		return 0
	elif b==1:
		return a
	else:
		return a*power(a,b-1)

assert power(3,4) == 81
assert power(2,3) == 8
assert power(5,5) == 3125

Write a function to calculate the value of 'a' to the power 'b'.


from operator import itemgetter
def index_minimum(test_list):
  res = min(test_list, key = itemgetter(1))[0]
  return (res)

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'

Write a function to extract the index minimum value record from the given tuples.


def Find_Min_Length(lst):
    minLength = min(len(x) for x in lst )
    return minLength

assert Find_Min_Length([[1],[1,2]]) == 1

Write a python function to find the minimum length of sublist.


def divisor(n):
  for i in range(n):
    x = len([i for i in range(1,n+1) if not n % i])
  return x

assert divisor(15) == 4
assert divisor(12) == 6
assert divisor(9) == 3

Write a python function to find the number of divisors of a given integer.


def frequency_lists(list1):
    list1 = [item for sublist in list1 for item in sublist]
    dic_data = {}
    for num in list1:
        if num in dic_data.keys():
            dic_data[num] += 1
        else:
            key = num
            value = 1
            dic_data[key] = value
    return dic_data

Write a function to find frequency count of list of lists.


def multiply_num(numbers):
    total = 1
    for x in numbers:
        total *= x
    return total/len(numbers)

Write a function to multiply all the numbers in a list and divide with the length of the list.


def decimal_to_binary(n):
    return bin(n).replace("0b","")

assert decimal_to_binary(8) == '1000'
assert decimal_to_binary(18) == '10010'
assert decimal_to_binary(7) == '111'

Write a function to convert the given decimal number to its binary equivalent.


import sys
def next_smallest_palindrome(num):
    numstr = str(num)
    for i in range(num+1,sys.maxsize):
        if str(i) == str(i)[::-1]:
            return i

Write a function to find the next smallest palindrome of a specified number.


def kth_element(arr, n, k):
  for i in range(n):
    for j in range(0, n-i-1):
      if arr[j] > arr[j+1]:
        arr[j], arr[j+1] == arr[j+1], arr[j]
  return arr[k-1]

Write a function to find the kth element in the given array.


def snake_to_camel(word):
        import re
        return ''.join(x.capitalize() or '_' for x in word.split('_'))

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


def eulerian_num(n, m):
	if (m >= n or n == 0):
		return 0
	if (m == 0):
		return 1
	return ((n - m) * eulerian_num(n - 1, m - 1) +(m + 1) * eulerian_num(n - 1, m))

assert eulerian_num(3, 1) == 4
assert eulerian_num(4, 1) == 11
assert eulerian_num(5, 3) == 26

Write a function to find eulerian number a(n, m).


def sort_sublists(input_list):
    result = [sorted(x, key = lambda x:x[0]) for x in input_list]
    return result

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']]

Write a function to sort each sublist of strings in a given list of lists using lambda function.


assert count([True,False,True]) == 2
assert count([False,False]) == 0
assert count([True,True,True]) == 3

Write a python function to count true booleans in the given list.


def add_lists(test_list, test_tup):
  res = tuple(list(test_tup) + test_list)
  return (res)

Write a function to add the given list to the given tuples.


def count_Hexadecimal(L,R) :
    count = 0;
    for i in range(L,R + 1) :
        if (i >= 10 and i <= 15) :
            count += 1;
        elif (i > 15) :
            k = i;
            while (k != 0) :
                if (k % 16 >= 10) :
                    count += 1;
                k = k // 16;
    return count;

assert count_Hexadecimal(10,15) == 6
assert count_Hexadecimal(2,4) == 0
assert count_Hexadecimal(15,16) == 1

Write a python function to count hexadecimal numbers for a given range.


import heapq
def merge_sorted_list(num1,num2,num3):
  num1=sorted(num1)
  num2=sorted(num2)
  num3=sorted(num3)
  result = heapq.merge(num1,num2,num3)
  return list(result)

Write a function to merge multiple sorted inputs into a single sorted iterator using heap queue algorithm.


def odd_Equivalent(s,n):
    count=0
    for i in range(0,n):
        if (s[i] == '1'):
            count = count + 1
    return count

assert odd_Equivalent("011001",6) == 3
assert odd_Equivalent("11011",5) == 4
assert odd_Equivalent("1010",4) == 2

Write a python function to find the count of rotations of a binary string with odd value.


def extract_missing(test_list, strt_val, stop_val):
  res = []
  for sub in test_list:
    if sub[0] > strt_val:
      res.append((strt_val, sub[0]))
      strt_val = sub[1]
    if strt_val < stop_val:
      res.append((strt_val, stop_val))
  return (res)

Write a function to extract the ranges that are missing from the given list with the given start range and end range values.


def common_in_nested_lists(nestedlist):
    result = list(set.intersection(*map(set, nestedlist)))
    return result

Write a function to find common elements in given nested lists. * list item * list item * list item * list item


def perimeter(diameter,height) :
    return 2*(diameter+height)

assert perimeter(2,4) == 12
assert perimeter(1,2) == 6
assert perimeter(3,1) == 8

Write a python function to find the perimeter of a cylinder.


def check_integer(text):
 text = text.strip()
 if len(text) < 1:
    return None
 else:
     if all(text[i] in "0123456789" for i in range(len(text))):
          return True
     elif (text[0] in "+-") and \
         all(text[i] in "0123456789" for i in range(1,len(text))):
         return True
     else:
        return False

assert check_integer("python")==False
assert check_integer("1")==True
assert check_integer("12345")==True

Write a function to check if a string represents an integer or not.


from collections import Counter
def assign_freq(test_list):
  res = [(*key, val) for key, val in Counter(test_list).items()]
  return (str(res))

Write a function to assign frequency to each tuple in the given tuple list.


def empty_dit(list1):
 empty_dit=all(not d for d in list1)
 return empty_dit

assert empty_dit([{},{},{}])==True
assert empty_dit([{1,2},{},{}])==False
assert empty_dit({})==True

Write a function to check whether all dictionaries in a list are empty or not.


def tuple_to_int(nums):
    result = int(''.join(map(str,nums)))
    return result

assert tuple_to_int((1,2,3))==123
assert tuple_to_int((4,5,6))==456
assert tuple_to_int((5,6,7))==567

Write a function to convert a given tuple of positive integers into an integer.


def list_to_float(test_list):
  res = []
  for tup in test_list:
    temp = []
    for ele in tup:
      if ele.isalpha():
        temp.append(ele)
      else:
        temp.append(float(ele))
    res.append((temp[0],temp[1]))
  return (str(res))

Write a function to convert all possible convertible elements in the list to float.


def string_to_list(string):
    lst = list(string.split(" "))
    return lst

assert string_to_list("lists tuples strings")==['lists','tuples','strings']

assert string_to_list("write a program")==['write','a','program']

[link text](https:// [link text](https:// [link text](https://)))write a function to convert a string to a list.


def search(arr,n) :
    XOR = 0
    for i in range(n) :
        XOR = XOR ^ arr[i]
    return (XOR)

Write a python function to find the element that appears only once in a sorted array.


def max_product_tuple(list1):
    result_max = max([abs(x * y) for x, y in list1] )
    return result_max

Write a function to find the maximum product from the pairs of tuples within a given list.


def check_triplet(A, n, sum, count):
    if count == 3 and sum == 0:
        return True
    if count == 3 or n == 0 or sum < 0:
        return False
    return check_triplet(A, n - 1, sum - A[n - 1], count + 1) or\
           check_triplet(A, n - 1, sum, count)

Write a function to find the triplet with sum of the given array


MAX = 3000
def smartNumber(n):
	primes = [0] * MAX
	result = []
	for i in range(2, MAX):
		if (primes[i] == 0):
			primes[i] = 1
			j = i * 2
			while (j < MAX):
				primes[j] -= 1
				if ( (primes[j] + 3) == 0):
					result.append(j)
				j = j + i
	result.sort()
	return result[n - 1]

assert smartNumber(1) == 30
assert smartNumber(50) == 273
assert smartNumber(1000) == 2664

Write a function to find n’th smart number.


def amicable_numbers_sum(limit):
    if not isinstance(limit, int):
        return "Input is not an integer!"
    if limit < 1:
        return "Input must be bigger than 0!"
    amicables = set()
    for num in range(2, limit+1):
        if num in amicables:
            continue
        sum_fact = sum([fact for fact in range(1, num) if num % fact == 0])
        sum_fact2 = sum([fact for fact in range(1, sum_fact) if sum_fact % fact == 0])
        if num == sum_fact2 and num != sum_fact:
            amicables.add(num)
            amicables.add(sum_fact2)
    return sum(amicables)

Write a function to sum all amicable numbers from 1 to a specified number.


import cmath
def angle_complex(a,b):
  cn=complex(a,b)
  angle=cmath.phase(a+b)
  return angle

Write a function to get the angle of a complex number.


def find_length(string, n):
	current_sum = 0
	max_sum = 0
	for i in range(n):
		current_sum += (1 if string[i] == '0' else -1)
		if current_sum < 0:
			current_sum = 0
		max_sum = max(current_sum, max_sum)
	return max_sum if max_sum else 0

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.


def sum(a,b):
    sum = 0
    for i in range (1,min(a,b)):
        if (a % i == 0 and b % i == 0):
            sum += i
    return sum

Write a python function to find the sum of common divisors of two given numbers.


def multiply_int(x, y):
    if y < 0:
        return -multiply_int(x, -y)
    elif y == 0:
        return 0
    elif y == 1:
        return x
    else:
        return x + multiply_int(x, y - 1)

assert multiply_int(10,20)==200
assert multiply_int(5,10)==50
assert multiply_int(4,8)==32

Write a function to multiply two integers without using the * operator in python.


def long_words(n, str):
    word_len = []
    txt = str.split(" ")
    for x in txt:
        if len(x) > n:
            word_len.append(x)
    return word_len

assert long_words(3,"python is a programming language")==['python','programming','language']

assert long_words(2,"writing a program")==['writing','program']

Write a function to shortlist words that are longer than n from a given list of words.


def magic_square_test(my_matrix):
    iSize = len(my_matrix[0])
    sum_list = []
    sum_list.extend([sum (lines) for lines in my_matrix])
    for col in range(iSize):
        sum_list.append(sum(row[col] for row in my_matrix))
    result1 = 0
    for i in range(0,iSize):
        result1 +=my_matrix[i][i]
    sum_list.append(result1)
    result2 = 0
    for i in range(iSize-1,-1,-1):
        result2 +=my_matrix[i][i]
    sum_list.append(result2)
    if len(set(sum_list))>1:
        return False
    return True

Write a function to calculate magic square.


from collections import defaultdict
def max_occurrences(nums):
    dict = defaultdict(int)
    for i in nums:
        dict[i] += 1
    result = max(dict.items(), key=lambda x: x[1])
    return result

Write a function to find the item with maximum frequency in a given list.


def reverse_vowels(str1):
	vowels = ""
	for char in str1:
		if char in "aeiouAEIOU":
			vowels += char
	result_string = ""
	for char in str1:
		if char in "aeiouAEIOU":
			result_string += vowels[-1]
			vowels = vowels[:-1]
		else:
			result_string += char
	return result_string

assert reverse_vowels("Python") == "Python"

Write a python function to reverse only the vowels of a given string.


def tup_string(tup1):
  str =  ''.join(tup1)
  return str

Write a function to convert tuple to a string.


def sum_negativenum(nums):
  sum_negativenum = list(filter(lambda nums:nums<0,nums))
  return sum(sum_negativenum)

Write a function to calculate the sum of the negative numbers of a given list of numbers using lambda function.


def check_last (arr,n,p):
    _sum = 0
    for i in range(n):
        _sum = _sum + arr[i]
    if p == 1:
        if _sum % 2 == 0:
            return "ODD"
        else:
            return "EVEN"
    return "EVEN"

Write a python function to check whether the last element of given array is even or odd after performing an operation p times.


def hexagonal_num(n):
	return n*(2*n - 1)

assert hexagonal_num(10) == 190
assert hexagonal_num(5) == 45
assert hexagonal_num(7) == 91

Write a function to find the nth hexagonal number.


def cal_electbill(units):
 if(units < 50):
    amount = units * 2.60
    surcharge = 25
 elif(units <= 100):
    amount = 130 + ((units - 50) * 3.25)
    surcharge = 35
 elif(units <= 200):
    amount = 130 + 162.50 + ((units - 100) * 5.26)
    surcharge = 45
 else:
    amount = 130 + 162.50 + 526 + ((units - 200) * 8.45)
    surcharge = 75
 total = amount + surcharge
 return total

assert cal_electbill(75)==246.25
assert cal_electbill(265)==1442.75
assert cal_electbill(100)==327.5

Write a function to calculate electricity bill.


from array import array
def zero_count(nums):
    n = len(nums)
    n1 = 0
    for x in nums:
        if x == 0:
            n1 += 1
        else:
          None
    return round(n1/n,2)

Write a function to find the ration of zeroes in an array of integers.


def is_Sum_Of_Powers_Of_Two(n):
    if (n % 2 == 1):
        return False
    else:
        return True

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

Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.


def circle_circumference(r):
  perimeter=2*3.1415*r
  return perimeter

Write a function to find the circumference of a circle.


def extract_singly(test_list):
  res = []
  temp = set()
  for inner in test_list:
    for ele in inner:
      if not ele in temp:
        temp.add(ele)
        res.append(ele)
  return (res)

Write a function to extract elements that occur singly in the given tuple list.


def pancake_sort(nums):
    arr_len = len(nums)
    while arr_len > 1:
        mi = nums.index(max(nums[0:arr_len]))
        nums = nums[mi::-1] + nums[mi+1:len(nums)]
        nums = nums[arr_len-1::-1] + nums[arr_len:len(nums)]
        arr_len -= 1
    return nums

Write a function to sort a list of elements using pancake sort.


def count_samepair(list1,list2,list3):
    result = sum(m == n == o for m, n, o in zip(list1,list2,list3))
    return result

Write a function to count the same pair in three given lists.


def find_lists(Input):
	if isinstance(Input, list):
		return 1
	else:
		return len(Input)

Write a function to find number of lists present in the given tuple.


def sum_Pairs(arr,n):
    sum = 0
    for i in range(n - 1,-1,-1):
        sum += i*arr[i] - (n-1-i) * arr[i]
    return sum

Write a python function to find the sum of absolute differences in all pairs of the given array.


def max_Abs_Diff(arr,n):
    minEle = arr[0]
    maxEle = arr[0]
    for i in range(1, n):
        minEle = min(minEle,arr[i])
        maxEle = max(maxEle,arr[i])
    return (maxEle - minEle)

Write a python function to find the maximum difference between any two elements in a given array.


def ascii_value_string(str1):
  for i in range(len(str1)):
   return ord(str1[i])

Write a function to find the ascii value of total characters in a string.


def max_path_sum(tri, m, n):
	for i in range(m-1, -1, -1):
		for j in range(i+1):
			if (tri[i+1][j] > tri[i+1][j+1]):
				tri[i][j] += tri[i+1][j]
			else:
				tri[i][j] += tri[i+1][j+1]
	return tri[0][0]

Write a function to find the maximum total path sum in the given triangle.


def sum_digits_single(x) :
    ans = 0
    while x :
        ans += x % 10
        x //= 10
    return ans
def closest(x) :
    ans = 0
    while (ans * 10 + 9 <= x) :
        ans = ans * 10 + 9
    return ans
def sum_digits_twoparts(N) :
    A = closest(N)
    return sum_digits_single(A) + sum_digits_single(N - A)

assert sum_digits_twoparts(35)==17
assert sum_digits_twoparts(7)==7
assert sum_digits_twoparts(100)==19

Write a function to divide a number into two parts such that the sum of digits is maximum.


def longest_subseq_with_diff_one(arr, n):
	dp = [1 for i in range(n)]
	for i in range(n):
		for j in range(i):
			if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
				dp[i] = max(dp[i], dp[j]+1)
	result = 1
	for i in range(n):
		if (result < dp[i]):
			result = dp[i]
	return result

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

Write a function to find the longest subsequence such that the difference between adjacents is one for the given array.


def does_Contain_B(a,b,c):
    if (a == b):
        return True
    if ((b - a) * c > 0 and (b - a) % c == 0):
        return True
    return False

assert does_Contain_B(1,7,3) == True
assert does_Contain_B(1,-3,5) == False
assert does_Contain_B(3,2,5) == False

Write a python function to find whether the given number is present in the infinite sequence or not.


def gcd(p,q):
    while q != 0:
        p, q = q,p%q
    return p
def is_coprime(x,y):
    return gcd(x,y) == 1

assert is_coprime(17,13) == True
assert is_coprime(15,21) == False
assert is_coprime(25,45) == False

Write a python function to check whether the given number is co-prime or not.


def merge(a,b):
    c = []
    while len(a) != 0 and len(b) != 0:
        if a[0] < b[0]:
            c.append(a[0])
            a.remove(a[0])
        else:
            c.append(b[0])
            b.remove(b[0])
    if len(a) == 0:
        c += b
    else:
        c += a
    return c
def merge_sort(x):
    if len(x) == 0 or len(x) == 1:
        return x
    else:
        middle = len(x)//2
        a = merge_sort(x[:middle])
        b = merge_sort(x[middle:])
        return merge(a,b)

Write a function to sort the given array by using merge sort.


def parabola_vertex(a, b, c):
  vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
  return vertex

Write a function to find the vertex of a parabola.


def specified_element(nums, N):
    result = [i[N] for i in nums]
    return result

Write a function to extract every specified element from a given two dimensional list.


def even_bit_toggle_number(n) :
    res = 0; count = 0; temp = n
    while (temp > 0) :
        if (count % 2 == 1) :
            res = res | (1 << count)
        count = count + 1
        temp >>= 1
    return n ^ res

assert even_bit_toggle_number(10) == 0
assert even_bit_toggle_number(20) == 30
assert even_bit_toggle_number(30) == 20

Write a python function to toggle all even bits of a given number.


def tuple_int_str(tuple_str):
    result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
    return result

Write a function to convert a tuple of string values to a tuple of integer values.


from itertools import groupby
def encode_list(list1):
    return [[len(list(group)), key] for key, group in groupby(list1)]

Write a function to reflect the run-length encoding from a list.


def min_Ops(arr,n,k):
    max1 = max(arr)
    res = 0
    for i in range(0,n):
        if ((max1 - arr[i]) % k != 0):
            return -1
        else:
            res += (max1 - arr[i]) / k
    return int(res)

Write a python function to find k number of operations required to make all elements equal.


def month_season(month,days):
 if month in ('January', 'February', 'March'):
	 season = 'winter'
 elif month in ('April', 'May', 'June'):
	 season = 'spring'
 elif month in ('July', 'August', 'September'):
	 season = 'summer'
 else:
	 season = 'autumn'
 if (month == 'March') and (days > 19):
	 season = 'spring'
 elif (month == 'June') and (days > 20):
	 season = 'summer'
 elif (month == 'September') and (days > 21):
	 season = 'autumn'
 elif (month == 'October') and (days > 21):
	 season = 'autumn'
 elif (month == 'November') and (days > 21):
	 season = 'autumn'
 elif (month == 'December') and (days > 20):
	 season = 'winter'
 return season

Write a function to print the season for the given month and day.


def solution (a, b, n):
	i = 0
	while i * a <= n:
		if (n - (i * a)) % b == 0:
			return ("x = ",i ,", y = ",
			int((n - (i * a)) / b))
			return 0
		i = i + 1
	return ("No solution")

assert solution(4, 2, 7) == 'No solution'

Write a function to find x and y that satisfies ax + by = n.


def remove_elements(list1, list2):
    result = [x for x in list1 if x not in list2]
    return result

Write a function to remove all elements from a given list present in another list.


def sum_series(n):
  if n < 1:
    return 0
  else:
    return n + sum_series(n - 2)

assert sum_series(6)==12
assert sum_series(10)==30
assert sum_series(9)==25

Write a function to calculate the sum of the positive integers of n+(n-2)+(n-4)... (until n-x =< 0).


from math import tan, pi
def area_polygon(s,l):
  area = s * (l ** 2) / (4 * tan(pi / s))
  return area

Write a function to calculate the area of a regular polygon.


import math
def divSum(n):
    sum = 1;
    i = 2;
    while(i * i <= n):
        if (n % i == 0):
            sum = (sum + i +math.floor(n / i));
        i += 1;
    return sum;
def areEquivalent(num1,num2):
    return divSum(num1) == divSum(num2);

assert areEquivalent(36,57) == False
assert areEquivalent(2,4) == False
assert areEquivalent(23,47) == True

Write a python function to check whether the sum of divisors are same or not.


def count_char_position(str1):
    count_chars = 0
    for i in range(len(str1)):
        if ((i == ord(str1[i]) - ord('A')) or
            (i == ord(str1[i]) - ord('a'))):
            count_chars += 1
    return count_chars

assert count_char_position("xbcefg") == 2

assert count_char_position("ABcED") == 3

assert count_char_position("AbgdeF") == 5

Write a python function to count characters at same position in a given string (lower and uppercase characters) as in english alphabet.


def find_even_Pair(A,N):
    evenPair = 0
    for i in range(0,N):
        for j in range(i+1,N):
            if ((A[i] ^ A[j]) % 2 == 0):
                evenPair+=1
    return evenPair;

Write a python function to count the pairs with xor as an even number.


def next_Power_Of_2(n):
    count = 0;
    if (n and not(n & (n - 1))):
        return n
    while( n != 0):
        n >>= 1
        count += 1
    return 1 << count;

assert next_Power_Of_2(0) == 1
assert next_Power_Of_2(5) == 8
assert next_Power_Of_2(17) == 32

Write a python function to find smallest power of 2 greater than or equal to n.


def frequency(a,x):
    count = 0
    for i in a:
        if i == x: count += 1
    return count

Write a python function to find the frequency of a number in a given array.


def get_pell(n):
	if (n <= 2):
		return n
	a = 1
	b = 2
	for i in range(3, n+1):
		c = 2 * b + a
		a = b
		b = c
	return b

assert get_pell(4) == 12
assert get_pell(7) == 169
assert get_pell(8) == 408

Write a function to calculate the nth pell number.


def sum_range_list(list1, m, n):
    sum_range = 0
    for i in range(m, n+1, 1):
        sum_range += list1[i]
    return sum_range

Write a function to find sum of the numbers in a list between the indices of a specified range.


import math
def perimeter_pentagon(a):
  perimeter=(5*a)
  return perimeter

assert perimeter_pentagon(5)==25
assert perimeter_pentagon(10)==50
assert perimeter_pentagon(15)==75

Write a function to find the perimeter of a pentagon.


def count_occurance(s):
  count=0
  for i in range(len(s)):
    if (s[i]== 's' and s[i+1]=='t' and s[i+2]== 'd'):
      count = count + 1
  return count

assert count_occurance("letstdlenstdporstd") == 3

assert count_occurance("truststdsolensporsd") == 1

assert count_occurance("makestdsostdworthit") == 2

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


import re
def remove_splchar(text):
 pattern = re.compile('[\W_]+')
 return (pattern.sub('', text))

assert remove_splchar('python  @#&^%$*program123')==('pythonprogram123')

assert remove_splchar('python %^$@!^&*()  programming24%$^^()    language')==('pythonprogramming24language')

assert remove_splchar('python   ^%&^()(+_)(_^&67)                  program')==('python67program')

Write a function to remove everything except alphanumeric characters from a string.


def group_keyvalue(l):
    result = {}
    for k, v in l:
         result.setdefault(k, []).append(v)
    return result

Write a function to group a sequence of key-value pairs into a dictionary of lists.


def is_valid_parenthese( str1):
        stack, pchar = [], {"(": ")", "{": "}", "[": "]"}
        for parenthese in str1:
            if parenthese in pchar:
                stack.append(parenthese)
            elif len(stack) == 0 or pchar[stack.pop()] != parenthese:
                return False
        return len(stack) == 0

Write a function to verify validity of a string of parentheses.


def perimeter_triangle(a,b,c):
  perimeter=a+b+c
  return perimeter

Write a function to find the perimeter of a triangle.


def answer(L,R):
    if (2 * L <= R):
        return (L ,2*L)
    else:
        return (-1)

assert answer(3,8) == (3,6)
assert answer(2,6) == (2,4)
assert answer(1,3) == (1,2)

Write a python function to find two distinct numbers such that their lcm lies within the given range.


import re
def string_literals(patterns,text):
  for pattern in patterns:
     if re.search(pattern,  text):
       return ('Matched!')
     else:
       return ('Not Matched!')

assert string_literals(['program'],'python language')==('Not Matched!')

assert string_literals(['python'],'programming language')==('Not Matched!')

Write a function to search some literals strings in a string.


def is_num_keith(x):
	terms = []
	temp = x
	n = 0
	while (temp > 0):
		terms.append(temp % 10)
		temp = int(temp / 10)
		n+=1
	terms.reverse()
	next_term = 0
	i = n
	while (next_term < x):
		next_term = 0
		for j in range(1,n+1):
			next_term += terms[i - j]
		terms.append(next_term)
		i+=1
	return (next_term == x)

assert is_num_keith(14) == True
assert is_num_keith(12) == False
assert is_num_keith(197) == True

Write a function to find if the given number is a keith number or not.


from math import radians, sin, cos, acos
def distance_lat_long(slat,slon,elat,elon):
 dist = 6371.01 * acos(sin(slat)*sin(elat) + cos(slat)*cos(elat)*cos(slon - elon))
 return dist

Write a function to calculate distance between two points using latitude and longitude.


def common_prefix_util(str1, str2):
	result = "";
	n1 = len(str1)
	n2 = len(str2)
	i = 0
	j = 0
	while i <= n1 - 1 and j <= n2 - 1:
		if (str1[i] != str2[j]):
			break
		result += str1[i]
		i += 1
		j += 1
	return (result)
def common_prefix (arr, n):
	prefix = arr[0]
	for i in range (1, n):
		prefix = common_prefix_util(prefix, arr[i])
	return (prefix)

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'

Write a function to find the longest common prefix in the given set of strings.


import re
def find_character(string):
  uppercase_characters = re.findall(r"[A-Z]", string)
  lowercase_characters = re.findall(r"[a-z]", string)
  numerical_characters = re.findall(r"[0-9]", string)
  special_characters = re.findall(r"[, .!?]", string)
  return uppercase_characters, lowercase_characters, numerical_characters, special_characters

Write a function to find uppercase, lowercase, special character and numeric values using regex.


def count_pairs(arr, n, k):
  count=0;
  for i in range(0,n):
    for j in range(i+1, n):
      if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
        count += 1
  return count

Write a function to count all the distinct pairs having a difference of k in any array.


def greater_specificnum(list,num):
 greater_specificnum=all(x >= num for x in list)
 return greater_specificnum

assert greater_specificnum([220, 330, 500],200)==True

assert greater_specificnum([12, 17, 21],20)==False

Write a function to find all the values in a list that are greater than a specified number.


def parabola_focus(a, b, c):
  focus= (((-b / (2 * a)),(((4 * a * c) - (b * b) + 1) / (4 * a))))
  return focus

Write a function to find the focus of a parabola.


import re
def check_literals(text, patterns):
  for pattern in patterns:
    if re.search(pattern,  text):
        return ('Matched!')
    else:
        return ('Not Matched!')

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!'

Write a function to search some literals strings in a string by using regex.


def longest_common_subsequence(X, Y, m, n):
    if m == 0 or n == 0:
       return 0
    elif X[m-1] == Y[n-1]:
       return 1 + longest_common_subsequence(X, Y, m-1, n-1)
    else:
       return max(longest_common_subsequence(X, Y, m, n-1), longest_common_subsequence(X, Y, m-1, n))

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

Write a function to find the longest common subsequence for the given two sequences.


def prod_Square(n):
    for i in range(2,(n) + 1):
        if (i*i < (n+1)):
            for j in range(2,n + 1):
                if ((i*i*j*j) == n):
                    return True;
    return False;

assert prod_Square(25) == False
assert prod_Square(30) == False
assert prod_Square(16) == True

Write a python function to check whether the given number can be represented by product of two squares or not.


def first_Missing_Positive(arr,n):
    ptr = 0
    for i in range(n):
        if arr[i] == 1:
            ptr = 1
            break
    if ptr == 0:
        return(1)
    for i in range(n):
        if arr[i] <= 0 or arr[i] > n:
            arr[i] = 1
    for i in range(n):
        arr[(arr[i] - 1) % n] += n
    for i in range(n):
        if arr[i] <= n:
            return(i + 1)
    return(n + 1)

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

Write a python function to find the first missing positive number.


def count_Intgral_Points(x1,y1,x2,y2):
    return ((y2 - y1 - 1) * (x2 - x1 - 1))

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

Write a python function to count the number of integral co-ordinates that lie inside a square.


def check_monthnumber(monthname3):
  if monthname3 =="April" or monthname3== "June" or monthname3== "September" or monthname3== "November":
    return True
  else:
    return False

Write a function to check whether the given month name contains 30 days or not.


def check_String(str):
    flag_l = False
    flag_n = False
    for i in str:
        if i.isalpha():
            flag_l = True
        if i.isdigit():
            flag_n = True
    return flag_l and flag_n

assert check_String('thishasboth29') == True

Write a python function to check whether a string has atleast one letter and one number.


def remove_tuple(test_tup):
  res = tuple(set(test_tup))
  return (res)

Write a function to remove the duplicates from the given tuple.


def octal_To_Decimal(n):
    num = n;
    dec_value = 0;
    base = 1;
    temp = num;
    while (temp):
        last_digit = temp % 10;
        temp = int(temp / 10);
        dec_value += last_digit*base;
        base = base * 8;
    return dec_value;

assert octal_To_Decimal(25) == 21
assert octal_To_Decimal(30) == 24
assert octal_To_Decimal(40) == 32

Write a python function to convert octal number to decimal number.


def first(arr,x,n):
    low = 0
    high = n - 1
    res = -1
    while (low <= high):
        mid = (low + high) // 2
        if arr[mid] > x:
            high = mid - 1
        elif arr[mid] < x:
            low = mid + 1
        else:
            res = mid
            high = mid - 1
    return res

Write a python function to find the first position of an element in a sorted array.


def remove_tuples(test_list, K):
  res = [ele for ele in test_list if len(ele) != K]
  return (res)

Write a function to remove all the tuples with length k.


def find_exponentio(test_tup1, test_tup2):
  res = tuple(ele1 ** ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
  return (res)

Write a function to perform the exponentiation of the given two tuples.


import math
def largest_triangle(a,b):
    if (a < 0 or b < 0):
        return -1
    area = (3 * math.sqrt(3) * pow(a, 2)) / (4 * b);
    return area

Write a function to find the largest triangle that can be inscribed in an ellipse.


def highest_Power_of_2(n):
    res = 0;
    for i in range(n, 0, -1):
        if ((i & (i - 1)) == 0):
            res = i;
            break;
    return res;

assert highest_Power_of_2(10) == 8
assert highest_Power_of_2(19) == 16
assert highest_Power_of_2(32) == 32

Write a python function to find highest power of 2 less than or equal to given number.


def position_max(list1):
    max_val = max(list1)
    max_result = [i for i, j in enumerate(list1) if j == max_val]
    return max_result

Write a function to find all index positions of the maximum values in a given list.


def chkList(lst):
    return len(set(lst)) == 1

assert chkList(['one','one','one']) == True

assert chkList(['one','Two','Three']) == False

assert chkList(['bigdata','python','Django']) == False

Write a python function to check whether the elements in a list are same or not.


def remove_even(str1):
 str2 = ''
 for i in range(1, len(str1) + 1):
    if(i % 2 != 0):
        str2 = str2 + str1[i - 1]
 return str2

Write a function to remove even characters in a string.


def hamming_Distance(n1,n2) :
    x = n1 ^ n2
    setBits = 0
    while (x > 0) :
        setBits += x & 1
        x >>= 1
    return setBits

assert hamming_Distance(4,8) == 2
assert hamming_Distance(2,4) == 2
assert hamming_Distance(1,2) == 2

Write a python function to find the hamming distance between given two integers.


def count(s,c) :
    res = 0
    for i in range(len(s)) :
        if (s[i] == c):
            res = res + 1
    return res

assert count("abcc","c") == 2
assert count("ababca","a") == 3
assert count("mnmm0pm","m") == 4

Write a python function to count the occurrence of a given character in a string.


def inversion_elements(test_tup):
  res = tuple(list(map(lambda x: ~x, list(test_tup))))
  return (res)

Write a function to find the inversions of tuple elements in the given tuple list.


def concatenate_elements(test_tup):
  res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
  return (res)

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')

Write a function to perform the adjacent element concatenation in the given tuples.


def find_longest_repeating_subseq(str):
	n = len(str)
	dp = [[0 for k in range(n+1)] for l in range(n+1)]
	for i in range(1, n+1):
		for j in range(1, n+1):
			if (str[i-1] == str[j-1] and i != j):
				dp[i][j] = 1 + dp[i-1][j-1]
			else:
				dp[i][j] = max(dp[i][j-1], dp[i-1][j])
	return dp[n][n]

assert find_longest_repeating_subseq("AABEBCDD") == 3

assert find_longest_repeating_subseq("aabb") == 2

assert find_longest_repeating_subseq("aab") == 1

Write a function to count the longest repeating subsequences such that the two subsequences don’t have same string characters at same positions.


import re
def is_decimal(num):
  num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
  result = num_fetch.search(num)
  return bool(result)

assert is_decimal('123.11') == True
assert is_decimal('0.21') == True
assert is_decimal('123.1214') == False

Write a function to check the given decimal with a precision of 2 by using regex.


import heapq as hq
def heap_replace(heap,a):
  hq.heapify(heap)
  hq.heapreplace(heap, a)
  return heap

Write a function to delete the smallest element from the given heap and then insert a new item.


import re
def is_allowed_specific_char(string):
    get_char = re.compile(r'[^a-zA-Z0-9.]')
    string = get_char.search(string)
    return not bool(string)

assert is_allowed_specific_char("ABCDEFabcdef123450") == True

assert is_allowed_specific_char("*&%@#!}{") == False

assert is_allowed_specific_char("HELLOhowareyou98765") == True

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.


def count_Num(n):
    if (n == 1):
        return 1
    count = pow(2,n - 2)
    return count

assert count_Num(2) == 1
assert count_Num(3) == 2
assert count_Num(1) == 1

Write a python function to count numbers whose oth and nth bits are set.


import math
def fourth_Power_Sum(n):
    sum = 0
    for i in range(1,n+1) :
        sum = sum + (i*i*i*i)
    return sum

assert fourth_Power_Sum(2) == 17
assert fourth_Power_Sum(4) == 354
assert fourth_Power_Sum(6) == 2275

Write a python function to find the sum of fourth power of n natural numbers.


def concatenate_strings(test_tup1, test_tup2):
  res = tuple(ele1 + ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
  return (res)

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')

Write a function to perform the concatenation of two string tuples.


import math
def degree_radian(radian):
 degree = radian*(180/math.pi)
 return degree

Write a function to convert radians to degrees.


def decode_list(alist):
    def aux(g):
        if isinstance(g, list):
            return [(g[1], range(g[0]))]
        else:
            return [(g, [0])]
    return [x for g in alist for x, R in aux(g) for i in R]

Write a function to decode a run-length encoded given list.


def check_subset_list(list1, list2):
    l1, l2 = list1[0], list2[0]
    exist = True
    for i in list2:
        if i not in list1:
            exist = False
    return exist

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


def first_Repeated_Char(str):
    h = {}
    for ch in str:
        if ch in h:
            return ch;
        else:
            h[ch] = 0
    return '\0'

assert first_Repeated_Char("Google") == "o"

assert first_Repeated_Char("data") == "a"

assert first_Repeated_Char("python") == '\0'

Write a python function to find the first repeated character in a given string.


import math
def min_Operations(A,B):
    if (A > B):
        swap(A,B)
    B = B // math.gcd(A,B);
    return B - 1

assert min_Operations(2,4) == 1
assert min_Operations(4,10) == 4
assert min_Operations(1,4) == 3

Write a python function to find the minimum operations required to make two numbers equal.


def extract_min_max(test_tup, K):
  res = []
  test_tup = list(test_tup)
  temp = sorted(test_tup)
  for idx, val in enumerate(temp):
    if idx < K or idx >= len(temp) - K:
      res.append(val)
  res = tuple(res)
  return (res)

Write a function to extract maximum and minimum k elements in the given tuple.


import re
def replace_max_specialchar(text,n):
 return (re.sub("[ ,.]", ":", text, n))

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')

Write a function to replace maximum n occurrences of spaces, commas, or dots with a colon.


def first_even(nums):
    first_even = next((el for el in nums if el%2==0),-1)
    return first_even

Write a python function to find the first even number in a given list of numbers.


def check_type(test_tuple):
  res = True
  for ele in test_tuple:
    if not isinstance(ele, type(test_tuple[0])):
      res = False
      break
  return (res)

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

Write a function to check if all the elements in tuple have same data type or not.


def is_majority(arr, n, x):
	i = binary_search(arr, 0, n-1, x)
	if i == -1:
		return False
	if ((i + n//2) <= (n -1)) and arr[i + n//2] == x:
		return True
	else:
		return False
def binary_search(arr, low, high, x):
	if high >= low:
		mid = (low + high)//2
		if (mid == 0 or x > arr[mid-1]) and (arr[mid] == x):
			return mid
		elif x > arr[mid]:
			return binary_search(arr, (mid + 1), high, x)
		else:
			return binary_search(arr, low, (mid -1), x)
	return -1

assert is_majority([1, 1, 1, 2, 2], 5, 1) == True

Write a function to check for majority element in the given sorted array.


def count_Set_Bits(n):
    count = 0
    while (n):
        count += n & 1
        n >>= 1
    return count

assert count_Set_Bits(2) == 1
assert count_Set_Bits(4) == 1
assert count_Set_Bits(6) == 2

Write a python function to count set bits of a given number.


def find_Min(arr,low,high):
    while (low < high):
        mid = low + (high - low) // 2;
        if (arr[mid] == arr[high]):
            high -= 1;
        elif (arr[mid] > arr[high]):
            low = mid + 1;
        else:
            high = mid;
    return arr[high];

Write a python function to find the minimum element in a sorted and rotated array.


def odd_values_string(str):
  result = ""
  for i in range(len(str)):
    if i % 2 == 0:
      result = result + str[i]
  return result

assert odd_values_string('abcdef') == 'ace'

assert odd_values_string('python') == 'pto'

assert odd_values_string('data') == 'dt'

Write a python function to remove the characters which have odd index values of a given string.


def min_of_three(a,b,c):
      if (a <= b) and (a <= c):
        smallest = a
      elif (b <= a) and (b <= c):
        smallest = b
      else:
        smallest = c
      return smallest

Write a function to find minimum of three numbers.


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

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

Write a python function to check whether all the bits are unset in the given range or not.


def re_arrange_array(arr, n):
  j=0
  for i in range(0, n):
    if (arr[i] < 0):
      temp = arr[i]
      arr[i] = arr[j]
      arr[j] = temp
      j = j + 1
  return arr

Write a function to re-arrange the elements of the given array so that all negative elements appear before positive ones.


def replace_blank(str1,char):
 str2 = str1.replace(' ', char)
 return str2

assert replace_blank("python program language",'$')==("python$program$language")

Write a function to replace blank spaces with any character in a string.


Write a function to find the maximum sum in the given right triangle of numbers.


import heapq
def larg_nnum(list1,n):
 largest=heapq.nlargest(n,list1)
 return largest

Write a function to get the n largest items from a dataset.


def lateralsuface_cylinder(r,h):
  lateralsurface= 2*3.1415*r*h
  return lateralsurface

Write a function to find the lateral surface area of a cylinder.


def volume_cube(l):
  volume = l * l * l
  return volume

assert volume_cube(3)==27
assert volume_cube(2)==8
assert volume_cube(5)==125

Write a function to find the volume of a cube.


def even_bit_set_number(n):
    count = 0;res = 0;temp = n
    while(temp > 0):
        if (count % 2 == 1):
            res |= (1 << count)
        count+=1
        temp >>= 1
    return (n | res)

assert even_bit_set_number(10) == 10
assert even_bit_set_number(20) == 30
assert even_bit_set_number(30) == 30

Write a python function to set all even bits of a given number.


def No_of_Triangle(N,K):
    if (N < K):
        return -1;
    else:
        Tri_up = 0;
        Tri_up = ((N - K + 1) *(N - K + 2)) // 2;
        Tri_down = 0;
        Tri_down = ((N - 2 * K + 1) *(N - 2 * K + 2)) // 2;
        return Tri_up + Tri_down;

assert No_of_Triangle(4,2) == 7
assert No_of_Triangle(4,3) == 3
assert No_of_Triangle(1,3) == -1

Write a python function to count the maximum number of equilateral triangles that can be formed within a given equilateral triangle.


from collections import Counter
def check_occurences(test_list):
  res = dict(Counter(tuple(ele) for ele in map(sorted, test_list)))
  return  (res)

Write a function to check the occurrences of records which occur similar times in the given tuples.


def number_of_substrings(str):
	str_len = len(str);
	return int(str_len * (str_len + 1) / 2);

assert number_of_substrings("abcd") == 10

assert number_of_substrings("abcde") == 15

Write a python function to count number of non-empty substrings of a given string.


def get_total_number_of_sequences(m,n):
	T=[[0 for i in range(n+1)] for i in range(m+1)]
	for i in range(m+1):
		for j in range(n+1):
			if i==0 or j==0:
				T[i][j]=0
			elif i<j:
				T[i][j]=0
			elif j==1:
				T[i][j]=i
			else:
				T[i][j]=T[i-1][j]+T[i//2][j-1]
	return T[m][n]

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

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.


def replace_list(list1,list2):
 list1[-1:] = list2
 replace_list=list1
 return replace_list

Write a function to replace the last element of the list with another list.


def array_3d(m,n,o):
 array_3d = [[ ['*' for col in range(m)] for col in range(n)] for row in range(o)]
 return array_3d

Write a function to generate a 3d array having each element as '*'.


def count_charac(str1):
 total = 0
 for i in str1:
    total = total + 1
 return total

Write a function to count total characters in a string.


def sort_on_occurence(lst):
	dct = {}
	for i, j in lst:
		dct.setdefault(i, []).append(j)
	return ([(i, *dict.fromkeys(j), len(j))
				for i, j in dct.items()])

Write a function to sort the given list based on the occurrence of first element of tuples.


import math
def next_Perfect_Square(N):
    nextN = math.floor(math.sqrt(N)) + 1
    return nextN * nextN

assert next_Perfect_Square(35) == 36
assert next_Perfect_Square(6) == 9
assert next_Perfect_Square(9) == 16

Write a python function to find the next perfect square greater than a given number.


def max_sum(arr, n):
	MSIBS = arr[:]
	for i in range(n):
		for j in range(0, i):
			if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
				MSIBS[i] = MSIBS[j] + arr[i]
	MSDBS = arr[:]
	for i in range(1, n + 1):
		for j in range(1, i):
			if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
				MSDBS[-i] = MSDBS[-j] + arr[-i]
	max_sum = float("-Inf")
	for i, j, k in zip(MSIBS, MSDBS, arr):
		max_sum = max(max_sum, i + j - k)
	return max_sum

Write a function to find the maximum sum of bi-tonic sub-sequence for the given array.


def babylonian_squareroot(number):
    if(number == 0):
        return 0;
    g = number/2.0;
    g2 = g + 1;
    while(g != g2):
        n = number/ g;
        g2 = g;
        g = (g + n)/2;
    return g;

Write a function for computing square roots using the babylonian method.


def lps(str):
	n = len(str)
	L = [[0 for x in range(n)] for x in range(n)]
	for i in range(n):
		L[i][i] = 1
	for cl in range(2, n+1):
		for i in range(n-cl+1):
			j = i+cl-1
			if str[i] == str[j] and cl == 2:
				L[i][j] = 2
			elif str[i] == str[j]:
				L[i][j] = L[i+1][j-1] + 2
			else:
				L[i][j] = max(L[i][j-1], L[i+1][j]);
	return L[0][n-1]

assert lps("PART OF THE JOURNEY IS PART") == 9

Write a function to find the longest palindromic subsequence in the given string.


def harmonic_sum(n):
  if n < 2:
    return 1
  else:
    return 1 / n + (harmonic_sum(n - 1))

Write a function to calculate the harmonic sum of n-1.


def intersection_array(array_nums1,array_nums2):
 result = list(filter(lambda x: x in array_nums1, array_nums2))
 return result

Write a function to find the intersection of two arrays using lambda function.


def count_X(tup, x):
    count = 0
    for ele in tup:
        if (ele == x):
            count = count + 1
    return count

Write a python function to count the occcurences of an element in a tuple.


def insert_element(list,element):
 list = [v for elt in list for v in (element, elt)]
 return 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']

Write a function to insert an element before each element of a list.


import cmath
def convert(numbers):
  num = cmath.polar(numbers)
  return (num)

Write a python function to convert complex numbers to polar coordinates.


def count_integer(list1):
    ctr = 0
    for i in list1:
        if isinstance(i, int):
            ctr = ctr + 1
    return ctr

assert count_integer([1,2,'abc',1.2]) == 2

Write a python function to count integers from a given list.


import re
def words_ae(text):
 list = re.findall("[ae]\w+", text)
 return list

assert words_ae("python programe language")==['ame','anguage']

assert words_ae("assert statement")==['assert', 'atement']

Write a function to find all words starting with 'a' or 'e' in a given string.


from itertools import combinations_with_replacement
def combinations_colors(l, n):
    return list(combinations_with_replacement(l,n))

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')]

Write a function to choose specified number of colours from three different colours and generate all the combinations with repetitions.


def count_Primes_nums(n):
    ctr = 0
    for num in range(n):
        if num <= 1:
            continue
        for i in range(2,num):
            if (num % i) == 0:
                break
        else:
            ctr += 1
    return ctr

assert count_Primes_nums(5) == 2
assert count_Primes_nums(10) == 4
assert count_Primes_nums(100) == 25

Write a python function to count the number of prime numbers less than a given non-negative number.


def swap_numbers(a,b):
 temp = a
 a = b
 b = temp
 return (a,b)

Write a function to swap two numbers.


def count_odd(array_nums):
   count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
   return count_odd

Write a function to find number of odd elements in the given list using lambda function.


def maximize_elements(test_tup1, test_tup2):
  res = tuple(tuple(max(a, b) for a, b in zip(tup1, tup2))
   for tup1, tup2 in zip(test_tup1, test_tup2))
  return (res)

Write a function to maximize the given two tuples.


def newman_prime(n):
	if n == 0 or n == 1:
		return 1
	return 2 * newman_prime(n - 1) + newman_prime(n - 2)

assert newman_prime(3) == 7
assert newman_prime(4) == 17
assert newman_prime(5) == 41

Write a function to find the nth newman–shanks–williams prime number.