task_id int32 11 510 | text stringlengths 908 2.9k | code stringlengths 37 1.33k | test_list listlengths 3 3 | test_setup_code stringclasses 2
values | challenge_test_list listlengths 0 3 |
|---|---|---|---|---|---|
111 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def common_in_nested_lists(nestedlist):
result = list(set.intersection(*map(set, nestedlist)))
return result | [
"assert common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])==[18, 12]",
"assert common_in_nested_lists([[12, 5, 23, 25, 45], [7, 11, 5, 23, 28], [1, 5, 8, 18, 23, 16]])==[5,23]",
"assert common_in_nested_lists([[2, 3,4, 1], [4, 5], [6,4, 8],[4, 5], [6, 8,4]])==[4]"
] | [] | |
112 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def perimeter(diameter,height) :
return 2*(diameter+height) | [
"assert perimeter(2,4) == 12",
"assert perimeter(1,2) == 6",
"assert perimeter(3,1) == 8"
] | [] | |
113 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def check_integer(text):
text = text.strip()
if len(text) < 1:
return None
else:
if all(text[i] in "0123456789" for i in range(len(text))):
return True
elif (text[0] in "+-") and \
all(text[i] in "0123456789" for i in range(1,len(text))):
return True
else:
... | [
"assert check_integer(\"python\")==False",
"assert check_integer(\"1\")==True",
"assert check_integer(\"12345\")==True"
] | [] | |
114 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from collections import Counter
def assign_freq(test_list):
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res)) | [
"assert assign_freq([(6, 5, 8), (2, 7), (6, 5, 8), (6, 5, 8), (9, ), (2, 7)] ) == '[(6, 5, 8, 3), (2, 7, 2), (9, 1)]'",
"assert assign_freq([(4, 2, 4), (7, 1), (4, 8), (4, 2, 4), (9, 2), (7, 1)] ) == '[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]'",
"assert assign_freq([(11, 13, 10), (17, 21), (4, 2, 3), (17,... | [] | |
115 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit | [
"assert empty_dit([{},{},{}])==True",
"assert empty_dit([{1,2},{},{}])==False",
"assert empty_dit({})==True"
] | [] | |
116 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def tuple_to_int(nums):
result = int(''.join(map(str,nums)))
return result | [
"assert tuple_to_int((1,2,3))==123",
"assert tuple_to_int((4,5,6))==456",
"assert tuple_to_int((5,6,7))==567"
] | [] | |
117 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def list_to_float(test_list):
res = []
for tup in test_list:
temp = []
for ele in tup:
if ele.isalpha():
temp.append(ele)
else:
temp.append(float(ele))
res.append((temp[0],temp[1]))
return (str(res)) | [
"assert list_to_float( [(\"3\", \"4\"), (\"1\", \"26.45\"), (\"7.32\", \"8\"), (\"4\", \"8\")] ) == '[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]'",
"assert list_to_float( [(\"4\", \"4\"), (\"2\", \"27\"), (\"4.12\", \"9\"), (\"7\", \"11\")] ) == '[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]'",
"a... | [] | |
118 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def string_to_list(string):
lst = list(string.split(" "))
return lst | [
"assert string_to_list(\"python programming\")==['python','programming']",
"assert string_to_list(\"lists tuples strings\")==['lists','tuples','strings']",
"assert string_to_list(\"write a program\")==['write','a','program']"
] | [] | |
119 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | [
"assert search([1,1,2,2,3],5) == 3",
"assert search([1,1,3,3,4,4,5,5,7,7,8],11) == 8",
"assert search([1,2,2,3,3,4,4],7) == 1"
] | [] | |
120 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | [
"assert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==36",
"assert max_product_tuple([(10,20), (15,2), (5,10)] )==200",
"assert max_product_tuple([(11,44), (10,15), (20,5), (12, 9)] )==484"
] | [] | |
121 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def check_triplet(A, n, sum, count):
if count == 3 and sum == 0:
return True
if count == 3 or n == 0 or sum < 0:
return False
return check_triplet(A, n - 1, sum - A[n - 1], count + 1) or\
check_triplet(A, n - 1, sum, count) | [
"assert check_triplet([2, 7, 4, 0, 9, 5, 1, 3], 8, 6, 0) == True",
"assert check_triplet([1, 4, 5, 6, 7, 8, 5, 9], 8, 6, 0) == False",
"assert check_triplet([10, 4, 2, 3, 5], 5, 15, 0) == True"
] | [] | |
122 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | MAX = 3000
def smartNumber(n):
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | [
"assert smartNumber(1) == 30",
"assert smartNumber(50) == 273",
"assert smartNumber(1000) == 2664"
] | [] | |
123 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def amicable_numbers_sum(limit):
if not isinstance(limit, int):
return "Input is not an integer!"
if limit < 1:
return "Input must be bigger than 0!"
amicables = set()
for num in range(2, limit+1):
if num in amicables:
continue
sum_fact = sum([fact fo... | [
"assert amicable_numbers_sum(999)==504",
"assert amicable_numbers_sum(9999)==31626",
"assert amicable_numbers_sum(99)==0"
] | [] | |
124 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import cmath
def angle_complex(a,b):
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | [
"assert angle_complex(0,1j)==1.5707963267948966 ",
"assert angle_complex(2,1j)==0.4636476090008061",
"assert angle_complex(0,2j)==1.5707963267948966"
] | [] | |
125 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | [
"assert find_length(\"11000010001\", 11) == 6",
"assert find_length(\"10111\", 5) == 1",
"assert find_length(\"11011101100101\", 14) == 2 "
] | [] | |
126 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | [
"assert sum(10,15) == 6",
"assert sum(100,150) == 93",
"assert sum(4,6) == 3"
] | [] | |
127 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | [
"assert multiply_int(10,20)==200",
"assert multiply_int(5,10)==50",
"assert multiply_int(4,8)==32"
] | [] | |
128 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def long_words(n, str):
word_len = []
txt = str.split(" ")
for x in txt:
if len(x) > n:
word_len.append(x)
return word_len | [
"assert long_words(3,\"python is a programming language\")==['python','programming','language']",
"assert long_words(2,\"writing a program\")==['writing','program']",
"assert long_words(5,\"sorting list\")==['sorting']"
] | [] | |
129 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
... | [
"assert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]])==True",
"assert magic_square_test([[2, 7, 6], [9, 5, 1], [4, 3, 8]])==True",
"assert magic_square_test([[2, 7, 6], [9, 5, 1], [4, 3, 7]])==False"
] | [] | |
130 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from collections import defaultdict
def max_occurrences(nums):
dict = defaultdict(int)
for i in nums:
dict[i] += 1
result = max(dict.items(), key=lambda x: x[1])
return result | [
"assert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2])==(2, 5)",
"assert max_occurrences([2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18])==(8, 2)",
"assert max_occurrences([10,20,20,30,40,90,80,50,30,20,50,10])==(20, 3)"
] | [] | |
131 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def reverse_vowels(str1):
vowels = ""
for char in str1:
if char in "aeiouAEIOU":
vowels += char
result_string = ""
for char in str1:
if char in "aeiouAEIOU":
result_string += vowels[-1]
vowels = vowels[:-1]
else:
result_string += char
return result_string | [
"assert reverse_vowels(\"Python\") == \"Python\"",
"assert reverse_vowels(\"USA\") == \"ASU\"",
"assert reverse_vowels(\"ab\") == \"ab\""
] | [] | |
132 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def tup_string(tup1):
str = ''.join(tup1)
return str | [
"assert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's'))==(\"exercises\")",
"assert tup_string(('p','y','t','h','o','n'))==(\"python\")",
"assert tup_string(('p','r','o','g','r','a','m'))==(\"program\")"
] | [] | |
133 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum_negativenum(nums):
sum_negativenum = list(filter(lambda nums:nums<0,nums))
return sum(sum_negativenum) | [
"assert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32",
"assert sum_negativenum([10,15,-14,13,-18,12,-20])==-52",
"assert sum_negativenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==-894"
] | [] | |
134 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def check_last (arr,n,p):
_sum = 0
for i in range(n):
_sum = _sum + arr[i]
if p == 1:
if _sum % 2 == 0:
return "ODD"
else:
return "EVEN"
return "EVEN"
| [
"assert check_last([5,7,10],3,1) == \"ODD\"",
"assert check_last([2,3],2,3) == \"EVEN\"",
"assert check_last([1,2,3],3,1) == \"ODD\""
] | [] | |
135 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def hexagonal_num(n):
return n*(2*n - 1) | [
"assert hexagonal_num(10) == 190",
"assert hexagonal_num(5) == 45",
"assert hexagonal_num(7) == 91"
] | [] | |
136 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def cal_electbill(units):
if(units < 50):
amount = units * 2.60
surcharge = 25
elif(units <= 100):
amount = 130 + ((units - 50) * 3.25)
surcharge = 35
elif(units <= 200):
amount = 130 + 162.50 + ((units - 100) * 5.26)
surcharge = 45
else:
amount = 130 + 162.50 + 526 + ((units ... | [
"assert cal_electbill(75)==246.25",
"assert cal_electbill(265)==1442.75",
"assert cal_electbill(100)==327.5"
] | [] | |
137 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from array import array
def zero_count(nums):
n = len(nums)
n1 = 0
for x in nums:
if x == 0:
n1 += 1
else:
None
return round(n1/n,2) | [
"assert zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.15",
"assert zero_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.00",
"assert zero_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.00"
] | [] | |
138 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def is_Sum_Of_Powers_Of_Two(n):
if (n % 2 == 1):
return False
else:
return True | [
"assert is_Sum_Of_Powers_Of_Two(10) == True",
"assert is_Sum_Of_Powers_Of_Two(7) == False",
"assert is_Sum_Of_Powers_Of_Two(14) == True"
] | [] | |
139 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def circle_circumference(r):
perimeter=2*3.1415*r
return perimeter | [
"assert circle_circumference(10)==62.830000000000005",
"assert circle_circumference(5)==31.415000000000003",
"assert circle_circumference(4)==25.132"
] | [] | |
140 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def extract_singly(test_list):
res = []
temp = set()
for inner in test_list:
for ele in inner:
if not ele in temp:
temp.add(ele)
res.append(ele)
return (res) | [
"assert extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)]) == [3, 4, 5, 7, 1]",
"assert extract_singly([(1, 2, 3), (4, 2, 3), (7, 8)]) == [1, 2, 3, 4, 7, 8]",
"assert extract_singly([(7, 8, 9), (10, 11, 12), (10, 11)]) == [7, 8, 9, 10, 11, 12]"
] | [] | |
141 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def pancake_sort(nums):
arr_len = len(nums)
while arr_len > 1:
mi = nums.index(max(nums[0:arr_len]))
nums = nums[mi::-1] + nums[mi+1:len(nums)]
nums = nums[arr_len-1::-1] + nums[arr_len:len(nums)]
arr_len -= 1
return nums | [
"assert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]",
"assert pancake_sort([98, 12, 54, 36, 85]) == [12, 36, 54, 85, 98]",
"assert pancake_sort([41, 42, 32, 12, 23]) == [12, 23, 32, 41, 42]"
] | [] | |
142 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count_samepair(list1,list2,list3):
result = sum(m == n == o for m, n, o in zip(list1,list2,list3))
return result | [
"assert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,9],[2,1,3,1,2,6,7,9])==3",
"assert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==4",
"assert count_samepair([1,2,3,4,2,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==5"
] | [] | |
143 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def find_lists(Input):
if isinstance(Input, list):
return 1
else:
return len(Input) | [
"assert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2",
"assert find_lists(([1, 2], [3, 4], [5, 6])) == 3",
"assert find_lists(([9, 8, 7, 6, 5, 4, 3, 2, 1])) == 1"
] | [] | |
144 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum_Pairs(arr,n):
sum = 0
for i in range(n - 1,-1,-1):
sum += i*arr[i] - (n-1-i) * arr[i]
return sum | [
"assert sum_Pairs([1,8,9,15,16],5) == 74",
"assert sum_Pairs([1,2,3,4],4) == 10",
"assert sum_Pairs([1,2,3,4,5,7,9,11,14],9) == 188"
] | [] | |
145 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def max_Abs_Diff(arr,n):
minEle = arr[0]
maxEle = arr[0]
for i in range(1, n):
minEle = min(minEle,arr[i])
maxEle = max(maxEle,arr[i])
return (maxEle - minEle) | [
"assert max_Abs_Diff((2,1,5,3),4) == 4",
"assert max_Abs_Diff((9,3,2,5,1),5) == 8",
"assert max_Abs_Diff((3,2,1),3) == 2"
] | [] | |
146 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i]) | [
"assert ascii_value_string(\"python\")==112",
"assert ascii_value_string(\"Program\")==80",
"assert ascii_value_string(\"Language\")==76"
] | [] | |
147 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def max_path_sum(tri, m, n):
for i in range(m-1, -1, -1):
for j in range(i+1):
if (tri[i+1][j] > tri[i+1][j+1]):
tri[i][j] += tri[i+1][j]
else:
tri[i][j] += tri[i+1][j+1]
return tri[0][0] | [
"assert max_path_sum([[1, 0, 0], [4, 8, 0], [1, 5, 3]], 2, 2) == 14",
"assert max_path_sum([[13, 0, 0], [7, 4, 0], [2, 4, 6]], 2, 2) == 24 ",
"assert max_path_sum([[2, 0, 0], [11, 18, 0], [21, 25, 33]], 2, 2) == 53"
] | [] | |
148 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum_digits_single(x) :
ans = 0
while x :
ans += x % 10
x //= 10
return ans
def closest(x) :
ans = 0
while (ans * 10 + 9 <= x) :
ans = ans * 10 + 9
return ans
def sum_digits_twoparts(N) :
A = closest(N)
return sum_digits_single(A) + ... | [
"assert sum_digits_twoparts(35)==17",
"assert sum_digits_twoparts(7)==7",
"assert sum_digits_twoparts(100)==19"
] | [] | |
149 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result | [
"assert longest_subseq_with_diff_one([1, 2, 3, 4, 5, 3, 2], 7) == 6",
"assert longest_subseq_with_diff_one([10, 9, 4, 5, 4, 8, 6], 7) == 3",
"assert longest_subseq_with_diff_one([1, 2, 3, 2, 3, 7, 2, 1], 8) == 7"
] | [] | |
150 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False | [
"assert does_Contain_B(1,7,3) == True",
"assert does_Contain_B(1,-3,5) == False",
"assert does_Contain_B(3,2,5) == False"
] | [] | |
151 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def gcd(p,q):
while q != 0:
p, q = q,p%q
return p
def is_coprime(x,y):
return gcd(x,y) == 1 | [
"assert is_coprime(17,13) == True",
"assert is_coprime(15,21) == False",
"assert is_coprime(25,45) == False"
] | [] | |
152 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
def merge_sort(x):
... | [
"assert merge_sort([3, 4, 2, 6, 5, 7, 1, 9]) == [1, 2, 3, 4, 5, 6, 7, 9]",
"assert merge_sort([7, 25, 45, 78, 11, 33, 19]) == [7, 11, 19, 25, 33, 45, 78]",
"assert merge_sort([3, 1, 4, 9, 8]) == [1, 3, 4, 8, 9]"
] | [] | |
153 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex | [
"assert parabola_vertex(5,3,2)==(-0.3, 1.55)",
"assert parabola_vertex(9,8,4)==(-0.4444444444444444, 2.2222222222222223)",
"assert parabola_vertex(2,4,6)==(-1.0, 4.0)"
] | [] | |
154 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def specified_element(nums, N):
result = [i[N] for i in nums]
return result | [
"assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]",
"assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],2)==[3, 6, 9]",
"assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],3)==[2,2,5]"
] | [] | |
155 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res | [
"assert even_bit_toggle_number(10) == 0",
"assert even_bit_toggle_number(20) == 30",
"assert even_bit_toggle_number(30) == 20"
] | [] | |
156 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result | [
"assert tuple_int_str((('333', '33'), ('1416', '55')))==((333, 33), (1416, 55))",
"assert tuple_int_str((('999', '99'), ('1000', '500')))==((999, 99), (1000, 500))",
"assert tuple_int_str((('666', '66'), ('1500', '555')))==((666, 66), (1500, 555))"
] | [] | |
157 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from itertools import groupby
def encode_list(list1):
return [[len(list(group)), key] for key, group in groupby(list1)] | [
"assert encode_list([1,1,2,3,4,4.3,5,1])==[[2, 1], [1, 2], [1, 3], [1, 4], [1, 4.3], [1, 5], [1, 1]]",
"assert encode_list('automatically')==[[1, 'a'], [1, 'u'], [1, 't'], [1, 'o'], [1, 'm'], [1, 'a'], [1, 't'], [1, 'i'], [1, 'c'], [1, 'a'], [2, 'l'], [1, 'y']]",
"assert encode_list('python')==[[1, 'p'], [1, 'y... | [] | |
158 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def min_Ops(arr,n,k):
max1 = max(arr)
res = 0
for i in range(0,n):
if ((max1 - arr[i]) % k != 0):
return -1
else:
res += (max1 - arr[i]) / k
return int(res) | [
"assert min_Ops([2,2,2,2],4,3) == 0",
"assert min_Ops([4,2,6,8],4,3) == -1",
"assert min_Ops([21,33,9,45,63],5,6) == 24"
] | [] | |
159 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def month_season(month,days):
if month in ('January', 'February', 'March'):
season = 'winter'
elif month in ('April', 'May', 'June'):
season = 'spring'
elif month in ('July', 'August', 'September'):
season = 'summer'
else:
season = 'autumn'
if (month == 'March') and (days > 19):
season = 'sprin... | [
"assert month_season('January',4)==('winter')",
"assert month_season('October',28)==('autumn')",
"assert month_season('June',6)==('spring')"
] | [] | |
160 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def solution (a, b, n):
i = 0
while i * a <= n:
if (n - (i * a)) % b == 0:
return ("x = ",i ,", y = ",
int((n - (i * a)) / b))
return 0
i = i + 1
return ("No solution") | [
"assert solution(2, 3, 7) == ('x = ', 2, ', y = ', 1)",
"assert solution(4, 2, 7) == 'No solution'",
"assert solution(1, 13, 17) == ('x = ', 4, ', y = ', 1)"
] | [] | |
161 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def remove_elements(list1, list2):
result = [x for x in list1 if x not in list2]
return result | [
"assert remove_elements([1,2,3,4,5,6,7,8,9,10],[2,4,6,8])==[1, 3, 5, 7, 9, 10]",
"assert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],[1, 3, 5, 7])==[2, 4, 6, 8, 9, 10]",
"assert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],[5,7])==[1, 2, 3, 4, 6, 8, 9, 10]"
] | [] | |
162 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum_series(n):
if n < 1:
return 0
else:
return n + sum_series(n - 2) | [
"assert sum_series(6)==12",
"assert sum_series(10)==30",
"assert sum_series(9)==25"
] | [] | |
163 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from math import tan, pi
def area_polygon(s,l):
area = s * (l ** 2) / (4 * tan(pi / s))
return area | [
"assert area_polygon(4,20)==400.00000000000006",
"assert area_polygon(10,15)==1731.1969896610804",
"assert area_polygon(9,7)==302.90938549487214"
] | [] | |
164 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import math
def divSum(n):
sum = 1;
i = 2;
while(i * i <= n):
if (n % i == 0):
sum = (sum + i +math.floor(n / i));
i += 1;
return sum;
def areEquivalent(num1,num2):
return divSum(num1) == divSum(num2); | [
"assert areEquivalent(36,57) == False",
"assert areEquivalent(2,4) == False",
"assert areEquivalent(23,47) == True"
] | [] | |
165 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count_char_position(str1):
count_chars = 0
for i in range(len(str1)):
if ((i == ord(str1[i]) - ord('A')) or
(i == ord(str1[i]) - ord('a'))):
count_chars += 1
return count_chars | [
"assert count_char_position(\"xbcefg\") == 2",
"assert count_char_position(\"ABcED\") == 3",
"assert count_char_position(\"AbgdeF\") == 5"
] | [] | |
166 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def find_even_Pair(A,N):
evenPair = 0
for i in range(0,N):
for j in range(i+1,N):
if ((A[i] ^ A[j]) % 2 == 0):
evenPair+=1
return evenPair; | [
"assert find_even_Pair([5,4,7,2,1],5) == 4",
"assert find_even_Pair([7,2,8,1,0,5,11],7) == 9",
"assert find_even_Pair([1,2,3],3) == 1"
] | [] | |
167 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def next_Power_Of_2(n):
count = 0;
if (n and not(n & (n - 1))):
return n
while( n != 0):
n >>= 1
count += 1
return 1 << count; | [
"assert next_Power_Of_2(0) == 1",
"assert next_Power_Of_2(5) == 8",
"assert next_Power_Of_2(17) == 32"
] | [] | |
168 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def frequency(a,x):
count = 0
for i in a:
if i == x: count += 1
return count | [
"assert frequency([1,2,3],4) == 0",
"assert frequency([1,2,2,3,3,3,4],3) == 3",
"assert frequency([0,1,2,3,1,2],1) == 2"
] | [] | |
169 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | [
"assert get_pell(4) == 12",
"assert get_pell(7) == 169",
"assert get_pell(8) == 408"
] | [] | |
170 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def sum_range_list(list1, m, n):
sum_range = 0 ... | [
"assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],8,10)==29",
"assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],5,7)==16",
"assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],7,10)==38"
] | [] | |
171 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import math
def perimeter_pentagon(a):
perimeter=(5*a)
return perimeter | [
"assert perimeter_pentagon(5)==25",
"assert perimeter_pentagon(10)==50",
"assert perimeter_pentagon(15)==75"
] | [] | |
172 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count_occurance(s):
count=0
for i in range(len(s)):
if (s[i]== 's' and s[i+1]=='t' and s[i+2]== 'd'):
count = count + 1
return count | [
"assert count_occurance(\"letstdlenstdporstd\") == 3",
"assert count_occurance(\"truststdsolensporsd\") == 1",
"assert count_occurance(\"makestdsostdworthit\") == 2"
] | [] | |
173 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def remove_splchar(text):
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | [
"assert remove_splchar('python @#&^%$*program123')==('pythonprogram123')",
"assert remove_splchar('python %^$@!^&*() programming24%$^^() language')==('pythonprogramming24language')",
"assert remove_splchar('python ^%&^()(+_)(_^&67) program')==('python67program')"
] | [] | |
174 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | [
"assert group_keyvalue([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])=={'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}",
"assert group_keyvalue([('python', 1), ('python', 2), ('python', 3), ('python', 4), ('python', 5)])=={'python': [1,2,3,4,5]}",
"assert group_keyvalue([('yellow',100), ('... | [] | |
175 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def is_valid_parenthese( str1):
stack, pchar = [], {"(": ")", "{": "}", "[": "]"}
for parenthese in str1:
if parenthese in pchar:
stack.append(parenthese)
elif len(stack) == 0 or pchar[stack.pop()] != parenthese:
return False
return ... | [
"assert is_valid_parenthese(\"(){}[]\")==True",
"assert is_valid_parenthese(\"()[{)}\")==False",
"assert is_valid_parenthese(\"()\")==True"
] | [] | |
176 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def perimeter_triangle(a,b,c):
perimeter=a+b+c
return perimeter | [
"assert perimeter_triangle(10,20,30)==60",
"assert perimeter_triangle(3,4,5)==12",
"assert perimeter_triangle(25,35,45)==105"
] | [] | |
177 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def answer(L,R):
if (2 * L <= R):
return (L ,2*L)
else:
return (-1) | [
"assert answer(3,8) == (3,6)",
"assert answer(2,6) == (2,4)",
"assert answer(1,3) == (1,2)"
] | [] | |
178 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def string_literals(patterns,text):
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | [
"assert string_literals(['language'],'python language')==('Matched!')",
"assert string_literals(['program'],'python language')==('Not Matched!')",
"assert string_literals(['python'],'programming language')==('Not Matched!')"
] | [] | |
179 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def is_num_keith(x):
terms = []
temp = x
n = 0
while (temp > 0):
terms.append(temp % 10)
temp = int(temp / 10)
n+=1
terms.reverse()
next_term = 0
i = n
while (next_term < x):
next_term = 0
for j in range(1,n+1):
next_term += terms[i - j]
terms.append(next_term)
i... | [
"assert is_num_keith(14) == True",
"assert is_num_keith(12) == False",
"assert is_num_keith(197) == True"
] | [] | |
180 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | from math import radians, sin, cos, acos
def distance_lat_long(slat,slon,elat,elon):
dist = 6371.01 * acos(sin(slat)*sin(elat) + cos(slat)*cos(elat)*cos(slon - elon))
return dist | [
"assert distance_lat_long(23.5,67.5,25.5,69.5)==12179.372041317429",
"assert distance_lat_long(10.5,20.5,30.5,40.5)==6069.397933300514",
"assert distance_lat_long(10,20,30,40)==6783.751974994595"
] | [] | |
181 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def common_prefix_util(str1, str2):
result = "";
n1 = len(str1)
n2 = len(str2)
i = 0
j = 0
while i <= n1 - 1 and j <= n2 - 1:
if (str1[i] != str2[j]):
break
result += str1[i]
i += 1
j += 1
return (result)
def common_prefix (arr, n):
prefix = arr[0]
for i in range (1, n):
... | [
"assert common_prefix([\"tablets\", \"tables\", \"taxi\", \"tamarind\"], 4) == 'ta'",
"assert common_prefix([\"apples\", \"ape\", \"april\"], 3) == 'ap'",
"assert common_prefix([\"teens\", \"teenager\", \"teenmar\"], 3) == 'teen'"
] | [] | |
182 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def find_character(string):
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, num... | [
"assert find_character(\"ThisIsGeeksforGeeks\") == (['T', 'I', 'G', 'G'], ['h', 'i', 's', 's', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'e', 'e', 'k', 's'], [], [])",
"assert find_character(\"Hithere2\") == (['H'], ['i', 't', 'h', 'e', 'r', 'e'], ['2'], [])",
"assert find_character(\"HeyFolks32\") == (['H', 'F'], ['e... | [] | |
183 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | [
"assert count_pairs([1, 5, 3, 4, 2], 5, 3) == 2",
"assert count_pairs([8, 12, 16, 4, 0, 20], 6, 4) == 5",
"assert count_pairs([2, 4, 1, 3, 4], 5, 2) == 3"
] | [] | |
184 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def greater_specificnum(list,num):
greater_specificnum=all(x >= num for x in list)
return greater_specificnum | [
"assert greater_specificnum([220, 330, 500],200)==True",
"assert greater_specificnum([12, 17, 21],20)==False",
"assert greater_specificnum([1,2,3,4],10)==False"
] | [] | |
185 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def parabola_focus(a, b, c):
focus= (((-b / (2 * a)),(((4 * a * c) - (b * b) + 1) / (4 * a))))
return focus | [
"assert parabola_focus(5,3,2)==(-0.3, 1.6)",
"assert parabola_focus(9,8,4)==(-0.4444444444444444, 2.25)",
"assert parabola_focus(2,4,6)==(-1.0, 4.125)"
] | [] | |
186 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def check_literals(text, patterns):
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | [
"assert check_literals('The quick brown fox jumps over the lazy dog.',['fox']) == 'Matched!'",
"assert check_literals('The quick brown fox jumps over the lazy dog.',['horse']) == 'Not Matched!'",
"assert check_literals('The quick brown fox jumps over the lazy dog.',['lazy']) == 'Matched!'"
] | [] | |
187 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def longest_common_subsequence(X, Y, m, n):
if m == 0 or n == 0:
return 0
elif X[m-1] == Y[n-1]:
return 1 + longest_common_subsequence(X, Y, m-1, n-1)
else:
return max(longest_common_subsequence(X, Y, m, n-1), longest_common_subsequence(X, Y, m-1, n)) | [
"assert longest_common_subsequence(\"AGGTAB\" , \"GXTXAYB\", 6, 7) == 4",
"assert longest_common_subsequence(\"ABCDGH\" , \"AEDFHR\", 6, 6) == 3",
"assert longest_common_subsequence(\"AXYT\" , \"AYZX\", 4, 4) == 2"
] | [] | |
188 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def prod_Square(n):
for i in range(2,(n) + 1):
if (i*i < (n+1)):
for j in range(2,n + 1):
if ((i*i*j*j) == n):
return True;
return False; | [
"assert prod_Square(25) == False",
"assert prod_Square(30) == False",
"assert prod_Square(16) == True"
] | [] | |
189 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += ... | [
"assert first_Missing_Positive([1,2,3,-1,5],5) == 4",
"assert first_Missing_Positive([0,-1,-2,1,5,8],6) == 2",
"assert first_Missing_Positive([0,1,2,5,-8],5) == 3"
] | [] | |
190 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count_Intgral_Points(x1,y1,x2,y2):
return ((y2 - y1 - 1) * (x2 - x1 - 1)) | [
"assert count_Intgral_Points(1,1,4,4) == 4",
"assert count_Intgral_Points(1,2,1,2) == 1",
"assert count_Intgral_Points(4,2,6,4) == 1"
] | [] | |
191 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def check_monthnumber(monthname3):
if monthname3 =="April" or monthname3== "June" or monthname3== "September" or monthname3== "November":
return True
else:
return False | [
"assert check_monthnumber(\"February\")==False",
"assert check_monthnumber(\"June\")==True",
"assert check_monthnumber(\"April\")==True"
] | [] | |
192 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def check_String(str):
flag_l = False
flag_n = False
for i in str:
if i.isalpha():
flag_l = True
if i.isdigit():
flag_n = True
return flag_l and flag_n | [
"assert check_String('thishasboth29') == True",
"assert check_String('python') == False",
"assert check_String ('string') == False"
] | [] | |
193 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def remove_tuple(test_tup):
res = tuple(set(test_tup))
return (res) | [
"assert remove_tuple((1, 3, 5, 2, 3, 5, 1, 1, 3)) == (1, 2, 3, 5)",
"assert remove_tuple((2, 3, 4, 4, 5, 6, 6, 7, 8, 8)) == (2, 3, 4, 5, 6, 7, 8)",
"assert remove_tuple((11, 12, 13, 11, 11, 12, 14, 13)) == (11, 12, 13, 14)"
] | [] | |
194 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def octal_To_Decimal(n):
num = n;
dec_value = 0;
base = 1;
temp = num;
while (temp):
last_digit = temp % 10;
temp = int(temp / 10);
dec_value += last_digit*base;
base = base * 8;
return dec_value; | [
"assert octal_To_Decimal(25) == 21",
"assert octal_To_Decimal(30) == 24",
"assert octal_To_Decimal(40) == 32"
] | [] | |
195 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def first(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
high = mid - 1
return res | [
"assert first([1,2,3,4,5,6,6],6,6) == 5",
"assert first([1,2,2,2,3,2,2,4,2],2,9) == 1",
"assert first([1,2,3],1,3) == 0"
] | [] | |
196 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def remove_tuples(test_list, K):
res = [ele for ele in test_list if len(ele) != K]
return (res) | [
"assert remove_tuples([(4, 5), (4, ), (8, 6, 7), (1, ), (3, 4, 6, 7)] , 1) == [(4, 5), (8, 6, 7), (3, 4, 6, 7)]",
"assert remove_tuples([(4, 5), (4,5), (6, 7), (1, 2, 3), (3, 4, 6, 7)] ,2) == [(1, 2, 3), (3, 4, 6, 7)]",
"assert remove_tuples([(1, 4, 4), (4, 3), (8, 6, 7), (1, ), (3, 6, 7)] , 3) == [(4, 3), (1,)... | [] | |
197 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def find_exponentio(test_tup1, test_tup2):
res = tuple(ele1 ** ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
| [
"assert find_exponentio((10, 4, 5, 6), (5, 6, 7, 5)) == (100000, 4096, 78125, 7776)",
"assert find_exponentio((11, 5, 6, 7), (6, 7, 8, 6)) == (1771561, 78125, 1679616, 117649)",
"assert find_exponentio((12, 6, 7, 8), (7, 8, 9, 7)) == (35831808, 1679616, 40353607, 2097152)"
] | [] | |
198 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import math
def largest_triangle(a,b):
if (a < 0 or b < 0):
return -1
area = (3 * math.sqrt(3) * pow(a, 2)) / (4 * b);
return area | [
"assert largest_triangle(4,2)==10.392304845413264",
"assert largest_triangle(5,7)==4.639421805988064",
"assert largest_triangle(9,1)==105.2220865598093"
] | [] | |
199 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def highest_Power_of_2(n):
res = 0;
for i in range(n, 0, -1):
if ((i & (i - 1)) == 0):
res = i;
break;
return res; | [
"assert highest_Power_of_2(10) == 8",
"assert highest_Power_of_2(19) == 16",
"assert highest_Power_of_2(32) == 32"
] | [] | |
200 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_result | [
"assert position_max([12,33,23,10,67,89,45,667,23,12,11,10,54])==[7]",
"assert position_max([1,2,2,2,4,4,4,5,5,5,5])==[7,8,9,10]",
"assert position_max([2,1,5,6,8,3,4,9,10,11,8,12])==[11]"
] | [] | |
201 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def chkList(lst):
return len(set(lst)) == 1 | [
"assert chkList(['one','one','one']) == True",
"assert chkList(['one','Two','Three']) == False",
"assert chkList(['bigdata','python','Django']) == False"
] | [] | |
202 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def remove_even(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 != 0):
str2 = str2 + str1[i - 1]
return str2 | [
"assert remove_even(\"python\")==(\"pto\")",
"assert remove_even(\"program\")==(\"porm\")",
"assert remove_even(\"language\")==(\"lnug\")"
] | [] | |
203 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | [
"assert hamming_Distance(4,8) == 2",
"assert hamming_Distance(2,4) == 2",
"assert hamming_Distance(1,2) == 2"
] | [] | |
204 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | [
"assert count(\"abcc\",\"c\") == 2",
"assert count(\"ababca\",\"a\") == 3",
"assert count(\"mnmm0pm\",\"m\") == 4"
] | [] | |
205 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | [
"assert inversion_elements((7, 8, 9, 1, 10, 7)) == (-8, -9, -10, -2, -11, -8)",
"assert inversion_elements((2, 4, 5, 6, 1, 7)) == (-3, -5, -6, -7, -2, -8)",
"assert inversion_elements((8, 9, 11, 14, 12, 13)) == (-9, -10, -12, -15, -13, -14)"
] | [] | |
206 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | [
"assert concatenate_elements((\"DSP \", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"UTS\")) == ('DSP IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL UTS')",
"assert concatenate_elements((\"RES \", \"IS \", \"BEST \", \"FOR \", \"ALL \", \"QESR\")) == ('RES IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL QESR')",
... | [] | |
207 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | def find_longest_repeating_subseq(str):
n = len(str)
dp = [[0 for k in range(n+1)] for l in range(n+1)]
for i in range(1, n+1):
for j in range(1, n+1):
if (str[i-1] == str[j-1] and i != j):
dp[i][j] = 1 + dp[i-1][j-1]
else:
dp[i][j] = max(dp[i][j-1], dp[i-1][j])
return dp[n][n] | [
"assert find_longest_repeating_subseq(\"AABEBCDD\") == 3",
"assert find_longest_repeating_subseq(\"aabb\") == 2",
"assert find_longest_repeating_subseq(\"aab\") == 1"
] | [] | |
208 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def is_decimal(num):
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | [
"assert is_decimal('123.11') == True",
"assert is_decimal('0.21') == True",
"assert is_decimal('123.1214') == False"
] | [] | |
209 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import heapq as hq
def heap_replace(heap,a):
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | [
"assert heap_replace( [25, 44, 68, 21, 39, 23, 89],21)==[21, 25, 23, 44, 39, 68, 89]",
"assert heap_replace([25, 44, 68, 21, 39, 23, 89],110)== [23, 25, 68, 44, 39, 110, 89]",
"assert heap_replace([25, 44, 68, 21, 39, 23, 89],500)==[23, 25, 68, 44, 39, 500, 89]"
] | [] | |
210 | """
Write a function to find the similar elements from the given two tuple lists.
assert similar_elements((3, 4, 5, 6),(5, 7, 4, 10)) == (4, 5)
"""
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
"""
Write a python function to identify non-prime numbers.
as... | import re
def is_allowed_specific_char(string):
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | [
"assert is_allowed_specific_char(\"ABCDEFabcdef123450\") == True",
"assert is_allowed_specific_char(\"*&%@#!}{\") == False",
"assert is_allowed_specific_char(\"HELLOhowareyou98765\") == True"
] | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.