mr44/mbsearch huggingface dataset:
Task: Write a function to find the longest chain which can be formed from the given set of pairs.

Solution:
class Pair(object): 
	def __init__(self, a, b): 
		self.a = a 
		self.b = b 
def max_chain_length(arr, n): 
	max = 0
	mcl = [1 for i in range(n)] 
	for i in range(1, n): 
		for j in range(0, i): 
			if (arr[i].a > arr[j].b and
				mcl[i] < mcl[j] + 1): 
				mcl[i] = mcl[j] + 1
	for i in range(n): 
		if (max < mcl[i]): 
			max = mcl[i] 
	return max


Tests:
assert max_chain_length([Pair(5, 24), Pair(15, 25),Pair(27, 40), Pair(50, 60)], 4) == 3
assert max_chain_length([Pair(1, 2), Pair(3, 4),Pair(5, 6), Pair(7, 8)], 4) == 4
assert max_chain_length([Pair(19, 10), Pair(11, 12),Pair(13, 14), Pair(15, 16), Pair(31, 54)], 5) == 5
Task: Write a python function to find the first repeated character in a given string.

Solution:
def first_repeated_char(str1):
  for index,c in enumerate(str1):
    if str1[:index+1].count(c) > 1:
      return c 
  return "None"


Tests:
assert first_repeated_char("abcabc") == "a"
assert first_repeated_char("abc") == "None"
assert first_repeated_char("123123") == "1"
Task: Write a function to get a lucid number smaller than or equal to n.

Solution:
def get_ludic(n):
	ludics = []
	for i in range(1, n + 1):
		ludics.append(i)
	index = 1
	while(index != len(ludics)):
		first_ludic = ludics[index]
		remove_index = index + first_ludic
		while(remove_index < len(ludics)):
			ludics.remove(ludics[remove_index])
			remove_index = remove_index + first_ludic - 1
		index += 1
	return ludics


Tests:
assert get_ludic(10) == [1, 2, 3, 5, 7]
assert get_ludic(25) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25]
assert get_ludic(45) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43]
Task: Write a function to reverse words in a given string.

Solution:
def reverse_words(s):
        return ' '.join(reversed(s.split()))


Tests:
assert reverse_words("python program")==("program python")
assert reverse_words("java language")==("language java")
assert reverse_words("indian man")==("man indian")
Task: Write a function to check if the given integer is a prime number.

Solution:
def prime_num(num):
  if num >=1:
   for i in range(2, num//2):
     if (num % i) == 0:
                return False
     else:
                return True
  else:
          return False


Tests:
assert prime_num(13)==True
assert prime_num(7)==True
assert prime_num(-1010)==False
Task: Write a function to convert degrees to radians.

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


Tests:
assert radian_degree(90)==1.5707963267948966
assert radian_degree(60)==1.0471975511965976
assert radian_degree(120)==2.0943951023931953
Task: Write a function to search a literals string in a string and also find the location within the original string where the pattern occurs by using regex.

Solution:
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
def find_literals(text, pattern):
  match = re.search(pattern, text)
  s = match.start()
  e = match.end()
  return (match.re.pattern, s, e)


Tests:
assert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)
assert find_literals('Its been a very crazy procedure right', 'crazy') == ('crazy', 16, 21)
assert find_literals('Hardest choices required strongest will', 'will') == ('will', 35, 39)
Task: Write a python function to find nth bell number.

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


Tests:
assert bell_Number(2) == 2
assert bell_Number(3) == 5
assert bell_Number(4) == 15
Task: Write a python function to find minimum possible value for the given periodic function.

Solution:
def floor_Min(A,B,N):
    x = max(B - 1,N)
    return (A*x) // B


Tests:
assert floor_Min(10,20,30) == 15
assert floor_Min(1,2,1) == 0
assert floor_Min(11,10,9) == 9
Task: Write a python function to remove the k'th element from a given list.

Solution:
def remove_kth_element(list1, L):
    return  list1[:L-1] + list1[L:]


Tests:
assert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 3, 4, 4, 5, 1]
assert remove_kth_element([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4],4)==[0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]
assert remove_kth_element([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10],5)==[10,10,15,19, 18, 17, 26, 26, 17, 18, 10]
Task: Write a function to find the maximum of nth column from the given tuple list.

