Datasets:

md-nishat-008
/

MBPP-Bangla

task_id int64 1 974	text stringlengths 40 260	code stringlengths 30 1.33k	test_list stringlengths 71 4.16k	test_setup_code stringclasses 2 values	challenge_test_list stringclasses 12 values
601	একটি ফাংশন লিখুন যা দিয়ে দেওয়া জোড়া থেকে তৈরি করা সবচেয়ে দীর্ঘতম চেইন খুঁজে বের করতে হবে।	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 (ma...	['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']	null	[]
602	একটি প্রদত্ত স্ট্রিং-এ প্রথম পুনরাবৃত্ত অক্ষর খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	def first_repeated_char(str1): for index,c in enumerate(str1): if str1[:index+1].count(c) > 1: return c return "None"	['assert first_repeated_char("abcabc") == "a"', 'assert first_repeated_char("abc") == "None"', 'assert first_repeated_char("123123") == "1"']	null	[]
603	একটি ফাংশন লিখুন যা n এর চেয়ে ছোট বা সমান একটি স্বচ্ছ সংখ্যা পেতে পারে।	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 ...	['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]']	null	[]
604	একটি প্রদত্ত স্ট্রিং এর শব্দগুলোকে বিপরীত করার জন্য একটি ফাংশন লিখুন।	def reverse_words(s): return ' '.join(reversed(s.split()))	['assert reverse_words("python program")==("program python")', 'assert reverse_words("java language")==("language java")', 'assert reverse_words("indian man")==("man indian")']	null	[]
605	প্রদত্ত পূর্ণসংখ্যাটি একটি মৌলিক সংখ্যা কিনা তা পরীক্ষা করার জন্য একটি ফাংশন লিখুন।	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	['assert prime_num(13)==True', 'assert prime_num(7)==True', 'assert prime_num(-1010)==False']	null	[]
606	ডিগ্রিকে রেডিয়ান রূপান্তর করার জন্য একটি ফাংশন লিখুন।	import math def radian_degree(degree): radian = degree*(math.pi/180) return radian	['assert radian_degree(90)==1.5707963267948966', 'assert radian_degree(60)==1.0471975511965976', 'assert radian_degree(120)==2.0943951023931953']	null	[]
607	একটি স্ট্রিং-এ একটি আক্ষরিক স্ট্রিং অনুসন্ধান করার জন্য একটি ফাংশন লিখুন এবং রেজেক্স ব্যবহার করে মূল স্ট্রিং-এর মধ্যে অবস্থানটি খুঁজে বের করুন যেখানে প্যাটার্নটি ঘটে।	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)	["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)"]	null	[]
608	একটি পাইথন ফাংশন লিখুন nth বেল নম্বর খুঁজে পেতে।	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]	['assert bell_Number(2) == 2', 'assert bell_Number(3) == 5', 'assert bell_Number(4) == 15']	null	[]
609	প্রদত্ত পর্যায়ক্রমিক ফাংশনের জন্য সর্বনিম্ন সম্ভাব্য মান খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	def floor_Min(A,B,N): x = max(B - 1,N) return (A*x) // B	['assert floor_Min(10,20,30) == 15', 'assert floor_Min(1,2,1) == 0', 'assert floor_Min(11,10,9) == 9']	null	[]
610	একটি প্রদত্ত তালিকা থেকে k'th উপাদান অপসারণের জন্য একটি পাইথন ফাংশন লিখুন।	def remove_kth_element(list1, L): return list1[:L-1] + list1[L:]	['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, ...	null	[]
611	প্রদত্ত টিপল তালিকা থেকে n-তম কলামের সর্বোচ্চ সংখ্যা খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def max_of_nth(test_list, N): res = max([sub[N] for sub in test_list]) return (res)	['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']	null	[]
612	একটি পাইথন ফাংশন লিখুন যা প্রথম এবং শেষ উপাদানগুলিকে আলাদাভাবে তালিকার তালিকায় একত্রিত করে।	def merge(lst): return [list(ele) for ele in list(zip(*lst))]	["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']]"]	null	[]
613	প্রদত্ত তালিকায় টুপল বৈশিষ্ট্য হিসাবে রেকর্ড তালিকার সর্বাধিক মান খুঁজে পেতে একটি ফাংশন লিখুন।	def maximum_value(test_list): res = [(key, max(lst)) for key, lst in test_list] return (res)	["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,...	null	[]
614	প্রদত্ত টিপল তালিকায় উপস্থিত সমস্ত মানের ক্রমিক যোগফল খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def cummulative_sum(test_list): res = sum(map(sum, test_list)) return (res)	['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']	null	[]
615	একটি প্রদত্ত টুপল টুপল এর সংখ্যার গড় মান খুঁজে পেতে একটি ফাংশন লিখুন।	def average_tuple(nums): result = [sum(x) / len(x) for x in zip(*nums)] return result	['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...	null	[]
616	প্রদত্ত দুটি টুপলে টুপল উপাদানগুলির মডুলো সম্পাদন করার জন্য একটি ফাংশন লিখুন।	def tuple_modulo(test_tup1, test_tup2): res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)) return (res)	['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)']	null	[]
617	একটি 2 ডি সমতল থেকে উৎপত্তি থেকে একটি ফর্ম (d, 0) এর একটি বিন্দুতে পৌঁছানোর জন্য প্রদত্ত দৈর্ঘ্যের প্রয়োজনীয় জাম্পের সংখ্যা পরীক্ষা করার জন্য একটি ফাংশন লিখুন।	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	['assert min_Jumps(3,4,11)==3.5', 'assert min_Jumps(3,4,0)==0', 'assert min_Jumps(11,14,11)==1']	null	[]
618	মানচিত্র এবং ল্যাম্বদা ফাংশন ব্যবহার করে দুটি তালিকা ভাগ করার জন্য একটি ফাংশন লিখুন।	def div_list(nums1,nums2): result = map(lambda x, y: x / y, nums1, nums2) return list(result)	['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]']	null	[]
619	একটি ফাংশন লিখুন যাতে সবগুলো সংখ্যাকে দেওয়া স্ট্রিংয়ে স্থানান্তর করা যায়।	def move_num(test_str): res = '' dig = '' for ele in test_str: if ele.isdigit(): dig += ele else: res += ele res += dig return (res)	["assert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'", "assert move_num('Avengers124Assemble') == 'AvengersAssemble124'", "assert move_num('Its11our12path13to14see15things16do17things') == 'Itsourpathtoseethingsdothings11121314151617'"]	null	[]
620	একটি ফাংশন লিখুন যেখানে প্রতিটি জোড়া বিভাজ্য হয়।	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)	['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']	null	[]
621	একটি ফাংশন লিখুন যা প্রদত্ত স্ট্রিংগুলিতে k দ্বারা সংখ্যাসূচক মান বৃদ্ধি করে।	def increment_numerics(test_list, K): res = [str(int(ele) + K) if ele.isdigit() else ele for ele in test_list] return res	['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_nu...	null	[]
622	একই আকারের দুটি সাজানো অ্যারের মধ্যমা খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	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] ...	['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']	null	[]
623	ল্যাম্বদা ফাংশন ব্যবহার করে একটি তালিকার পৃথক উপাদানগুলির n-তম শক্তি খুঁজে পেতে একটি ফাংশন লিখুন।	def nth_nums(nums,n): nth_nums = list(map(lambda x: x ** n, nums)) return nth_nums	['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])']	null	[]
624	প্রদত্ত স্ট্রিংকে বড় হাতের অক্ষরে রূপান্তর করতে একটি পাইথন ফাংশন লিখুন।	def is_upper(string): return (string.upper())	['assert is_upper("person") =="PERSON"', 'assert is_upper("final") == "FINAL"', 'assert is_upper("Valid") == "VALID"']	null	[]
625	একটি প্রদত্ত তালিকার প্রথম এবং শেষ উপাদান বিনিময় করার জন্য একটি পাইথন ফাংশন লিখুন।	def swap_List(newList): size = len(newList) temp = newList[0] newList[0] = newList[size - 1] newList[size - 1] = temp return newList	['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]']	null	[]
626	একটি পাইথন ফাংশন লিখুন যাতে সেমি সার্কেলে যে বৃহত্তম ত্রিভুজটি লেখা যায় তা খুঁজে পাওয়া যায়।	def triangle_area(r) : if r < 0 : return -1 return r * r	['assert triangle_area(0) == 0', 'assert triangle_area(-1) == -1', 'assert triangle_area(2) == 4']	null	[]
627	প্রদত্ত অ্যারে থেকে ক্ষুদ্রতম অনুপস্থিত সংখ্যা খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	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)	['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']	null	[]
628	প্রদত্ত স্ট্রিং-এর সমস্ত স্পেসকে অক্ষর * তালিকা আইটেম * তালিকা আইটেম * তালিকা আইটেম * তালিকা আইটেম '%20' দিয়ে প্রতিস্থাপনের জন্য একটি ফাংশন লিখুন।	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...	['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\'']	null	[]
629	একটি মিশ্র তালিকা থেকে এমনকি সংখ্যা খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	def Split(list): ev_li = [] for i in list: if (i % 2 == 0): ev_li.append(i) return ev_li	['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]']	null	[]
630	একটি ফাংশন লিখুন যা প্রদত্ত সমন্বয় টুপলের সমস্ত সংলগ্ন সমন্বয়গুলি বের করে।	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)	['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], ...	null	[]
631	রেজেক্স ব্যবহার করে একটি প্রদত্ত স্ট্রিংয়ে হোয়াইটস্পেসগুলিকে একটি আন্ডারস্কোর এবং বিপরীতভাবে প্রতিস্থাপনের জন্য একটি ফাংশন লিখুন।	import re text = 'Python Exercises' def replace_spaces(text): text =text.replace (" ", "_") return (text) text =text.replace ("_", " ") return (text)	["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'"]	null	[]
632	একটি পাইথন ফাংশন লিখুন যাতে সব শূন্যকে দেওয়া তালিকার শেষে সরানো যায়।	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)	['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]']	null	[]
633	প্রদত্ত অ্যারেতে সমস্ত সংখ্যার জোড়ার xor এর যোগফল খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	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	['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']	null	[]
634	প্রথম n টি সম সংখ্যাগুলির চতুর্থ ক্ষমতার যোগফল খুঁজে বের করার জন্য একটি পাইথন ফাংশন লিখুন।	def even_Power_Sum(n): sum = 0; for i in range(1,n + 1): j = 2i; sum = sum + (jjjj); return sum;	['assert even_Power_Sum(2) == 272', 'assert even_Power_Sum(3) == 1568', 'assert even_Power_Sum(4) == 5664']	null	[]
635	একটি ফাংশন লিখুন যাতে সবগুলো ভ্যালু এক হিপে ঢুকিয়ে দেওয়া হয় এবং তারপর ছোট ভ্যালুগুলো একের পর এক বের করে দেওয়া হয়।	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))]	['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]']	null	[]
636	একটি চতুর্ভুজ সমীকরণের মূলগুলি একে অপরের প্রতিদ্বন্দ্বিতা কিনা তা পরীক্ষা করার জন্য একটি পাইথন ফাংশন লিখুন।	def Check_Solution(a,b,c): if (a == c): return ("Yes"); else: return ("No");	['assert Check_Solution(2,0,2) == "Yes"', 'assert Check_Solution(2,-5,2) == "Yes"', 'assert Check_Solution(1,2,3) == "No"']	null	[]
637	একটি ফাংশন লিখুন যা দিয়ে চেক করা যায় যে প্রদত্ত পরিমাণে কোন লাভ এবং কোন ক্ষতি নেই	def noprofit_noloss(actual_cost,sale_amount): if(sale_amount == actual_cost): return True else: return False	['assert noprofit_noloss(1500,1200)==False', 'assert noprofit_noloss(100,100)==True', 'assert noprofit_noloss(2000,5000)==False']	null	[]
638	বায়ু শীতলতা সূচক গণনা করার জন্য একটি ফাংশন লিখুন।	import math def wind_chill(v,t): windchill = 13.12 + 0.6215t - 11.37math.pow(v, 0.16) + 0.3965tmath.pow(v, 0.16) return int(round(windchill, 0))	['assert wind_chill(120,35)==40', 'assert wind_chill(40,70)==86', 'assert wind_chill(10,100)==116']	null	[]
639	একটি ফাংশন লিখুন যা একটি নামের তালিকা থেকে ছোট অক্ষর দিয়ে শুরু হওয়া নামগুলি সরিয়ে দেওয়ার পরে নামের দৈর্ঘ্যের যোগফল দেয়।	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))	["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']	null	[]
640	একটি স্ট্রিংয়ে বন্ধনী এলাকা অপসারণের জন্য একটি ফাংশন লিখুন।	import re def remove_parenthesis(items): for item in items: return (re.sub(r" ?$[^)]+$", "", item))	['assert remove_parenthesis(["python (chrome)"])==("python")', 'assert remove_parenthesis(["string(.abc)"])==("string")', 'assert remove_parenthesis(["alpha(num)"])==("alpha")']	null	[]
641	nth অ-অনুভূমিক সংখ্যা খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def is_nonagonal(n): return int(n * (7 * n - 5) / 2)	['assert is_nonagonal(10) == 325', 'assert is_nonagonal(15) == 750', 'assert is_nonagonal(18) == 1089']	null	[]
642	প্রদত্ত টিপল ম্যাট্রিক্স থেকে অনুরূপ সারিগুলি সরিয়ে ফেলার জন্য একটি ফাংশন লিখুন।	def remove_similar_row(test_list): res = set(sorted([tuple(sorted(set(sub))) for sub in test_list])) return (res)	['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...	null	[]
643	এমন একটি ফাংশন লিখুন যা শব্দের শুরু বা শেষে নয়, 'z' যুক্ত একটি শব্দের সাথে মিলবে।	import re def text_match_wordz_middle(text): patterns = '\Bz\B' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')	['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!\')']	null	[]
644	একটি প্রদত্ত অবস্থানে একটি অ্যারেকে বিপরীত করার জন্য একটি পাইথন ফাংশন লিখুন।	def reverse_Array_Upto_K(input, k): return (input[k-1::-1] + input[k:])	['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]']	null	[]
645	প্রদত্ত টুপলগুলিতে এটির kth সূচকের পণ্য খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	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)	['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']	null	[]
646	একটি পাইথন ফাংশন লিখুন যা n আকারের একটি ঘনক্ষেত্রে k আকারের ঘনক্ষেত্রের সংখ্যা গণনা করে।	def No_of_cubes(N,K): No = 0 No = (N - K + 1) No = pow(No, 3) return No	['assert No_of_cubes(2,1) == 8', 'assert No_of_cubes(5,2) == 64', 'assert No_of_cubes(1,1) == 1']	null	[]
647	একটি স্ট্রিংকে বড় অক্ষরে বিভক্ত করার জন্য একটি ফাংশন লিখুন।	import re def split_upperstring(text): return (re.findall('[A-Z][^A-Z]*', text))	['assert split_upperstring("PythonProgramLanguage")==[\'Python\',\'Program\',\'Language\']', 'assert split_upperstring("PythonProgram")==[\'Python\',\'Program\']', 'assert split_upperstring("ProgrammingLanguage")==[\'Programming\',\'Language\']']	null	[]
648	একটি প্রদত্ত তালিকায় প্রতিটি n-তম মানের অবস্থান (n+1) তম মান এবং (n+1) তম মানের সাথে n- তম মানের সাথে বিনিময় করার জন্য একটি ফাংশন লিখুন।	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])))	['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] ']	null	[]
649	একটি নির্দিষ্ট পরিসরের সূচকের মধ্যে একটি তালিকার সংখ্যার যোগফল গণনা করার জন্য একটি পাইথন ফাংশন লিখুন।	def sum_Range_list(nums, m, n): sum_range = 0 ...	['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']	null	[]
650	প্রদত্ত দুটি অ্যারে সমান কিনা তা পরীক্ষা করার জন্য একটি পাইথন ফাংশন লিখুন।	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	['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']	null	[]
651	একটি টিপল অন্য টিপলের উপসেট কিনা তা পরীক্ষা করার জন্য একটি ফাংশন লিখুন।	def check_subset(test_tup1, test_tup2): res = set(test_tup2).issubset(test_tup1) return (res)	['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']	null	[]
652	একটি ফাংশন লিখুন যাতে প্রদত্ত টিপল ম্যাট্রিক্সটি টিপল তালিকায় সমতল করা যায় যেখানে প্রতিটি টিপল প্রতিটি কলামকে প্রতিনিধিত্ব করে।	def matrix_to_list(test_list): temp = [ele for sub in test_list for ele in sub] res = list(zip(*temp)) return (str(res))	["assert matrix_to_list([[(4, 5), (7, 8)], [(10, 13), (18, 17)], [(0, 4), (10, 1)]]) == '[(4, 7, 10, 18, 0, 10), (5, 8, 13, 17, 4, 1)]'", "assert matrix_to_list([[(5, 6), (8, 9)], [(11, 14), (19, 18)], [(1, 5), (11, 2)]]) == '[(5, 8, 11, 19, 1, 11), (6, 9, 14, 18, 5, 2)]'", "assert matrix_to_list([[(6, 7), (9, 10)], [(...	null	[]
653	একটি ফাংশন লিখুন যা সংগ্রহ মডিউল ব্যবহার করে একটি কী-মান জোড়ার ক্রমকে একটি তালিকার অভিধানে গোষ্ঠীভুক্ত করে।	from collections import defaultdict def grouping_dictionary(l): d = defaultdict(list) for k, v in l: d[k].append(v) return d	["assert grouping_dictionary([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])== ({'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})", "assert grouping_dictionary([('yellow', 10), ('blue', 20), ('yellow', 30), ('blue', 40), ('red', 10)])== ({'yellow': [10, 30], 'blue': [20, 40], 'red': [10]})", "assert...	null	[]
654	একটি আয়তক্ষেত্রের পরিধি খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def rectangle_perimeter(l,b): perimeter=2*(l+b) return perimeter	['assert rectangle_perimeter(10,20)==60', 'assert rectangle_perimeter(10,5)==30', 'assert rectangle_perimeter(4,2)==12']	null	[]
655	একটি পাইথন ফাংশন লিখুন যা n প্রাকৃতিক সংখ্যার পঞ্চম শক্তির যোগফল খুঁজে বের করবে।	def fifth_Power_Sum(n) : sm = 0 for i in range(1,n+1) : sm = sm + (iiiii) return sm	['assert fifth_Power_Sum(2) == 33', 'assert fifth_Power_Sum(4) == 1300', 'assert fifth_Power_Sum(3) == 276']	null	[]
656	দুটি অ্যারের পরম পার্থক্যের সর্বনিম্ন যোগফল খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	def find_Min_Sum(a,b,n): a.sort() b.sort() sum = 0 for i in range(n): sum = sum + abs(a[i] - b[i]) return sum	['assert find_Min_Sum([3,2,1],[2,1,3],3) == 0', 'assert find_Min_Sum([1,2,3],[4,5,6],3) == 9', 'assert find_Min_Sum([4,1,8,7],[2,3,6,5],4) == 6']	null	[]
657	একটি প্রদত্ত সংখ্যার ফ্যাক্টরিয়ালের প্রথম অঙ্কটি খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	import math def first_Digit(n) : fact = 1 for i in range(2,n + 1) : fact = fact * i while (fact % 10 == 0) : fact = int(fact / 10) while (fact >= 10) : fact = int(fact / 10) return math.floor(fact)	['assert first_Digit(5) == 1', 'assert first_Digit(10) == 3', 'assert first_Digit(7) == 5']	null	[]
658	একটি প্রদত্ত তালিকায় সর্বোচ্চ সংখ্যক বার প্রদর্শিত আইটেমটি খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def max_occurrences(list1): max_val = 0 result = list1[0] for i in list1: occu = list1.count(i) if occu > max_val: max_val = occu result = i return result	['assert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,4,6,9,1,2])==2', 'assert max_occurrences([1, 3,5, 7,1, 3,13, 15, 17,5, 7,9,1, 11])==1', 'assert max_occurrences([1, 2, 3,2, 4, 5,1, 1, 1])==1']	null	[]
659	পূর্ণসংখ্যার তালিকা থেকে ডুপ্লিকেট মুদ্রণ করার জন্য একটি পাইথন ফাংশন লিখুন।	def Repeat(x): _size = len(x) repeated = [] for i in range(_size): k = i + 1 for j in range(k, _size): if x[i] == x[j] and x[i] not in repeated: repeated.append(x[i]) return repeated	['assert Repeat([10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20]) == [20, 30, -20, 60]', 'assert Repeat([-1, 1, -1, 8]) == [-1]', 'assert Repeat([1, 2, 3, 1, 2,]) == [1, 2]']	null	[]
660	একটি পাইথন ফাংশন লিখুন যাতে দুটি রেঞ্জের মধ্যে থেকে পয়েন্ট নির্বাচন করতে পারে যাতে উভয় রেঞ্জের মধ্যে কোন পয়েন্ট থাকে না।	def find_Points(l1,r1,l2,r2): x = min(l1,l2) if (l1 != l2) else -1 y = max(r1,r2) if (r1 != r2) else -1 return (x,y)	['assert find_Points(5,10,1,5) == (1,10)', 'assert find_Points(3,5,7,9) == (3,9)', 'assert find_Points(1,5,2,8) == (1,8)']	null	[]
661	একটি ফাংশন লিখুন যাতে সর্বোচ্চ যোগফল পাওয়া যায় যা তিনটি পরপর উপাদান উপস্থিত না থাকলে গঠন করা যায়।	def max_sum_of_three_consecutive(arr, n): sum = [0 for k in range(n)] if n >= 1: sum[0] = arr[0] if n >= 2: sum[1] = arr[0] + arr[1] if n > 2: sum[2] = max(sum[1], max(arr[1] + arr[2], arr[0] + arr[2])) for i in range(3, n): sum[i] = max(max(sum[i-1], sum[i-2] + arr[i]), arr[i] + arr[i-1]...	['assert max_sum_of_three_consecutive([100, 1000, 100, 1000, 1], 5) == 2101', 'assert max_sum_of_three_consecutive([3000, 2000, 1000, 3, 10], 5) == 5013', 'assert max_sum_of_three_consecutive([1, 2, 3, 4, 5, 6, 7, 8], 8) == 27']	null	[]
662	একটি অভিধানে একটি তালিকা বাছাই করার জন্য একটি ফাংশন লিখুন।	def sorted_dict(dict1): sorted_dict = {x: sorted(y) for x, y in dict1.items()} return sorted_dict	["assert sorted_dict({'n1': [2, 3, 1], 'n2': [5, 1, 2], 'n3': [3, 2, 4]})=={'n1': [1, 2, 3], 'n2': [1, 2, 5], 'n3': [2, 3, 4]}", "assert sorted_dict({'n1': [25,37,41], 'n2': [41,54,63], 'n3': [29,38,93]})=={'n1': [25, 37, 41], 'n2': [41, 54, 63], 'n3': [29, 38, 93]}", "assert sorted_dict({'n1': [58,44,56], 'n2': [91,34...	null	[]
663	একটি ফাংশন লিখুন k এর বৃহত্তম সম্ভাব্য মান খুঁজে বের করতে যাতে k মডুলাস x হল y।	import sys def find_max_val(n, x, y): ans = -sys.maxsize for k in range(n + 1): if (k % x == y): ans = max(ans, k) return (ans if (ans >= 0 and ans <= n) else -1)	['assert find_max_val(15, 10, 5) == 15', 'assert find_max_val(187, 10, 5) == 185', 'assert find_max_val(16, 11, 1) == 12']	null	[]
664	একটি নির্দিষ্ট সংখ্যার মধ্যবর্তী সংখ্যার গড় খুঁজে বের করার জন্য একটি পাইথন ফাংশন লিখুন।	def average_Even(n) : if (n% 2!= 0) : return ("Invalid Input") return -1 sm = 0 count = 0 while (n>= 2) : count = count+1 sm = sm+n n = n-2 return sm // count	['assert average_Even(2) == 2', 'assert average_Even(4) == 3', 'assert average_Even(100) == 51']	null	[]
665	প্রদত্ত তালিকার শেষে প্রথম উপাদান স্থানান্তর করতে একটি পাইথন ফাংশন লিখুন।	def move_last(num_list): a = [num_list[0] for i in range(num_list.count(num_list[0]))] x = [ i for i in num_list if i != num_list[0]] x.extend(a) return (x)	['assert move_last([1,2,3,4]) == [2,3,4,1]', 'assert move_last([2,3,4,1,5,0]) == [3,4,1,5,0,2]', 'assert move_last([5,4,3,2,1]) == [4,3,2,1,5]']	null	[]
666	একটি স্ট্রিংয়ে অক্ষরের উপস্থিতি গণনা করার জন্য একটি ফাংশন লিখুন।	def count_char(string,char): count = 0 for i in range(len(string)): if(string[i] == char): count = count + 1 return count	['assert count_char("Python",\'o\')==1', 'assert count_char("little",\'t\')==2', 'assert count_char("assert",\'s\')==2']	null	[]
667	স্ট্রিংয়ে স্বরবর্ণের সংখ্যা গণনা করার জন্য একটি পাইথন ফাংশন লিখুন।	def Check_Vow(string, vowels): final = [each for each in string if each in vowels] return(len(final))	["assert Check_Vow('corner','AaEeIiOoUu') == 2", "assert Check_Vow('valid','AaEeIiOoUu') == 2", "assert Check_Vow('true','AaEeIiOoUu') ==2"]	null	[]
668	একটি পাইথন ফাংশন লিখুন যাতে অক্ষরের একাধিক উপস্থিতি একক দ্বারা প্রতিস্থাপিত হয়।	import re def replace(string, char): pattern = char + '{2,}' string = re.sub(pattern, char, string) return string	["assert replace('peep','e') == 'pep'", "assert replace('Greek','e') == 'Grek'", "assert replace('Moon','o') == 'Mon'"]	null	[]
669	রেজেক্স ব্যবহার করে প্রদত্ত আইপি ঠিকানাটি বৈধ কিনা তা পরীক্ষা করার জন্য একটি ফাংশন লিখুন।	import re regex = '''^(25[0-5]\|2[0-4][0-9]\|[0-1]?[0-9][0-9]?)\.( 25[0-5]\|2[0-4][0-9]\|[0-1]?[0-9][0-9]?)\.( 25[0-5]\|2[0-4][0-9]\|[0-1]?[0-9][0-9]?)\.( 25[0-5]\|2[0-4][0-9]\|[0-1]?[0-9][0-9]?)$''' def check_IP(Ip): if(re.search(regex, Ip)): return ("Valid IP address") else: return ("Invalid I...	['assert check_IP("192.168.0.1") == \'Valid IP address\'', 'assert check_IP("110.234.52.124") == \'Valid IP address\'', 'assert check_IP("366.1.2.2") == \'Invalid IP address\'']	null	[]
670	একটি সংখ্যা ক্রমের প্রবণতা হ্রাস পাচ্ছে কিনা তা পরীক্ষা করার জন্য একটি পাইথন ফাংশন লিখুন।	def decreasing_trend(nums): if (sorted(nums)== nums): return True else: return False	['assert decreasing_trend([-4,-3,-2,-1]) == True', 'assert decreasing_trend([1,2,3]) == True', 'assert decreasing_trend([3,2,1]) == False']	null	[]
671	ডানদিকে সবচেয়ে বেশি বিট সেট না করার জন্য একটি পাইথন ফাংশন লিখুন।	import math def get_Pos_Of_Right_most_Set_Bit(n): return int(math.log2(n&-n)+1) def set_Right_most_Unset_Bit(n): if (n == 0): return 1 if ((n & (n + 1)) == 0): return n pos = get_Pos_Of_Right_most_Set_Bit(~n) return ((1 << (pos - 1)) \| n)	['assert set_Right_most_Unset_Bit(21) == 23', 'assert set_Right_most_Unset_Bit(11) == 15', 'assert set_Right_most_Unset_Bit(15) == 15']	null	[]
672	একটি ফাংশন লিখুন যাতে সর্বোচ্চ তিনটি সংখ্যা পাওয়া যায়।	def max_of_three(num1,num2,num3): if (num1 >= num2) and (num1 >= num3): lnum = num1 elif (num2 >= num1) and (num2 >= num3): lnum = num2 else: lnum = num3 return lnum	['assert max_of_three(10,20,30)==30', 'assert max_of_three(55,47,39)==55', 'assert max_of_three(10,49,30)==49']	null	[]
673	একাধিক পূর্ণসংখ্যার একটি তালিকাকে একটি একক পূর্ণসংখ্যায় রূপান্তর করতে একটি পাইথন ফাংশন লিখুন।	def convert(list): s = [str(i) for i in list] res = int("".join(s)) return (res)	['assert convert([1,2,3]) == 123', 'assert convert([4,5,6]) == 456', 'assert convert([7,8,9]) == 789']	null	[]
674	একটি প্রদত্ত স্ট্রিং থেকে ডুপ্লিকেট শব্দ অপসারণের জন্য একটি ফাংশন লিখুন।	from collections import OrderedDict def remove_duplicate(string): result = ' '.join(OrderedDict((w,w) for w in string.split()).keys()) return result	['assert remove_duplicate("Python Exercises Practice Solution Exercises")==("Python Exercises Practice Solution")', 'assert remove_duplicate("Python Exercises Practice Solution Python")==("Python Exercises Practice Solution")', 'assert remove_duplicate("Python Exercises Practice Solution Practice")==("Python Exercises ...	null	[]
675	দুটি পূর্ণসংখ্যার যোগ করার জন্য একটি ফাংশন লিখুন। তবে, যদি যোগফল প্রদত্ত পরিসরের মধ্যে থাকে তবে এটি 20 প্রদান করবে।	def sum_nums(x, y,m,n): sum_nums= x + y if sum_nums in range(m, n): return 20 else: return sum_nums	['assert sum_nums(2,10,11,20)==20', 'assert sum_nums(15,17,1,10)==32', 'assert sum_nums(10,15,5,30)==20']	null	[]
676	একটি ফাংশন লিখুন যা রেজেক্স ব্যবহার করে প্রদত্ত স্ট্রিং থেকে আলফানিউমেরিক অক্ষর ছাড়া অন্য সব কিছু সরিয়ে ফেলবে।	import re def remove_extra_char(text1): pattern = re.compile('[\W_]+') return (pattern.sub('', text1))	["assert remove_extra_char('//Google Android// - 12. ') == 'GoogleAndroid12'", "assert remove_extra_char('//Google Flutter//* - 36. ') == 'GoogleFlutter36'", "assert remove_extra_char('**//Google Firebase// - 478. ') == 'GoogleFirebase478'"]	null	[]
677	একটি ফাংশন লিখুন যাতে ত্রিভুজটি বৈধ কিনা তা পরীক্ষা করা যায়।	def validity_triangle(a,b,c): total = a + b + c if total == 180: return True else: return False	['assert validity_triangle(60,50,90)==False', 'assert validity_triangle(45,75,60)==True', 'assert validity_triangle(30,50,100)==True']	null	[]
678	একটি প্রদত্ত স্ট্রিং থেকে স্পেস অপসারণের জন্য একটি পাইথন ফাংশন লিখুন।	def remove_spaces(str1): str1 = str1.replace(' ','') return str1	['assert remove_spaces("a b c") == "abc"', 'assert remove_spaces("1 2 3") == "123"', 'assert remove_spaces(" b c") == "bc"']	null	[]
679	একটি ফাংশন লিখুন যা ডিকশনারি কী এর উপাদানগুলিকে সূচক অনুসারে অ্যাক্সেস করে।	def access_key(ditionary,key): return list(ditionary)[key]	["assert access_key({'physics': 80, 'math': 90, 'chemistry': 86},0)== 'physics'", "assert access_key({'python':10, 'java': 20, 'C++':30},2)== 'C++'", "assert access_key({'program':15,'computer':45},1)== 'computer'"]	null	[]
680	একটি সংখ্যা ক্রমের প্রবণতা বাড়ছে কিনা তা পরীক্ষা করার জন্য একটি পাইথন ফাংশন লিখুন।	def increasing_trend(nums): if (sorted(nums)== nums): return True else: return False	['assert increasing_trend([1,2,3,4]) == True', 'assert increasing_trend([4,3,2,1]) == False', 'assert increasing_trend([0,1,4,9]) == True']	null	[]
681	একটি সংখ্যার ক্ষুদ্রতম অক্ষরের বিভাজক খুঁজে বের করার জন্য একটি পাইথন ফাংশন লিখুন।	def smallest_Divisor(n): if (n % 2 == 0): return 2; i = 3; while (i*i <= n): if (n % i == 0): return i; i += 2; return n;	['assert smallest_Divisor(10) == 2', 'assert smallest_Divisor(25) == 5', 'assert smallest_Divisor(31) == 31']	null	[]
682	মানচিত্র এবং ল্যাম্বদা ফাংশন ব্যবহার করে দুটি তালিকার গুণ করার জন্য একটি ফাংশন লিখুন।	def mul_list(nums1,nums2): result = map(lambda x, y: x * y, nums1, nums2) return list(result)	['assert mul_list([1, 2, 3],[4,5,6])==[4,10,18]', 'assert mul_list([1,2],[3,4])==[3,8]', 'assert mul_list([90,120],[50,70])==[4500,8400]']	null	[]
683	একটি পাইথন ফাংশন লিখুন যা দিয়ে পরীক্ষা করা যায় যে, প্রদত্ত সংখ্যাটি দুইটি বর্গক্ষেত্রের যোগফল দ্বারা উপস্থাপিত হতে পারে কি না।	def sum_Square(n) : i = 1 while ii <= n : j = 1 while (jj <= n) : if (ii+jj == n) : return True j = j+1 i = i+1 return False	['assert sum_Square(25) == True', 'assert sum_Square(24) == False', 'assert sum_Square(17) == True']	null	[]
684	একটি পুনরাবৃত্ত স্ট্রিংয়ে অক্ষরের উপস্থিতি গণনা করার জন্য একটি পাইথন ফাংশন লিখুন।	def count_Char(str,x): count = 0 for i in range(len(str)): if (str[i] == x) : count += 1 n = 10 repititions = n // len(str) count = count * repititions l = n % len(str) for i in range(l): if (str[i] == x): count += 1 return...	['assert count_Char("abcac",\'a\') == 4', 'assert count_Char("abca",\'c\') == 2', 'assert count_Char("aba",\'a\') == 7']	null	[]
685	১ থেকে এন এর মধ্যে মৌলিক সংখ্যার যোগফল খুঁজে বের করার জন্য একটি পাইথন ফাংশন লিখুন।	def sum_Of_Primes(n): prime = [True] * (n + 1) p = 2 while p * p <= n: if prime[p] == True: i = p * 2 while i <= n: prime[i] = False i += p p += 1 sum = 0 for i in range (2,n + 1): if(prime[i]): ...	['assert sum_Of_Primes(10) == 17', 'assert sum_Of_Primes(20) == 77', 'assert sum_Of_Primes(5) == 10']	null	[]
686	প্রদত্ত তালিকার প্রতিটি উপাদানের ফ্রিকোয়েন্সি খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	from collections import defaultdict def freq_element(test_tup): res = defaultdict(int) for ele in test_tup: res[ele] += 1 return (str(dict(res)))	["assert freq_element((4, 5, 4, 5, 6, 6, 5, 5, 4) ) == '{4: 3, 5: 4, 6: 2}'", "assert freq_element((7, 8, 8, 9, 4, 7, 6, 5, 4) ) == '{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}'", "assert freq_element((1, 4, 3, 1, 4, 5, 2, 6, 2, 7) ) == '{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}'"]	null	[]
687	পুনরাবৃত্তি ব্যবহার করে দুটি পূর্ণসংখ্যার বৃহত্তম সাধারণ বিভাজক (জিসিডি) খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def recur_gcd(a, b): low = min(a, b) high = max(a, b) if low == 0: return high elif low == 1: return 1 else: return recur_gcd(low, high%low)	['assert recur_gcd(12,14) == 2', 'assert recur_gcd(13,17) == 1', 'assert recur_gcd(9, 3) == 3']	null	[]
688	একটি জটিল সংখ্যার দৈর্ঘ্য পেতে একটি ফাংশন লিখুন।	import cmath def len_complex(a,b): cn=complex(a,b) length=abs(cn) return length	['assert len_complex(3,4)==5.0', 'assert len_complex(9,10)==13.45362404707371', 'assert len_complex(7,9)==11.40175425099138']	null	[]
689	## একটি ফাংশন লিখুন যাতে প্রদত্ত পূর্ণসংখ্যা অ্যারের জন্য অ্যারের শেষে পৌঁছানোর জন্য সর্বনিম্ন সংখ্যক লাফ খুঁজে পাওয়া যায় যেখানে প্রতিটি উপাদান সেই উপাদান থেকে এগিয়ে যেতে পারে এমন সর্বোচ্চ সংখ্যক পদক্ষেপের প্রতিনিধিত্ব করে। > ইন্ডেন্টড ব্লক > ইন্ডেন্টড ব্লক	def min_jumps(arr, n): jumps = [0 for i in range(n)] if (n == 0) or (arr[0] == 0): return float('inf') jumps[0] = 0 for i in range(1, n): jumps[i] = float('inf') for j in range(i): if (i <= j + arr[j]) and (jumps[j] != float('inf')): jumps[i] = min(jumps[i], jumps[j] + 1) break return j...	['assert min_jumps([1, 3, 6, 1, 0, 9], 6) == 3', 'assert min_jumps([1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9], 11) == 3', 'assert min_jumps([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 11) == 10']	null	[]
690	একটি প্রদত্ত তালিকার পরপর সংখ্যাকে গুণ করার জন্য একটি ফাংশন লিখুন।	def mul_consecutive_nums(nums): result = [b*a for a, b in zip(nums[:-1], nums[1:])] return result	['assert mul_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[1, 3, 12, 16, 20, 30, 42]', 'assert mul_consecutive_nums([4, 5, 8, 9, 6, 10])==[20, 40, 72, 54, 60]', 'assert mul_consecutive_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[2, 6, 12, 20, 30, 42, 56, 72, 90]']	null	[]
691	প্রদত্ত টিপল তালিকার ২য় উপাদানগুলির উপর ভিত্তি করে 1ম উপাদানগুলিকে গ্রুপ করার জন্য একটি ফাংশন লিখুন।	from itertools import groupby def group_element(test_list): res = dict() for key, val in groupby(sorted(test_list, key = lambda ele: ele[1]), key = lambda ele: ele[1]): res[key] = [ele[0] for ele in val] return (res)	['assert group_element([(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]) == {5: [6, 2], 7: [2, 8, 3], 8: [9]}', 'assert group_element([(7, 6), (3, 8), (3, 6), (9, 8), (10, 9), (4, 8)]) == {6: [7, 3], 8: [3, 9, 4], 9: [10]}', 'assert group_element([(8, 7), (4, 9), (4, 7), (10, 9), (11, 10), (5, 9)]) == {7: [8, 4], 9: [4...	null	[]
692	একটি প্রদত্ত সংখ্যার ফ্যাক্টরিয়ালের শেষ দুটি অঙ্ক খুঁজে পেতে একটি পাইথন ফাংশন লিখুন।	def last_Two_Digits(N): if (N >= 10): return fac = 1 for i in range(1,N + 1): fac = (fac * i) % 100 return (fac)	['assert last_Two_Digits(7) == 40', 'assert last_Two_Digits(5) == 20', 'assert last_Two_Digits(2) == 2']	null	[]
693	রেজেক্স ব্যবহার করে স্ট্রিংয়ে একাধিক স্পেস অপসারণের জন্য একটি ফাংশন লিখুন।	import re def remove_multiple_spaces(text1): return (re.sub(' +',' ',text1))	["assert remove_multiple_spaces('Google Assistant') == 'Google Assistant'", "assert remove_multiple_spaces('Quad Core') == 'Quad Core'", "assert remove_multiple_spaces('ChromeCast Built-in') == 'ChromeCast Built-in'"]	null	[]
694	প্রদত্ত অভিধানের মান থেকে অনন্য মান বের করার জন্য একটি ফাংশন লিখুন।	def extract_unique(test_dict): res = list(sorted({ele for val in test_dict.values() for ele in val})) return res	["assert extract_unique({'msm' : [5, 6, 7, 8],'is' : [10, 11, 7, 5],'best' : [6, 12, 10, 8],'for' : [1, 2, 5]} ) == [1, 2, 5, 6, 7, 8, 10, 11, 12]", "assert extract_unique({'Built' : [7, 1, 9, 4],'for' : [11, 21, 36, 14, 9],'ISP' : [4, 1, 21, 39, 47],'TV' : [1, 32, 38]} ) == [1, 4, 7, 9, 11, 14, 21, 32, 36, 38, 39, 47]...	null	[]
695	দ্বিতীয় টিপলের প্রতিটি উপাদান প্রথম টিপলের সংশ্লিষ্ট সূচকের চেয়ে বড় কিনা তা পরীক্ষা করার জন্য একটি ফাংশন লিখুন।	def check_greater(test_tup1, test_tup2): res = all(x < y for x, y in zip(test_tup1, test_tup2)) return (res)	['assert check_greater((10, 4, 5), (13, 5, 18)) == True', 'assert check_greater((1, 2, 3), (2, 1, 4)) == False', 'assert check_greater((4, 5, 6), (5, 6, 7)) == True']	null	[]
696	একটি ফাংশন লিখুন যা দুইটি তালিকাকে একসাথে সংযুক্ত করে।	def zip_list(list1,list2): result = list(map(list.__add__, list1, list2)) return result	['assert zip_list([[1, 3], [5, 7], [9, 11]] ,[[2, 4], [6, 8], [10, 12, 14]] )==[[1, 3, 2, 4], [5, 7, 6, 8], [9, 11, 10, 12, 14]]', 'assert zip_list([[1, 2], [3, 4], [5, 6]] ,[[7, 8], [9, 10], [11, 12]] )==[[1, 2, 7, 8], [3, 4, 9, 10], [5, 6, 11, 12]]', "assert zip_list([['a','b'],['c','d']] , [['e','f'],['g','h']] )==[...	null	[]
697	ল্যাম্বদা ফাংশন ব্যবহার করে প্রদত্ত তালিকার সমসংখ্যক উপাদান খুঁজে বের করার জন্য একটি ফাংশন লিখুন।	def count_even(array_nums): count_even = len(list(filter(lambda x: (x%2 == 0) , array_nums))) return count_even	['assert count_even([1, 2, 3, 5, 7, 8, 9, 10])==3', 'assert count_even([10,15,14,13,-18,12,-20])==5', 'assert count_even([1, 2, 4, 8, 9])==3']	null	[]
698	একটি ফাংশন লিখুন যা একটি নির্দিষ্ট অভিধানের জন্য টিপল কীগুলির টুপল পণ্য দ্বারা অভিধানের আইটেমগুলি বাছাই করে।	def sort_dict_item(test_dict): res = {key: test_dict[key] for key in sorted(test_dict.keys(), key = lambda ele: ele[1] * ele[0])} return (res)	['assert sort_dict_item({(5, 6) : 3, (2, 3) : 9, (8, 4): 10, (6, 4): 12} ) == {(2, 3): 9, (6, 4): 12, (5, 6): 3, (8, 4): 10}', 'assert sort_dict_item({(6, 7) : 4, (3, 4) : 10, (9, 5): 11, (7, 5): 13} ) == {(3, 4): 10, (7, 5): 13, (6, 7): 4, (9, 5): 11}', 'assert sort_dict_item({(7, 8) : 5, (4, 5) : 11, (10, 6): 12, (8,...	null	[]
699	একটি বাইনারি স্ট্রিংকে অন্য একটিতে রূপান্তর করতে প্রয়োজনীয় ন্যূনতম সংখ্যক সোয়্যাপের জন্য একটি পাইথন ফাংশন লিখুন।	def min_Swaps(str1,str2) : count = 0 for i in range(len(str1)) : if str1[i] != str2[i] : count += 1 if count % 2 == 0 : return (count // 2) else : return ("Not Possible")	['assert min_Swaps("1101","1110") == 1', 'assert min_Swaps("1111","0100") == "Not Possible"', 'assert min_Swaps("1110000","0001101") == 3']	null	[]
700	একটি নির্দিষ্ট পরিসরের মধ্যে থাকা একটি তালিকার উপাদানগুলির সংখ্যা গণনা করার জন্য একটি ফাংশন লিখুন।	def count_range_in_list(li, min, max): ctr = 0 for x in li: if min <= x <= max: ctr += 1 return ctr	['assert count_range_in_list([10,20,30,40,40,40,70,80,99],40,100)==6', "assert count_range_in_list(['a','b','c','d','e','f'],'a','e')==5", 'assert count_range_in_list([7,8,9,15,17,19,45],15,20)==3']	null	[]

End of preview. Expand in Data Studio

🐯 MBPP-Bangla: A Benchmark for Evaluating Bangla Code Generation

Accepted at LREC 2026

Nishat Raihan, Antonios Anastasopoulos, Marcos Zampieri

George Mason University, Fairfax, VA, USA

The first expert-validated, multi-language Bangla code generation benchmark with 974 problems across 5 programming languages.

⚠️ Note: The benchmark will be released after the LREC 2026 conference. Stay tuned!

Overview

MBPP-Bangla is a comprehensive evaluation benchmark for Bangla code generation, derived from the Mostly Basic Python Programs (MBPP) dataset (Austin et al., 2021). It comprises 974 programming problems, each presented as a Bangla natural language prompt paired with canonical reference solutions in five programming languages: Python, Java, JavaScript, Ruby, and C++. Every problem is assigned to one of five topical classes, enabling controlled, category-wise evaluation.

MBPP-Bangla was designed to complement mHumanEval-Bangla. While mHumanEval-Bangla features docstring-style completions, MBPP-Bangla uses conversational Bangla prompts, stressing a model's ability to comprehend varied natural language specifications and generate syntactically valid code across multiple target languages. Using both benchmarks jointly provides a comprehensive assessment of Bangla code generation capability.

Benchmark Statistics

Property	Value
Total Problems	974
Source	MBPP (Austin et al., 2021)
Prompt Language	Bangla (human-translated)
Programming Languages	Python, Java, JavaScript, Ruby, C++
Difficulty	Basic to Intermediate
Topical Classes	5 (String, Math, Data Structures, Algorithms, File-I/O)

Curation Process

MBPP-Bangla was constructed through a rigorous five-step pipeline ensuring linguistic fidelity, technical correctness, and cross-language consistency:

Step	Description	Details
1. Extraction	Extract all 974 basic-to-intermediate problems from MBPP	Covers five topical classes
2. Translation	Two native Bangla speakers independently translate every English prompt into Bangla	Each translator has certified English proficiency (TOEFL iBT > 100)
3. Multi-Language Solutions	Curate or port five reference solutions per task	Python, Java, JavaScript, Ruby, C++
4. Expert Verification	A third reviewer manually verifies every item	Fluent in Bangla and all five programming languages
5. Release	Package validated records into the benchmark	Each record includes: Task ID, Bangla prompt, 5 reference codes, test cases, topic label

Annotator Qualifications

Role	Count	Qualifications
Translators	2	Native Bangla speakers, TOEFL iBT > 100, worked independently
Verifier	1	Native Bangla speaker, proficient in all 5 programming languages

Verification Scope

The expert verifier checked every item across three dimensions:

Linguistic Fidelity: Bangla prompt accurately captures the intent of the original English prompt
Technical Correctness: All five reference solutions produce correct outputs for the provided test cases
Cross-Language Consistency: Solutions across all five programming languages are semantically equivalent

Output Components

Each record in MBPP-Bangla contains the following fields:

Field	Description
Task ID	Unique identifier for each problem
Bangla Prompt	Human-translated Bangla natural language description
Python Solution	Reference solution in Python
Java Solution	Reference solution in Java
JavaScript Solution	Reference solution in JavaScript
Ruby Solution	Reference solution in Ruby
C++ Solution	Reference solution in C++
Test Cases	Original MBPP test cases for automated evaluation
Topic Label	One of: String, Math, Data Structures, Algorithms, File-I/O

Evaluation Metric

We use Pass@K as the evaluation metric. For a task with n generated programs, m of which pass all tests:

$\text{Pass@K} = 1 - \frac{\binom{n-m}{K}}{\binom{n}{K}}, \quad 1 \leq K \leq n$

We report three variations: Pass@1 (single-shot quality), Pass@10 (practical shortlist), and Pass@100 (upper potential under heavy sampling).

Benchmark Results (Python, Bangla Prompts)

Model	P@1	P@10	P@100
GPT-3.5	0.60	0.62	0.62
Gemini-Flash 2.5	0.62	0.62	0.70
GPT-4o-mini	0.51	0.53	0.54
LLaMA-3.2 (11B)	0.22	0.22	0.30
Gemma-3 (27B)	0.69	0.70	0.70
Phi-4 (7B)	0.09	0.15	0.20
TigerLLM (1B)	0.65	0.68	0.71
TigerLLM (9B)	0.61	0.68	0.73
TigerCoder (1B)	0.74	0.74	0.81
TigerCoder (9B)	0.82	0.84	0.91

Comparison with mHumanEval-Bangla

Feature	MBPP-Bangla	mHumanEval-Bangla
Size	974 problems	164 problems
Prompt Style	Conversational Bangla	Docstring-style completion
Programming Languages	5 (Python, Java, JS, Ruby, C++)	5 (Python, Java, JS, Ruby, C++)
Translation	Human (independent, dual-annotator)	Human
Topical Classes	5 categories	N/A
Statistical Robustness	Higher (larger size)	Lower (smaller size)
Complementary Strength	Varied NL specifications	Traditional code completion

Using both benchmarks jointly affords a comprehensive assessment of Bangla code generation capability.

Intended Use

Evaluating LLMs on Bangla code generation across multiple programming languages
Benchmarking multilingual code generation performance
Comparing model capabilities on conversational vs. docstring-style Bangla prompts (when paired with mHumanEval-Bangla)
Studying the impact of natural language on code generation quality across low-resource languages
Category-wise evaluation using topical class labels

Limitations

The benchmark is derived from MBPP, which covers basic-to-intermediate difficulty. It does not include advanced or production-level programming tasks.
Reference solutions were curated or ported, not independently authored from scratch for each language, which may introduce stylistic uniformity.
The benchmark evaluates functional correctness via test cases only. Code quality aspects such as readability, efficiency, and best practices are not assessed.
While translations were independently produced and expert-verified, subtle nuances in Bangla phrasing may still vary from the original English intent.

Ethics Statement

We adhere to the ethical guidelines outlined in the LREC 2026 CFP. The benchmark was constructed through careful human translation and expert verification by qualified native speakers. We promote transparency through open-source release and encourage responsible downstream use and community scrutiny.

Citation

If you find our work helpful, please consider citing our paper:

@article{raihan2025tigercoder,
  title={Tigercoder: A novel suite of llms for code generation in bangla},
  author={Raihan, Nishat and Anastasopoulos, Antonios and Zampieri, Marcos},
  journal={arXiv preprint arXiv:2509.09101},
  year={2025}
}

You may also find our related work useful:

@inproceedings{raihan-zampieri-2025-tigerllm,
    title = "{T}iger{LLM} - A Family of {B}angla Large Language Models",
    author = "Raihan, Nishat and
      Zampieri, Marcos",
    booktitle = "Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers)",
    month = jul,
    year = "2025",
    address = "Vienna, Austria",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2025.acl-short.69/",
    doi = "10.18653/v1/2025.acl-short.69",
    pages = "887--896",
    ISBN = "979-8-89176-252-7"
}

@inproceedings{raihan-etal-2025-mhumaneval,
    title = "m{H}uman{E}val - A Multilingual Benchmark to Evaluate Large Language Models for Code Generation",
    author = "Raihan, Nishat and
      Anastasopoulos, Antonios and
      Zampieri, Marcos",
    booktitle = "Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers)",
    year = "2025",
}

Downloads last month: 28

Paper for md-nishat-008/MBPP-Bangla

TigerCoder: A Novel Suite of LLMs for Code Generation in Bangla

Paper • 2509.09101 • Published Sep 11, 2025