task_id
int32 511
974
| source
stringlengths 149
914
| task_source
stringclasses 1
value | task_name
stringclasses 1
value | target
stringlengths 30
908
| split
stringclasses 2
values |
|---|---|---|---|---|---|
801 | Instruct: Write a python function to count the number of equal numbers from three given integers.
>>> assert test_three_equal(1,1,1) == 3
>>> assert test_three_equal(-1,-2,-3) == 0
>>> assert test_three_equal(1,2,2) == 2
Answer: | mbpp | mbpp | def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result)) | train |
802 | Instruct: Write a python function to count the number of rotations required to generate a sorted array.
>>> assert count_Rotation([3,2,1],3) == 1
>>> assert count_Rotation([4,5,1,2,3],5) == 2
>>> assert count_Rotation([7,8,9,1,2,3],6) == 3
Answer: | mbpp | mbpp | def count_Rotation(arr,n):
for i in range (1,n):
if (arr[i] < arr[i - 1]):
return i
return 0 | train |
803 | Instruct: Write a python function to check whether the given number is a perfect square or not.
>>> assert is_Perfect_Square(10) == False
>>> assert is_Perfect_Square(36) == True
>>> assert is_Perfect_Square(14) == False
Answer: | mbpp | mbpp | def is_Perfect_Square(n) :
i = 1
while (i * i<= n):
if ((n % i == 0) and (n / i == i)):
return True
i = i + 1
return False | train |
804 | Instruct: Write a python function to check whether the product of numbers is even or not.
>>> assert is_Product_Even([1,2,3],3) == True
>>> assert is_Product_Even([1,2,1,4],4) == True
>>> assert is_Product_Even([1,1],2) == False
Answer: | mbpp | mbpp | def is_Product_Even(arr,n):
for i in range(0,n):
if ((arr[i] & 1) == 0):
return True
return False | train |
805 | Instruct: Write a function to find the list in a list of lists whose sum of elements is the highest.
>>> assert max_sum_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]])==[10, 11, 12]
>>> assert max_sum_list([[3,2,1], [6,5,4], [12,11,10]])==[12,11,10]
>>> assert max_sum_list([[2,3,1]])==[2,3,1]
Answer: | mbpp | mbpp | def max_sum_list(lists):
return max(lists, key=sum) | train |
806 | Instruct: Write a function to find maximum run of uppercase characters in the given string.
>>> assert max_run_uppercase('GeMKSForGERksISBESt') == 5
>>> assert max_run_uppercase('PrECIOusMOVemENTSYT') == 6
>>> assert max_run_uppercase('GooGLEFluTTER') == 4
Answer: | mbpp | mbpp | def max_run_uppercase(test_str):
cnt = 0
res = 0
for idx in range(0, len(test_str)):
if test_str[idx].isupper():
cnt += 1
else:
res = cnt
cnt = 0
if test_str[len(test_str) - 1].isupper():
res = cnt
return (res) | train |
807 | Instruct: Write a python function to find the first odd number in a given list of numbers.
>>> assert first_odd([1,3,5]) == 1
>>> assert first_odd([2,4,1,3]) == 1
>>> assert first_odd ([8,9,1]) == 9
Answer: | mbpp | mbpp | def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd | train |
808 | Instruct: Write a function to check if the given tuples contain the k or not.
>>> assert check_K((10, 4, 5, 6, 8), 6) == True
>>> assert check_K((1, 2, 3, 4, 5, 6), 7) == False
>>> assert check_K((7, 8, 9, 44, 11, 12), 11) == True
Answer: | mbpp | mbpp | def check_K(test_tup, K):
res = False
for ele in test_tup:
if ele == K:
res = True
break
return (res) | train |
809 | Instruct: Write a function to check if each element of second tuple is smaller than its corresponding index in first tuple.
>>> assert check_smaller((1, 2, 3), (2, 3, 4)) == False
>>> assert check_smaller((4, 5, 6), (3, 4, 5)) == True
>>> assert check_smaller((11, 12, 13), (10, 11, 12)) == True
Answer: | mbpp | mbpp | def check_smaller(test_tup1, test_tup2):
res = all(x > y for x, y in zip(test_tup1, test_tup2))
return (res) | train |
810 | Instruct: Write a function to iterate over elements repeating each as many times as its count.
>>> assert count_variable(4,2,0,-2)==['p', 'p', 'p', 'p', 'q', 'q']
>>> assert count_variable(0,1,2,3)==['q', 'r', 'r', 's', 's', 's']
>>> assert count_variable(11,15,12,23)==['p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's']
Answer: | mbpp | mbpp | from collections import Counter
def count_variable(a,b,c,d):
c = Counter(p=a, q=b, r=c, s=d)
return list(c.elements()) | train |
811 | Instruct: Write a function to check if two lists of tuples are identical or not.
>>> assert check_identical([(10, 4), (2, 5)], [(10, 4), (2, 5)]) == True
>>> assert check_identical([(1, 2), (3, 7)], [(12, 14), (12, 45)]) == False
>>> assert check_identical([(2, 14), (12, 25)], [(2, 14), (12, 25)]) == True
Answer: | mbpp | mbpp | def check_identical(test_list1, test_list2):
res = test_list1 == test_list2
return (res) | train |
812 | Instruct: Write a function to abbreviate 'road' as 'rd.' in a given string.
>>> assert road_rd("ravipadu Road")==('ravipadu Rd.')
>>> assert road_rd("palnadu Road")==('palnadu Rd.')
>>> assert road_rd("eshwar enclave Road")==('eshwar enclave Rd.')
Answer: | mbpp | mbpp | import re
def road_rd(street):
return (re.sub('Road$', 'Rd.', street)) | train |
813 | Instruct: Write a function to find length of the string.
>>> assert string_length('python')==6
>>> assert string_length('program')==7
>>> assert string_length('language')==8
Answer: | mbpp | mbpp | def string_length(str1):
count = 0
for char in str1:
count += 1
return count | train |
814 | Instruct: Write a function to find the area of a rombus.
>>> assert rombus_area(10,20)==100
>>> assert rombus_area(10,5)==25
>>> assert rombus_area(4,2)==4
Answer: | mbpp | mbpp | def rombus_area(p,q):
area=(p*q)/2
return area | train |
815 | Instruct: Write a function to sort the given array without using any sorting algorithm. the given array consists of only 0, 1, and 2.
>>> assert sort_by_dnf([1,2,0,1,0,1,2,1,1], 9) == [0, 0, 1, 1, 1, 1, 1, 2, 2]
>>> assert sort_by_dnf([1,0,0,1,2,1,2,2,1,0], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]
>>> assert sort_by_dnf([2,2,1,0,0,0,1,1,2,1], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]
Answer: | mbpp | mbpp | def sort_by_dnf(arr, n):
low=0
mid=0
high=n-1
while mid <= high:
if arr[mid] == 0:
arr[low], arr[mid] = arr[mid], arr[low]
low = low + 1
mid = mid + 1
elif arr[mid] == 1:
mid = mid + 1
else:
arr[mid], arr[high] = arr[high], arr[mid]
high = high - 1
return arr | train |
816 | Instruct: Write a function to clear the values of the given tuples.
>>> assert clear_tuple((1, 5, 3, 6, 8)) == ()
>>> assert clear_tuple((2, 1, 4 ,5 ,6)) == ()
>>> assert clear_tuple((3, 2, 5, 6, 8)) == ()
Answer: | mbpp | mbpp | def clear_tuple(test_tup):
temp = list(test_tup)
temp.clear()
test_tup = tuple(temp)
return (test_tup) | train |
817 | Instruct: Write a function to find numbers divisible by m or n from a list of numbers using lambda function.
>>> assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],19,13)==[19, 65, 57, 39, 152, 190]
>>> assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[2, 5, 8, 10]
>>> assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10, 15, 20]
Answer: | mbpp | mbpp | def div_of_nums(nums,m,n):
result = list(filter(lambda x: (x % m == 0 or x % n == 0), nums))
return result | train |
818 | Instruct: Write a python function to count lower case letters in a given string.
>>> assert lower_ctr('abc') == 3
>>> assert lower_ctr('string') == 6
>>> assert lower_ctr('Python') == 5
Answer: | mbpp | mbpp | def lower_ctr(str):
lower_ctr= 0
for i in range(len(str)):
if str[i] >= 'a' and str[i] <= 'z': lower_ctr += 1
return lower_ctr | train |
819 | Instruct: Write a function to count the frequency of consecutive duplicate elements in a given list of numbers.
>>> assert count_duplic([1,2,2,2,4,4,4,5,5,5,5])==([1, 2, 4, 5], [1, 3, 3, 4])
>>> assert count_duplic([2,2,3,1,2,6,7,9])==([2, 3, 1, 2, 6, 7, 9], [2, 1, 1, 1, 1, 1, 1])
>>> assert count_duplic([2,1,5,6,8,3,4,9,10,11,8,12])==([2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
Answer: | mbpp | mbpp | def count_duplic(lists):
element = []
frequency = []
if not lists:
return element
running_count = 1
for i in range(len(lists)-1):
if lists[i] == lists[i+1]:
running_count += 1
else:
frequency.append(running_count)
element.append(lists[i])
running_count = 1
frequency.append(running_count)
element.append(lists[i+1])
return element,frequency
| train |
820 | Instruct: Write a function to check whether the given month number contains 28 days or not.
>>> assert check_monthnum_number(2)==True
>>> assert check_monthnum_number(1)==False
>>> assert check_monthnum_number(3)==False
Answer: | mbpp | mbpp | def check_monthnum_number(monthnum1):
if monthnum1 == 2:
return True
else:
return False | train |
821 | Instruct: Write a function to merge two dictionaries into a single expression.
>>> assert merge_dictionaries({ "R": "Red", "B": "Black", "P": "Pink" }, { "G": "Green", "W": "White" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White'}
>>> assert merge_dictionaries({ "R": "Red", "B": "Black", "P": "Pink" },{ "O": "Orange", "W": "White", "B": "Black" })=={'O': 'Orange', 'P': 'Pink', 'B': 'Black', 'W': 'White', 'R': 'Red'}
>>> assert merge_dictionaries({ "G": "Green", "W": "White" },{ "O": "Orange", "W": "White", "B": "Black" })=={'W': 'White', 'O': 'Orange', 'G': 'Green', 'B': 'Black'}
Answer: | mbpp | mbpp | import collections as ct
def merge_dictionaries(dict1,dict2):
merged_dict = dict(ct.ChainMap({}, dict1, dict2))
return merged_dict | train |
822 | Instruct: Write a function to return true if the password is valid.
>>> assert pass_validity("password")==False
>>> assert pass_validity("Password@10")==True
>>> assert pass_validity("password@10")==False
Answer: | mbpp | mbpp | import re
def pass_validity(p):
x = True
while x:
if (len(p)<6 or len(p)>12):
break
elif not re.search("[a-z]",p):
break
elif not re.search("[0-9]",p):
break
elif not re.search("[A-Z]",p):
break
elif not re.search("[$#@]",p):
break
elif re.search("\s",p):
break
else:
return True
x=False
break
if x:
return False | train |
823 | Instruct: Write a function to check if the given string starts with a substring using regex.
>>> assert check_substring("dreams for dreams makes life fun", "makes") == 'string doesnt start with the given substring'
>>> assert check_substring("Hi there how are you Hi alex", "Hi") == 'string starts with the given substring'
>>> assert check_substring("Its been a long day", "been") == 'string doesnt start with the given substring'
Answer: | mbpp | mbpp | import re
def check_substring(string, sample) :
if (sample in string):
y = "\A" + sample
x = re.search(y, string)
if x :
return ("string starts with the given substring")
else :
return ("string doesnt start with the given substring")
else :
return ("entered string isnt a substring") | train |
824 | Instruct: Write a python function to remove even numbers from a given list.
>>> assert remove_even([1,3,5,2]) == [1,3,5]
>>> assert remove_even([5,6,7]) == [5,7]
>>> assert remove_even([1,2,3,4]) == [1,3]
Answer: | mbpp | mbpp | def remove_even(l):
for i in l:
if i % 2 == 0:
l.remove(i)
return l | train |
825 | Instruct: Write a python function to access multiple elements of specified index from a given list.
>>> assert access_elements([2,3,8,4,7,9],[0,3,5]) == [2, 4, 9]
>>> assert access_elements([1, 2, 3, 4, 5],[1,2]) == [2,3]
>>> assert access_elements([1,0,2,3],[0,1]) == [1,0]
Answer: | mbpp | mbpp | def access_elements(nums, list_index):
result = [nums[i] for i in list_index]
return result | train |
826 | Instruct: Write a python function to find the type of triangle from the given sides.
>>> assert check_Type_Of_Triangle(1,2,3) == "Obtuse-angled Triangle"
>>> assert check_Type_Of_Triangle(2,2,2) == "Acute-angled Triangle"
>>> assert check_Type_Of_Triangle(1,0,1) == "Right-angled Triangle"
Answer: | mbpp | mbpp | def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle") | train |
827 | Instruct: Write a function to sum a specific column of a list in a given list of lists.
>>> assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],0)==12
>>> assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],1)==15
>>> assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],3)==9
Answer: | mbpp | mbpp | def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result | train |
828 | Instruct: Write a function to count alphabets,digits and special charactes in a given string.
>>> assert count_alpha_dig_spl("abc!@#123")==(3,3,3)
>>> assert count_alpha_dig_spl("dgsuy@#$%&1255")==(5,4,5)
>>> assert count_alpha_dig_spl("fjdsif627348#%$^&")==(6,6,5)
Answer: | mbpp | mbpp | def count_alpha_dig_spl(string):
alphabets=digits = special = 0
for i in range(len(string)):
if(string[i].isalpha()):
alphabets = alphabets + 1
elif(string[i].isdigit()):
digits = digits + 1
else:
special = special + 1
return (alphabets,digits,special) | train |
829 | Instruct: Write a function to find out the second most repeated (or frequent) string in the given sequence.
>>> assert second_frequent(['aaa','bbb','ccc','bbb','aaa','aaa']) == 'bbb'
>>> assert second_frequent(['abc','bcd','abc','bcd','bcd','bcd']) == 'abc'
>>> assert second_frequent(['cdma','gsm','hspa','gsm','cdma','cdma']) == 'gsm'
Answer: | mbpp | mbpp | from collections import Counter
def second_frequent(input):
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key) | train |
830 | Instruct: Write a function to round up a number to specific digits.
>>> assert round_up(123.01247,0)==124
>>> assert round_up(123.01247,1)==123.1
>>> assert round_up(123.01247,2)==123.02
Answer: | mbpp | mbpp | import math
def round_up(a, digits):
n = 10**-digits
return round(math.ceil(a / n) * n, digits) | train |
831 | Instruct: Write a python function to count equal element pairs from the given array.
>>> assert count_Pairs([1,1,1,1],4) == 6
>>> assert count_Pairs([1,5,1],3) == 1
>>> assert count_Pairs([3,2,1,7,8,9],6) == 0
Answer: | mbpp | mbpp | def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt; | train |
832 | Instruct: Write a function to extract the maximum numeric value from a string by using regex.
>>> assert extract_max('100klh564abc365bg') == 564
>>> assert extract_max('hello300how546mer231') == 546
>>> assert extract_max('its233beenalong343journey234') == 343
Answer: | mbpp | mbpp | import re
def extract_max(input):
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers) | train |
833 | Instruct: Write a function to get dictionary keys as a list.
>>> assert get_key({1:'python',2:'java'})==[1,2]
>>> assert get_key({10:'red',20:'blue',30:'black'})==[10,20,30]
>>> assert get_key({27:'language',39:'java',44:'little'})==[27,39,44]
Answer: | mbpp | mbpp | def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list | train |
834 | Instruct: Write a function to generate a square matrix filled with elements from 1 to n raised to the power of 2 in spiral order.
>>> assert generate_matrix(3)==[[1, 2, 3], [8, 9, 4], [7, 6, 5]]
>>> assert generate_matrix(2)==[[1,2],[4,3]]
>>> assert generate_matrix(7)==[[1, 2, 3, 4, 5, 6, 7], [24, 25, 26, 27, 28, 29, 8], [23, 40, 41, 42, 43, 30, 9], [22, 39, 48, 49, 44, 31, 10], [21, 38, 47, 46, 45, 32, 11], [20, 37, 36, 35, 34, 33, 12], [19, 18, 17, 16, 15, 14, 13]]
Answer: | mbpp | mbpp | def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix | train |
835 | Instruct: Write a python function to find the slope of a line.
>>> assert slope(4,2,2,5) == -1.5
>>> assert slope(2,4,4,6) == 1
>>> assert slope(1,2,4,2) == 0
Answer: | mbpp | mbpp | def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1) | train |
836 | Instruct: Write a function to find length of the subarray having maximum sum.
>>> assert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3],8) == 5
>>> assert max_sub_array_sum([1, -2, 1, 1, -2, 1],6) == 2
>>> assert max_sub_array_sum([-1, -2, 3, 4, 5],5) == 3
Answer: | mbpp | mbpp | from sys import maxsize
def max_sub_array_sum(a,size):
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1) | train |
837 | Instruct: Write a python function to find the cube sum of first n odd natural numbers.
>>> assert cube_Sum(2) == 28
>>> assert cube_Sum(3) == 153
>>> assert cube_Sum(4) == 496
Answer: | mbpp | mbpp | def cube_Sum(n):
sum = 0
for i in range(0,n) :
sum += (2*i+1)*(2*i+1)*(2*i+1)
return sum | train |
838 | Instruct: Write a python function to find minimum number swaps required to make two binary strings equal.
>>> assert min_Swaps("0011","1111") == 1
>>> assert min_Swaps("00011","01001") == 2
>>> assert min_Swaps("111","111") == 0
Answer: | mbpp | mbpp | def min_Swaps(s1,s2) :
c0 = 0; c1 = 0;
for i in range(len(s1)) :
if (s1[i] == '0' and s2[i] == '1') :
c0 += 1;
elif (s1[i] == '1' and s2[i] == '0') :
c1 += 1;
result = c0 // 2 + c1 // 2;
if (c0 % 2 == 0 and c1 % 2 == 0) :
return result;
elif ((c0 + c1) % 2 == 0) :
return result + 2;
else :
return -1; | train |
839 | Instruct: Write a function to sort the tuples alphabetically by the first item of each tuple.
>>> assert sort_tuple([("Amana", 28), ("Zenat", 30), ("Abhishek", 29),("Nikhil", 21), ("B", "C")]) == [('Abhishek', 29), ('Amana', 28), ('B', 'C'), ('Nikhil', 21), ('Zenat', 30)]
>>> assert sort_tuple([("aaaa", 28), ("aa", 30), ("bab", 29), ("bb", 21), ("csa", "C")]) == [('aa', 30), ('aaaa', 28), ('bab', 29), ('bb', 21), ('csa', 'C')]
>>> assert sort_tuple([("Sarala", 28), ("Ayesha", 30), ("Suman", 29),("Sai", 21), ("G", "H")]) == [('Ayesha', 30), ('G', 'H'), ('Sai', 21), ('Sarala', 28), ('Suman', 29)]
Answer: | mbpp | mbpp | def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | train |
840 | Instruct: Write a python function to check whether the roots of a quadratic equation are numerically equal but opposite in sign or not.
>>> assert Check_Solution(2,0,-1) == "Yes"
>>> assert Check_Solution(1,-5,6) == "No"
>>> assert Check_Solution(2,0,2) == "Yes"
Answer: | mbpp | mbpp | def Check_Solution(a,b,c):
if b == 0:
return ("Yes")
else:
return ("No") | train |
841 | Instruct: Write a function to count the number of inversions in the given array.
>>> assert get_inv_count([1, 20, 6, 4, 5], 5) == 5
>>> assert get_inv_count([8, 4, 2, 1], 4) == 6
>>> assert get_inv_count([3, 1, 2], 3) == 2
Answer: | mbpp | mbpp | def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | train |
842 | Instruct: Write a function to find the number which occurs for odd number of times in the given array.
>>> assert get_odd_occurence([2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2], 13) == 5
>>> assert get_odd_occurence([1, 2, 3, 2, 3, 1, 3], 7) == 3
>>> assert get_odd_occurence([5, 7, 2, 7, 5, 2, 5], 7) == 5
Answer: | mbpp | mbpp | def get_odd_occurence(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 | train |
843 | Instruct: Write a function to find the nth super ugly number from a given prime list of size k using heap queue algorithm.
>>> assert nth_super_ugly_number(12,[2,7,13,19])==32
>>> assert nth_super_ugly_number(10,[2,7,13,19])==26
>>> assert nth_super_ugly_number(100,[2,7,13,19])==5408
Answer: | mbpp | mbpp | import heapq
def nth_super_ugly_number(n, primes):
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
return uglies[-1] | train |
844 | Instruct: Write a python function to find the kth element in an array containing odd elements first and then even elements.
>>> assert get_Number(8,5) == 2
>>> assert get_Number(7,2) == 3
>>> assert get_Number(5,2) == 3
Answer: | mbpp | mbpp | def get_Number(n, k):
arr = [0] * n;
i = 0;
odd = 1;
while (odd <= n):
arr[i] = odd;
i += 1;
odd += 2;
even = 2;
while (even <= n):
arr[i] = even;
i += 1;
even += 2;
return arr[k - 1]; | train |
845 | Instruct: Write a python function to count the number of digits in factorial of a given number.
>>> assert find_Digits(7) == 4
>>> assert find_Digits(5) == 3
>>> assert find_Digits(4) == 2
Answer: | mbpp | mbpp | import math
def find_Digits(n):
if (n < 0):
return 0;
if (n <= 1):
return 1;
x = ((n * math.log10(n / math.e) + math.log10(2 * math.pi * n) /2.0));
return math.floor(x) + 1; | train |
846 | Instruct: Write a function to find the minimum number of platforms required for a railway/bus station.
>>> assert find_platform([900, 940, 950, 1100, 1500, 1800],[910, 1200, 1120, 1130, 1900, 2000],6)==3
>>> assert find_platform([100,200,300,400],[700,800,900,1000],4)==4
>>> assert find_platform([5,6,7,8],[4,3,2,1],4)==1
Answer: | mbpp | mbpp | def find_platform(arr, dep, n):
arr.sort()
dep.sort()
plat_needed = 1
result = 1
i = 1
j = 0
while (i < n and j < n):
if (arr[i] <= dep[j]):
plat_needed+= 1
i+= 1
elif (arr[i] > dep[j]):
plat_needed-= 1
j+= 1
if (plat_needed > result):
result = plat_needed
return result | train |
847 | Instruct: Write a python function to copy a list from a singleton tuple.
>>> assert lcopy([1, 2, 3]) == [1, 2, 3]
>>> assert lcopy([4, 8, 2, 10, 15, 18]) == [4, 8, 2, 10, 15, 18]
>>> assert lcopy([4, 5, 6]) == [4, 5, 6]
Answer: | mbpp | mbpp | def lcopy(xs):
return xs[:]
| train |
848 | Instruct: Write a function to find the area of a trapezium.
>>> assert area_trapezium(6,9,4)==30
>>> assert area_trapezium(10,20,30)==450
>>> assert area_trapezium(15,25,35)==700
Answer: | mbpp | mbpp | def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | train |
849 | Instruct: Write a python function to find sum of all prime divisors of a given number.
>>> assert Sum(60) == 10
>>> assert Sum(39) == 16
>>> assert Sum(40) == 7
Answer: | mbpp | mbpp | def Sum(N):
SumOfPrimeDivisors = [0]*(N + 1)
for i in range(2,N + 1) :
if (SumOfPrimeDivisors[i] == 0) :
for j in range(i,N + 1,i) :
SumOfPrimeDivisors[j] += i
return SumOfPrimeDivisors[N] | train |
850 | Instruct: Write a function to check if a triangle of positive area is possible with the given angles.
>>> assert is_triangleexists(50,60,70)==True
>>> assert is_triangleexists(90,45,45)==True
>>> assert is_triangleexists(150,30,70)==False
Answer: | mbpp | mbpp | def is_triangleexists(a,b,c):
if(a != 0 and b != 0 and c != 0 and (a + b + c)== 180):
if((a + b)>= c or (b + c)>= a or (a + c)>= b):
return True
else:
return False
else:
return False | train |
851 | Instruct: Write a python function to find sum of inverse of divisors.
>>> assert Sum_of_Inverse_Divisors(6,12) == 2
>>> assert Sum_of_Inverse_Divisors(9,13) == 1.44
>>> assert Sum_of_Inverse_Divisors(1,4) == 4
Answer: | mbpp | mbpp | def Sum_of_Inverse_Divisors(N,Sum):
ans = float(Sum)*1.0 /float(N);
return round(ans,2); | train |
852 | Instruct: Write a python function to remove negative numbers from a list.
>>> assert remove_negs([1,-2,3,-4]) == [1,3]
>>> assert remove_negs([1,2,3,-4]) == [1,2,3]
>>> assert remove_negs([4,5,-6,7,-8]) == [4,5,7]
Answer: | mbpp | mbpp | def remove_negs(num_list):
for item in num_list:
if item < 0:
num_list.remove(item)
return num_list | train |
853 | Instruct: Write a python function to find sum of odd factors of a number.
>>> assert sum_of_odd_Factors(30) == 24
>>> assert sum_of_odd_Factors(18) == 13
>>> assert sum_of_odd_Factors(2) == 1
Answer: | mbpp | mbpp | import math
def sum_of_odd_Factors(n):
res = 1
while n % 2 == 0:
n = n // 2
for i in range(3,int(math.sqrt(n) + 1)):
count = 0
curr_sum = 1
curr_term = 1
while n % i == 0:
count+=1
n = n // i
curr_term *= i
curr_sum += curr_term
res *= curr_sum
if n >= 2:
res *= (1 + n)
return res | train |
854 | Instruct: Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm.
>>> assert raw_heap([25, 44, 68, 21, 39, 23, 89])==[21, 25, 23, 44, 39, 68, 89]
>>> assert raw_heap([25, 35, 22, 85, 14, 65, 75, 25, 58])== [14, 25, 22, 25, 35, 65, 75, 85, 58]
>>> assert raw_heap([4, 5, 6, 2])==[2, 4, 6, 5]
Answer: | mbpp | mbpp | import heapq as hq
def raw_heap(rawheap):
hq.heapify(rawheap)
return rawheap | train |
855 | Instruct: Write a python function to check for even parity of a given number.
>>> assert check_Even_Parity(10) == True
>>> assert check_Even_Parity(11) == False
>>> assert check_Even_Parity(18) == True
Answer: | mbpp | mbpp | def check_Even_Parity(x):
parity = 0
while (x != 0):
x = x & (x - 1)
parity += 1
if (parity % 2 == 0):
return True
else:
return False | train |
856 | Instruct: Write a python function to find minimum adjacent swaps required to sort binary array.
>>> assert find_Min_Swaps([1,0,1,0],4) == 3
>>> assert find_Min_Swaps([0,1,0],3) == 1
>>> assert find_Min_Swaps([0,0,1,1,0],5) == 2
Answer: | mbpp | mbpp | def find_Min_Swaps(arr,n) :
noOfZeroes = [0] * n
count = 0
noOfZeroes[n - 1] = 1 - arr[n - 1]
for i in range(n-2,-1,-1) :
noOfZeroes[i] = noOfZeroes[i + 1]
if (arr[i] == 0) :
noOfZeroes[i] = noOfZeroes[i] + 1
for i in range(0,n) :
if (arr[i] == 1) :
count = count + noOfZeroes[i]
return count | train |
857 | Instruct: Write a function to list out the list of given strings individually using map function.
>>> assert listify_list(['Red', 'Blue', 'Black', 'White', 'Pink'])==[['R', 'e', 'd'], ['B', 'l', 'u', 'e'], ['B', 'l', 'a', 'c', 'k'], ['W', 'h', 'i', 't', 'e'], ['P', 'i', 'n', 'k']]
>>> assert listify_list(['python'])==[['p', 'y', 't', 'h', 'o', 'n']]
>>> assert listify_list([' red ', 'green',' black', 'blue ',' orange', 'brown'])==[[' ', 'r', 'e', 'd', ' '], ['g', 'r', 'e', 'e', 'n'], [' ', 'b', 'l', 'a', 'c', 'k'], ['b', 'l', 'u', 'e', ' '], [' ', 'o', 'r', 'a', 'n', 'g', 'e'], ['b', 'r', 'o', 'w', 'n']]
Answer: | mbpp | mbpp | def listify_list(list1):
result = list(map(list,list1))
return result | train |
858 | Instruct: Write a function to count number of lists in a given list of lists and square the count.
>>> assert count_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==25
>>> assert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]] )==16
>>> assert count_list([[2, 4], [[6,8], [4,5,8]], [10, 12, 14]])==9
Answer: | mbpp | mbpp | def count_list(input_list):
return (len(input_list))**2 | train |
859 | Instruct: Write a function to generate all sublists of a given list.
>>> assert sub_lists([10, 20, 30, 40])==[[], [10], [20], [30], [40], [10, 20], [10, 30], [10, 40], [20, 30], [20, 40], [30, 40], [10, 20, 30], [10, 20, 40], [10, 30, 40], [20, 30, 40], [10, 20, 30, 40]]
>>> assert sub_lists(['X', 'Y', 'Z'])==[[], ['X'], ['Y'], ['Z'], ['X', 'Y'], ['X', 'Z'], ['Y', 'Z'], ['X', 'Y', 'Z']]
>>> assert sub_lists([1,2,3])==[[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]
Answer: | mbpp | mbpp | from itertools import combinations
def sub_lists(my_list):
subs = []
for i in range(0, len(my_list)+1):
temp = [list(x) for x in combinations(my_list, i)]
if len(temp)>0:
subs.extend(temp)
return subs | train |
860 | Instruct: Write a function to check whether the given string is ending with only alphanumeric characters or not using regex.
>>> assert check_alphanumeric("dawood@") == 'Discard'
>>> assert check_alphanumeric("skdmsam326") == 'Accept'
>>> assert check_alphanumeric("cooltricks@") == 'Discard'
Answer: | mbpp | mbpp | import re
regex = '[a-zA-z0-9]$'
def check_alphanumeric(string):
if(re.search(regex, string)):
return ("Accept")
else:
return ("Discard") | train |
861 | Instruct: Write a function to find all anagrams of a string in a given list of strings using lambda function.
>>> assert anagram_lambda(["bcda", "abce", "cbda", "cbea", "adcb"],"abcd")==['bcda', 'cbda', 'adcb']
>>> assert anagram_lambda(["recitals"," python"], "articles" )==["recitals"]
>>> assert anagram_lambda([" keep"," abcdef"," xyz"]," peek")==[" keep"]
Answer: | mbpp | mbpp | from collections import Counter
def anagram_lambda(texts,str):
result = list(filter(lambda x: (Counter(str) == Counter(x)), texts))
return result | train |
862 | Instruct: Write a function to find the occurrences of n most common words in a given text.
>>> assert n_common_words("python is a programming language",1)==[('python', 1)]
>>> assert n_common_words("python is a programming language",1)==[('python', 1)]
>>> assert n_common_words("python is a programming language",5)==[('python', 1),('is', 1), ('a', 1), ('programming', 1), ('language', 1)]
Answer: | mbpp | mbpp | from collections import Counter
import re
def n_common_words(text,n):
words = re.findall('\w+',text)
n_common_words= Counter(words).most_common(n)
return list(n_common_words) | train |
863 | Instruct: Write a function to find the length of the longest sub-sequence such that elements in the subsequences are consecutive integers.
>>> assert find_longest_conseq_subseq([1, 2, 2, 3], 4) == 3
>>> assert find_longest_conseq_subseq([1, 9, 3, 10, 4, 20, 2], 7) == 4
>>> assert find_longest_conseq_subseq([36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42], 11) == 5
Answer: | mbpp | mbpp | def find_longest_conseq_subseq(arr, n):
ans = 0
count = 0
arr.sort()
v = []
v.append(arr[0])
for i in range(1, n):
if (arr[i] != arr[i - 1]):
v.append(arr[i])
for i in range(len(v)):
if (i > 0 and v[i] == v[i - 1] + 1):
count += 1
else:
count = 1
ans = max(ans, count)
return ans | train |
864 | Instruct: Write a function to find palindromes in a given list of strings using lambda function.
>>> assert palindrome_lambda(["php", "res", "Python", "abcd", "Java", "aaa"])==['php', 'aaa']
>>> assert palindrome_lambda(["abcd", "Python", "abba", "aba"])==['abba', 'aba']
>>> assert palindrome_lambda(["abcd", "abbccbba", "abba", "aba"])==['abbccbba', 'abba', 'aba']
Answer: | mbpp | mbpp | def palindrome_lambda(texts):
result = list(filter(lambda x: (x == "".join(reversed(x))), texts))
return result | train |
865 | Instruct: Write a function to print n-times a list using map function.
>>> assert ntimes_list([1, 2, 3, 4, 5, 6, 7],3)==[3, 6, 9, 12, 15, 18, 21]
>>> assert ntimes_list([1, 2, 3, 4, 5, 6, 7],4)==[4, 8, 12, 16, 20, 24, 28]
>>> assert ntimes_list([1, 2, 3, 4, 5, 6, 7],10)==[10, 20, 30, 40, 50, 60, 70]
Answer: | mbpp | mbpp | def ntimes_list(nums,n):
result = map(lambda x:n*x, nums)
return list(result) | train |
866 | Instruct: Write a function to check whether the given month name contains 31 days or not.
>>> assert check_monthnumb("February")==False
>>> assert check_monthnumb("January")==True
>>> assert check_monthnumb("March")==True
Answer: | mbpp | mbpp | def check_monthnumb(monthname2):
if(monthname2=="January" or monthname2=="March"or monthname2=="May" or monthname2=="July" or monthname2=="Augest" or monthname2=="October" or monthname2=="December"):
return True
else:
return False | train |
867 | Instruct: Write a python function to add a minimum number such that the sum of array becomes even.
>>> assert min_Num([1,2,3,4,5,6,7,8,9],9) == 1
>>> assert min_Num([1,2,3,4,5,6,7,8],8) == 2
>>> assert min_Num([1,2,3],3) == 2
Answer: | mbpp | mbpp | def min_Num(arr,n):
odd = 0
for i in range(n):
if (arr[i] % 2):
odd += 1
if (odd % 2):
return 1
return 2 | train |
868 | Instruct: Write a python function to find the length of the last word in a given string.
>>> assert length_Of_Last_Word("python language") == 8
>>> assert length_Of_Last_Word("PHP") == 3
>>> assert length_Of_Last_Word("") == 0
Answer: | mbpp | mbpp | def length_Of_Last_Word(a):
l = 0
x = a.strip()
for i in range(len(x)):
if x[i] == " ":
l = 0
else:
l += 1
return l | train |
869 | Instruct: Write a function to remove sublists from a given list of lists, which are outside a given range.
>>> assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],13,17)==[[13, 14, 15, 17]]
>>> assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],1,3)==[[2], [1, 2, 3]]
>>> assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],0,7)==[[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7]]
Answer: | mbpp | mbpp | def remove_list_range(list1, leftrange, rigthrange):
result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)]
return result | train |
870 | Instruct: Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function.
>>> assert sum_positivenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==48
>>> assert sum_positivenum([10,15,-14,13,-18,12,-20])==50
>>> assert sum_positivenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==522
Answer: | mbpp | mbpp | def sum_positivenum(nums):
sum_positivenum = list(filter(lambda nums:nums>0,nums))
return sum(sum_positivenum) | train |
871 | Instruct: Write a python function to check whether the given strings are rotations of each other or not.
>>> assert are_Rotations("abc","cba") == False
>>> assert are_Rotations("abcd","cdba") == False
>>> assert are_Rotations("abacd","cdaba") == True
Answer: | mbpp | mbpp | def are_Rotations(string1,string2):
size1 = len(string1)
size2 = len(string2)
temp = ''
if size1 != size2:
return False
temp = string1 + string1
if (temp.count(string2)> 0):
return True
else:
return False | train |
872 | Instruct: Write a function to check if a nested list is a subset of another nested list.
>>> assert check_subset([[1, 3], [5, 7], [9, 11], [13, 15, 17]] ,[[1, 3],[13,15,17]])==True
>>> assert check_subset([[1, 2], [2, 3], [3, 4], [5, 6]],[[3, 4], [5, 6]])==True
>>> assert check_subset([[[1, 2], [2, 3]], [[3, 4], [5, 7]]],[[[3, 4], [5, 6]]])==False
Answer: | mbpp | mbpp | def check_subset(list1,list2):
return all(map(list1.__contains__,list2)) | train |
873 | Instruct: Write a function to solve the fibonacci sequence using recursion.
>>> assert fibonacci(7) == 13
>>> assert fibonacci(8) == 21
>>> assert fibonacci(9) == 34
Answer: | mbpp | mbpp | def fibonacci(n):
if n == 1 or n == 2:
return 1
else:
return (fibonacci(n - 1) + (fibonacci(n - 2))) | train |
874 | Instruct: Write a python function to check if the string is a concatenation of another string.
>>> assert check_Concat("abcabcabc","abc") == True
>>> assert check_Concat("abcab","abc") == False
>>> assert check_Concat("aba","ab") == False
Answer: | mbpp | mbpp | def check_Concat(str1,str2):
N = len(str1)
M = len(str2)
if (N % M != 0):
return False
for i in range(N):
if (str1[i] != str2[i % M]):
return False
return True | train |
875 | Instruct: Write a function to find the minimum difference in the tuple pairs of given tuples.
>>> assert min_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 1
>>> assert min_difference([(4, 6), (12, 8), (11, 4), (2, 13)]) == 2
>>> assert min_difference([(5, 17), (3, 9), (12, 5), (3, 24)]) == 6
Answer: | mbpp | mbpp | def min_difference(test_list):
temp = [abs(b - a) for a, b in test_list]
res = min(temp)
return (res) | train |
876 | Instruct: Write a python function to find lcm of two positive integers.
>>> assert lcm(4,6) == 12
>>> assert lcm(15,17) == 255
>>> assert lcm(2,6) == 6
Answer: | mbpp | mbpp | def lcm(x, y):
if x > y:
z = x
else:
z = y
while(True):
if((z % x == 0) and (z % y == 0)):
lcm = z
break
z += 1
return lcm | train |
877 | Instruct: Write a python function to sort the given string.
>>> assert sort_String("cba") == "abc"
>>> assert sort_String("data") == "aadt"
>>> assert sort_String("zxy") == "xyz"
Answer: | mbpp | mbpp | def sort_String(str) :
str = ''.join(sorted(str))
return (str) | train |
878 | Instruct: Write a function to check if the given tuple contains only k elements.
>>> assert check_tuples((3, 5, 6, 5, 3, 6),[3, 6, 5]) == True
>>> assert check_tuples((4, 5, 6, 4, 6, 5),[4, 5, 6]) == True
>>> assert check_tuples((9, 8, 7, 6, 8, 9),[9, 8, 1]) == False
Answer: | mbpp | mbpp | def check_tuples(test_tuple, K):
res = all(ele in K for ele in test_tuple)
return (res) | train |
879 | Instruct: Write a function that matches a string that has an 'a' followed by anything, ending in 'b' by using regex.
>>> assert text_match("aabbbbd") == 'Not matched!'
>>> assert text_match("aabAbbbc") == 'Not matched!'
>>> assert text_match("accddbbjjjb") == 'Found a match!'
Answer: | mbpp | mbpp | import re
def text_match(text):
patterns = 'a.*?b$'
if re.search(patterns, text):
return ('Found a match!')
else:
return ('Not matched!') | train |
880 | Instruct: Write a python function to find number of solutions in quadratic equation.
>>> assert Check_Solution(2,5,2) == "2 solutions"
>>> assert Check_Solution(1,1,1) == "No solutions"
>>> assert Check_Solution(1,2,1) == "1 solution"
Answer: | mbpp | mbpp | def Check_Solution(a,b,c) :
if ((b*b) - (4*a*c)) > 0 :
return ("2 solutions")
elif ((b*b) - (4*a*c)) == 0 :
return ("1 solution")
else :
return ("No solutions") | train |
881 | Instruct: Write a function to find the sum of first even and odd number of a given list.
>>> assert sum_even_odd([1,3,5,7,4,1,6,8])==5
>>> assert sum_even_odd([1,2,3,4,5,6,7,8,9,10])==3
>>> assert sum_even_odd([1,5,7,9,10])==11
Answer: | mbpp | mbpp | def sum_even_odd(list1):
first_even = next((el for el in list1 if el%2==0),-1)
first_odd = next((el for el in list1 if el%2!=0),-1)
return (first_even+first_odd) | train |
882 | Instruct: Write a function to caluclate perimeter of a parallelogram.
>>> assert parallelogram_perimeter(10,20)==400
>>> assert parallelogram_perimeter(15,20)==600
>>> assert parallelogram_perimeter(8,9)==144
Answer: | mbpp | mbpp | def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter | train |
883 | Instruct: Write a function to find numbers divisible by m and n from a list of numbers using lambda function.
>>> assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],2,4)==[ 152,44]
>>> assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[10]
>>> assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10,20]
Answer: | mbpp | mbpp | def div_of_nums(nums,m,n):
result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums))
return result | train |
884 | Instruct: Write a python function to check whether all the bits are within a given range or not.
>>> assert all_Bits_Set_In_The_Given_Range(10,2,1) == True
>>> assert all_Bits_Set_In_The_Given_Range(5,2,4) == False
>>> assert all_Bits_Set_In_The_Given_Range(22,2,3) == True
Answer: | mbpp | mbpp | def all_Bits_Set_In_The_Given_Range(n,l,r):
num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1)
new_num = n & num
if (num == new_num):
return True
return False | train |
885 | Instruct: Write a python function to check whether the two given strings are isomorphic to each other or not.
>>> assert is_Isomorphic("paper","title") == True
>>> assert is_Isomorphic("ab","ba") == True
>>> assert is_Isomorphic("ab","aa") == False
Answer: | mbpp | mbpp | def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False | train |
886 | Instruct: Write a function to add all the numbers in a list and divide it with the length of the list.
>>> assert sum_num((8, 2, 3, 0, 7))==4.0
>>> assert sum_num((-10,-20,-30))==-20.0
>>> assert sum_num((19,15,18))==17.333333333333332
Answer: | mbpp | mbpp | def sum_num(numbers):
total = 0
for x in numbers:
total += x
return total/len(numbers) | train |
887 | Instruct: Write a python function to check whether the given number is odd or not using bitwise operator.
>>> assert is_odd(5) == True
>>> assert is_odd(6) == False
>>> assert is_odd(7) == True
Answer: | mbpp | mbpp | def is_odd(n) :
if (n^1 == n-1) :
return True;
else :
return False; | train |
888 | Instruct: Write a function to substract the elements of the given nested tuples.
>>> assert substract_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((-5, -4), (1, -4), (1, 8), (-6, 7))
>>> assert substract_elements(((13, 4), (14, 6), (13, 10), (12, 11)), ((19, 8), (14, 10), (12, 2), (18, 4))) == ((-6, -4), (0, -4), (1, 8), (-6, 7))
>>> assert substract_elements(((19, 5), (18, 7), (19, 11), (17, 12)), ((12, 9), (17, 11), (13, 3), (19, 5))) == ((7, -4), (1, -4), (6, 8), (-2, 7))
Answer: | mbpp | mbpp | def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res) | train |
889 | Instruct: Write a function to reverse each list in a given list of lists.
>>> assert reverse_list_lists([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])==[[4, 3, 2, 1], [8, 7, 6, 5], [12, 11, 10, 9], [16, 15, 14, 13]]
>>> assert reverse_list_lists([[1,2],[2,3],[3,4]])==[[2,1],[3,2],[4,3]]
>>> assert reverse_list_lists([[10,20],[30,40]])==[[20,10],[40,30]]
Answer: | mbpp | mbpp | def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists | train |
890 | Instruct: Write a python function to find the index of an extra element present in one sorted array.
>>> assert find_Extra([1,2,3,4],[1,2,3],3) == 3
>>> assert find_Extra([2,4,6,8,10],[2,4,6,8],4) == 4
>>> assert find_Extra([1,3,5,7,9,11],[1,3,5,7,9],5) == 5
Answer: | mbpp | mbpp | def find_Extra(arr1,arr2,n) :
for i in range(0, n) :
if (arr1[i] != arr2[i]) :
return i
return n | train |
891 | Instruct: Write a python function to check whether the given two numbers have same number of digits or not.
>>> assert same_Length(12,1) == False
>>> assert same_Length(2,2) == True
>>> assert same_Length(10,20) == True
Answer: | mbpp | mbpp | def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False; | train |
892 | Instruct: Write a function to remove multiple spaces in a string.
>>> assert remove_spaces('python program')==('python program')
>>> assert remove_spaces('python programming language')==('python programming language')
>>> assert remove_spaces('python program')==('python program')
Answer: | mbpp | mbpp | import re
def remove_spaces(text):
return (re.sub(' +',' ',text)) | train |
893 | Instruct: Write a python function to get the last element of each sublist.
>>> assert Extract([[1, 2, 3], [4, 5], [6, 7, 8, 9]]) == [3, 5, 9]
>>> assert Extract([['x', 'y', 'z'], ['m'], ['a', 'b'], ['u', 'v']]) == ['z', 'm', 'b', 'v']
>>> assert Extract([[1, 2, 3], [4, 5]]) == [3, 5]
Answer: | mbpp | mbpp | def Extract(lst):
return [item[-1] for item in lst] | train |
894 | Instruct: Write a function to convert the given string of float type into tuple.
>>> assert float_to_tuple("1.2, 1.3, 2.3, 2.4, 6.5") == (1.2, 1.3, 2.3, 2.4, 6.5)
>>> assert float_to_tuple("2.3, 2.4, 5.6, 5.4, 8.9") == (2.3, 2.4, 5.6, 5.4, 8.9)
>>> assert float_to_tuple("0.3, 0.5, 7.8, 9.4") == (0.3, 0.5, 7.8, 9.4)
Answer: | mbpp | mbpp | def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res) | train |
895 | Instruct: Write a function to find the maximum sum of subsequences of given array with no adjacent elements.
>>> assert max_sum_subseq([1, 2, 9, 4, 5, 0, 4, 11, 6]) == 26
>>> assert max_sum_subseq([1, 2, 9, 5, 6, 0, 5, 12, 7]) == 28
>>> assert max_sum_subseq([1, 3, 10, 5, 6, 0, 6, 14, 21]) == 44
Answer: | mbpp | mbpp | def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1] | train |
896 | Instruct: Write a function to sort a list in increasing order by the last element in each tuple from a given list of non-empty tuples.
>>> assert sort_list_last([(2, 5), (1, 2), (4, 4), (2, 3), (2, 1)])==[(2, 1), (1, 2), (2, 3), (4, 4), (2, 5)]
>>> assert sort_list_last([(9,8), (4, 7), (3,5), (7,9), (1,2)])==[(1,2), (3,5), (4,7), (9,8), (7,9)]
>>> assert sort_list_last([(20,50), (10,20), (40,40)])==[(10,20),(40,40),(20,50)]
Answer: | mbpp | mbpp | def last(n):
return n[-1]
def sort_list_last(tuples):
return sorted(tuples, key=last) | train |
897 | Instruct: Write a python function to check whether the word is present in a given sentence or not.
>>> assert is_Word_Present("machine learning","machine") == True
>>> assert is_Word_Present("easy","fun") == False
>>> assert is_Word_Present("python language","code") == False
Answer: | mbpp | mbpp | def is_Word_Present(sentence,word):
s = sentence.split(" ")
for i in s:
if (i == word):
return True
return False | train |
898 | Instruct: Write a function to extract specified number of elements from a given list, which follow each other continuously.
>>> assert extract_elements([1, 1, 3, 4, 4, 5, 6, 7],2)==[1, 4]
>>> assert extract_elements([0, 1, 2, 3, 4, 4, 4, 4, 5, 7],4)==[4]
>>> assert extract_elements([0,0,0,0,0],5)==[0]
Answer: | mbpp | mbpp | from itertools import groupby
def extract_elements(numbers, n):
result = [i for i, j in groupby(numbers) if len(list(j)) == n]
return result | train |
899 | Instruct: Write a python function to check whether an array can be sorted or not by picking only the corner elements.
>>> assert check([3,2,1,2,3,4],6) == True
>>> assert check([2,1,4,5,1],5) == True
>>> assert check([1,2,2,1,2,3],6) == True
Answer: | mbpp | mbpp | def check(arr,n):
g = 0
for i in range(1,n):
if (arr[i] - arr[i - 1] > 0 and g == 1):
return False
if (arr[i] - arr[i] < 0):
g = 1
return True | train |
900 | Instruct: Write a function where a string will start with a specific number.
>>> assert match_num('5-2345861')==True
>>> assert match_num('6-2345861')==False
>>> assert match_num('78910')==False
Answer: | mbpp | mbpp | import re
def match_num(string):
text = re.compile(r"^5")
if text.match(string):
return True
else:
return False | train |