Solution:
def max_of_nth(test_list, N):
  res = max([sub[N] for sub in test_list])
  return (res) 


Tests:
assert max_of_nth([(5, 6, 7), (1, 3, 5), (8, 9, 19)], 2) == 19
assert max_of_nth([(6, 7, 8), (2, 4, 6), (9, 10, 20)], 1) == 10
assert max_of_nth([(7, 8, 9), (3, 5, 7), (10, 11, 21)], 1) == 11
Task: Write a python function to merge the first and last elements separately in a list of lists.

Solution:
def merge(lst):  
    return [list(ele) for ele in list(zip(*lst))] 


Tests:
assert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]
assert merge([[1, 2], [3, 4], [5, 6], [7, 8]]) == [[1, 3, 5, 7], [2, 4, 6, 8]]
assert merge([['x', 'y','z' ], ['a', 'b','c'], ['m', 'n','o']]) == [['x', 'a', 'm'], ['y', 'b', 'n'],['z', 'c','o']]
Task: Write a function to find the maximum value in record list as tuple attribute in the given tuple list.

Solution:
def maximum_value(test_list):
  res = [(key, max(lst)) for key, lst in test_list]
  return (res) 


Tests:
assert maximum_value([('key1', [3, 4, 5]), ('key2', [1, 4, 2]), ('key3', [9, 3])]) == [('key1', 5), ('key2', 4), ('key3', 9)]
assert maximum_value([('key1', [4, 5, 6]), ('key2', [2, 5, 3]), ('key3', [10, 4])]) == [('key1', 6), ('key2', 5), ('key3', 10)]
assert maximum_value([('key1', [5, 6, 7]), ('key2', [3, 6, 4]), ('key3', [11, 5])]) == [('key1', 7), ('key2', 6), ('key3', 11)]
Task: Write a function to find the cumulative sum of all the values that are present in the given tuple list.

Solution:
def cummulative_sum(test_list):
  res = sum(map(sum, test_list))
  return (res)


Tests:
assert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30
assert cummulative_sum([(2, 4), (6, 7, 8), (3, 7)]) == 37
assert cummulative_sum([(3, 5), (7, 8, 9), (4, 8)]) == 44
Task: Write a function to find average value of the numbers in a given tuple of tuples.

Solution:
def average_tuple(nums):
    result = [sum(x) / len(x) for x in zip(*nums)]
    return result


Tests:
assert average_tuple(((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4)))==[30.5, 34.25, 27.0, 23.25]
assert average_tuple(((1, 1, -5), (30, -15, 56), (81, -60, -39), (-10, 2, 3)))== [25.5, -18.0, 3.75]
assert average_tuple( ((100, 100, 100, 120), (300, 450, 560, 450), (810, 800, 390, 320), (10, 20, 30, 40)))==[305.0, 342.5, 270.0, 232.5]
Task: Write a function to perfom the modulo of tuple elements in the given two tuples.

Solution:
def tuple_modulo(test_tup1, test_tup2):
  res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)) 
  return (res) 


Tests:
assert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)
assert tuple_modulo((11, 5, 6, 7), (6, 7, 8, 6)) == (5, 5, 6, 1)
assert tuple_modulo((12, 6, 7, 8), (7, 8, 9, 7)) == (5, 6, 7, 1)
Task: Write a function to check for the number of jumps required of given length to reach a point of form (d, 0) from origin in a 2d plane.

Solution:
def min_Jumps(a, b, d): 
    temp = a 
    a = min(a, b) 
    b = max(temp, b) 
    if (d >= b): 
        return (d + b - 1) / b 
    if (d == 0): 
        return 0
    if (d == a): 
        return 1
    else:
        return 2


Tests:
assert min_Jumps(3,4,11)==3.5
assert min_Jumps(3,4,0)==0
assert min_Jumps(11,14,11)==1
Task: Write a function to divide two lists using map and lambda function.

Solution:
def div_list(nums1,nums2):
  result = map(lambda x, y: x / y, nums1, nums2)
  return list(result)


