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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find common elements in given nested lists. * list item * list item * list item * list item
assert common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])==[18, 12]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the perimeter of a cylinder.
assert perimeter(2,4) == 12
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to check if a string represents an integer or not.
assert check_integer("python")==False
"""
| 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:
return False | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to assign frequency to each tuple in the given tuple list.
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)]'
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to check whether all dictionaries in a list are empty or not.
assert empty_dit([{},{},{}])==True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to convert a given tuple of positive integers into an integer.
assert tuple_to_int((1,2,3))==123
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to convert all possible convertible elements in the list to float.
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)]'
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
[link text](https:// [link text](https:// [link text](https://)))write a function to convert a string to a list.
assert string_to_list("python programming")==['python','programming']
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the element that appears only once in a sorted array.
assert search([1,1,2,2,3],5) == 3
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the maximum product from the pairs of tuples within a given list.
assert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==36
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the triplet with sum of the given array
assert check_triplet([2, 7, 4, 0, 9, 5, 1, 3], 8, 6, 0) == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find n’th smart number.
assert smartNumber(1) == 30
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to sum all amicable numbers from 1 to a specified number.
assert amicable_numbers_sum(999)==504
"""
| 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 for fact in range(1, num) if num % fact == 0])
sum_fact2 = sum([fact for fact in range(1, sum_fact) if sum_fact % fact == 0])
if num == sum_fact2 and num != sum_fact:
amicables.add(num)
amicables.add(sum_fact2)
return sum(amicables) | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to get the angle of a complex number.
assert angle_complex(0,1j)==1.5707963267948966
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.
assert find_length("11000010001", 11) == 6
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the sum of common divisors of two given numbers.
assert sum(10,15) == 6
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to multiply two integers without using the * operator in python.
assert multiply_int(10,20)==200
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to shortlist words that are longer than n from a given list of words.
assert long_words(3,"python is a programming language")==['python','programming','language']
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate magic square.
assert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]])==True
"""
| 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]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the item with maximum frequency in a given list.
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)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to reverse only the vowels of a given string.
assert reverse_vowels("Python") == "Python"
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to convert tuple to a string.
assert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's'))==("exercises")
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate the sum of the negative numbers of a given list of numbers using lambda function.
assert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the last element of given array is even or odd after performing an operation p times.
assert check_last([5,7,10],3,1) == "ODD"
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the nth hexagonal number.
assert hexagonal_num(10) == 190
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate electricity bill.
assert cal_electbill(75)==246.25
"""
| 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 - 200) * 8.45)
surcharge = 75
total = amount + surcharge
return total | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the ration of zeroes in an array of integers.
assert zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.15
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.
assert is_Sum_Of_Powers_Of_Two(10) == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the circumference of a circle.
assert circle_circumference(10)==62.830000000000005
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to extract elements that occur singly in the given tuple list.
assert extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)]) == [3, 4, 5, 7, 1]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to sort a list of elements using pancake sort.
assert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to count the same pair in three given lists.
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
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find number of lists present in the given tuple.
assert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the sum of absolute differences in all pairs of the given array.
assert sum_Pairs([1,8,9,15,16],5) == 74
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the maximum difference between any two elements in a given array.
assert max_Abs_Diff((2,1,5,3),4) == 4
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the ascii value of total characters in a string.
assert ascii_value_string("python")==112
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the maximum total path sum in the given triangle.
assert max_path_sum([[1, 0, 0], [4, 8, 0], [1, 5, 3]], 2, 2) == 14
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to divide a number into two parts such that the sum of digits is maximum.
assert sum_digits_twoparts(35)==17
"""
| 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) + sum_digits_single(N - 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the longest subsequence such that the difference between adjacents is one for the given array.
assert longest_subseq_with_diff_one([1, 2, 3, 4, 5, 3, 2], 7) == 6
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find whether the given number is present in the infinite sequence or not.
assert does_Contain_B(1,7,3) == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the given number is co-prime or not.
assert is_coprime(17,13) == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to sort the given array by using merge sort.
assert merge_sort([3, 4, 2, 6, 5, 7, 1, 9]) == [1, 2, 3, 4, 5, 6, 7, 9]
"""
| 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):
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the vertex of a parabola.
assert parabola_vertex(5,3,2)==(-0.3, 1.55)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to extract every specified element from a given two dimensional list.
assert specified_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]],0)==[1, 4, 7]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to toggle all even bits of a given number.
assert even_bit_toggle_number(10) == 0
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to convert a tuple of string values to a tuple of integer values.
assert tuple_int_str((('333', '33'), ('1416', '55')))==((333, 33), (1416, 55))
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to reflect the run-length encoding from a list.
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]]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find k number of operations required to make all elements equal.
assert min_Ops([2,2,2,2],4,3) == 0
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to print the season for the given month and day.
assert month_season('January',4)==('winter')
"""
| 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 = 'spring'
elif (month == 'June') and (days > 20):
season = 'summer'
elif (month == 'September') and (days > 21):
season = 'autumn'
elif (month == 'October') and (days > 21):
season = 'autumn'
elif (month == 'November') and (days > 21):
season = 'autumn'
elif (month == 'December') and (days > 20):
season = 'winter'
return season | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find x and y that satisfies ax + by = n.
assert solution(2, 3, 7) == ('x = ', 2, ', y = ', 1)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to remove all elements from a given list present in another list.
assert remove_elements([1,2,3,4,5,6,7,8,9,10],[2,4,6,8])==[1, 3, 5, 7, 9, 10]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate the sum of the positive integers of n+(n-2)+(n-4)... (until n-x =< 0).
assert sum_series(6)==12
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate the area of a regular polygon.
assert area_polygon(4,20)==400.00000000000006
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the sum of divisors are same or not.
assert areEquivalent(36,57) == False
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to count characters at same position in a given string (lower and uppercase characters) as in english alphabet.
assert count_char_position("xbcefg") == 2
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to count the pairs with xor as an even number.
assert find_even_Pair([5,4,7,2,1],5) == 4
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find smallest power of 2 greater than or equal to n.
assert next_Power_Of_2(0) == 1
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the frequency of a number in a given array.
assert frequency([1,2,3],4) == 0
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate the nth pell number.
assert get_pell(4) == 12
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find sum of the numbers in a list between the indices of a specified range.
assert sum_range_list( [2,1,5,6,8,3,4,9,10,11,8,12],8,10)==29
"""
| def sum_range_list(list1, m, n):
sum_range = 0
for i in range(m, n+1, 1):
sum_range += list1[i]
return sum_range | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the perimeter of a pentagon.
assert perimeter_pentagon(5)==25
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the occurence of characters 'std' in the given string 1. list item 1. list item 1. list item 2. list item 2. list item 2. list item
assert count_occurance("letstdlenstdporstd") == 3
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to remove everything except alphanumeric characters from a string.
assert remove_splchar('python @#&^%$*program123')==('pythonprogram123')
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to group a sequence of key-value pairs into a dictionary of lists.
assert group_keyvalue([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])=={'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to verify validity of a string of parentheses.
assert is_valid_parenthese("(){}[]")==True
"""
| 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 len(stack) == 0 | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the perimeter of a triangle.
assert perimeter_triangle(10,20,30)==60
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find two distinct numbers such that their lcm lies within the given range.
assert answer(3,8) == (3,6)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to search some literals strings in a string.
assert string_literals(['language'],'python language')==('Matched!')
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find if the given number is a keith number or not.
assert is_num_keith(14) == True
"""
| 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+=1
return (next_term == x) | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to calculate distance between two points using latitude and longitude.
assert distance_lat_long(23.5,67.5,25.5,69.5)==12179.372041317429
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the longest common prefix in the given set of strings.
assert common_prefix(["tablets", "tables", "taxi", "tamarind"], 4) == 'ta'
"""
| 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):
prefix = common_prefix_util(prefix, arr[i])
return (prefix) | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find uppercase, lowercase, special character and numeric values using regex.
assert find_character("ThisIsGeeksforGeeks") == (['T', 'I', 'G', 'G'], ['h', 'i', 's', 's', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'e', 'e', 'k', 's'], [], [])
"""
| 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, numerical_characters, special_characters | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to count all the distinct pairs having a difference of k in any array.
assert count_pairs([1, 5, 3, 4, 2], 5, 3) == 2
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find all the values in a list that are greater than a specified number.
assert greater_specificnum([220, 330, 500],200)==True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the focus of a parabola.
assert parabola_focus(5,3,2)==(-0.3, 1.6)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to search some literals strings in a string by using regex.
assert check_literals('The quick brown fox jumps over the lazy dog.',['fox']) == 'Matched!'
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the longest common subsequence for the given two sequences.
assert longest_common_subsequence("AGGTAB" , "GXTXAYB", 6, 7) == 4
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the given number can be represented by product of two squares or not.
assert prod_Square(25) == False
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the first missing positive number.
assert first_Missing_Positive([1,2,3,-1,5],5) == 4
"""
| 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] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | [
"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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to count the number of integral co-ordinates that lie inside a square.
assert count_Intgral_Points(1,1,4,4) == 4
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to check whether the given month name contains 30 days or not.
assert check_monthnumber("February")==False
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether a string has atleast one letter and one number.
assert check_String('thishasboth29') == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to remove the duplicates from the given tuple.
assert remove_tuple((1, 3, 5, 2, 3, 5, 1, 1, 3)) == (1, 2, 3, 5)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to convert octal number to decimal number.
assert octal_To_Decimal(25) == 21
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the first position of an element in a sorted array.
assert first([1,2,3,4,5,6,6],6,6) == 5
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to remove all the tuples with length k.
assert remove_tuples([(4, 5), (4, ), (8, 6, 7), (1, ), (3, 4, 6, 7)] , 1) == [(4, 5), (8, 6, 7), (3, 4, 6, 7)]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to perform the exponentiation of the given two tuples.
assert find_exponentio((10, 4, 5, 6), (5, 6, 7, 5)) == (100000, 4096, 78125, 7776)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the largest triangle that can be inscribed in an ellipse.
assert largest_triangle(4,2)==10.392304845413264
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find highest power of 2 less than or equal to given number.
assert highest_Power_of_2(10) == 8
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find all index positions of the maximum values in a given list.
assert position_max([12,33,23,10,67,89,45,667,23,12,11,10,54])==[7]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to check whether the elements in a list are same or not.
assert chkList(['one','one','one']) == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to remove even characters in a string.
assert remove_even("python")==("pto")
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to find the hamming distance between given two integers.
assert hamming_Distance(4,8) == 2
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a python function to count the occurrence of a given character in a string.
assert count("abcc","c") == 2
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to find the inversions of tuple elements in the given tuple list.
assert inversion_elements((7, 8, 9, 1, 10, 7)) == (-8, -9, -10, -2, -11, -8)
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to perform the adjacent element concatenation in the given tuples.
assert concatenate_elements(("DSP ", "IS ", "BEST ", "FOR ", "ALL ", "UTS")) == ('DSP IS ', 'IS BEST ', 'BEST FOR ', 'FOR ALL ', 'ALL UTS')
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to count the longest repeating subsequences such that the two subsequences don’t have same string characters at same positions.
assert find_longest_repeating_subseq("AABEBCDD") == 3
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to check the given decimal with a precision of 2 by using regex.
assert is_decimal('123.11') == True
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to delete the smallest element from the given heap and then insert a new item.
assert heap_replace( [25, 44, 68, 21, 39, 23, 89],21)==[21, 25, 23, 44, 39, 68, 89]
"""
| 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.
assert is_not_prime(2) == False
"""
import math
def is_not_prime(n):
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
"""
Write a function to find the largest integers from a given list of numbers using heap queue algorithm.
assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]
"""
import heapq as hq
def heap_queue_largest(nums,n):
largest_nums = hq.nlargest(n, nums)
return largest_nums
"""
Write a function to check that the given string contains only a certain set of characters(in this case a-z, a-z and 0-9) by using regex.
assert is_allowed_specific_char("ABCDEFabcdef123450") == True
"""
| 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.