task_id
int32 11
510
| text
stringlengths 37
191
| code
stringlengths 37
1.33k
| test_list
sequence | test_setup_code
stringclasses 2
values | challenge_test_list
sequence |
|---|---|---|---|---|---|
211 | Write a python function to count numbers whose oth and nth bits are set. | def count_Num(n):
if (n == 1):
return 1
count = pow(2,n - 2)
return count | [
"assert count_Num(2) == 1",
"assert count_Num(3) == 2",
"assert count_Num(1) == 1"
] | [] |
|
212 | Write a python function to find the sum of fourth power of n natural numbers. | import math
def fourth_Power_Sum(n):
sum = 0
for i in range(1,n+1) :
sum = sum + (i*i*i*i)
return sum | [
"assert fourth_Power_Sum(2) == 17",
"assert fourth_Power_Sum(4) == 354",
"assert fourth_Power_Sum(6) == 2275"
] | [] |
|
213 | Write a function to perform the concatenation of two string tuples. | def concatenate_strings(test_tup1, test_tup2):
res = tuple(ele1 + ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res) | [
"assert concatenate_strings((\"Manjeet\", \"Nikhil\", \"Akshat\"), (\" Singh\", \" Meherwal\", \" Garg\")) == ('Manjeet Singh', 'Nikhil Meherwal', 'Akshat Garg')",
"assert concatenate_strings((\"Shaik\", \"Ayesha\", \"Sanya\"), (\" Dawood\", \" Begum\", \" Singh\")) == ('Shaik Dawood', 'Ayesha Begum', 'Sanya Singh')",
"assert concatenate_strings((\"Harpreet\", \"Priyanka\", \"Muskan\"), (\"Kour\", \" Agarwal\", \"Sethi\")) == ('HarpreetKour', 'Priyanka Agarwal', 'MuskanSethi')"
] | [] |
|
214 | Write a function to convert radians to degrees. | import math
def degree_radian(radian):
degree = radian*(180/math.pi)
return degree | [
"assert degree_radian(90)==5156.620156177409",
"assert degree_radian(60)==3437.746770784939",
"assert degree_radian(120)==6875.493541569878"
] | [] |
|
215 | Write a function to decode a run-length encoded given list. | def decode_list(alist):
def aux(g):
if isinstance(g, list):
return [(g[1], range(g[0]))]
else:
return [(g, [0])]
return [x for g in alist for x, R in aux(g) for i in R] | [
"assert decode_list([[2, 1], 2, 3, [2, 4], 5,1])==[1,1,2,3,4,4,5,1]",
"assert decode_list(['a', 'u', 't', 'o', 'm', 'a', 't', 'i', 'c', 'a', [2, 'l'], 'y'])==['a', 'u', 't', 'o', 'm', 'a', 't', 'i', 'c', 'a', 'l', 'l', 'y']",
"assert decode_list(['p', 'y', 't', 'h', 'o', 'n'])==['p', 'y', 't', 'h', 'o', 'n']"
] | [] |
|
216 | Write a function to check if a nested list is a subset of another nested list. | def check_subset_list(list1, list2):
l1, l2 = list1[0], list2[0]
exist = True
for i in list2:
if i not in list1:
exist = False
return exist | [
"assert check_subset_list([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==False",
"assert check_subset_list([[2, 3, 1], [4, 5], [6, 8]],[[4, 5], [6, 8]])==True",
"assert check_subset_list([['a', 'b'], ['e'], ['c', 'd']],[['g']])==False"
] | [] |
|
217 | Write a python function to find the first repeated character in a given string. | def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | [
"assert first_Repeated_Char(\"Google\") == \"o\"",
"assert first_Repeated_Char(\"data\") == \"a\"",
"assert first_Repeated_Char(\"python\") == '\\0'"
] | [] |
|
218 | Write a python function to find the minimum operations required to make two numbers equal. | import math
def min_Operations(A,B):
if (A > B):
swap(A,B)
B = B // math.gcd(A,B);
return B - 1 | [
"assert min_Operations(2,4) == 1",
"assert min_Operations(4,10) == 4",
"assert min_Operations(1,4) == 3"
] | [] |
|
219 | Write a function to extract maximum and minimum k elements in the given tuple. |
def extract_min_max(test_tup, K):
res = []
test_tup = list(test_tup)
temp = sorted(test_tup)
for idx, val in enumerate(temp):
if idx < K or idx >= len(temp) - K:
res.append(val)
res = tuple(res)
return (res) | [
"assert extract_min_max((5, 20, 3, 7, 6, 8), 2) == (3, 5, 8, 20)",
"assert extract_min_max((4, 5, 6, 1, 2, 7), 3) == (1, 2, 4, 5, 6, 7)",
"assert extract_min_max((2, 3, 4, 8, 9, 11, 7), 4) == (2, 3, 4, 7, 8, 9, 11)"
] | [] |
|
220 | Write a function to replace maximum n occurrences of spaces, commas, or dots with a colon. | import re
def replace_max_specialchar(text,n):
return (re.sub("[ ,.]", ":", text, n)) | [
"assert replace_max_specialchar('Python language, Programming language.',2)==('Python:language: Programming language.')",
"assert replace_max_specialchar('a b c,d e f',3)==('a:b:c:d e f')",
"assert replace_max_specialchar('ram reshma,ram rahim',1)==('ram:reshma,ram rahim')"
] | [] |
|
221 | Write a python function to find the first even number in a given list of numbers. | def first_even(nums):
first_even = next((el for el in nums if el%2==0),-1)
return first_even | [
"assert first_even ([1, 3, 5, 7, 4, 1, 6, 8]) == 4",
"assert first_even([2, 3, 4]) == 2",
"assert first_even([5, 6, 7]) == 6"
] | [] |
|
222 | Write a function to check if all the elements in tuple have same data type or not. | def check_type(test_tuple):
res = True
for ele in test_tuple:
if not isinstance(ele, type(test_tuple[0])):
res = False
break
return (res) | [
"assert check_type((5, 6, 7, 3, 5, 6) ) == True",
"assert check_type((1, 2, \"4\") ) == False",
"assert check_type((3, 2, 1, 4, 5) ) == True"
] | [] |
|
223 | Write a function to check for majority element in the given sorted array. | def is_majority(arr, n, x):
i = binary_search(arr, 0, n-1, x)
if i == -1:
return False
if ((i + n//2) <= (n -1)) and arr[i + n//2] == x:
return True
else:
return False
def binary_search(arr, low, high, x):
if high >= low:
mid = (low + high)//2
if (mid == 0 or x > arr[mid-1]) and (arr[mid] == x):
return mid
elif x > arr[mid]:
return binary_search(arr, (mid + 1), high, x)
else:
return binary_search(arr, low, (mid -1), x)
return -1 | [
"assert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True",
"assert is_majority([1, 1, 2, 4, 4, 4, 6, 6], 8, 4) == False",
"assert is_majority([1, 1, 1, 2, 2], 5, 1) == True"
] | [] |
|
224 | Write a python function to count set bits of a given number. | def count_Set_Bits(n):
count = 0
while (n):
count += n & 1
n >>= 1
return count | [
"assert count_Set_Bits(2) == 1",
"assert count_Set_Bits(4) == 1",
"assert count_Set_Bits(6) == 2"
] | [] |
|
225 | Write a python function to find the minimum element in a sorted and rotated array. | def find_Min(arr,low,high):
while (low < high):
mid = low + (high - low) // 2;
if (arr[mid] == arr[high]):
high -= 1;
elif (arr[mid] > arr[high]):
low = mid + 1;
else:
high = mid;
return arr[high]; | [
"assert find_Min([1,2,3,4,5],0,4) == 1",
"assert find_Min([4,6,8],0,2) == 4",
"assert find_Min([2,3,5,7,9],0,4) == 2"
] | [] |
|
226 | Write a python function to remove the characters which have odd index values of a given string. | def odd_values_string(str):
result = ""
for i in range(len(str)):
if i % 2 == 0:
result = result + str[i]
return result | [
"assert odd_values_string('abcdef') == 'ace'",
"assert odd_values_string('python') == 'pto'",
"assert odd_values_string('data') == 'dt'"
] | [] |
|
227 | Write a function to find minimum of three numbers. | def min_of_three(a,b,c):
if (a <= b) and (a <= c):
smallest = a
elif (b <= a) and (b <= c):
smallest = b
else:
smallest = c
return smallest | [
"assert min_of_three(10,20,0)==0",
"assert min_of_three(19,15,18)==15",
"assert min_of_three(-10,-20,-30)==-30"
] | [] |
|
228 | Write a python function to check whether all the bits are unset in the 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 (new_num == 0):
return True
return False | [
"assert all_Bits_Set_In_The_Given_Range(4,1,2) == True",
"assert all_Bits_Set_In_The_Given_Range(17,2,4) == True",
"assert all_Bits_Set_In_The_Given_Range(39,4,6) == False"
] | [] |
|
229 | Write a function to re-arrange the elements of the given array so that all negative elements appear before positive ones. | def re_arrange_array(arr, n):
j=0
for i in range(0, n):
if (arr[i] < 0):
temp = arr[i]
arr[i] = arr[j]
arr[j] = temp
j = j + 1
return arr | [
"assert re_arrange_array([-1, 2, -3, 4, 5, 6, -7, 8, 9], 9) == [-1, -3, -7, 4, 5, 6, 2, 8, 9]",
"assert re_arrange_array([12, -14, -26, 13, 15], 5) == [-14, -26, 12, 13, 15]",
"assert re_arrange_array([10, 24, 36, -42, -39, -78, 85], 7) == [-42, -39, -78, 10, 24, 36, 85]"
] | [] |
|
230 | Write a function to replace blank spaces with any character in a string. | def replace_blank(str1,char):
str2 = str1.replace(' ', char)
return str2 | [
"assert replace_blank(\"hello people\",'@')==(\"hello@people\")",
"assert replace_blank(\"python program language\",'$')==(\"python$program$language\")",
"assert replace_blank(\"blank space\",\"-\")==(\"blank-space\")"
] | [] |
|
231 | Write a function to find the maximum sum in the given right triangle of numbers. | def max_sum(tri, n):
if n > 1:
tri[1][1] = tri[1][1]+tri[0][0]
tri[1][0] = tri[1][0]+tri[0][0]
for i in range(2, n):
tri[i][0] = tri[i][0] + tri[i-1][0]
tri[i][i] = tri[i][i] + tri[i-1][i-1]
for j in range(1, i):
if tri[i][j]+tri[i-1][j-1] >= tri[i][j]+tri[i-1][j]:
tri[i][j] = tri[i][j] + tri[i-1][j-1]
else:
tri[i][j] = tri[i][j]+tri[i-1][j]
return (max(tri[n-1])) | [
"assert max_sum([[1], [2,1], [3,3,2]], 3) == 6",
"assert max_sum([[1], [1, 2], [4, 1, 12]], 3) == 15 ",
"assert max_sum([[2], [3,2], [13,23,12]], 3) == 28"
] | [] |
|
232 | Write a function to get the n largest items from a dataset. | import heapq
def larg_nnum(list1,n):
largest=heapq.nlargest(n,list1)
return largest | [
"assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],2)==[100,90]",
"assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],5)==[100,90,80,70,60]",
"assert larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],3)==[100,90,80]"
] | [] |
|
233 | Write a function to find the lateral surface area of a cylinder. | def lateralsuface_cylinder(r,h):
lateralsurface= 2*3.1415*r*h
return lateralsurface | [
"assert lateralsuface_cylinder(10,5)==314.15000000000003",
"assert lateralsuface_cylinder(4,5)==125.66000000000001",
"assert lateralsuface_cylinder(4,10)==251.32000000000002"
] | [] |
|
234 | Write a function to find the volume of a cube. | def volume_cube(l):
volume = l * l * l
return volume | [
"assert volume_cube(3)==27",
"assert volume_cube(2)==8",
"assert volume_cube(5)==125"
] | [] |
|
235 | Write a python function to set all even bits of a given number. | def even_bit_set_number(n):
count = 0;res = 0;temp = n
while(temp > 0):
if (count % 2 == 1):
res |= (1 << count)
count+=1
temp >>= 1
return (n | res) | [
"assert even_bit_set_number(10) == 10",
"assert even_bit_set_number(20) == 30",
"assert even_bit_set_number(30) == 30"
] | [] |
|
236 | Write a python function to count the maximum number of equilateral triangles that can be formed within a given equilateral triangle. | def No_of_Triangle(N,K):
if (N < K):
return -1;
else:
Tri_up = 0;
Tri_up = ((N - K + 1) *(N - K + 2)) // 2;
Tri_down = 0;
Tri_down = ((N - 2 * K + 1) *(N - 2 * K + 2)) // 2;
return Tri_up + Tri_down; | [
"assert No_of_Triangle(4,2) == 7",
"assert No_of_Triangle(4,3) == 3",
"assert No_of_Triangle(1,3) == -1"
] | [] |
|
237 | Write a function to check the occurrences of records which occur similar times in the given tuples. | from collections import Counter
def check_occurences(test_list):
res = dict(Counter(tuple(ele) for ele in map(sorted, test_list)))
return (res) | [
"assert check_occurences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)] ) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}",
"assert check_occurences([(4, 2), (2, 4), (3, 6), (6, 3), (7, 4)] ) == {(2, 4): 2, (3, 6): 2, (4, 7): 1}",
"assert check_occurences([(13, 2), (11, 23), (12, 25), (25, 12), (16, 23)] ) == {(2, 13): 1, (11, 23): 1, (12, 25): 2, (16, 23): 1}"
] | [] |
|
238 | Write a python function to count number of non-empty substrings of a given string. | def number_of_substrings(str):
str_len = len(str);
return int(str_len * (str_len + 1) / 2); | [
"assert number_of_substrings(\"abc\") == 6",
"assert number_of_substrings(\"abcd\") == 10",
"assert number_of_substrings(\"abcde\") == 15"
] | [] |
|
239 | Write a function to find the number of possible sequences of length n such that each of the next element is greater than or equal to twice of the previous element but less than or equal to m. | def get_total_number_of_sequences(m,n):
T=[[0 for i in range(n+1)] for i in range(m+1)]
for i in range(m+1):
for j in range(n+1):
if i==0 or j==0:
T[i][j]=0
elif i<j:
T[i][j]=0
elif j==1:
T[i][j]=i
else:
T[i][j]=T[i-1][j]+T[i//2][j-1]
return T[m][n] | [
"assert get_total_number_of_sequences(10, 4) == 4",
"assert get_total_number_of_sequences(5, 2) == 6",
"assert get_total_number_of_sequences(16, 3) == 84"
] | [] |
|
240 | Write a function to replace the last element of the list with another list. | def replace_list(list1,list2):
list1[-1:] = list2
replace_list=list1
return replace_list
| [
"assert replace_list([1, 3, 5, 7, 9, 10],[2, 4, 6, 8])==[1, 3, 5, 7, 9, 2, 4, 6, 8]",
"assert replace_list([1,2,3,4,5],[5,6,7,8])==[1,2,3,4,5,6,7,8]",
"assert replace_list([\"red\",\"blue\",\"green\"],[\"yellow\"])==[\"red\",\"blue\",\"yellow\"]"
] | [] |
|
241 | Write a function to generate a 3d array having each element as '*'. | def array_3d(m,n,o):
array_3d = [[ ['*' for col in range(m)] for col in range(n)] for row in range(o)]
return array_3d | [
"assert array_3d(6,4,3)==[[['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*', '*']]]",
"assert array_3d(5,3,4)==[[['*', '*', '*', '*', '*'], ['*', '*', '*', '*','*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'],['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']], [['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*'], ['*', '*', '*', '*', '*']]]",
"assert array_3d(1,2,3)==[[['*'],['*']],[['*'],['*']],[['*'],['*']]]"
] | [] |
|
242 | Write a function to count total characters in a string. | def count_charac(str1):
total = 0
for i in str1:
total = total + 1
return total | [
"assert count_charac(\"python programming\")==18",
"assert count_charac(\"language\")==8",
"assert count_charac(\"words\")==5"
] | [] |
|
243 | Write a function to sort the given list based on the occurrence of first element of tuples. | def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()]) | [
"assert sort_on_occurence([(1, 'Jake'), (2, 'Bob'), (1, 'Cara')]) == [(1, 'Jake', 'Cara', 2), (2, 'Bob', 1)]",
"assert sort_on_occurence([('b', 'ball'), ('a', 'arm'), ('b', 'b'), ('a', 'ant')]) == [('b', 'ball', 'b', 2), ('a', 'arm', 'ant', 2)]",
"assert sort_on_occurence([(2, 'Mark'), (3, 'Maze'), (2, 'Sara')]) == [(2, 'Mark', 'Sara', 2), (3, 'Maze', 1)]"
] | [] |
|
244 | Write a python function to find the next perfect square greater than a given number. | import math
def next_Perfect_Square(N):
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN | [
"assert next_Perfect_Square(35) == 36",
"assert next_Perfect_Square(6) == 9",
"assert next_Perfect_Square(9) == 16"
] | [] |
|
245 | Write a function to find the maximum sum of bi-tonic sub-sequence for the given array. | def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum | [
"assert max_sum([1, 15, 51, 45, 33, 100, 12, 18, 9], 9) == 194",
"assert max_sum([80, 60, 30, 40, 20, 10], 6) == 210",
"assert max_sum([2, 3 ,14, 16, 21, 23, 29, 30], 8) == 138"
] | [] |
|
246 | Write a function for computing square roots using the babylonian method. | def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g; | [
"assert babylonian_squareroot(10)==3.162277660168379",
"assert babylonian_squareroot(2)==1.414213562373095",
"assert babylonian_squareroot(9)==3.0"
] | [] |
|
247 | Write a function to find the longest palindromic subsequence in the given string. | def lps(str):
n = len(str)
L = [[0 for x in range(n)] for x in range(n)]
for i in range(n):
L[i][i] = 1
for cl in range(2, n+1):
for i in range(n-cl+1):
j = i+cl-1
if str[i] == str[j] and cl == 2:
L[i][j] = 2
elif str[i] == str[j]:
L[i][j] = L[i+1][j-1] + 2
else:
L[i][j] = max(L[i][j-1], L[i+1][j]);
return L[0][n-1] | [
"assert lps(\"TENS FOR TENS\") == 5 ",
"assert lps(\"CARDIO FOR CARDS\") == 7",
"assert lps(\"PART OF THE JOURNEY IS PART\") == 9 "
] | [] |
|
248 | Write a function to calculate the harmonic sum of n-1. | def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1)) | [
"assert harmonic_sum(7) == 2.5928571428571425",
"assert harmonic_sum(4) == 2.083333333333333",
"assert harmonic_sum(19) == 3.547739657143682"
] | [] |
|
249 | Write a function to find the intersection of two arrays using lambda function. | def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result | [
"assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[1, 2, 4, 8, 9])==[1, 2, 8, 9]",
"assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[3,5,7,9])==[3,5,7,9]",
"assert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[10,20,30,40])==[10]"
] | [] |
|
250 | Write a python function to count the occcurences of an element in a tuple. | def count_X(tup, x):
count = 0
for ele in tup:
if (ele == x):
count = count + 1
return count | [
"assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),4) == 0",
"assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),10) == 3",
"assert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),8) == 4"
] | [] |
|
251 | Write a function to insert an element before each element of a list. | def insert_element(list,element):
list = [v for elt in list for v in (element, elt)]
return list | [
"assert insert_element(['Red', 'Green', 'Black'] ,'c')==['c', 'Red', 'c', 'Green', 'c', 'Black'] ",
"assert insert_element(['python', 'java'] ,'program')==['program', 'python', 'program', 'java'] ",
"assert insert_element(['happy', 'sad'] ,'laugh')==['laugh', 'happy', 'laugh', 'sad'] "
] | [] |
|
252 | Write a python function to convert complex numbers to polar coordinates. | import cmath
def convert(numbers):
num = cmath.polar(numbers)
return (num) | [
"assert convert(1) == (1.0, 0.0)",
"assert convert(4) == (4.0,0.0)",
"assert convert(5) == (5.0,0.0)"
] | [] |
|
253 | Write a python function to count integers from a given list. | def count_integer(list1):
ctr = 0
for i in list1:
if isinstance(i, int):
ctr = ctr + 1
return ctr | [
"assert count_integer([1,2,'abc',1.2]) == 2",
"assert count_integer([1,2,3]) == 3",
"assert count_integer([1,1.2,4,5.1]) == 2"
] | [] |
|
254 | Write a function to find all words starting with 'a' or 'e' in a given string. | import re
def words_ae(text):
list = re.findall("[ae]\w+", text)
return list | [
"assert words_ae(\"python programe\")==['ame']",
"assert words_ae(\"python programe language\")==['ame','anguage']",
"assert words_ae(\"assert statement\")==['assert', 'atement']"
] | [] |
|
255 | Write a function to choose specified number of colours from three different colours and generate all the combinations with repetitions. | from itertools import combinations_with_replacement
def combinations_colors(l, n):
return list(combinations_with_replacement(l,n))
| [
"assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],1)==[('Red',), ('Green',), ('Blue',)]",
"assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],2)==[('Red', 'Red'), ('Red', 'Green'), ('Red', 'Blue'), ('Green', 'Green'), ('Green', 'Blue'), ('Blue', 'Blue')]",
"assert combinations_colors( [\"Red\",\"Green\",\"Blue\"],3)==[('Red', 'Red', 'Red'), ('Red', 'Red', 'Green'), ('Red', 'Red', 'Blue'), ('Red', 'Green', 'Green'), ('Red', 'Green', 'Blue'), ('Red', 'Blue', 'Blue'), ('Green', 'Green', 'Green'), ('Green', 'Green', 'Blue'), ('Green', 'Blue', 'Blue'), ('Blue', 'Blue', 'Blue')]"
] | [] |
|
256 | Write a python function to count the number of prime numbers less than a given non-negative number. | def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr | [
"assert count_Primes_nums(5) == 2",
"assert count_Primes_nums(10) == 4",
"assert count_Primes_nums(100) == 25"
] | [] |
|
257 | Write a function to swap two numbers. | def swap_numbers(a,b):
temp = a
a = b
b = temp
return (a,b) | [
"assert swap_numbers(10,20)==(20,10)",
"assert swap_numbers(15,17)==(17,15)",
"assert swap_numbers(100,200)==(200,100)"
] | [] |
|
258 | Write a function to find number of odd elements in the given list using lambda function. | def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd | [
"assert count_odd([1, 2, 3, 5, 7, 8, 10])==4",
"assert count_odd([10,15,14,13,-18,12,-20])==2",
"assert count_odd([1, 2, 4, 8, 9])==2"
] | [] |
|
259 | Write a function to maximize the given two tuples. | def maximize_elements(test_tup1, test_tup2):
res = tuple(tuple(max(a, b) for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res) | [
"assert maximize_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((6, 7), (4, 9), (2, 9), (7, 10))",
"assert maximize_elements(((2, 4), (5, 6), (3, 10), (2, 11)), ((7, 8), (4, 10), (2, 2), (8, 4))) == ((7, 8), (5, 10), (3, 10), (8, 11))",
"assert maximize_elements(((3, 5), (6, 7), (4, 11), (3, 12)), ((8, 9), (5, 11), (3, 3), (9, 5))) == ((8, 9), (6, 11), (4, 11), (9, 12))"
] | [] |
|
260 | Write a function to find the nth newman–shanks–williams prime number. | def newman_prime(n):
if n == 0 or n == 1:
return 1
return 2 * newman_prime(n - 1) + newman_prime(n - 2) | [
"assert newman_prime(3) == 7 ",
"assert newman_prime(4) == 17",
"assert newman_prime(5) == 41"
] | [] |
|
261 | Write a function to perform mathematical division operation across the given tuples. | def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res) | [
"assert division_elements((10, 4, 6, 9),(5, 2, 3, 3)) == (2, 2, 2, 3)",
"assert division_elements((12, 6, 8, 16),(6, 3, 4, 4)) == (2, 2, 2, 4)",
"assert division_elements((20, 14, 36, 18),(5, 7, 6, 9)) == (4, 2, 6, 2)"
] | [] |
|
262 | Write a function to split a given list into two parts where the length of the first part of the list is given. | def split_two_parts(list1, L):
return list1[:L], list1[L:] | [
"assert split_two_parts([1,1,2,3,4,4,5,1],3)==([1, 1, 2], [3, 4, 4, 5, 1])",
"assert split_two_parts(['a', 'b', 'c', 'd'],2)==(['a', 'b'], ['c', 'd'])",
"assert split_two_parts(['p', 'y', 't', 'h', 'o', 'n'],4)==(['p', 'y', 't', 'h'], ['o', 'n'])"
] | [] |
|
263 | Write a function to merge two dictionaries. | def merge_dict(d1,d2):
d = d1.copy()
d.update(d2)
return d | [
"assert merge_dict({'a': 100, 'b': 200},{'x': 300, 'y': 200})=={'x': 300, 'y': 200, 'a': 100, 'b': 200}",
"assert merge_dict({'a':900,'b':900,'d':900},{'a':900,'b':900,'d':900})=={'a':900,'b':900,'d':900,'a':900,'b':900,'d':900}",
"assert merge_dict({'a':10,'b':20},{'x':30,'y':40})=={'x':30,'y':40,'a':10,'b':20}"
] | [] |
|
264 | Write a function to calculate a dog's age in dog's years. | def dog_age(h_age):
if h_age < 0:
exit()
elif h_age <= 2:
d_age = h_age * 10.5
else:
d_age = 21 + (h_age - 2)*4
return d_age | [
"assert dog_age(12)==61",
"assert dog_age(15)==73",
"assert dog_age(24)==109"
] | [] |
|
265 | Write a function to split a list for every nth element. | def list_split(S, step):
return [S[i::step] for i in range(step)] | [
"assert list_split(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'],3)==[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']] ",
"assert list_split([1,2,3,4,5,6,7,8,9,10,11,12,13,14],3)==[[1,4,7,10,13], [2,5,8,11,14], [3,6,9,12]] ",
"assert list_split(['python','java','C','C++','DBMS','SQL'],2)==[['python', 'C', 'DBMS'], ['java', 'C++', 'SQL']] "
] | [] |
|
266 | Write a function to find the lateral surface area of a cube. | def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA | [
"assert lateralsurface_cube(5)==100",
"assert lateralsurface_cube(9)==324",
"assert lateralsurface_cube(10)==400"
] | [] |
|
267 | Write a python function to find the sum of squares of first n odd natural numbers. | def square_Sum(n):
return int(n*(4*n*n-1)/3) | [
"assert square_Sum(2) == 10",
"assert square_Sum(3) == 35",
"assert square_Sum(4) == 84"
] | [] |
|
268 | Write a function to find the n'th star number. | def find_star_num(n):
return (6 * n * (n - 1) + 1) | [
"assert find_star_num(3) == 37",
"assert find_star_num(4) == 73",
"assert find_star_num(5) == 121"
] | [] |
|
269 | Write a function to find the ascii value of a character. | def ascii_value(k):
ch=k
return ord(ch) | [
"assert ascii_value('A')==65",
"assert ascii_value('R')==82",
"assert ascii_value('S')==83"
] | [] |
|
270 | Write a python function to find the sum of even numbers at even positions. | def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum | [
"assert sum_even_and_even_index([5, 6, 12, 1, 18, 8],6) == 30",
"assert sum_even_and_even_index([3, 20, 17, 9, 2, 10, 18, 13, 6, 18],10) == 26",
"assert sum_even_and_even_index([5, 6, 12, 1],4) == 12"
] | [] |
|
271 | Write a python function to find the sum of fifth power of first n even natural numbers. | def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum; | [
"assert even_Power_Sum(2) == 1056",
"assert even_Power_Sum(3) == 8832",
"assert even_Power_Sum(1) == 32"
] | [] |
|
272 | Write a function to perfom the rear element extraction from list of tuples records. | def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res) | [
"assert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]",
"assert rear_extract([(1, 'Sai', 36), (2, 'Ayesha', 25), (3, 'Salman', 45)]) == [36, 25, 45]",
"assert rear_extract([(1, 'Sudeep', 14), (2, 'Vandana', 36), (3, 'Dawood', 56)]) == [14, 36, 56]"
] | [] |
|
273 | Write a function to substract the contents of one tuple with corresponding index of other tuple. | def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res) | [
"assert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)",
"assert substract_elements((11, 2, 3), (24, 45 ,16)) == (-13, -43, -13)",
"assert substract_elements((7, 18, 9), (10, 11, 12)) == (-3, 7, -3)"
] | [] |
|
274 | Write a python function to find sum of even index binomial coefficients. | import math
def even_binomial_Coeff_Sum( n):
return (1 << (n - 1)) | [
"assert even_binomial_Coeff_Sum(4) == 8",
"assert even_binomial_Coeff_Sum(6) == 32",
"assert even_binomial_Coeff_Sum(2) == 2"
] | [] |
|
275 | Write a python function to find the position of the last removed element from the given array. | import math as mt
def get_Position(a,n,m):
for i in range(n):
a[i] = (a[i] // m + (a[i] % m != 0))
result,maxx = -1,-1
for i in range(n - 1,-1,-1):
if (maxx < a[i]):
maxx = a[i]
result = i
return result + 1 | [
"assert get_Position([2,5,4],3,2) == 2",
"assert get_Position([4,3],2,2) == 2",
"assert get_Position([1,2,3,4],4,1) == 4"
] | [] |
|
276 | Write a function to find the volume of a cylinder. | def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume | [
"assert volume_cylinder(10,5)==1570.7500000000002",
"assert volume_cylinder(4,5)==251.32000000000002",
"assert volume_cylinder(4,10)==502.64000000000004"
] | [] |
|
277 | Write a function to filter a dictionary based on values. | def dict_filter(dict,n):
result = {key:value for (key, value) in dict.items() if value >=n}
return result | [
"assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},170)=={'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}",
"assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},180)=={ 'Alden Cantrell': 180, 'Pierre Cox': 190}",
"assert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},190)=={ 'Pierre Cox': 190}"
] | [] |
|
278 | Write a function to find the element count that occurs before the record in the given tuple. | def count_first_elements(test_tup):
for count, ele in enumerate(test_tup):
if isinstance(ele, tuple):
break
return (count) | [
"assert count_first_elements((1, 5, 7, (4, 6), 10) ) == 3",
"assert count_first_elements((2, 9, (5, 7), 11) ) == 2",
"assert count_first_elements((11, 15, 5, 8, (2, 3), 8) ) == 4"
] | [] |
|
279 | Write a function to find the nth decagonal number. | def is_num_decagonal(n):
return 4 * n * n - 3 * n | [
"assert is_num_decagonal(3) == 27",
"assert is_num_decagonal(7) == 175",
"assert is_num_decagonal(10) == 370"
] | [] |
|
280 | Write a function to search an element in the given array by using sequential search. | def sequential_search(dlist, item):
pos = 0
found = False
while pos < len(dlist) and not found:
if dlist[pos] == item:
found = True
else:
pos = pos + 1
return found, pos | [
"assert sequential_search([11,23,58,31,56,77,43,12,65,19],31) == (True, 3)",
"assert sequential_search([12, 32, 45, 62, 35, 47, 44, 61],61) == (True, 7)",
"assert sequential_search([9, 10, 17, 19, 22, 39, 48, 56],48) == (True, 6)"
] | [] |
|
281 | Write a python function to check if the elements of a given list are unique or not. | def all_unique(test_list):
if len(test_list) > len(set(test_list)):
return False
return True | [
"assert all_unique([1,2,3]) == True",
"assert all_unique([1,2,1,2]) == False",
"assert all_unique([1,2,3,4,5]) == True"
] | [] |
|
282 | Write a function to substaract two lists using map and lambda function. | def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result) | [
"assert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]",
"assert sub_list([1,2],[3,4])==[-2,-2]",
"assert sub_list([90,120],[50,70])==[40,50]"
] | [] |
|
283 | Write a python function to check whether the frequency of each digit is less than or equal to the digit itself. | def validate(n):
for i in range(10):
temp = n;
count = 0;
while (temp):
if (temp % 10 == i):
count+=1;
if (count > i):
return False
temp //= 10;
return True | [
"assert validate(1234) == True",
"assert validate(51241) == False",
"assert validate(321) == True"
] | [] |
|
284 | Write a function to check whether all items of a list are equal to a given string. | def check_element(list,element):
check_element=all(v== element for v in list)
return check_element | [
"assert check_element([\"green\", \"orange\", \"black\", \"white\"],'blue')==False",
"assert check_element([1,2,3,4],7)==False",
"assert check_element([\"green\", \"green\", \"green\", \"green\"],'green')==True"
] | [] |
|
285 | Write a function that matches a string that has an a followed by two to three 'b'. | import re
def text_match_two_three(text):
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!') | [
"assert text_match_two_three(\"ac\")==('Not matched!')",
"assert text_match_two_three(\"dc\")==('Not matched!')",
"assert text_match_two_three(\"abbbba\")==('Found a match!')"
] | [] |
|
286 | Write a function to find the largest sum of contiguous array in the modified array which is formed by repeating the given array k times. | def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far | [
"assert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 3) == 30",
"assert max_sub_array_sum_repeated([-1, 10, 20], 3, 2) == 59",
"assert max_sub_array_sum_repeated([-1, -2, -3], 3, 3) == -1"
] | [] |
|
287 | Write a python function to find the sum of squares of first n even natural numbers. | def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3) | [
"assert square_Sum(2) == 20",
"assert square_Sum(3) == 56",
"assert square_Sum(4) == 120"
] | [] |
|
288 | Write a function to count array elements having modular inverse under given prime number p equal to itself. | def modular_inverse(arr, N, P):
current_element = 0
for i in range(0, N):
if ((arr[i] * arr[i]) % P == 1):
current_element = current_element + 1
return current_element | [
"assert modular_inverse([ 1, 6, 4, 5 ], 4, 7) == 2",
"assert modular_inverse([1, 3, 8, 12, 12], 5, 13) == 3",
"assert modular_inverse([2, 3, 4, 5], 4, 6) == 1"
] | [] |
|
289 | Write a python function to calculate the number of odd days in a given year. | def odd_Days(N):
hund1 = N // 100
hund4 = N // 400
leap = N >> 2
ordd = N - leap
if (hund1):
ordd += hund1
leap -= hund1
if (hund4):
ordd -= hund4
leap += hund4
days = ordd + leap * 2
odd = days % 7
return odd | [
"assert odd_Days(100) == 5",
"assert odd_Days(50) ==6",
"assert odd_Days(75) == 2"
] | [] |
|
290 | Write a function to find the list of lists with maximum length. | def max_length(list1):
max_length = max(len(x) for x in list1 )
max_list = max((x) for x in list1)
return(max_length, max_list) | [
"assert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])",
"assert max_length([[1], [5, 7], [10, 12, 14,15]])==(4, [10, 12, 14,15])",
"assert max_length([[5], [15,20,25]])==(3, [15,20,25])"
] | [] |
|
291 | Write a function to find out the number of ways of painting the fence such that at most 2 adjacent posts have the same color for the given fence with n posts and k colors. | def count_no_of_ways(n, k):
dp = [0] * (n + 1)
total = k
mod = 1000000007
dp[1] = k
dp[2] = k * k
for i in range(3,n+1):
dp[i] = ((k - 1) * (dp[i - 1] + dp[i - 2])) % mod
return dp[n] | [
"assert count_no_of_ways(2, 4) == 16",
"assert count_no_of_ways(3, 2) == 6",
"assert count_no_of_ways(4, 4) == 228"
] | [] |
|
292 | Write a python function to find quotient of two numbers. | def find(n,m):
q = n//m
return (q) | [
"assert find(10,3) == 3",
"assert find(4,2) == 2",
"assert find(20,5) == 4"
] | [] |
|
293 | Write a function to find the third side of a right angled triangle. | import math
def otherside_rightangle(w,h):
s=math.sqrt((w*w)+(h*h))
return s | [
"assert otherside_rightangle(7,8)==10.63014581273465",
"assert otherside_rightangle(3,4)==5",
"assert otherside_rightangle(7,15)==16.55294535724685"
] | [] |
|
294 | Write a function to find the maximum value in a given heterogeneous list. | def max_val(listval):
max_val = max(i for i in listval if isinstance(i, int))
return(max_val) | [
"assert max_val(['Python', 3, 2, 4, 5, 'version'])==5",
"assert max_val(['Python', 15, 20, 25])==25",
"assert max_val(['Python', 30, 20, 40, 50, 'version'])==50"
] | [] |
|
295 | Write a function to return the sum of all divisors of a number. | def sum_div(number):
divisors = [1]
for i in range(2, number):
if (number % i)==0:
divisors.append(i)
return sum(divisors) | [
"assert sum_div(8)==7",
"assert sum_div(12)==16",
"assert sum_div(7)==1"
] | [] |
|
296 | Write a python function to count inversions in an 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 | [
"assert get_Inv_Count([1,20,6,4,5],5) == 5",
"assert get_Inv_Count([1,2,1],3) == 1",
"assert get_Inv_Count([1,2,5,6,1],5) == 3"
] | [] |
|
297 | Write a function to flatten a given nested list structure. | def flatten_list(list1):
result_list = []
if not list1: return result_list
stack = [list(list1)]
while stack:
c_num = stack.pop()
next = c_num.pop()
if c_num: stack.append(c_num)
if isinstance(next, list):
if next: stack.append(list(next))
else: result_list.append(next)
result_list.reverse()
return result_list | [
"assert flatten_list([0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]])==[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]",
"assert flatten_list([[10, 20], [40], [30, 56, 25], [10, 20], [33], [40]])==[10, 20, 40, 30, 56, 25, 10, 20, 33, 40]",
"assert flatten_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]])==[1, 2, 3, 4, 5, 6, 10, 11, 12, 7, 8, 9]"
] | [] |
|
298 | Write a function to find the nested list elements which are present in another list. | def intersection_nested_lists(l1, l2):
result = [[n for n in lst if n in l1] for lst in l2]
return result | [
"assert intersection_nested_lists( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],[[12, 18, 23, 25, 45], [7, 11, 19, 24, 28], [1, 5, 8, 18, 15, 16]])==[[12], [7, 11], [1, 5, 8]]",
"assert intersection_nested_lists([[2, 3, 1], [4, 5], [6, 8]], [[4, 5], [6, 8]])==[[], []]",
"assert intersection_nested_lists(['john','amal','joel','george'],[['john'],['jack','john','mary'],['howard','john'],['jude']])==[['john'], ['john'], ['john'], []]"
] | [] |
|
299 | Write a function to calculate the maximum aggregate from the list of tuples. | from collections import defaultdict
def max_aggregate(stdata):
temp = defaultdict(int)
for name, marks in stdata:
temp[name] += marks
return max(temp.items(), key=lambda x: x[1]) | [
"assert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)",
"assert max_aggregate([('Juan Whelan',50),('Sabah Colley',48),('Peter Nichols',37),('Juan Whelan',22),('Sabah Colley',14)])==('Juan Whelan', 72)",
"assert max_aggregate([('Juan Whelan',10),('Sabah Colley',20),('Peter Nichols',30),('Juan Whelan',40),('Sabah Colley',50)])==('Sabah Colley', 70)"
] | [] |
|
300 | Write a function to find the count of all binary sequences of length 2n such that sum of first n bits is same as sum of last n bits. | def count_binary_seq(n):
nCr = 1
res = 1
for r in range(1, n + 1):
nCr = (nCr * (n + 1 - r)) / r
res += nCr * nCr
return res | [
"assert count_binary_seq(1) == 2.0",
"assert count_binary_seq(2) == 6.0",
"assert count_binary_seq(3) == 20.0"
] | [] |
|
301 | Write a function to find the depth of a dictionary. | def dict_depth(d):
if isinstance(d, dict):
return 1 + (max(map(dict_depth, d.values())) if d else 0)
return 0 | [
"assert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4",
"assert dict_depth({'a':1, 'b': {'c':'python'}})==2",
"assert dict_depth({1: 'Sun', 2: {3: {4:'Mon'}}})==3"
] | [] |
|
302 | Write a python function to find the most significant bit number which is also a set bit. | def set_Bit_Number(n):
if (n == 0):
return 0;
msb = 0;
n = int(n / 2);
while (n > 0):
n = int(n / 2);
msb += 1;
return (1 << msb) | [
"assert set_Bit_Number(6) == 4",
"assert set_Bit_Number(10) == 8",
"assert set_Bit_Number(18) == 16"
] | [] |
|
303 | Write a python function to check whether the count of inversion of two types are same or not. | import sys
def solve(a,n):
mx = -sys.maxsize - 1
for j in range(1,n):
if (mx > a[j]):
return False
mx = max(mx,a[j - 1])
return True | [
"assert solve([1,0,2],3) == True",
"assert solve([1,2,0],3) == False",
"assert solve([1,2,1],3) == True"
] | [] |
|
304 | Write a python function to find element at a given index after number of rotations. | def find_Element(arr,ranges,rotations,index) :
for i in range(rotations - 1,-1,-1 ) :
left = ranges[i][0]
right = ranges[i][1]
if (left <= index and right >= index) :
if (index == left) :
index = right
else :
index = index - 1
return arr[index] | [
"assert find_Element([1,2,3,4,5],[[0,2],[0,3]],2,1) == 3",
"assert find_Element([1,2,3,4],[[0,1],[0,2]],1,2) == 3",
"assert find_Element([1,2,3,4,5,6],[[0,1],[0,2]],1,1) == 1"
] | [] |
|
305 | Write a function to match two words from a list of words starting with letter 'p'. | import re
def start_withp(words):
for w in words:
m = re.match("(P\w+)\W(P\w+)", w)
if m:
return m.groups() | [
"assert start_withp([\"Python PHP\", \"Java JavaScript\", \"c c++\"])==('Python', 'PHP')",
"assert start_withp([\"Python Programming\",\"Java Programming\"])==('Python','Programming')",
"assert start_withp([\"Pqrst Pqr\",\"qrstuv\"])==('Pqrst','Pqr')"
] | [] |
|
306 | Write a function to find the maximum sum of increasing subsequence from prefix till ith index and also including a given kth element which is after i, i.e., k > i . | def max_sum_increasing_subseq(a, n, index, k):
dp = [[0 for i in range(n)]
for i in range(n)]
for i in range(n):
if a[i] > a[0]:
dp[0][i] = a[i] + a[0]
else:
dp[0][i] = a[i]
for i in range(1, n):
for j in range(n):
if a[j] > a[i] and j > i:
if dp[i - 1][i] + a[j] > dp[i - 1][j]:
dp[i][j] = dp[i - 1][i] + a[j]
else:
dp[i][j] = dp[i - 1][j]
else:
dp[i][j] = dp[i - 1][j]
return dp[index][k] | [
"assert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11",
"assert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 2, 5) == 7",
"assert max_sum_increasing_subseq([11, 15, 19, 21, 26, 28, 31], 7, 2, 4) == 71"
] | [] |
|
307 | Write a function to get a colon of a tuple. | from copy import deepcopy
def colon_tuplex(tuplex,m,n):
tuplex_colon = deepcopy(tuplex)
tuplex_colon[m].append(n)
return tuplex_colon | [
"assert colon_tuplex((\"HELLO\", 5, [], True) ,2,50)==(\"HELLO\", 5, [50], True) ",
"assert colon_tuplex((\"HELLO\", 5, [], True) ,2,100)==((\"HELLO\", 5, [100],True))",
"assert colon_tuplex((\"HELLO\", 5, [], True) ,2,500)==(\"HELLO\", 5, [500], True)"
] | [] |
|
308 | Write a function to find the specified number of largest products from two given lists. | def large_product(nums1, nums2, N):
result = sorted([x*y for x in nums1 for y in nums2], reverse=True)[:N]
return result | [
"assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]",
"assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],4)==[60, 54, 50, 48]",
"assert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],5)==[60, 54, 50, 48, 45]"
] | [] |
|
309 | Write a python function to find the maximum of two numbers. | def maximum(a,b):
if a >= b:
return a
else:
return b | [
"assert maximum(5,10) == 10",
"assert maximum(-1,-2) == -1",
"assert maximum(9,7) == 9"
] | [] |
|
310 | Write a function to convert a given string to a tuple. | def string_to_tuple(str1):
result = tuple(x for x in str1 if not x.isspace())
return result | [
"assert string_to_tuple(\"python 3.0\")==('p', 'y', 't', 'h', 'o', 'n', '3', '.', '0')",
"assert string_to_tuple(\"item1\")==('i', 't', 'e', 'm', '1')",
"assert string_to_tuple(\"15.10\")==('1', '5', '.', '1', '0')"
] | [] |