Tests:
assert div_list([4,5,6],[1, 2, 3])==[4.0,2.5,2.0]
assert div_list([3,2],[1,4])==[3.0, 0.5]
assert div_list([90,120],[50,70])==[1.8, 1.7142857142857142]
Task: Write a function to move all the numbers in it to the given string.

Solution:
def move_num(test_str):
  res = ''
  dig = ''
  for ele in test_str:
    if ele.isdigit():
      dig += ele
    else:
      res += ele
  res += dig
  return (res) 


Tests:
assert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'
assert move_num('Avengers124Assemble') == 'AvengersAssemble124'
assert move_num('Its11our12path13to14see15things16do17things') == 'Itsourpathtoseethingsdothings11121314151617'
Task: Write a function to find the largest subset where each pair is divisible.

Solution:
def largest_subset(a, n):
	dp = [0 for i in range(n)]
	dp[n - 1] = 1; 
	for i in range(n - 2, -1, -1):
		mxm = 0;
		for j in range(i + 1, n):
			if a[j] % a[i] == 0 or a[i] % a[j] == 0:
				mxm = max(mxm, dp[j])
		dp[i] = 1 + mxm
	return max(dp)


Tests:
assert largest_subset([ 1, 3, 6, 13, 17, 18 ], 6) == 4
assert largest_subset([10, 5, 3, 15, 20], 5) == 3
assert largest_subset([18, 1, 3, 6, 13, 17], 6) == 4
Task: Write a function to increment the numeric values in the given strings by k.

Solution:
def increment_numerics(test_list, K):
  res = [str(int(ele) + K) if ele.isdigit() else ele for ele in test_list]
  return res 


Tests:
assert increment_numerics(["MSM", "234", "is", "98", "123", "best", "4"] , 6) == ['MSM', '240', 'is', '104', '129', 'best', '10']
assert increment_numerics(["Dart", "356", "is", "88", "169", "Super", "6"] , 12) == ['Dart', '368', 'is', '100', '181', 'Super', '18']
assert increment_numerics(["Flutter", "451", "is", "44", "96", "Magnificent", "12"] , 33) == ['Flutter', '484', 'is', '77', '129', 'Magnificent', '45']
Task: Write a function to find the median of two sorted arrays of same size.

Solution:
def get_median(arr1, arr2, n):
  i = 0
  j = 0
  m1 = -1
  m2 = -1
  count = 0
  while count < n + 1:
    count += 1
    if i == n:
      m1 = m2
      m2 = arr2[0]
      break
    elif j == n:
      m1 = m2
      m2 = arr1[0]
      break
    if arr1[i] <= arr2[j]:
      m1 = m2
      m2 = arr1[i]
      i += 1
    else:
      m1 = m2
      m2 = arr2[j]
      j += 1
  return (m1 + m2)/2


Tests:
assert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0
assert get_median([2, 4, 8, 9], [7, 13, 19, 28], 4) == 8.5
assert get_median([3, 6, 14, 23, 36, 42], [2, 18, 27, 39, 49, 55], 6) == 25.0
Task: Write a function to find the n-th power of individual elements in a list using lambda function.

Solution:
def nth_nums(nums,n):
 nth_nums = list(map(lambda x: x ** n, nums))
 return nth_nums


Tests:
assert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2)==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
assert nth_nums([10,20,30],3)==([1000, 8000, 27000])
assert nth_nums([12,15],5)==([248832, 759375])
Task: Write a python function to convert the given string to upper case.

Solution:
def is_upper(string):
  return (string.upper())


Tests:
assert is_upper("person") =="PERSON"
assert is_upper("final") == "FINAL"
assert is_upper("Valid") == "VALID"
Task: Write a python function to interchange first and last elements in a given list.

Solution:
def swap_List(newList): 
    size = len(newList) 
    temp = newList[0] 
    newList[0] = newList[size - 1] 
    newList[size - 1] = temp   
    return newList 


Tests:
assert swap_List([1,2,3]) == [3,2,1]
assert swap_List([1,2,3,4,4]) == [4,2,3,4,1]
assert swap_List([4,5,6]) == [6,5,4]
Task: Write a python function to find the largest triangle that can be inscribed in the semicircle.

Solution:
def triangle_area(r) :  
    if r < 0 : 
        return -1
    return r * r 


