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 |
|---|---|---|---|---|---|
901 | Instruct: Write a function to find the smallest multiple of the first n numbers.
>>> assert smallest_multiple(13)==360360
>>> assert smallest_multiple(2)==2
>>> assert smallest_multiple(1)==1
Answer: | mbpp | mbpp | def smallest_multiple(n):
if (n<=2):
return n
i = n * 2
factors = [number for number in range(n, 1, -1) if number * 2 > n]
while True:
for a in factors:
if i % a != 0:
i += n
break
if (a == factors[-1] and i % a == 0):
return i | train |
902 | Instruct: Write a function to combine two dictionaries by adding values for common keys.
>>> assert add_dict({'a': 100, 'b': 200, 'c':300},{'a': 300, 'b': 200, 'd':400})==({'b': 400, 'd': 400, 'a': 400, 'c': 300})
>>> assert add_dict({'a': 500, 'b': 700, 'c':900},{'a': 500, 'b': 600, 'd':900})==({'b': 1300, 'd': 900, 'a': 1000, 'c': 900})
>>> assert add_dict({'a':900,'b':900,'d':900},{'a':900,'b':900,'d':900})==({'b': 1800, 'd': 1800, 'a': 1800})
Answer: | mbpp | mbpp | from collections import Counter
def add_dict(d1,d2):
add_dict = Counter(d1) + Counter(d2)
return add_dict | train |
903 | Instruct: Write a python function to count the total unset bits from 1 to n.
>>> assert count_Unset_Bits(2) == 1
>>> assert count_Unset_Bits(5) == 4
>>> assert count_Unset_Bits(14) == 17
Answer: | mbpp | mbpp | def count_Unset_Bits(n) :
cnt = 0;
for i in range(1,n + 1) :
temp = i;
while (temp) :
if (temp % 2 == 0) :
cnt += 1;
temp = temp // 2;
return cnt; | train |
904 | Instruct: Write a function to return true if the given number is even else return false.
>>> assert even_num(13.5)==False
>>> assert even_num(0)==True
>>> assert even_num(-9)==False
Answer: | mbpp | mbpp | def even_num(x):
if x%2==0:
return True
else:
return False | train |
905 | Instruct: Write a python function to find the sum of squares of binomial co-efficients.
>>> assert sum_of_square(4) == 70
>>> assert sum_of_square(5) == 252
>>> assert sum_of_square(2) == 6
Answer: | mbpp | mbpp | def factorial(start,end):
res = 1
for i in range(start,end + 1):
res *= i
return res
def sum_of_square(n):
return int(factorial(n + 1, 2 * n) /factorial(1, n)) | train |
906 | Instruct: Write a function to extract year, month and date from a url by using regex.
>>> assert extract_date("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/") == [('2016', '09', '02')]
>>> assert extract_date("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/") == [('2020', '11', '03')]
>>> assert extract_date("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms") == [('2020', '12', '29')]
Answer: | mbpp | mbpp | import re
def extract_date(url):
return re.findall(r'/(\d{4})/(\d{1,2})/(\d{1,2})/', url) | train |
907 | Instruct: Write a function to print the first n lucky numbers.
>>> assert lucky_num(10)==[1, 3, 7, 9, 13, 15, 21, 25, 31, 33]
>>> assert lucky_num(5)==[1, 3, 7, 9, 13]
>>> assert lucky_num(8)==[1, 3, 7, 9, 13, 15, 21, 25]
Answer: | mbpp | mbpp | def lucky_num(n):
List=range(-1,n*n+9,2)
i=2
while List[i:]:List=sorted(set(List)-set(List[List[i]::List[i]]));i+=1
return List[1:n+1] | train |
908 | Instruct: Write a function to find the fixed point in the given array.
>>> assert find_fixed_point([-10, -1, 0, 3, 10, 11, 30, 50, 100],9) == 3
>>> assert find_fixed_point([1, 2, 3, 4, 5, 6, 7, 8],8) == -1
>>> assert find_fixed_point([0, 2, 5, 8, 17],5) == 0
Answer: | mbpp | mbpp | def find_fixed_point(arr, n):
for i in range(n):
if arr[i] is i:
return i
return -1 | train |
909 | Instruct: Write a function to find the previous palindrome of a specified number.
>>> assert previous_palindrome(99)==88
>>> assert previous_palindrome(1221)==1111
>>> assert previous_palindrome(120)==111
Answer: | mbpp | mbpp | def previous_palindrome(num):
for x in range(num-1,0,-1):
if str(x) == str(x)[::-1]:
return x | train |
910 | Instruct: Write a function to validate a gregorian date.
>>> assert check_date(11,11,2002)==True
>>> assert check_date(13,11,2002)==False
>>> assert check_date('11','11','2002')==True
Answer: | mbpp | mbpp | import datetime
def check_date(m, d, y):
try:
m, d, y = map(int, (m, d, y))
datetime.date(y, m, d)
return True
except ValueError:
return False | train |
911 | Instruct: Write a function to compute maximum product of three numbers of a given array of integers using heap queue algorithm.
>>> assert maximum_product( [12, 74, 9, 50, 61, 41])==225700
>>> assert maximum_product([25, 35, 22, 85, 14, 65, 75, 25, 58])==414375
>>> assert maximum_product([18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1])==2520
Answer: | mbpp | mbpp | def maximum_product(nums):
import heapq
a, b = heapq.nlargest(3, nums), heapq.nsmallest(2, nums)
return max(a[0] * a[1] * a[2], a[0] * b[0] * b[1]) | train |
912 | Instruct: Write a function to find ln, m lobb number.
>>> assert int(lobb_num(5, 3)) == 35
>>> assert int(lobb_num(3, 2)) == 5
>>> assert int(lobb_num(4, 2)) == 20
Answer: | mbpp | mbpp | def binomial_coeff(n, k):
C = [[0 for j in range(k + 1)]
for i in range(n + 1)]
for i in range(0, n + 1):
for j in range(0, min(i, k) + 1):
if (j == 0 or j == i):
C[i][j] = 1
else:
C[i][j] = (C[i - 1][j - 1]
+ C[i - 1][j])
return C[n][k]
def lobb_num(n, m):
return (((2 * m + 1) *
binomial_coeff(2 * n, m + n))
/ (m + n + 1)) | train |
913 | Instruct: Write a function to check for a number at the end of a string.
>>> assert end_num('abcdef')==False
>>> assert end_num('abcdef7')==True
>>> assert end_num('abc')==False
Answer: | mbpp | mbpp | import re
def end_num(string):
text = re.compile(r".*[0-9]$")
if text.match(string):
return True
else:
return False | train |
914 | Instruct: Write a python function to check whether the given string is made up of two alternating characters or not.
>>> assert is_Two_Alter("abab") == True
>>> assert is_Two_Alter("aaaa") == False
>>> assert is_Two_Alter("xyz") == False
Answer: | mbpp | mbpp | def is_Two_Alter(s):
for i in range (len( s) - 2) :
if (s[i] != s[i + 2]) :
return False
if (s[0] == s[1]):
return False
return True | train |
915 | Instruct: Write a function to rearrange positive and negative numbers in a given array using lambda function.
>>> assert rearrange_numbs([-1, 2, -3, 5, 7, 8, 9, -10])==[2, 5, 7, 8, 9, -10, -3, -1]
>>> assert rearrange_numbs([10,15,14,13,-18,12,-20])==[10, 12, 13, 14, 15, -20, -18]
>>> assert rearrange_numbs([-20,20,-10,10,-30,30])==[10, 20, 30, -30, -20, -10]
Answer: | mbpp | mbpp | def rearrange_numbs(array_nums):
result = sorted(array_nums, key = lambda i: 0 if i == 0 else -1 / i)
return result | train |
916 | Instruct: Write a function to find if there is a triplet in the array whose sum is equal to a given value.
>>> assert find_triplet_array([1, 4, 45, 6, 10, 8], 6, 22) == (4, 10, 8)
>>> assert find_triplet_array([12, 3, 5, 2, 6, 9], 6, 24) == (12, 3, 9)
>>> assert find_triplet_array([1, 2, 3, 4, 5], 5, 9) == (1, 3, 5)
Answer: | mbpp | mbpp | def find_triplet_array(A, arr_size, sum):
for i in range( 0, arr_size-2):
for j in range(i + 1, arr_size-1):
for k in range(j + 1, arr_size):
if A[i] + A[j] + A[k] == sum:
return A[i],A[j],A[k]
return True
return False | train |
917 | Instruct: Write a function to find the sequences of one upper case letter followed by lower case letters.
>>> assert text_uppercase_lowercase("AaBbGg")==('Found a match!')
>>> assert text_uppercase_lowercase("aA")==('Not matched!')
>>> assert text_uppercase_lowercase("PYTHON")==('Not matched!')
Answer: | mbpp | mbpp | import re
def text_uppercase_lowercase(text):
patterns = '[A-Z]+[a-z]+$'
if re.search(patterns, text):
return 'Found a match!'
else:
return ('Not matched!') | train |
918 | Instruct: Write a function to count coin change.
>>> assert coin_change([1, 2, 3],3,4)==4
>>> assert coin_change([4,5,6,7,8,9],6,9)==2
>>> assert coin_change([4,5,6,7,8,9],6,4)==1
Answer: | mbpp | mbpp | def coin_change(S, m, n):
table = [[0 for x in range(m)] for x in range(n+1)]
for i in range(m):
table[0][i] = 1
for i in range(1, n+1):
for j in range(m):
x = table[i - S[j]][j] if i-S[j] >= 0 else 0
y = table[i][j-1] if j >= 1 else 0
table[i][j] = x + y
return table[n][m-1] | train |
919 | Instruct: Write a python function to multiply all items in the list.
>>> assert multiply_list([1,-2,3]) == -6
>>> assert multiply_list([1,2,3,4]) == 24
>>> assert multiply_list([3,1,2,3]) == 18
Answer: | mbpp | mbpp | def multiply_list(items):
tot = 1
for x in items:
tot *= x
return tot | train |
920 | Instruct: Write a function to remove all tuples with all none values in the given tuple list.
>>> assert remove_tuple([(None, 2), (None, None), (3, 4), (12, 3), (None, )] ) == '[(None, 2), (3, 4), (12, 3)]'
>>> assert remove_tuple([(None, None), (None, None), (3, 6), (17, 3), (None,1 )] ) == '[(3, 6), (17, 3), (None, 1)]'
>>> assert remove_tuple([(1, 2), (2, None), (3, None), (24, 3), (None, None )] ) == '[(1, 2), (2, None), (3, None), (24, 3)]'
Answer: | mbpp | mbpp | def remove_tuple(test_list):
res = [sub for sub in test_list if not all(ele == None for ele in sub)]
return (str(res)) | train |
921 | Instruct: Write a function to perform chunking of tuples each of size n.
>>> assert chunk_tuples((10, 4, 5, 6, 7, 6, 8, 3, 4), 3) == [(10, 4, 5), (6, 7, 6), (8, 3, 4)]
>>> assert chunk_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 2) == [(1, 2), (3, 4), (5, 6), (7, 8), (9,)]
>>> assert chunk_tuples((11, 14, 16, 17, 19, 21, 22, 25), 4) == [(11, 14, 16, 17), (19, 21, 22, 25)]
Answer: | mbpp | mbpp | def chunk_tuples(test_tup, N):
res = [test_tup[i : i + N] for i in range(0, len(test_tup), N)]
return (res) | train |
922 | Instruct: Write a function to find a pair with the highest product from a given array of integers.
>>> assert max_product([1, 2, 3, 4, 7, 0, 8, 4])==(7, 8)
>>> assert max_product([0, -1, -2, -4, 5, 0, -6])==(-4, -6)
>>> assert max_product([1, 3, 5, 6, 8, 9])==(8,9)
Answer: | mbpp | mbpp | def max_product(arr):
arr_len = len(arr)
if (arr_len < 2):
return None
x = arr[0]; y = arr[1]
for i in range(0, arr_len):
for j in range(i + 1, arr_len):
if (arr[i] * arr[j] > x * y):
x = arr[i]; y = arr[j]
return x,y | train |
923 | Instruct: Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.
>>> assert super_seq("AGGTAB", "GXTXAYB", 6, 7) == 9
>>> assert super_seq("feek", "eke", 4, 3) == 5
>>> assert super_seq("PARRT", "RTA", 5, 3) == 6
Answer: | mbpp | mbpp | def super_seq(X, Y, m, n):
if (not m):
return n
if (not n):
return m
if (X[m - 1] == Y[n - 1]):
return 1 + super_seq(X, Y, m - 1, n - 1)
return 1 + min(super_seq(X, Y, m - 1, n), super_seq(X, Y, m, n - 1)) | train |
924 | Instruct: Write a function to find maximum of two numbers.
>>> assert max_of_two(10,20)==20
>>> assert max_of_two(19,15)==19
>>> assert max_of_two(-10,-20)==-10
Answer: | mbpp | mbpp | def max_of_two( x, y ):
if x > y:
return x
return y | train |
925 | Instruct: Write a python function to calculate the product of all the numbers of a given tuple.
>>> assert mutiple_tuple((4, 3, 2, 2, -1, 18)) == -864
>>> assert mutiple_tuple((1,2,3)) == 6
>>> assert mutiple_tuple((-2,-4,-6)) == -48
Answer: | mbpp | mbpp | def mutiple_tuple(nums):
temp = list(nums)
product = 1
for x in temp:
product *= x
return product | train |
926 | Instruct: Write a function to find n-th rencontres number.
>>> assert rencontres_number(7, 2) == 924
>>> assert rencontres_number(3, 0) == 2
>>> assert rencontres_number(3, 1) == 3
Answer: | mbpp | mbpp | def binomial_coeffi(n, k):
if (k == 0 or k == n):
return 1
return (binomial_coeffi(n - 1, k - 1)
+ binomial_coeffi(n - 1, k))
def rencontres_number(n, m):
if (n == 0 and m == 0):
return 1
if (n == 1 and m == 0):
return 0
if (m == 0):
return ((n - 1) * (rencontres_number(n - 1, 0)+ rencontres_number(n - 2, 0)))
return (binomial_coeffi(n, m) * rencontres_number(n - m, 0)) | train |
927 | Instruct: Write a function to calculate the height of the given binary tree.
>>> assert (max_height(root)) == 3
>>> assert (max_height(root1)) == 5
>>> assert (max_height(root2)) == 4
Answer: | mbpp | mbpp | class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def max_height(node):
if node is None:
return 0 ;
else :
left_height = max_height(node.left)
right_height = max_height(node.right)
if (left_height > right_height):
return left_height+1
else:
return right_height+1 | train |
928 | Instruct: Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.
>>> assert change_date_format('2026-01-02')=='02-01-2026'
>>> assert change_date_format('2021-01-04')=='04-01-2021'
>>> assert change_date_format('2030-06-06')=='06-06-2030'
Answer: | mbpp | mbpp | import re
def change_date_format(dt):
return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\\3-\\2-\\1', dt)
return change_date_format(dt) | train |
929 | Instruct: Write a function to count repeated items of a tuple.
>>> assert count_tuplex((2, 4, 5, 6, 2, 3, 4, 4, 7),4)==3
>>> assert count_tuplex((2, 4, 5, 6, 2, 3, 4, 4, 7),2)==2
>>> assert count_tuplex((2, 4, 7, 7, 7, 3, 4, 4, 7),7)==4
Answer: | mbpp | mbpp | def count_tuplex(tuplex,value):
count = tuplex.count(value)
return count | train |
930 | Instruct: Write a function that matches a string that has an a followed by zero or more b's by using regex.
>>> assert text_match("msb") == 'Not matched!'
>>> assert text_match("a0c") == 'Found a match!'
>>> assert text_match("abbc") == 'Found a match!'
Answer: | mbpp | mbpp | import re
def text_match(text):
patterns = 'ab*?'
if re.search(patterns, text):
return ('Found a match!')
else:
return ('Not matched!') | train |
931 | Instruct: Write a function to calculate the sum of series 1³+2³+3³+….+n³.
>>> assert sum_series(7)==784
>>> assert sum_series(5)==225
>>> assert sum_series(15)==14400
Answer: | mbpp | mbpp | import math
def sum_series(number):
total = 0
total = math.pow((number * (number + 1)) /2, 2)
return total | train |
932 | Instruct: Write a function to remove duplicate words from a given list of strings.
>>> assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises"])==['Python', 'Exercises', 'Practice', 'Solution']
>>> assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","Java"])==['Python', 'Exercises', 'Practice', 'Solution', 'Java']
>>> assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","C++","C","C++"])==['Python', 'Exercises', 'Practice', 'Solution','C++','C']
Answer: | mbpp | mbpp | def remove_duplic_list(l):
temp = []
for x in l:
if x not in temp:
temp.append(x)
return temp | train |
933 | Instruct: Write a function to convert camel case string to snake case string by using regex.
>>> assert camel_to_snake('GoogleAssistant') == 'google_assistant'
>>> assert camel_to_snake('ChromeCast') == 'chrome_cast'
>>> assert camel_to_snake('QuadCore') == 'quad_core'
Answer: | mbpp | mbpp | import re
def camel_to_snake(text):
str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower() | train |
934 | Instruct: Write a function to find the nth delannoy number.
>>> assert dealnnoy_num(3, 4) == 129
>>> assert dealnnoy_num(3, 3) == 63
>>> assert dealnnoy_num(4, 5) == 681
Answer: | mbpp | mbpp | def dealnnoy_num(n, m):
if (m == 0 or n == 0) :
return 1
return dealnnoy_num(m - 1, n) + dealnnoy_num(m - 1, n - 1) + dealnnoy_num(m, n - 1) | train |
935 | Instruct: Write a function to calculate the sum of series 1²+2²+3²+….+n².
>>> assert series_sum(6)==91
>>> assert series_sum(7)==140
>>> assert series_sum(12)==650
Answer: | mbpp | mbpp | def series_sum(number):
total = 0
total = (number * (number + 1) * (2 * number + 1)) / 6
return total | train |
936 | Instruct: Write a function to re-arrange the given tuples based on the given ordered list.
>>> assert re_arrange_tuples([(4, 3), (1, 9), (2, 10), (3, 2)], [1, 4, 2, 3]) == [(1, 9), (4, 3), (2, 10), (3, 2)]
>>> assert re_arrange_tuples([(5, 4), (2, 10), (3, 11), (4, 3)], [3, 4, 2, 3]) == [(3, 11), (4, 3), (2, 10), (3, 11)]
>>> assert re_arrange_tuples([(6, 3), (3, 8), (5, 7), (2, 4)], [2, 5, 3, 6]) == [(2, 4), (5, 7), (3, 8), (6, 3)]
Answer: | mbpp | mbpp | def re_arrange_tuples(test_list, ord_list):
temp = dict(test_list)
res = [(key, temp[key]) for key in ord_list]
return (res) | train |
937 | Instruct: Write a function to count the most common character in a given string.
>>> assert max_char("hello world")==('l')
>>> assert max_char("hello ")==('l')
>>> assert max_char("python pr")==('p')
Answer: | mbpp | mbpp | from collections import Counter
def max_char(str1):
temp = Counter(str1)
max_char = max(temp, key = temp.get)
return max_char | train |
938 | Instruct: Write a function to find three closest elements from three sorted arrays.
>>> assert find_closet([1, 4, 10],[2, 15, 20],[10, 12],3,3,2) == (10, 15, 10)
>>> assert find_closet([20, 24, 100],[2, 19, 22, 79, 800],[10, 12, 23, 24, 119],3,5,5) == (24, 22, 23)
>>> assert find_closet([2, 5, 11],[3, 16, 21],[11, 13],3,3,2) == (11, 16, 11)
Answer: | mbpp | mbpp | import sys
def find_closet(A, B, C, p, q, r):
diff = sys.maxsize
res_i = 0
res_j = 0
res_k = 0
i = 0
j = 0
k = 0
while(i < p and j < q and k < r):
minimum = min(A[i], min(B[j], C[k]))
maximum = max(A[i], max(B[j], C[k]));
if maximum-minimum < diff:
res_i = i
res_j = j
res_k = k
diff = maximum - minimum;
if diff == 0:
break
if A[i] == minimum:
i = i+1
elif B[j] == minimum:
j = j+1
else:
k = k+1
return A[res_i],B[res_j],C[res_k] | train |
939 | Instruct: Write a function to sort a list of dictionaries using lambda function.
>>> assert sorted_models([{'make':'Nokia', 'model':216, 'color':'Black'}, {'make':'Mi Max', 'model':2, 'color':'Gold'}, {'make':'Samsung', 'model': 7, 'color':'Blue'}])==[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': 2, 'color': 'Gold'}]
>>> assert sorted_models([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])==([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])
>>> assert sorted_models([{'make':'micromax','model':40,'color':'grey'},{'make':'poco','model':60,'color':'blue'}])==([{'make':'poco','model':60,'color':'blue'},{'make':'micromax','model':40,'color':'grey'}])
Answer: | mbpp | mbpp | def sorted_models(models):
sorted_models = sorted(models, key = lambda x: x['color'])
return sorted_models | train |
940 | Instruct: Write a function to sort the given array by using heap sort.
>>> assert heap_sort([12, 2, 4, 5, 2, 3]) == [2, 2, 3, 4, 5, 12]
>>> assert heap_sort([32, 14, 5, 6, 7, 19]) == [5, 6, 7, 14, 19, 32]
>>> assert heap_sort([21, 15, 29, 78, 65]) == [15, 21, 29, 65, 78]
Answer: | mbpp | mbpp | def heap_sort(arr):
heapify(arr)
end = len(arr) - 1
while end > 0:
arr[end], arr[0] = arr[0], arr[end]
shift_down(arr, 0, end - 1)
end -= 1
return arr
def heapify(arr):
start = len(arr) // 2
while start >= 0:
shift_down(arr, start, len(arr) - 1)
start -= 1
def shift_down(arr, start, end):
root = start
while root * 2 + 1 <= end:
child = root * 2 + 1
if child + 1 <= end and arr[child] < arr[child + 1]:
child += 1
if child <= end and arr[root] < arr[child]:
arr[root], arr[child] = arr[child], arr[root]
root = child
else:
return
| train |
941 | Instruct: Write a function to count the elements in a list until an element is a tuple.
>>> assert count_elim([10,20,30,(10,20),40])==3
>>> assert count_elim([10,(20,30),(10,20),40])==1
>>> assert count_elim([(10,(20,30,(10,20),40))])==0
Answer: | mbpp | mbpp | def count_elim(num):
count_elim = 0
for n in num:
if isinstance(n, tuple):
break
count_elim += 1
return count_elim | train |
942 | Instruct: Write a function to check if any list element is present in the given list.
>>> assert check_element((4, 5, 7, 9, 3), [6, 7, 10, 11]) == True
>>> assert check_element((1, 2, 3, 4), [4, 6, 7, 8, 9]) == True
>>> assert check_element((3, 2, 1, 4, 5), [9, 8, 7, 6]) == False
Answer: | mbpp | mbpp | def check_element(test_tup, check_list):
res = False
for ele in check_list:
if ele in test_tup:
res = True
break
return (res) | train |
943 | Instruct: Write a function to combine two given sorted lists using heapq module.
>>> assert combine_lists([1, 3, 5, 7, 9, 11],[0, 2, 4, 6, 8, 10])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> assert combine_lists([1, 3, 5, 6, 8, 9], [2, 5, 7, 11])==[1,2,3,5,5,6,7,8,9,11]
>>> assert combine_lists([1,3,7],[2,4,6])==[1,2,3,4,6,7]
Answer: | mbpp | mbpp | from heapq import merge
def combine_lists(num1,num2):
combine_lists=list(merge(num1, num2))
return combine_lists | train |
944 | Instruct: Write a function to separate and print the numbers and their position of a given string.
>>> assert num_position("there are 70 flats in this apartment")==10
>>> assert num_position("every adult have 32 teeth")==17
>>> assert num_position("isha has 79 chocolates in her bag")==9
Answer: | mbpp | mbpp | import re
def num_position(text):
for m in re.finditer("\d+", text):
return m.start() | train |
945 | Instruct: Write a function to convert the given tuples into set.
>>> assert tuple_to_set(('x', 'y', 'z') ) == {'y', 'x', 'z'}
>>> assert tuple_to_set(('a', 'b', 'c') ) == {'c', 'a', 'b'}
>>> assert tuple_to_set(('z', 'd', 'e') ) == {'d', 'e', 'z'}
Answer: | mbpp | mbpp | def tuple_to_set(t):
s = set(t)
return (s) | train |
946 | Instruct: Write a function to find the most common elements and their counts of a specified text.
>>> assert most_common_elem('lkseropewdssafsdfafkpwe',3)==[('s', 4), ('e', 3), ('f', 3)]
>>> assert most_common_elem('lkseropewdssafsdfafkpwe',2)==[('s', 4), ('e', 3)]
>>> assert most_common_elem('lkseropewdssafsdfafkpwe',7)==[('s', 4), ('e', 3), ('f', 3), ('k', 2), ('p', 2), ('w', 2), ('d', 2)]
Answer: | mbpp | mbpp | from collections import Counter
def most_common_elem(s,a):
most_common_elem=Counter(s).most_common(a)
return most_common_elem | train |
947 | Instruct: Write a python function to find the length of the shortest word.
>>> assert len_log(["win","lose","great"]) == 3
>>> assert len_log(["a","ab","abc"]) == 1
>>> assert len_log(["12","12","1234"]) == 2
Answer: | mbpp | mbpp | def len_log(list1):
min=len(list1[0])
for i in list1:
if len(i)<min:
min=len(i)
return min | train |
948 | Instruct: Write a function to get an item of a tuple.
>>> assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),3)==('e')
>>> assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),-4)==('u')
>>> assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),-3)==('r')
Answer: | mbpp | mbpp | def get_item(tup1,index):
item = tup1[index]
return item | train |
949 | Instruct: Write a function to sort the given tuple list basis the total digits in tuple.
>>> assert sort_list([(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)] ) == '[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]'
>>> assert sort_list([(3, 4, 8), (1, 2), (1234335,), (1345, 234, 334)] ) == '[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]'
>>> assert sort_list([(34, 4, 61, 723), (1, 2), (145,), (134, 23)] ) == '[(1, 2), (145,), (134, 23), (34, 4, 61, 723)]'
Answer: | mbpp | mbpp | def count_digs(tup):
return sum([len(str(ele)) for ele in tup ])
def sort_list(test_list):
test_list.sort(key = count_digs)
return (str(test_list)) | train |
950 | Instruct: Write a function to display sign of the chinese zodiac for given year.
>>> assert chinese_zodiac(1997)==('Ox')
>>> assert chinese_zodiac(1998)==('Tiger')
>>> assert chinese_zodiac(1994)==('Dog')
Answer: | mbpp | mbpp | def chinese_zodiac(year):
if (year - 2000) % 12 == 0:
sign = 'Dragon'
elif (year - 2000) % 12 == 1:
sign = 'Snake'
elif (year - 2000) % 12 == 2:
sign = 'Horse'
elif (year - 2000) % 12 == 3:
sign = 'sheep'
elif (year - 2000) % 12 == 4:
sign = 'Monkey'
elif (year - 2000) % 12 == 5:
sign = 'Rooster'
elif (year - 2000) % 12 == 6:
sign = 'Dog'
elif (year - 2000) % 12 == 7:
sign = 'Pig'
elif (year - 2000) % 12 == 8:
sign = 'Rat'
elif (year - 2000) % 12 == 9:
sign = 'Ox'
elif (year - 2000) % 12 == 10:
sign = 'Tiger'
else:
sign = 'Hare'
return sign | train |
951 | Instruct: Write a function to find the maximum of similar indices in two lists of tuples.
>>> assert max_similar_indices([(2, 4), (6, 7), (5, 1)],[(5, 4), (8, 10), (8, 14)]) == [(5, 4), (8, 10), (8, 14)]
>>> assert max_similar_indices([(3, 5), (7, 8), (6, 2)],[(6, 5), (9, 11), (9, 15)]) == [(6, 5), (9, 11), (9, 15)]
>>> assert max_similar_indices([(4, 6), (8, 9), (7, 3)],[(7, 6), (10, 12), (10, 16)]) == [(7, 6), (10, 12), (10, 16)]
Answer: | mbpp | mbpp | def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res) | train |
952 | Instruct: Write a function to compute the value of ncr mod p.
>>> assert nCr_mod_p(10, 2, 13) == 6
>>> assert nCr_mod_p(11, 3, 14) == 11
>>> assert nCr_mod_p(18, 14, 19) == 1
Answer: | mbpp | mbpp | def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r] | train |
953 | Instruct: Write a python function to find the minimun number of subsets with distinct elements.
>>> assert subset([1, 2, 3, 4],4) == 1
>>> assert subset([5, 6, 9, 3, 4, 3, 4],7) == 2
>>> assert subset([1, 2, 3 ],3) == 1
Answer: | mbpp | mbpp | def subset(ar, n):
res = 0
ar.sort()
for i in range(0, n) :
count = 1
for i in range(n - 1):
if ar[i] == ar[i + 1]:
count+=1
else:
break
res = max(res, count)
return res | train |
954 | Instruct: Write a function that gives profit amount if the given amount has profit else return none.
>>> assert profit_amount(1500,1200)==300
>>> assert profit_amount(100,200)==None
>>> assert profit_amount(2000,5000)==None
Answer: | mbpp | mbpp | def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None | train |
955 | Instruct: Write a function to find out, if the given number is abundant.
>>> assert is_abundant(12)==True
>>> assert is_abundant(13)==False
>>> assert is_abundant(9)==False
Answer: | mbpp | mbpp | def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n | train |
956 | Instruct: Write a function to split the given string at uppercase letters by using regex.
>>> assert split_list("LearnToBuildAnythingWithGoogle") == ['Learn', 'To', 'Build', 'Anything', 'With', 'Google']
>>> assert split_list("ApmlifyingTheBlack+DeveloperCommunity") == ['Apmlifying', 'The', 'Black+', 'Developer', 'Community']
>>> assert split_list("UpdateInTheGoEcoSystem") == ['Update', 'In', 'The', 'Go', 'Eco', 'System']
Answer: | mbpp | mbpp | import re
def split_list(text):
return (re.findall('[A-Z][^A-Z]*', text)) | train |
957 | Instruct: Write a python function to get the position of rightmost set bit.
>>> assert get_First_Set_Bit_Pos(12) == 3
>>> assert get_First_Set_Bit_Pos(18) == 2
>>> assert get_First_Set_Bit_Pos(16) == 5
Answer: | mbpp | mbpp | import math
def get_First_Set_Bit_Pos(n):
return math.log2(n&-n)+1 | train |
958 | Instruct: Write a function to convert an integer into a roman numeral.
>>> assert int_to_roman(1)==("I")
>>> assert int_to_roman(50)==("L")
>>> assert int_to_roman(4)==("IV")
Answer: | mbpp | mbpp | def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num | train |
959 | Instruct: Write a python function to find the average of a list.
>>> assert Average([15, 9, 55, 41, 35, 20, 62, 49]) == 35.75
>>> assert Average([4, 5, 1, 2, 9, 7, 10, 8]) == 5.75
>>> assert Average([1,2,3]) == 2
Answer: | mbpp | mbpp | def Average(lst):
return sum(lst) / len(lst) | train |
960 | Instruct: Write a function to solve tiling problem.
>>> assert get_noOfways(4)==3
>>> assert get_noOfways(3)==2
>>> assert get_noOfways(5)==5
Answer: | mbpp | mbpp | def get_noOfways(n):
if (n == 0):
return 0;
if (n == 1):
return 1;
return get_noOfways(n - 1) + get_noOfways(n - 2); | train |
961 | Instruct: Write a function to convert a roman numeral to an integer.
>>> assert roman_to_int('MMMCMLXXXVI')==3986
>>> assert roman_to_int('MMMM')==4000
>>> assert roman_to_int('C')==100
Answer: | mbpp | mbpp | def roman_to_int(s):
rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
int_val = 0
for i in range(len(s)):
if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]:
int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]]
else:
int_val += rom_val[s[i]]
return int_val | train |
962 | Instruct: Write a python function to find the sum of all even natural numbers within the range l and r.
>>> assert sum_Even(2,5) == 6
>>> assert sum_Even(3,8) == 18
>>> assert sum_Even(4,6) == 10
Answer: | mbpp | mbpp | def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
def sum_Even(l,r):
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))) | train |
963 | Instruct: Write a function to calculate the discriminant value.
>>> assert discriminant_value(4,8,2)==("Two solutions",32)
>>> assert discriminant_value(5,7,9)==("no real solution",-131)
>>> assert discriminant_value(0,0,9)==("one solution",0)
Answer: | mbpp | mbpp | def discriminant_value(x,y,z):
discriminant = (y**2) - (4*x*z)
if discriminant > 0:
return ("Two solutions",discriminant)
elif discriminant == 0:
return ("one solution",discriminant)
elif discriminant < 0:
return ("no real solution",discriminant) | train |
964 | Instruct: Write a python function to check whether the length of the word is even or not.
>>> assert word_len("program") == False
>>> assert word_len("solution") == True
>>> assert word_len("data") == True
Answer: | mbpp | mbpp | def word_len(s):
s = s.split(' ')
for word in s:
if len(word)%2==0:
return True
else:
return False | train |
965 | Instruct: Write a function to convert camel case string to snake case string.
>>> assert camel_to_snake('PythonProgram')==('python_program')
>>> assert camel_to_snake('pythonLanguage')==('python_language')
>>> assert camel_to_snake('ProgrammingLanguage')==('programming_language')
Answer: | mbpp | mbpp | def camel_to_snake(text):
import re
str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower() | train |
966 | Instruct: Write a function to remove an empty tuple from a list of tuples.
>>> assert remove_empty([(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')])==[('',), ('a', 'b'), ('a', 'b', 'c'), 'd']
>>> assert remove_empty([(), (), ('',), ("python"), ("program")])==[('',), ("python"), ("program")]
>>> assert remove_empty([(), (), ('',), ("java")])==[('',),("java") ]
Answer: | mbpp | mbpp | def remove_empty(tuple1): #L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')]
tuple1 = [t for t in tuple1 if t]
return tuple1 | train |
967 | Instruct: Write a python function to accept the strings which contains all vowels.
>>> assert check("SEEquoiaL") == 'accepted'
>>> assert check('program') == "not accepted"
>>> assert check('fine') == "not accepted"
Answer: | mbpp | mbpp | def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted") | train |
968 | Instruct: Write a python function to find maximum possible value for the given periodic function.
>>> assert floor_Max(11,10,9) == 9
>>> assert floor_Max(5,7,4) == 2
>>> assert floor_Max(2,2,1) == 1
Answer: | mbpp | mbpp | def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B | train |
969 | Instruct: Write a function to join the tuples if they have similar initial elements.
>>> assert join_tuples([(5, 6), (5, 7), (6, 8), (6, 10), (7, 13)] ) == [(5, 6, 7), (6, 8, 10), (7, 13)]
>>> assert join_tuples([(6, 7), (6, 8), (7, 9), (7, 11), (8, 14)] ) == [(6, 7, 8), (7, 9, 11), (8, 14)]
>>> assert join_tuples([(7, 8), (7, 9), (8, 10), (8, 12), (9, 15)] ) == [(7, 8, 9), (8, 10, 12), (9, 15)]
Answer: | mbpp | mbpp | def join_tuples(test_list):
res = []
for sub in test_list:
if res and res[-1][0] == sub[0]:
res[-1].extend(sub[1:])
else:
res.append([ele for ele in sub])
res = list(map(tuple, res))
return (res) | train |
970 | Instruct: Write a function to find minimum of two numbers.
>>> assert min_of_two(10,20)==10
>>> assert min_of_two(19,15)==15
>>> assert min_of_two(-10,-20)==-20
Answer: | mbpp | mbpp | def min_of_two( x, y ):
if x < y:
return x
return y | train |
971 | Instruct: Write a function to find the maximum number of segments of lengths a, b and c that can be formed from n.
>>> assert maximum_segments(7, 5, 2, 5) == 2
>>> assert maximum_segments(17, 2, 1, 3) == 17
>>> assert maximum_segments(18, 16, 3, 6) == 6
Answer: | mbpp | mbpp | def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n] | train |
972 | Instruct: Write a function to concatenate the given two tuples to a nested tuple.
>>> assert concatenate_nested((3, 4), (5, 6)) == (3, 4, 5, 6)
>>> assert concatenate_nested((1, 2), (3, 4)) == (1, 2, 3, 4)
>>> assert concatenate_nested((4, 5), (6, 8)) == (4, 5, 6, 8)
Answer: | mbpp | mbpp | def concatenate_nested(test_tup1, test_tup2):
res = test_tup1 + test_tup2
return (res) | train |
973 | Instruct: Write a python function to left rotate the string.
>>> assert left_rotate("python",2) == "thonpy"
>>> assert left_rotate("bigdata",3 ) == "databig"
>>> assert left_rotate("hadoop",1 ) == "adooph"
Answer: | mbpp | mbpp | def left_rotate(s,d):
tmp = s[d : ] + s[0 : d]
return tmp | train |
974 | Instruct: Write a function to find the minimum total path sum in the given triangle.
>>> assert min_sum_path([[ 2 ], [3, 9 ], [1, 6, 7 ]]) == 6
>>> assert min_sum_path([[ 2 ], [3, 7 ], [8, 5, 6 ]]) == 10
>>> assert min_sum_path([[ 3 ], [6, 4 ], [5, 2, 7 ]]) == 9
Answer: | mbpp | mbpp | def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0] | train |
511 | Instruct: Write a python function to find minimum sum of factors of a given number.
>>> assert find_Min_Sum(12) == 7
>>> assert find_Min_Sum(105) == 15
>>> assert find_Min_Sum(2) == 2
Answer: | mbpp | mbpp | def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum | validation |
512 | Instruct: Write a function to count the element frequency in the mixed nested tuple.
>>> assert count_element_freq((5, 6, (5, 6), 7, (8, 9), 9) ) == {5: 2, 6: 2, 7: 1, 8: 1, 9: 2}
>>> assert count_element_freq((6, 7, (6, 7), 8, (9, 10), 10) ) == {6: 2, 7: 2, 8: 1, 9: 1, 10: 2}
>>> assert count_element_freq((7, 8, (7, 8), 9, (10, 11), 11) ) == {7: 2, 8: 2, 9: 1, 10: 1, 11: 2}
Answer: | mbpp | mbpp | def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
def count_element_freq(test_tuple):
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res) | validation |
513 | Instruct: Write a function to convert tuple into list by adding the given string after every element.
>>> assert add_str((5, 6, 7, 4, 9) , "FDF") == [5, 'FDF', 6, 'FDF', 7, 'FDF', 4, 'FDF', 9, 'FDF']
>>> assert add_str((7, 8, 9, 10) , "PF") == [7, 'PF', 8, 'PF', 9, 'PF', 10, 'PF']
>>> assert add_str((11, 14, 12, 1, 4) , "JH") == [11, 'JH', 14, 'JH', 12, 'JH', 1, 'JH', 4, 'JH']
Answer: | mbpp | mbpp | def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res) | validation |
514 | Instruct: Write a function to find the summation of tuple elements in the given tuple list.
>>> assert sum_elements((7, 8, 9, 1, 10, 7)) == 42
>>> assert sum_elements((1, 2, 3, 4, 5, 6)) == 21
>>> assert sum_elements((11, 12 ,13 ,45, 14)) == 95
Answer: | mbpp | mbpp | def sum_elements(test_tup):
res = sum(list(test_tup))
return (res) | validation |
515 | Instruct: Write a function to check if there is a subset with sum divisible by m.
>>> assert modular_sum([3, 1, 7, 5], 4, 6) == True
>>> assert modular_sum([1, 7], 2, 5) == False
>>> assert modular_sum([1, 6], 2, 5) == False
Answer: | mbpp | mbpp | def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0] | validation |
516 | Instruct: Write a function to sort a list of elements using radix sort.
>>> assert radix_sort([15, 79, 25, 68, 37]) == [15, 25, 37, 68, 79]
>>> assert radix_sort([9, 11, 8, 7, 3, 2]) == [2, 3, 7, 8, 9, 11]
>>> assert radix_sort([36, 12, 24, 26, 29]) == [12, 24, 26, 29, 36]
Answer: | mbpp | mbpp | def radix_sort(nums):
RADIX = 10
placement = 1
max_digit = max(nums)
while placement < max_digit:
buckets = [list() for _ in range( RADIX )]
for i in nums:
tmp = int((i / placement) % RADIX)
buckets[tmp].append(i)
a = 0
for b in range( RADIX ):
buck = buckets[b]
for i in buck:
nums[a] = i
a += 1
placement *= RADIX
return nums | validation |
517 | Instruct: Write a python function to find the largest postive number from the given list.
>>> assert largest_pos([1,2,3,4,-1]) == 4
>>> assert largest_pos([0,1,2,-5,-1,6]) == 6
>>> assert largest_pos([0,0,1,0]) == 1
Answer: | mbpp | mbpp | def largest_pos(list1):
max = list1[0]
for x in list1:
if x > max :
max = x
return max | validation |
518 | Instruct: Write a function to find the square root of a perfect number.
>>> assert sqrt_root(4)==2
>>> assert sqrt_root(16)==4
>>> assert sqrt_root(400)==20
Answer: | mbpp | mbpp | import math
def sqrt_root(num):
sqrt_root = math.pow(num, 0.5)
return sqrt_root | validation |
519 | Instruct: Write a function to calculate volume of a tetrahedron.
>>> assert volume_tetrahedron(10)==117.85
>>> assert volume_tetrahedron(15)==397.75
>>> assert volume_tetrahedron(20)==942.81
Answer: | mbpp | mbpp | import math
def volume_tetrahedron(num):
volume = (num ** 3 / (6 * math.sqrt(2)))
return round(volume, 2) | validation |
520 | Instruct: Write a function to find the lcm of the given array elements.
>>> assert get_lcm([2, 7, 3, 9, 4]) == 252
>>> assert get_lcm([1, 2, 8, 3]) == 24
>>> assert get_lcm([3, 8, 4, 10, 5]) == 120
Answer: | mbpp | mbpp | def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
def get_lcm(l):
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm | validation |
521 | Instruct: Write a function to print check if the triangle is scalene or not.
>>> assert check_isosceles(6,8,12)==True
>>> assert check_isosceles(6,6,12)==False
>>> assert check_isosceles(6,15,20)==True
Answer: | mbpp | mbpp | def check_isosceles(x,y,z):
if x!=y & y!=z & z!=x:
return True
else:
return False | validation |
522 | Instruct: Write a function to find the longest bitonic subsequence for the given array.
>>> assert lbs([0 , 8 , 4, 12, 2, 10 , 6 , 14 , 1 , 9 , 5 , 13, 3, 11 , 7 , 15]) == 7
>>> assert lbs([1, 11, 2, 10, 4, 5, 2, 1]) == 6
>>> assert lbs([80, 60, 30, 40, 20, 10]) == 5
Answer: | mbpp | mbpp | def lbs(arr):
n = len(arr)
lis = [1 for i in range(n+1)]
for i in range(1 , n):
for j in range(0 , i):
if ((arr[i] > arr[j]) and (lis[i] < lis[j] +1)):
lis[i] = lis[j] + 1
lds = [1 for i in range(n+1)]
for i in reversed(range(n-1)):
for j in reversed(range(i-1 ,n)):
if(arr[i] > arr[j] and lds[i] < lds[j] + 1):
lds[i] = lds[j] + 1
maximum = lis[0] + lds[0] - 1
for i in range(1 , n):
maximum = max((lis[i] + lds[i]-1), maximum)
return maximum | validation |
523 | Instruct: Write a function to check whether a given string has a capital letter, a lower case letter, a number and specified length using lambda function.
>>> assert check_string('python')==['String must have 1 upper case character.', 'String must have 1 number.', 'String length should be atleast 8.']
>>> assert check_string('123python')==['String must have 1 upper case character.']
>>> assert check_string('123Python')==['Valid string.']
Answer: | mbpp | mbpp | def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result | validation |
524 | Instruct: Write a function to find the sum of maximum increasing subsequence of the given array.
>>> assert max_sum_increasing_subsequence([1, 101, 2, 3, 100, 4, 5], 7) == 106
>>> assert max_sum_increasing_subsequence([3, 4, 5, 10], 4) == 22
>>> assert max_sum_increasing_subsequence([10, 5, 4, 3], 4) == 10
Answer: | mbpp | mbpp | def max_sum_increasing_subsequence(arr, n):
max = 0
msis = [0 for x in range(n)]
for i in range(n):
msis[i] = arr[i]
for i in range(1, n):
for j in range(i):
if (arr[i] > arr[j] and
msis[i] < msis[j] + arr[i]):
msis[i] = msis[j] + arr[i]
for i in range(n):
if max < msis[i]:
max = msis[i]
return max | validation |
525 | Instruct: Write a python function to check whether two given lines are parallel or not.
>>> assert parallel_lines([2,3,4], [2,3,8]) == True
>>> assert parallel_lines([2,3,4], [4,-3,8]) == False
>>> assert parallel_lines([3,3],[5,5]) == True
Answer: | mbpp | mbpp | def parallel_lines(line1, line2):
return line1[0]/line1[1] == line2[0]/line2[1] | validation |
526 | Instruct: Write a python function to capitalize first and last letters of each word of a given string.
>>> assert capitalize_first_last_letters("python") == "PythoN"
>>> assert capitalize_first_last_letters("bigdata") == "BigdatA"
>>> assert capitalize_first_last_letters("Hadoop") == "HadooP"
Answer: | mbpp | mbpp | def capitalize_first_last_letters(str1):
str1 = result = str1.title()
result = ""
for word in str1.split():
result += word[:-1] + word[-1].upper() + " "
return result[:-1] | validation |
527 | Instruct: Write a function to find all pairs in an integer array whose sum is equal to a given number.
>>> assert get_pairs_count([1, 5, 7, -1, 5], 5, 6) == 3
>>> assert get_pairs_count([1, 5, 7, -1], 4, 6) == 2
>>> assert get_pairs_count([1, 1, 1, 1], 4, 2) == 6
Answer: | mbpp | mbpp | def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count | validation |
528 | Instruct: Write a function to find the list of lists with minimum length.
>>> assert min_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(1, [0])
>>> assert min_length([[1], [5, 7], [10, 12, 14,15]])==(1, [1])
>>> assert min_length([[5], [15,20,25]])==(1, [5])
Answer: | mbpp | mbpp | def min_length(list1):
min_length = min(len(x) for x in list1 )
min_list = min((x) for x in list1)
return(min_length, min_list) | validation |
529 | Instruct: Write a function to find the nth jacobsthal-lucas number.
>>> assert jacobsthal_lucas(5) == 31
>>> assert jacobsthal_lucas(2) == 5
>>> assert jacobsthal_lucas(4) == 17
Answer: | mbpp | mbpp | def jacobsthal_lucas(n):
dp=[0] * (n + 1)
dp[0] = 2
dp[1] = 1
for i in range(2, n+1):
dp[i] = dp[i - 1] + 2 * dp[i - 2];
return dp[n] | validation |
530 | Instruct: Write a function to find the ration of negative numbers in an array of integers.
>>> assert negative_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.31
>>> assert negative_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.31
>>> assert negative_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.44
Answer: | mbpp | mbpp | from array import array
def negative_count(nums):
n = len(nums)
n1 = 0
for x in nums:
if x < 0:
n1 += 1
else:
None
return round(n1/n,2) | validation |
531 | Instruct: Write a function to find minimum number of coins that make a given value.
>>> assert min_coins([9, 6, 5, 1] ,4,11)==2
>>> assert min_coins([4,5,6,7,8,9],6,9)==1
>>> assert min_coins([1, 2, 3],3,4)==2
Answer: | mbpp | mbpp | import sys
def min_coins(coins, m, V):
if (V == 0):
return 0
res = sys.maxsize
for i in range(0, m):
if (coins[i] <= V):
sub_res = min_coins(coins, m, V-coins[i])
if (sub_res != sys.maxsize and sub_res + 1 < res):
res = sub_res + 1
return res | validation |
532 | Instruct: Write a function to check if the two given strings are permutations of each other.
>>> assert check_permutation("abc", "cba") == True
>>> assert check_permutation("test", "ttew") == False
>>> assert check_permutation("xxyz", "yxzx") == True
Answer: | mbpp | mbpp | def check_permutation(str1, str2):
n1=len(str1)
n2=len(str2)
if(n1!=n2):
return False
a=sorted(str1)
str1=" ".join(a)
b=sorted(str2)
str2=" ".join(b)
for i in range(0, n1, 1):
if(str1[i] != str2[i]):
return False
return True | validation |
533 | Instruct: Write a function to remove particular data type elements from the given tuple.
>>> assert remove_datatype((4, 5, 4, 7.7, 1.2), int) == [7.7, 1.2]
>>> assert remove_datatype((7, 8, 9, "SR"), str) == [7, 8, 9]
>>> assert remove_datatype((7, 1.1, 2, 2.2), float) == [7, 2]
Answer: | mbpp | mbpp | def remove_datatype(test_tuple, data_type):
res = []
for ele in test_tuple:
if not isinstance(ele, data_type):
res.append(ele)
return (res) | validation |
534 | Instruct: Write a function to search a literals string in a string and also find the location within the original string where the pattern occurs.
>>> assert search_literal('python','python programming language')==(0,6)
>>> assert search_literal('programming','python programming language')==(7,18)
>>> assert search_literal('language','python programming language')==(19,27)
Answer: | mbpp | mbpp | import re
def search_literal(pattern,text):
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (s, e) | validation |
535 | Instruct: Write a function to find the top or bottom surface area of a cylinder.
>>> assert topbottom_surfacearea(10)==314.15000000000003
>>> assert topbottom_surfacearea(5)==78.53750000000001
>>> assert topbottom_surfacearea(4)==50.264
Answer: | mbpp | mbpp | def topbottom_surfacearea(r):
toporbottomarea=3.1415*r*r
return toporbottomarea | validation |
536 | Instruct: Write a function to select the nth items of a list.
>>> assert nth_items([1, 2, 3, 4, 5, 6, 7, 8, 9],2)==[1, 3, 5, 7, 9]
>>> assert nth_items([10,15,19,17,16,18],3)==[10,17]
>>> assert nth_items([14,16,19,15,17],4)==[14,17]
Answer: | mbpp | mbpp | def nth_items(list,n):
return list[::n] | validation |