Unnamed: 0
int64 0
973
| source
stringlengths 37
249
| target
stringlengths 30
1.33k
| program_id
stringlengths 6
8
|
|---|---|---|---|
800 | Write a python function to count the number of equal numbers from three given integers. | def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result)) | MBPP_800 |
801 | Write a python function to count the number of rotations required to generate a sorted array. | def count_Rotation(arr,n):
for i in range (1,n):
if (arr[i] < arr[i - 1]):
return i
return 0 | MBPP_801 |
802 | Write a python function to check whether the given number is a perfect square or not. | 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 | MBPP_802 |
803 | Write a python function to check whether the product of numbers is even or not. | def is_Product_Even(arr,n):
for i in range(0,n):
if ((arr[i] & 1) == 0):
return True
return False | MBPP_803 |
804 | Write a function to find the list in a list of lists whose sum of elements is the highest. | def max_sum_list(lists):
return max(lists, key=sum) | MBPP_804 |
805 | Write a function to find maximum run of uppercase characters in the given string. | 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) | MBPP_805 |
806 | Write a python function to find the first odd number in a given list of numbers. | def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd | MBPP_806 |
807 | Write a function to check if the given tuples contain the k or not. | def check_K(test_tup, K):
res = False
for ele in test_tup:
if ele == K:
res = True
break
return (res) | MBPP_807 |
808 | Write a function to check if each element of second tuple is smaller than its corresponding index in first tuple. | def check_smaller(test_tup1, test_tup2):
res = all(x > y for x, y in zip(test_tup1, test_tup2))
return (res) | MBPP_808 |
809 | Write a function to iterate over elements repeating each as many times as its count. | 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()) | MBPP_809 |
810 | Write a function to check if two lists of tuples are identical or not. | def check_identical(test_list1, test_list2):
res = test_list1 == test_list2
return (res) | MBPP_810 |
811 | Write a function to abbreviate 'road' as 'rd.' in a given string. | import re
def road_rd(street):
return (re.sub('Road$', 'Rd.', street)) | MBPP_811 |
812 | Write a function to find length of the string. | def string_length(str1):
count = 0
for char in str1:
count += 1
return count | MBPP_812 |
813 | Write a function to find the area of a rombus. | def rombus_area(p,q):
area=(p*q)/2
return area | MBPP_813 |
814 | Write a function to sort the given array without using any sorting algorithm. the given array consists of only 0, 1, and 2. | 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 | MBPP_814 |
815 | Write a function to clear the values of the given tuples. | def clear_tuple(test_tup):
temp = list(test_tup)
temp.clear()
test_tup = tuple(temp)
return (test_tup) | MBPP_815 |
816 | Write a function to find numbers divisible by m or n from a list of numbers using lambda function. | def div_of_nums(nums,m,n):
result = list(filter(lambda x: (x % m == 0 or x % n == 0), nums))
return result | MBPP_816 |
817 | Write a python function to count lower case letters in a given string. | 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 | MBPP_817 |
818 | Write a function to count the frequency of consecutive duplicate elements in a given list of numbers. | 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
| MBPP_818 |
819 | Write a function to check whether the given month number contains 28 days or not. | def check_monthnum_number(monthnum1):
if monthnum1 == 2:
return True
else:
return False | MBPP_819 |
820 | Write a function to merge two dictionaries into a single expression. | import collections as ct
def merge_dictionaries(dict1,dict2):
merged_dict = dict(ct.ChainMap({}, dict1, dict2))
return merged_dict | MBPP_820 |
821 | Write a function to return true if the password is valid. | 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 | MBPP_821 |
822 | Write a function to check if the given string starts with a substring using regex. | 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") | MBPP_822 |
823 | Write a python function to remove even numbers from a given list. | def remove_even(l):
for i in l:
if i % 2 == 0:
l.remove(i)
return l | MBPP_823 |
824 | Write a python function to access multiple elements of specified index from a given list. | def access_elements(nums, list_index):
result = [nums[i] for i in list_index]
return result | MBPP_824 |
825 | Write a python function to find the type of triangle from the given sides. | 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") | MBPP_825 |
826 | Write a function to sum a specific column of a list in a given list of lists. | def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result | MBPP_826 |
827 | Write a function to count alphabets,digits and special charactes in a given string. | 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) | MBPP_827 |
828 | Write a function to find out the second most repeated (or frequent) string in the given sequence. | 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) | MBPP_828 |
829 | Write a function to round up a number to specific digits. | import math
def round_up(a, digits):
n = 10**-digits
return round(math.ceil(a / n) * n, digits) | MBPP_829 |
830 | Write a python function to count equal element pairs from the given array. | 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; | MBPP_830 |
831 | Write a function to extract the maximum numeric value from a string by using regex. | import re
def extract_max(input):
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers) | MBPP_831 |
832 | Write a function to get dictionary keys as a list. | def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list | MBPP_832 |
833 | Write a function to generate a square matrix filled with elements from 1 to n raised to the power of 2 in spiral order. | 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 | MBPP_833 |
834 | Write a python function to find the slope of a line. | def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1) | MBPP_834 |
835 | Write a function to find length of the subarray having maximum sum. | 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) | MBPP_835 |
836 | Write a python function to find the cube sum of first n odd natural numbers. | def cube_Sum(n):
sum = 0
for i in range(0,n) :
sum += (2*i+1)*(2*i+1)*(2*i+1)
return sum | MBPP_836 |
837 | Write a python function to find minimum number swaps required to make two binary strings equal. | 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; | MBPP_837 |
838 | Write a function to sort the tuples alphabetically by the first item of each tuple. | 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 | MBPP_838 |
839 | Write a python function to check whether the roots of a quadratic equation are numerically equal but opposite in sign or not. | def Check_Solution(a,b,c):
if b == 0:
return ("Yes")
else:
return ("No") | MBPP_839 |
840 | Write a function to count the number of inversions in the given array. | 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 | MBPP_840 |
841 | Write a function to find the number which occurs for odd number of times in the given array. | 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 | MBPP_841 |
842 | Write a function to find the nth super ugly number from a given prime list of size k using heap queue algorithm. | 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] | MBPP_842 |
843 | Write a python function to find the kth element in an array containing odd elements first and then even elements. | 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]; | MBPP_843 |
844 | Write a python function to count the number of digits in factorial of a given number. | 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; | MBPP_844 |
845 | Write a function to find the minimum number of platforms required for a railway/bus station. | 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 | MBPP_845 |
846 | Write a python function to copy a list from a singleton tuple. | def lcopy(xs):
return xs[:]
| MBPP_846 |
847 | Write a function to find the area of a trapezium. | def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | MBPP_847 |
848 | Write a python function to find sum of all prime divisors of a given number. | 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] | MBPP_848 |
849 | Write a function to check if a triangle of positive area is possible with the given angles. | 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 | MBPP_849 |
850 | Write a python function to find sum of inverse of divisors. | def Sum_of_Inverse_Divisors(N,Sum):
ans = float(Sum)*1.0 /float(N);
return round(ans,2); | MBPP_850 |
851 | Write a python function to remove negative numbers from a list. | def remove_negs(num_list):
for item in num_list:
if item < 0:
num_list.remove(item)
return num_list | MBPP_851 |
852 | Write a python function to find sum of odd factors of a number. | 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 | MBPP_852 |
853 | Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm. | import heapq as hq
def raw_heap(rawheap):
hq.heapify(rawheap)
return rawheap | MBPP_853 |
854 | Write a python function to check for even parity of a given number. | 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 | MBPP_854 |
855 | Write a python function to find minimum adjacent swaps required to sort binary array. | 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 | MBPP_855 |
856 | Write a function to list out the list of given strings individually using map function. | def listify_list(list1):
result = list(map(list,list1))
return result | MBPP_856 |
857 | Write a function to count number of lists in a given list of lists and square the count. | def count_list(input_list):
return (len(input_list))**2 | MBPP_857 |
858 | Write a function to generate all sublists of a given list. | 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 | MBPP_858 |
859 | Write a function to check whether the given string is ending with only alphanumeric characters or not using regex. | import re
regex = '[a-zA-z0-9]$'
def check_alphanumeric(string):
if(re.search(regex, string)):
return ("Accept")
else:
return ("Discard") | MBPP_859 |
860 | Write a function to find all anagrams of a string in a given list of strings using lambda function. | from collections import Counter
def anagram_lambda(texts,str):
result = list(filter(lambda x: (Counter(str) == Counter(x)), texts))
return result | MBPP_860 |
861 | Write a function to find the occurrences of n most common words in a given text. | 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) | MBPP_861 |
862 | Write a function to find the length of the longest sub-sequence such that elements in the subsequences are consecutive integers. | 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 | MBPP_862 |
863 | Write a function to find palindromes in a given list of strings using lambda function. | def palindrome_lambda(texts):
result = list(filter(lambda x: (x == "".join(reversed(x))), texts))
return result | MBPP_863 |
864 | Write a function to print n-times a list using map function. | def ntimes_list(nums,n):
result = map(lambda x:n*x, nums)
return list(result) | MBPP_864 |
865 | Write a function to check whether the given month name contains 31 days or not. | 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 | MBPP_865 |
866 | Write a python function to add a minimum number such that the sum of array becomes even. | 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 | MBPP_866 |
867 | Write a python function to find the length of the last word in a given string. | 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 | MBPP_867 |
868 | Write a function to remove sublists from a given list of lists, which are outside a given range. | def remove_list_range(list1, leftrange, rigthrange):
result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)]
return result | MBPP_868 |
869 | Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function. | def sum_positivenum(nums):
sum_positivenum = list(filter(lambda nums:nums>0,nums))
return sum(sum_positivenum) | MBPP_869 |
870 | Write a python function to check whether the given strings are rotations of each other or not. | 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 | MBPP_870 |
871 | Write a function to check if a nested list is a subset of another nested list. | def check_subset(list1,list2):
return all(map(list1.__contains__,list2)) | MBPP_871 |
872 | Write a function to solve the fibonacci sequence using recursion. | def fibonacci(n):
if n == 1 or n == 2:
return 1
else:
return (fibonacci(n - 1) + (fibonacci(n - 2))) | MBPP_872 |
873 | Write a python function to check if the string is a concatenation of another string. | 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 | MBPP_873 |
874 | Write a function to find the minimum difference in the tuple pairs of given tuples. | def min_difference(test_list):
temp = [abs(b - a) for a, b in test_list]
res = min(temp)
return (res) | MBPP_874 |
875 | Write a python function to find lcm of two positive integers. | 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 | MBPP_875 |
876 | Write a python function to sort the given string. | def sort_String(str) :
str = ''.join(sorted(str))
return (str) | MBPP_876 |
877 | Write a function to check if the given tuple contains only k elements. | def check_tuples(test_tuple, K):
res = all(ele in K for ele in test_tuple)
return (res) | MBPP_877 |
878 | Write a function that matches a string that has an 'a' followed by anything, ending in 'b' by using regex. | import re
def text_match(text):
patterns = 'a.*?b$'
if re.search(patterns, text):
return ('Found a match!')
else:
return ('Not matched!') | MBPP_878 |
879 | Write a python function to find number of solutions in quadratic equation. | 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") | MBPP_879 |
880 | Write a function to find the sum of first even and odd number of a given list. | 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) | MBPP_880 |
881 | Write a function to caluclate perimeter of a parallelogram. | def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter | MBPP_881 |
882 | Write a function to find numbers divisible by m and n from a list of numbers using lambda function. | def div_of_nums(nums,m,n):
result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums))
return result | MBPP_882 |
883 | Write a python function to check whether all the bits are within a given range or not. | 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 | MBPP_883 |
884 | Write a python function to check whether the two given strings are isomorphic to each other or not. | 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 | MBPP_884 |
885 | Write a function to add all the numbers in a list and divide it with the length of the list. | def sum_num(numbers):
total = 0
for x in numbers:
total += x
return total/len(numbers) | MBPP_885 |
886 | Write a python function to check whether the given number is odd or not using bitwise operator. | def is_odd(n) :
if (n^1 == n-1) :
return True;
else :
return False; | MBPP_886 |
887 | Write a function to substract the elements of the given nested tuples. | 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) | MBPP_887 |
888 | Write a function to reverse each list in a given list of lists. | def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists | MBPP_888 |
889 | Write a python function to find the index of an extra element present in one sorted array. | def find_Extra(arr1,arr2,n) :
for i in range(0, n) :
if (arr1[i] != arr2[i]) :
return i
return n | MBPP_889 |
890 | Write a python function to check whether the given two numbers have same number of digits or not. | 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; | MBPP_890 |
891 | Write a function to remove multiple spaces in a string. | import re
def remove_spaces(text):
return (re.sub(' +',' ',text)) | MBPP_891 |
892 | Write a python function to get the last element of each sublist. | def Extract(lst):
return [item[-1] for item in lst] | MBPP_892 |
893 | Write a function to convert the given string of float type into tuple. | def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res) | MBPP_893 |
894 | Write a function to find the maximum sum of subsequences of given array with no adjacent elements. | 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] | MBPP_894 |
895 | 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. | def last(n):
return n[-1]
def sort_list_last(tuples):
return sorted(tuples, key=last) | MBPP_895 |
896 | Write a python function to check whether the word is present in a given sentence or not. | def is_Word_Present(sentence,word):
s = sentence.split(" ")
for i in s:
if (i == word):
return True
return False | MBPP_896 |
897 | Write a function to extract specified number of elements from a given list, which follow each other continuously. | from itertools import groupby
def extract_elements(numbers, n):
result = [i for i, j in groupby(numbers) if len(list(j)) == n]
return result | MBPP_897 |
898 | Write a python function to check whether an array can be sorted or not by picking only the corner elements. | 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 | MBPP_898 |
899 | Write a function where a string will start with a specific number. | import re
def match_num(string):
text = re.compile(r"^5")
if text.match(string):
return True
else:
return False | MBPP_899 |