Tests:
assert triangle_area(0) == 0
assert triangle_area(-1) == -1
assert triangle_area(2) == 4
Task: Write a python function to find the smallest missing number from the given array.

Solution:
def find_First_Missing(array,start,end): 
    if (start > end): 
        return end + 1
    if (start != array[start]): 
        return start; 
    mid = int((start + end) / 2) 
    if (array[mid] == mid): 
        return find_First_Missing(array,mid+1,end) 
    return find_First_Missing(array,start,mid) 


Tests:
assert find_First_Missing([0,1,2,3],0,3) == 4
assert find_First_Missing([0,1,2,6,9],0,4) == 3
assert find_First_Missing([2,3,5,8,9],0,4) == 0
Task: Write a function to replace all spaces in the given string with character * list item * list item * list item * list item '%20'.

Solution:
MAX=1000;
def replace_spaces(string):
  string=string.strip()
  i=len(string)
  space_count=string.count(' ')
  new_length = i + space_count*2
  if new_length > MAX:
    return -1
  index = new_length-1
  string=list(string)
  for f in range(i-2, new_length-2):
    string.append('0')
  for j in range(i-1, 0, -1):
    if string[j] == ' ':
      string[index] = '0'
      string[index-1] = '2'
      string[index-2] = '%'
      index=index-3
    else:
      string[index] = string[j]
      index -= 1
  return ''.join(string)


Tests:
assert replace_spaces("My Name is Dawood") == 'My%20Name%20is%20Dawood'
assert replace_spaces("I am a Programmer") == 'I%20am%20a%20Programmer'
assert replace_spaces("I love Coding") == 'I%20love%20Coding'
Task: Write a python function to find even numbers from a mixed list.

Solution:
def Split(list): 
    ev_li = [] 
    for i in list: 
        if (i % 2 == 0): 
            ev_li.append(i)  
    return ev_li


Tests:
assert Split([1,2,3,4,5]) == [2,4]
assert Split([4,5,6,7,8,0,1]) == [4,6,8,0]
assert Split ([8,12,15,19]) == [8,12]
Task: Write a function to extract all the adjacent coordinates of the given coordinate tuple.

Solution:
def adjac(ele, sub = []): 
  if not ele: 
     yield sub 
  else: 
     yield from [idx for j in range(ele[0] - 1, ele[0] + 2) 
                for idx in adjac(ele[1:], sub + [j])] 
def get_coordinates(test_tup):
  res = list(adjac(test_tup))
  return (res) 


Tests:
assert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]
assert get_coordinates((4, 5)) ==[[3, 4], [3, 5], [3, 6], [4, 4], [4, 5], [4, 6], [5, 4], [5, 5], [5, 6]]
assert get_coordinates((5, 6)) == [[4, 5], [4, 6], [4, 7], [5, 5], [5, 6], [5, 7], [6, 5], [6, 6], [6, 7]]
Task: Write a function to replace whitespaces with an underscore and vice versa in a given string by using regex.

Solution:
import re
text = 'Python Exercises'
def replace_spaces(text):
  text =text.replace (" ", "_")
  return (text)
  text =text.replace ("_", " ")
  return (text)


Tests:
assert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'
assert replace_spaces('The Avengers') == 'The_Avengers'
assert replace_spaces('Fast and Furious') == 'Fast_and_Furious'
Task: Write a python function to move all zeroes to the end of the given list.

Solution:
def move_zero(num_list):
    a = [0 for i in range(num_list.count(0))]
    x = [ i for i in num_list if i != 0]
    x.extend(a)
    return (x)


Tests:
assert move_zero([1,0,2,0,3,4]) == [1,2,3,4,0,0]
assert move_zero([2,3,2,0,0,4,0,5,0]) == [2,3,2,4,5,0,0,0,0]
assert move_zero([0,1,0,1,1]) == [1,1,1,0,0]
Task: Write a python function to find the sum of xor of all pairs of numbers in the given array.

Solution:
def pair_OR_Sum(arr,n) : 
    ans = 0 
    for i in range(0,n) :    
        for j in range(i + 1,n) :   
            ans = ans + (arr[i] ^ arr[j])          
    return ans 


Tests:
assert pair_OR_Sum([5,9,7,6],4) == 47
assert pair_OR_Sum([7,3,5],3) == 12
assert pair_OR_Sum([7,3],2) == 4
Task: Write a python function to find the sum of fourth power of first n even natural numbers.

Solution:
def even_Power_Sum(n): 
    sum = 0; 
    for i in range(1,n + 1): 
        j = 2*i; 
        sum = sum + (j*j*j*j); 
    return sum; 


Tests:
assert even_Power_Sum(2) == 272
assert even_Power_Sum(3) == 1568
assert even_Power_Sum(4) == 5664
Task: Write a function to push all values into a heap and then pop off the smallest values one at a time.

Solution:
import heapq as hq
def heap_sort(iterable):
    h = []
    for value in iterable:
        hq.heappush(h, value)
    return [hq.heappop(h) for i in range(len(h))]


Tests:
assert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert heap_sort([25, 35, 22, 85, 14, 65, 75, 25, 58])==[14, 22, 25, 25, 35, 58, 65, 75, 85]
assert heap_sort( [7, 1, 9, 5])==[1,5,7,9]
Task: Write a python function to check if roots of a quadratic equation are reciprocal of each other or not.

Solution:
def Check_Solution(a,b,c): 
    if (a == c): 
        return ("Yes"); 
    else: 
        return ("No"); 


Tests:
assert Check_Solution(2,0,2) == "Yes"
assert Check_Solution(2,-5,2) == "Yes"
assert Check_Solution(1,2,3) == "No"
Task: Write a function to check whether the given amount has no profit and no loss

Solution:
def noprofit_noloss(actual_cost,sale_amount): 
  if(sale_amount == actual_cost):
    return True
  else:
    return False


Tests:
assert noprofit_noloss(1500,1200)==False
assert noprofit_noloss(100,100)==True
assert noprofit_noloss(2000,5000)==False
Task: Write a function to calculate wind chill index.

Solution:
import math
def wind_chill(v,t):
 windchill = 13.12 + 0.6215*t -  11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)
 return int(round(windchill, 0))


Tests:
assert wind_chill(120,35)==40
assert wind_chill(40,70)==86
assert wind_chill(10,100)==116
Task: Write a function to sum the length of the names of a given list of names after removing the names that start with a lowercase letter.

Solution:
def sample_nam(sample_names):
  sample_names=list(filter(lambda el:el[0].isupper() and el[1:].islower(),sample_names))
  return len(''.join(sample_names))


Tests:
assert sample_nam(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith'])==16
assert sample_nam(["php", "res", "Python", "abcd", "Java", "aaa"])==10
assert sample_nam(["abcd", "Python", "abba", "aba"])==6
Task: Write a function to remove the parenthesis area in a string.

Solution:
import re
def remove_parenthesis(items):
 for item in items:
    return (re.sub(r" ?\([^)]+\)", "", item))


Tests:
assert remove_parenthesis(["python (chrome)"])==("python")
assert remove_parenthesis(["string(.abc)"])==("string")
assert remove_parenthesis(["alpha(num)"])==("alpha")
Task: Write a function to find the nth nonagonal number.

Solution:
def is_nonagonal(n): 
	return int(n * (7 * n - 5) / 2) 


Tests:
assert is_nonagonal(10) == 325
assert is_nonagonal(15) == 750
assert is_nonagonal(18) == 1089
Task: Write a function to remove similar rows from the given tuple matrix.

Solution:
def remove_similar_row(test_list):
  res = set(sorted([tuple(sorted(set(sub))) for sub in test_list]))
  return (res) 


Tests:
assert remove_similar_row([[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]] ) == {((2, 2), (4, 6)), ((3, 2), (4, 5))}
assert remove_similar_row([[(5, 6), (4, 3)], [(3, 3), (5, 7)], [(4, 3), (5, 6)]] ) == {((4, 3), (5, 6)), ((3, 3), (5, 7))}
assert remove_similar_row([[(6, 7), (5, 4)], [(4, 4), (6, 8)], [(5, 4), (6, 7)]] ) =={((4, 4), (6, 8)), ((5, 4), (6, 7))}
Task: Write a function that matches a word containing 'z', not at the start or end of the word.

Solution:
import re
def text_match_wordz_middle(text):
        patterns = '\Bz\B'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


Tests:
assert text_match_wordz_middle("pythonzabc.")==('Found a match!')
assert text_match_wordz_middle("xyzabc.")==('Found a match!')
assert text_match_wordz_middle("  lang  .")==('Not matched!')
Task: Write a python function to reverse an array upto a given position.

Solution:
def reverse_Array_Upto_K(input, k): 
  return (input[k-1::-1] + input[k:]) 


Tests:
assert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6],4) == [4, 3, 2, 1, 5, 6]
assert reverse_Array_Upto_K([4, 5, 6, 7], 2) == [5, 4, 6, 7]
assert reverse_Array_Upto_K([9, 8, 7, 6, 5],3) == [7, 8, 9, 6, 5]
Task: Write a function to find the product of it’s kth index in the given tuples.

Solution:
def get_product(val) : 
	res = 1
	for ele in val: 
		res *= ele 
	return res 
def find_k_product(test_list, K):
  res = get_product([sub[K] for sub in test_list])
  return (res) 


Tests:
assert find_k_product([(5, 6, 7), (1, 3, 5), (8, 9, 19)], 2) == 665
assert find_k_product([(6, 7, 8), (2, 4, 6), (9, 10, 20)], 1) == 280
assert find_k_product([(7, 8, 9), (3, 5, 7), (10, 11, 21)], 0) == 210
Task: Write a python function to count number of cubes of size k in a cube of size n.

Solution:
def No_of_cubes(N,K):
    No = 0
    No = (N - K + 1)
    No = pow(No, 3)
    return No


Tests:
assert No_of_cubes(2,1) == 8
assert No_of_cubes(5,2) == 64
assert No_of_cubes(1,1) == 1
Task: Write a function to split a string at uppercase letters.

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


Tests:
assert split_upperstring("PythonProgramLanguage")==['Python','Program','Language']
assert split_upperstring("PythonProgram")==['Python','Program']
assert split_upperstring("ProgrammingLanguage")==['Programming','Language']
Task: Write a function to exchange the position of every n-th value with (n+1)th value and (n+1)th value with n-th value in a given list.

Solution:
from itertools import zip_longest, chain, tee
def exchange_elements(lst):
    lst1, lst2 = tee(iter(lst), 2)
    return list(chain.from_iterable(zip_longest(lst[1::2], lst[::2])))


Tests:
assert exchange_elements([0,1,2,3,4,5])==[1, 0, 3, 2, 5, 4] 
assert exchange_elements([5,6,7,8,9,10])==[6,5,8,7,10,9] 
assert exchange_elements([25,35,45,55,75,95])==[35,25,55,45,95,75]
Task: Write a python function to calculate the sum of the numbers in a list between the indices of a specified range.

Solution:
def sum_Range_list(nums, m, n):                                                                                                                                                                                                
    sum_range = 0                                                                                                                                                                                                         
    for i in range(m, n+1, 1):                                                                                                                                                                                        
        sum_range += nums[i]                                                                                                                                                                                                  
    return sum_range   


Tests:
assert sum_Range_list([2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12],8,10) == 29
assert sum_Range_list([1,2,3,4,5],1,2) == 5
assert sum_Range_list([1,0,1,2,5,6],4,5) == 11
Task: Write a python function to check whether the given two arrays are equal or not.

Solution:
def are_Equal(arr1,arr2,n,m):
    if (n != m):
        return False
    arr1.sort()
    arr2.sort()
    for i in range(0,n - 1):
        if (arr1[i] != arr2[i]):
            return False
    return True


Tests:
assert are_Equal([1,2,3],[3,2,1],3,3) == True
assert are_Equal([1,1,1],[2,2,2],3,3) == False
assert are_Equal([8,9],[4,5,6],2,3) == False
Task: Write a function to check if one tuple is a subset of another tuple.

Solution:
def check_subset(test_tup1, test_tup2):
  res = set(test_tup2).issubset(test_tup1)
  return (res) 


Tests:
assert check_subset((10, 4, 5, 6), (5, 10)) == True
assert check_subset((1, 2, 3, 4), (5, 6)) == False
assert check_subset((7, 8, 9, 10), (10, 8)) == True