source_file
stringclasses 1
value | task_id
int32 602
809
| prompt
listlengths 1
1
| code
stringlengths 47
500
| test_imports
listlengths 0
0
| test_list
listlengths 3
7
| completion
listlengths 1
1
|
|---|---|---|---|---|---|---|
Benchmark Questions Verification V2.ipynb
| 602
|
[
{
"content": "Write a python function to find the first repeated character in a given string.",
"role": "user"
}
] |
def first_repeated_char(str1):
for index,c in enumerate(str1):
if str1[:index+1].count(c) > 1:
return c
|
[] |
[
"assert first_repeated_char(\"abcabc\") == \"a\"",
"assert first_repeated_char(\"abc\") == None",
"assert first_repeated_char(\"123123\") == \"1\""
] |
[
{
"content": "def first_repeated_char(str1):\n for index,c in enumerate(str1):\n if str1[:index+1].count(c) > 1:\n return c",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 603
|
[
{
"content": "Write a function to get all lucid numbers smaller than or equal to a given integer.",
"role": "user"
}
] |
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
[] |
[
"assert get_ludic(10) == [1, 2, 3, 5, 7]",
"assert get_ludic(25) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25]",
"assert get_ludic(45) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43]"
] |
[
{
"content": "def get_ludic(n):\n\tludics = []\n\tfor i in range(1, n + 1):\n\t\tludics.append(i)\n\tindex = 1\n\twhile(index != len(ludics)):\n\t\tfirst_ludic = ludics[index]\n\t\tremove_index = index + first_ludic\n\t\twhile(remove_index < len(ludics)):\n\t\t\tludics.remove(ludics[remove_index])\n\t\t\tremove_index = remove_index + first_ludic - 1\n\t\tindex += 1\n\treturn ludics",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 604
|
[
{
"content": "Write a function to reverse words seperated by spaces in a given string.",
"role": "user"
}
] |
def reverse_words(s):
return ' '.join(reversed(s.split()))
|
[] |
[
"assert reverse_words(\"python program\")==(\"program python\")",
"assert reverse_words(\"java language\")==(\"language java\")",
"assert reverse_words(\"indian man\")==(\"man indian\")"
] |
[
{
"content": "def reverse_words(s):\n return ' '.join(reversed(s.split()))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 605
|
[
{
"content": "Write a function to check if the given integer is a prime number.",
"role": "user"
}
] |
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
[] |
[
"assert prime_num(13)==True",
"assert prime_num(7)==True",
"assert prime_num(-1010)==False"
] |
[
{
"content": "def prime_num(num):\n if num >=1:\n for i in range(2, num//2):\n if (num % i) == 0:\n return False\n else:\n return True\n else:\n return False",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 606
|
[
{
"content": "Write a function to convert degrees to radians.",
"role": "user"
}
] |
import math
def radian_degree(degree):
radian = degree*(math.pi/180)
return radian
|
[] |
[
"assert radian_degree(90)==1.5707963267948966",
"assert radian_degree(60)==1.0471975511965976",
"assert radian_degree(120)==2.0943951023931953"
] |
[
{
"content": "import math\ndef radian_degree(degree):\n radian = degree*(math.pi/180)\n return radian",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 607
|
[
{
"content": "Write a function to search a string for a regex pattern. The function should return the matching subtring, a start index and an end index.",
"role": "user"
}
] |
import re
def find_literals(text, pattern):
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
[] |
[
"assert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)",
"assert find_literals('Its been a very crazy procedure right', 'crazy') == ('crazy', 16, 21)",
"assert find_literals('Hardest choices required strongest will', 'will') == ('will', 35, 39)"
] |
[
{
"content": "import re\n\ndef find_literals(text, pattern):\n match = re.search(pattern, text)\n s = match.start()\n e = match.end()\n return (match.re.pattern, s, e)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 608
|
[
{
"content": "Write a python function to find nth bell number.",
"role": "user"
}
] |
def bell_Number(n):
bell = [[0 for i in range(n+1)] for j in range(n+1)]
bell[0][0] = 1
for i in range(1, n+1):
bell[i][0] = bell[i-1][i-1]
for j in range(1, i+1):
bell[i][j] = bell[i-1][j-1] + bell[i][j-1]
return bell[n][0]
|
[] |
[
"assert bell_Number(2) == 2",
"assert bell_Number(3) == 5",
"assert bell_Number(4) == 15"
] |
[
{
"content": "def bell_Number(n): \n bell = [[0 for i in range(n+1)] for j in range(n+1)] \n bell[0][0] = 1\n for i in range(1, n+1):\n bell[i][0] = bell[i-1][i-1]\n for j in range(1, i+1): \n bell[i][j] = bell[i-1][j-1] + bell[i][j-1] \n return bell[n][0] ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 610
|
[
{
"content": "Write a python function which takes a list and returns a list with the same elements, but the k'th element removed.",
"role": "user"
}
] |
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
[] |
[
"assert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 3, 4, 4, 5, 1]",
"assert remove_kth_element([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4],4)==[0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]",
"assert remove_kth_element([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10],5)==[10,10,15,19, 18, 17, 26, 26, 17, 18, 10]"
] |
[
{
"content": "def remove_kth_element(list1, L):\n return list1[:L-1] + list1[L:]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 611
|
[
{
"content": "Write a function which given a matrix represented as a list of lists returns the max of the n'th column.",
"role": "user"
}
] |
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
[] |
[
"assert max_of_nth([[5, 6, 7], [1, 3, 5], [8, 9, 19]], 2) == 19",
"assert max_of_nth([[6, 7, 8], [2, 4, 6], [9, 10, 20]], 1) == 10",
"assert max_of_nth([[7, 8, 9], [3, 5, 7], [10, 11, 21]], 1) == 11"
] |
[
{
"content": "def max_of_nth(test_list, N):\n res = max([sub[N] for sub in test_list])\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 612
|
[
{
"content": "Write a python function which takes a list of lists, where each sublist has two elements, and returns a list of two lists where the first list has the first element of each sublist and the second one has the second.",
"role": "user"
}
] |
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
[] |
[
"assert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]",
"assert merge([[1, 2], [3, 4], [5, 6], [7, 8]]) == [[1, 3, 5, 7], [2, 4, 6, 8]]",
"assert merge([['x', 'y','z' ], ['a', 'b','c'], ['m', 'n','o']]) == [['x', 'a', 'm'], ['y', 'b', 'n'],['z', 'c','o']]"
] |
[
{
"content": "def merge(lst): \n return [list(ele) for ele in list(zip(*lst))] ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 614
|
[
{
"content": "Write a function to find the cumulative sum of all the values that are present in the given tuple list.",
"role": "user"
}
] |
def cummulative_sum(test_list):
res = sum(map(sum, test_list))
return (res)
|
[] |
[
"assert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30",
"assert cummulative_sum([(2, 4), (6, 7, 8), (3, 7)]) == 37",
"assert cummulative_sum([(3, 5), (7, 8, 9), (4, 8)]) == 44"
] |
[
{
"content": "def cummulative_sum(test_list):\n res = sum(map(sum, test_list))\n return (res)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 615
|
[
{
"content": "Write a function which takes a tuple of tuples and returns the average value for each tuple as a list.",
"role": "user"
}
] |
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
[] |
[
"assert average_tuple(((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4)))==[30.5, 34.25, 27.0, 23.25]",
"assert average_tuple(((1, 1, -5), (30, -15, 56), (81, -60, -39), (-10, 2, 3)))== [25.5, -18.0, 3.75]",
"assert average_tuple( ((100, 100, 100, 120), (300, 450, 560, 450), (810, 800, 390, 320), (10, 20, 30, 40)))==[305.0, 342.5, 270.0, 232.5]"
] |
[
{
"content": "def average_tuple(nums):\n result = [sum(x) / len(x) for x in zip(*nums)]\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 616
|
[
{
"content": "Write a function which takes two tuples of the same length and performs the element wise modulo.",
"role": "user"
}
] |
def tuple_modulo(test_tup1, test_tup2):
res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
[] |
[
"assert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)",
"assert tuple_modulo((11, 5, 6, 7), (6, 7, 8, 6)) == (5, 5, 6, 1)",
"assert tuple_modulo((12, 6, 7, 8), (7, 8, 9, 7)) == (5, 6, 7, 1)"
] |
[
{
"content": "def tuple_modulo(test_tup1, test_tup2):\n res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)) \n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 617
|
[
{
"content": "Write a function to check for the number of jumps required of given length to reach a point of form (d, 0) from origin in a 2d plane.",
"role": "user"
}
] |
def min_Jumps(steps, d):
(a, b) = steps
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
[] |
[
"assert min_Jumps((3,4),11)==3.5",
"assert min_Jumps((3,4),0)==0",
"assert min_Jumps((11,14),11)==1"
] |
[
{
"content": "def min_Jumps(steps, d): \n (a, b) = steps\n temp = a \n a = min(a, b) \n b = max(temp, b) \n if (d >= b): \n return (d + b - 1) / b \n if (d == 0): \n return 0\n if (d == a): \n return 1\n else:\n return 2",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 618
|
[
{
"content": "Write a function to divide two lists element wise.",
"role": "user"
}
] |
def div_list(nums1,nums2):
result = map(lambda x, y: x / y, nums1, nums2)
return list(result)
|
[] |
[
"assert div_list([4,5,6],[1, 2, 3])==[4.0,2.5,2.0]",
"assert div_list([3,2],[1,4])==[3.0, 0.5]",
"assert div_list([90,120],[50,70])==[1.8, 1.7142857142857142]"
] |
[
{
"content": "def div_list(nums1,nums2):\n result = map(lambda x, y: x / y, nums1, nums2)\n return list(result)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 619
|
[
{
"content": "Write a function to move all the numbers to the end of the given string.",
"role": "user"
}
] |
def move_num(test_str):
res = ''
dig = ''
for ele in test_str:
if ele.isdigit():
dig += ele
else:
res += ele
res += dig
return (res)
|
[] |
[
"assert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'",
"assert move_num('Avengers124Assemble') == 'AvengersAssemble124'",
"assert move_num('Its11our12path13to14see15things16do17things') == 'Itsourpathtoseethingsdothings11121314151617'"
] |
[
{
"content": "def move_num(test_str):\n res = ''\n dig = ''\n for ele in test_str:\n if ele.isdigit():\n dig += ele\n else:\n res += ele\n res += dig\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 620
|
[
{
"content": "Write a function to find the size of the largest subset of a list of numbers so that every pair is divisible.",
"role": "user"
}
] |
def largest_subset(a):
n = len(a)
dp = [0 for i in range(n)]
dp[n - 1] = 1;
for i in range(n - 2, -1, -1):
mxm = 0;
for j in range(i + 1, n):
if a[j] % a[i] == 0 or a[i] % a[j] == 0:
mxm = max(mxm, dp[j])
dp[i] = 1 + mxm
return max(dp)
|
[] |
[
"assert largest_subset([ 1, 3, 6, 13, 17, 18 ]) == 4",
"assert largest_subset([10, 5, 3, 15, 20]) == 3",
"assert largest_subset([18, 1, 3, 6, 13, 17]) == 4"
] |
[
{
"content": "def largest_subset(a):\n\tn = len(a)\n\tdp = [0 for i in range(n)]\n\tdp[n - 1] = 1; \n\tfor i in range(n - 2, -1, -1):\n\t\tmxm = 0;\n\t\tfor j in range(i + 1, n):\n\t\t\tif a[j] % a[i] == 0 or a[i] % a[j] == 0:\n\t\t\t\tmxm = max(mxm, dp[j])\n\t\tdp[i] = 1 + mxm\n\treturn max(dp)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 622
|
[
{
"content": "Write a function to find the median of two sorted lists of same size.",
"role": "user"
}
] |
def get_median(arr1, arr2, n):
i = 0
j = 0
m1 = -1
m2 = -1
count = 0
while count < n + 1:
count += 1
if i == n:
m1 = m2
m2 = arr2[0]
break
elif j == n:
m1 = m2
m2 = arr1[0]
break
if arr1[i] <= arr2[j]:
m1 = m2
m2 = arr1[i]
i += 1
else:
m1 = m2
m2 = arr2[j]
j += 1
return (m1 + m2)/2
|
[] |
[
"assert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0",
"assert get_median([2, 4, 8, 9], [7, 13, 19, 28], 4) == 8.5",
"assert get_median([3, 6, 14, 23, 36, 42], [2, 18, 27, 39, 49, 55], 6) == 25.0"
] |
[
{
"content": "def get_median(arr1, arr2, n):\n i = 0\n j = 0\n m1 = -1\n m2 = -1\n count = 0\n while count < n + 1:\n count += 1\n if i == n:\n m1 = m2\n m2 = arr2[0]\n break\n elif j == n:\n m1 = m2\n m2 = arr1[0]\n break\n if arr1[i] <= arr2[j]:\n m1 = m2\n m2 = arr1[i]\n i += 1\n else:\n m1 = m2\n m2 = arr2[j]\n j += 1\n return (m1 + m2)/2",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 623
|
[
{
"content": "Write a function to compute the n-th power of each number in a list.",
"role": "user"
}
] |
def nth_nums(nums,n):
nth_nums = list(map(lambda x: x ** n, nums))
return nth_nums
|
[] |
[
"assert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2)==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]",
"assert nth_nums([10,20,30],3)==([1000, 8000, 27000])",
"assert nth_nums([12,15],5)==([248832, 759375])"
] |
[
{
"content": "def nth_nums(nums,n):\n nth_nums = list(map(lambda x: x ** n, nums))\n return nth_nums",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 624
|
[
{
"content": "Write a python function to convert a given string to uppercase.",
"role": "user"
}
] |
def is_upper(string):
return (string.upper())
|
[] |
[
"assert is_upper(\"person\") ==\"PERSON\"",
"assert is_upper(\"final\") == \"FINAL\"",
"assert is_upper(\"Valid\") == \"VALID\""
] |
[
{
"content": "def is_upper(string):\n return (string.upper())",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 625
|
[
{
"content": "Write a python function to interchange the first and last element in a given list.",
"role": "user"
}
] |
def swap_List(newList):
size = len(newList)
temp = newList[0]
newList[0] = newList[size - 1]
newList[size - 1] = temp
return newList
|
[] |
[
"assert swap_List([1,2,3]) == [3,2,1]",
"assert swap_List([1,2,3,4,4]) == [4,2,3,4,1]",
"assert swap_List([4,5,6]) == [6,5,4]"
] |
[
{
"content": "def swap_List(newList): \n size = len(newList) \n temp = newList[0] \n newList[0] = newList[size - 1] \n newList[size - 1] = temp \n return newList ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 626
|
[
{
"content": "Write a python function to find the area of the largest triangle that can be inscribed in a semicircle with a given radius.",
"role": "user"
}
] |
def triangle_area(r) :
if r < 0 :
return None
return r * r
|
[] |
[
"assert triangle_area(-1) == None",
"assert triangle_area(0) == 0",
"assert triangle_area(2) == 4"
] |
[
{
"content": "def triangle_area(r) : \n if r < 0 : \n return None\n return r * r ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 627
|
[
{
"content": "Write a python function to find the smallest missing number from a sorted list of natural numbers.",
"role": "user"
}
] |
def find_First_Missing(array,start=0,end=None):
if end is None:
end = len(array) - 1
if (start > end):
return end + 1
if (start != array[start]):
return start;
mid = int((start + end) / 2)
if (array[mid] == mid):
return find_First_Missing(array,mid+1,end)
return find_First_Missing(array,start,mid)
|
[] |
[
"assert find_First_Missing([0,1,2,3]) == 4",
"assert find_First_Missing([0,1,2,6,9]) == 3",
"assert find_First_Missing([2,3,5,8,9]) == 0"
] |
[
{
"content": "def find_First_Missing(array,start=0,end=None):\n if end is None:\n end = len(array) - 1 \n if (start > end): \n return end + 1\n if (start != array[start]): \n return start; \n mid = int((start + end) / 2) \n if (array[mid] == mid): \n return find_First_Missing(array,mid+1,end) \n return find_First_Missing(array,start,mid) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 628
|
[
{
"content": "Write a function to replace all spaces in the given string with '%20'.",
"role": "user"
}
] |
def replace_spaces(string):
return string.replace(" ", "%20")
|
[] |
[
"assert replace_spaces(\"My Name is Dawood\") == 'My%20Name%20is%20Dawood'",
"assert replace_spaces(\"I am a Programmer\") == 'I%20am%20a%20Programmer'",
"assert replace_spaces(\"I love Coding\") == 'I%20love%20Coding'"
] |
[
{
"content": "def replace_spaces(string):\n return string.replace(\" \", \"%20\")",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 629
|
[
{
"content": "Write a python function to find even numbers from a list of numbers.",
"role": "user"
}
] |
def Split(list):
return [num for num in list if num % 2 == 0]
|
[] |
[
"assert Split([1,2,3,4,5]) == [2,4]",
"assert Split([4,5,6,7,8,0,1]) == [4,6,8,0]",
"assert Split ([8,12,15,19]) == [8,12]"
] |
[
{
"content": "def Split(list): \n return [num for num in list if num % 2 == 0]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 630
|
[
{
"content": "Write a function to extract all the adjacent coordinates of the given coordinate tuple.",
"role": "user"
}
] |
def adjac(ele, sub = []):
if not ele:
yield sub
else:
yield from [idx for j in range(ele[0] - 1, ele[0] + 2)
for idx in adjac(ele[1:], sub + [j])]
def get_coordinates(test_tup):
return list(adjac(test_tup))
|
[] |
[
"assert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]",
"assert get_coordinates((4, 5)) ==[[3, 4], [3, 5], [3, 6], [4, 4], [4, 5], [4, 6], [5, 4], [5, 5], [5, 6]]",
"assert get_coordinates((5, 6)) == [[4, 5], [4, 6], [4, 7], [5, 5], [5, 6], [5, 7], [6, 5], [6, 6], [6, 7]]"
] |
[
{
"content": "def adjac(ele, sub = []): \n if not ele: \n yield sub \n else: \n yield from [idx for j in range(ele[0] - 1, ele[0] + 2) \n for idx in adjac(ele[1:], sub + [j])] \ndef get_coordinates(test_tup):\n return list(adjac(test_tup))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 631
|
[
{
"content": "Write a function to replace whitespaces with an underscore and vice versa in a given string.",
"role": "user"
}
] |
def replace_spaces(text):
return "".join(" " if c == "_" else ("_" if c == " " else c) for c in text)
|
[] |
[
"assert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'",
"assert replace_spaces('The_Avengers') == 'The Avengers'",
"assert replace_spaces('Fast and Furious') == 'Fast_and_Furious'"
] |
[
{
"content": "def replace_spaces(text):\n return \"\".join(\" \" if c == \"_\" else (\"_\" if c == \" \" else c) for c in text)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 632
|
[
{
"content": "Write a python function to move all zeroes to the end of the given list.",
"role": "user"
}
] |
def move_zero(num_list):
a = [0 for i in range(num_list.count(0))]
x = [i for i in num_list if i != 0]
return x + a
|
[] |
[
"assert move_zero([1,0,2,0,3,4]) == [1,2,3,4,0,0]",
"assert move_zero([2,3,2,0,0,4,0,5,0]) == [2,3,2,4,5,0,0,0,0]",
"assert move_zero([0,1,0,1,1]) == [1,1,1,0,0]"
] |
[
{
"content": "def move_zero(num_list):\n a = [0 for i in range(num_list.count(0))]\n x = [i for i in num_list if i != 0]\n return x + a",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 633
|
[
{
"content": "Write a python function to find the sum of xor of all pairs of numbers in the given list.",
"role": "user"
}
] |
def pair_xor_Sum(arr,n) :
ans = 0
for i in range(0,n) :
for j in range(i + 1,n) :
ans = ans + (arr[i] ^ arr[j])
return ans
|
[] |
[
"assert pair_xor_Sum([5,9,7,6],4) == 47",
"assert pair_xor_Sum([7,3,5],3) == 12",
"assert pair_xor_Sum([7,3],2) == 4"
] |
[
{
"content": "def pair_xor_Sum(arr,n) : \n ans = 0 \n for i in range(0,n) : \n for j in range(i + 1,n) : \n ans = ans + (arr[i] ^ arr[j]) \n return ans ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 635
|
[
{
"content": "Write a function to sort the given list.",
"role": "user"
}
] |
import heapq as hq
def heap_sort(iterable):
h = []
for value in iterable:
hq.heappush(h, value)
return [hq.heappop(h) for i in range(len(h))]
|
[] |
[
"assert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]",
"assert heap_sort([25, 35, 22, 85, 14, 65, 75, 25, 58])==[14, 22, 25, 25, 35, 58, 65, 75, 85]",
"assert heap_sort( [7, 1, 9, 5])==[1,5,7,9]"
] |
[
{
"content": "import heapq as hq\ndef heap_sort(iterable):\n h = []\n for value in iterable:\n hq.heappush(h, value)\n return [hq.heappop(h) for i in range(len(h))]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 637
|
[
{
"content": "Write a function to check whether the given amount has no profit and no loss",
"role": "user"
}
] |
def noprofit_noloss(actual_cost,sale_amount):
if(sale_amount == actual_cost):
return True
else:
return False
|
[] |
[
"assert noprofit_noloss(1500,1200)==False",
"assert noprofit_noloss(100,100)==True",
"assert noprofit_noloss(2000,5000)==False"
] |
[
{
"content": "def noprofit_noloss(actual_cost,sale_amount): \n if(sale_amount == actual_cost):\n return True\n else:\n return False",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 638
|
[
{
"content": "Write a function to calculate the wind chill index rounded to the next integer given the wind velocity in km/h and a temperature in celsius.",
"role": "user"
}
] |
import math
def wind_chill(v,t):
windchill = 13.12 + 0.6215*t - 11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)
return int(round(windchill, 0))
|
[] |
[
"assert wind_chill(120,35)==40",
"assert wind_chill(40,20)==19",
"assert wind_chill(10,8)==6"
] |
[
{
"content": "import math\ndef wind_chill(v,t):\n windchill = 13.12 + 0.6215*t - 11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)\n return int(round(windchill, 0))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 639
|
[
{
"content": "Write a function to sum the length of the names of a given list of names after removing the names that start with a lowercase letter.",
"role": "user"
}
] |
def sample_nam(sample_names):
sample_names=list(filter(lambda el:el[0].isupper() and el[1:].islower(),sample_names))
return len(''.join(sample_names))
|
[] |
[
"assert sample_nam(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith'])==16",
"assert sample_nam([\"php\", \"res\", \"Python\", \"abcd\", \"Java\", \"aaa\"])==10",
"assert sample_nam([\"abcd\", \"Python\", \"abba\", \"aba\"])==6"
] |
[
{
"content": "def sample_nam(sample_names):\n sample_names=list(filter(lambda el:el[0].isupper() and el[1:].islower(),sample_names))\n return len(''.join(sample_names))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 640
|
[
{
"content": "Write a function to remove the parenthesis and what is inbetween them from a string.",
"role": "user"
}
] |
import re
def remove_parenthesis(items):
for item in items:
return (re.sub(r" ?\([^)]+\)", "", item))
|
[] |
[
"assert remove_parenthesis([\"python (chrome)\"])==(\"python\")",
"assert remove_parenthesis([\"string(.abc)\"])==(\"string\")",
"assert remove_parenthesis([\"alpha(num)\"])==(\"alpha\")"
] |
[
{
"content": "import re\ndef remove_parenthesis(items):\n for item in items:\n return (re.sub(r\" ?\\([^)]+\\)\", \"\", item))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 641
|
[
{
"content": "Write a function to find the nth nonagonal number.",
"role": "user"
}
] |
def is_nonagonal(n):
return int(n * (7 * n - 5) / 2)
|
[] |
[
"assert is_nonagonal(10) == 325",
"assert is_nonagonal(15) == 750",
"assert is_nonagonal(18) == 1089"
] |
[
{
"content": "def is_nonagonal(n): \n\treturn int(n * (7 * n - 5) / 2) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 643
|
[
{
"content": "Write a function that checks if a strings contains 'z', except at the start and end of the word.",
"role": "user"
}
] |
import re
def text_match_wordz_middle(text):
return bool(re.search(r'\Bz\B', text))
|
[] |
[
"assert text_match_wordz_middle(\"pythonzabc.\")==True",
"assert text_match_wordz_middle(\"zxyabc.\")==False",
"assert text_match_wordz_middle(\" lang .\")==False"
] |
[
{
"content": "import re\ndef text_match_wordz_middle(text):\n return bool(re.search(r'\\Bz\\B', text))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 644
|
[
{
"content": "Write a python function to reverse an array upto a given position.",
"role": "user"
}
] |
def reverse_Array_Upto_K(input, k):
return (input[k-1::-1] + input[k:])
|
[] |
[
"assert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6],4) == [4, 3, 2, 1, 5, 6]",
"assert reverse_Array_Upto_K([4, 5, 6, 7], 2) == [5, 4, 6, 7]",
"assert reverse_Array_Upto_K([9, 8, 7, 6, 5],3) == [7, 8, 9, 6, 5]"
] |
[
{
"content": "def reverse_Array_Upto_K(input, k): \n return (input[k-1::-1] + input[k:]) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 720
|
[
{
"content": "Write a function to add a dictionary to the tuple. The output should be a tuple.",
"role": "user"
}
] |
def add_dict_to_tuple(test_tup, test_dict):
test_tup = list(test_tup)
test_tup.append(test_dict)
test_tup = tuple(test_tup)
return (test_tup)
|
[] |
[
"assert add_dict_to_tuple((4, 5, 6), {\"MSAM\" : 1, \"is\" : 2, \"best\" : 3} ) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3})",
"assert add_dict_to_tuple((1, 2, 3), {\"UTS\" : 2, \"is\" : 3, \"Worst\" : 4} ) == (1, 2, 3, {'UTS': 2, 'is': 3, 'Worst': 4})",
"assert add_dict_to_tuple((8, 9, 10), {\"POS\" : 3, \"is\" : 4, \"Okay\" : 5} ) == (8, 9, 10, {'POS': 3, 'is': 4, 'Okay': 5})"
] |
[
{
"content": "def add_dict_to_tuple(test_tup, test_dict):\n test_tup = list(test_tup)\n test_tup.append(test_dict)\n test_tup = tuple(test_tup)\n return (test_tup) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 721
|
[
{
"content": "Given a square matrix of size N*N given as a list of lists, where each cell is associated with a specific cost. A path is defined as a specific sequence of cells that starts from the top-left cell move only right or down and ends on bottom right cell. We want to find a path with the maximum average over all existing paths. Average is computed as total cost divided by the number of cells visited in the path.",
"role": "user"
}
] |
def maxAverageOfPath(cost):
N = len(cost)
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(dp[i - 1][j],
dp[i][j - 1]) + cost[i][j]
return dp[N - 1][N - 1] / (2 * N - 1)
|
[] |
[
"assert maxAverageOfPath([[1, 2, 3], [6, 5, 4], [7, 3, 9]]) == 5.2",
"assert maxAverageOfPath([[2, 3, 4], [7, 6, 5], [8, 4, 10]]) == 6.2",
"assert maxAverageOfPath([[3, 4, 5], [8, 7, 6], [9, 5, 11]]) == 7.2",
"assert maxAverageOfPath([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 5.8"
] |
[
{
"content": "def maxAverageOfPath(cost):\n N = len(cost)\n dp = [[0 for i in range(N + 1)] for j in range(N + 1)]\n dp[0][0] = cost[0][0]\n for i in range(1, N):\n dp[i][0] = dp[i - 1][0] + cost[i][0]\n for j in range(1, N):\n dp[0][j] = dp[0][j - 1] + cost[0][j]\n for i in range(1, N):\n for j in range(1, N):\n dp[i][j] = max(dp[i - 1][j],\n dp[i][j - 1]) + cost[i][j]\n return dp[N - 1][N - 1] / (2 * N - 1)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 722
|
[
{
"content": "The input is given as - a dictionary with a student name as a key and a tuple of float (student_height, student_weight) as a value, - minimal height, - minimal weight. Write a function to filter students that have height and weight above the minimum.",
"role": "user"
}
] |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result
|
[] |
[
"assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},6.0,70)=={'Cierra Vega': (6.2, 70)}",
"assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},5.9,67)=={'Cierra Vega': (6.2, 70),'Kierra Gentry': (6.0, 68)}",
"assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},5.7,64)=={'Cierra Vega': (6.2, 70),'Alden Cantrell': (5.9, 65),'Kierra Gentry': (6.0, 68),'Pierre Cox': (5.8, 66)}"
] |
[
{
"content": "def filter_data(students,h,w):\n result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}\n return result ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 723
|
[
{
"content": "The input is defined as two lists of the same length. Write a function to count indices where the lists have the same values.",
"role": "user"
}
] |
from operator import eq
def count_same_pair(nums1, nums2):
result = sum(map(eq, nums1, nums2))
return result
|
[] |
[
"assert count_same_pair([1, 2, 3, 4, 5, 6, 7, 8],[2, 2, 3, 1, 2, 6, 7, 9])==4",
"assert count_same_pair([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==11",
"assert count_same_pair([2, 4, -6, -9, 11, -12, 14, -5, 17],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==1",
"assert count_same_pair([0, 1, 1, 2],[0, 1, 2, 2])==3"
] |
[
{
"content": "from operator import eq\ndef count_same_pair(nums1, nums2):\n result = sum(map(eq, nums1, nums2))\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 724
|
[
{
"content": "Write a function that takes base and power as arguments and calculate the sum of all digits of the base to the specified power.",
"role": "user"
}
] |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))])
|
[] |
[
"assert power_base_sum(2,100)==115",
"assert power_base_sum(8,10)==37",
"assert power_base_sum(8,15)==62",
"assert power_base_sum(3,3)==9"
] |
[
{
"content": "def power_base_sum(base, power):\n return sum([int(i) for i in str(pow(base, power))])",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 725
|
[
{
"content": "Write a function to extract values between quotation marks \" \" of the given string.",
"role": "user"
}
] |
import re
def extract_quotation(text1):
return (re.findall(r'"(.*?)"', text1))
|
[] |
[
"assert extract_quotation('Cortex \"A53\" Based \"multi\" tasking \"Processor\"') == ['A53', 'multi', 'Processor']",
"assert extract_quotation('Cast your \"favorite\" entertainment \"apps\"') == ['favorite', 'apps']",
"assert extract_quotation('Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support') == ['4k Ultra HD', 'HDR 10']",
"assert extract_quotation(\"Watch content '4k Ultra HD' resolution with 'HDR 10' Support\") == []"
] |
[
{
"content": "import re\ndef extract_quotation(text1):\n return (re.findall(r'\"(.*?)\"', text1))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 726
|
[
{
"content": "Write a function that takes as input a tuple of numbers (t_1,...,t_{N+1}) and returns a tuple of length N where the i-th element of the tuple is equal to t_i * t_{i+1}.",
"role": "user"
}
] |
def multiply_elements(test_tup):
res = tuple(i * j for i, j in zip(test_tup, test_tup[1:]))
return (res)
|
[] |
[
"assert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80)",
"assert multiply_elements((2, 4, 5, 6, 7)) == (8, 20, 30, 42)",
"assert multiply_elements((12, 13, 14, 9, 15)) == (156, 182, 126, 135)",
"assert multiply_elements((12,)) == ()"
] |
[
{
"content": "def multiply_elements(test_tup):\n res = tuple(i * j for i, j in zip(test_tup, test_tup[1:]))\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 728
|
[
{
"content": "Write a function takes as input two lists [a_1,...,a_n], [b_1,...,b_n] and returns [a_1+b_1,...,a_n+b_n].",
"role": "user"
}
] |
def sum_list(lst1,lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list
|
[] |
[
"assert sum_list([10,20,30],[15,25,35])==[25,45,65]",
"assert sum_list([1,2,3],[5,6,7])==[6,8,10]",
"assert sum_list([15,20,30],[15,45,75])==[30,65,105]"
] |
[
{
"content": "def sum_list(lst1,lst2):\n res_list = [lst1[i] + lst2[i] for i in range(len(lst1))] \n return res_list",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 730
|
[
{
"content": "Write a function to remove consecutive duplicates of a given list.",
"role": "user"
}
] |
from itertools import groupby
def consecutive_duplicates(nums):
return [key for key, group in groupby(nums)]
|
[] |
[
"assert consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4 ])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4]",
"assert consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[10, 15, 19, 18, 17, 26, 17, 18, 10]",
"assert consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==['a', 'b', 'c', 'd']",
"assert consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd', 'a', 'a'])==['a', 'b', 'c', 'd', 'a']"
] |
[
{
"content": "from itertools import groupby\ndef consecutive_duplicates(nums):\n return [key for key, group in groupby(nums)] ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 731
|
[
{
"content": "Write a function to find the lateral surface area of a cone given radius r and the height h.",
"role": "user"
}
] |
import math
def lateralsurface_cone(r,h):
l = math.sqrt(r * r + h * h)
LSA = math.pi * r * l
return LSA
|
[] |
[
"assert lateralsurface_cone(5,12)==204.20352248333654",
"assert lateralsurface_cone(10,15)==566.3586699569488",
"assert lateralsurface_cone(19,17)==1521.8090132193388"
] |
[
{
"content": "import math\ndef lateralsurface_cone(r,h):\n l = math.sqrt(r * r + h * h)\n LSA = math.pi * r * l\n return LSA",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 732
|
[
{
"content": "Write a function to replace all occurrences of spaces, commas, or dots with a colon.",
"role": "user"
}
] |
import re
def replace_specialchar(text):
return (re.sub("[ ,.]", ":", text))
|
[] |
[
"assert replace_specialchar('Python language, Programming language.')==('Python:language::Programming:language:')",
"assert replace_specialchar('a b c,d e f')==('a:b:c:d:e:f')",
"assert replace_specialchar('ram reshma,ram rahim')==('ram:reshma:ram:rahim')"
] |
[
{
"content": "import re\ndef replace_specialchar(text):\n return (re.sub(\"[ ,.]\", \":\", text))\n",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 733
|
[
{
"content": "Write a function to find the index of the first occurrence of a given number in a sorted array.",
"role": "user"
}
] |
def find_first_occurrence(A, x):
(left, right) = (0, len(A) - 1)
result = -1
while left <= right:
mid = (left + right) // 2
if x == A[mid]:
result = mid
right = mid - 1
elif x < A[mid]:
right = mid - 1
else:
left = mid + 1
return result
|
[] |
[
"assert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1",
"assert find_first_occurrence([2, 3, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 2",
"assert find_first_occurrence([2, 4, 1, 5, 6, 6, 8, 9, 9, 9], 6) == 4"
] |
[
{
"content": "def find_first_occurrence(A, x):\n (left, right) = (0, len(A) - 1)\n result = -1\n while left <= right:\n mid = (left + right) // 2\n if x == A[mid]:\n result = mid\n right = mid - 1\n elif x < A[mid]:\n right = mid - 1\n else:\n left = mid + 1\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 734
|
[
{
"content": "Write a python function to find sum of products of all possible sublists of a given list. https://www.geeksforgeeks.org/sum-of-products-of-all-possible-subarrays/",
"role": "user"
}
] |
def sum_Of_Subarray_Prod(arr):
ans = 0
res = 0
i = len(arr) - 1
while (i >= 0):
incr = arr[i]*(1 + res)
ans += incr
res = incr
i -= 1
return (ans)
|
[] |
[
"assert sum_Of_Subarray_Prod([1,2,3]) == 20",
"assert sum_Of_Subarray_Prod([1,2]) == 5",
"assert sum_Of_Subarray_Prod([1,2,3,4]) == 84"
] |
[
{
"content": "def sum_Of_Subarray_Prod(arr):\n ans = 0\n res = 0\n i = len(arr) - 1\n while (i >= 0):\n incr = arr[i]*(1 + res)\n ans += incr\n res = incr\n i -= 1\n return (ans)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 735
|
[
{
"content": "Write a python function to toggle bits of the number except the first and the last bit. https://www.geeksforgeeks.org/toggle-bits-number-expect-first-last-bits/",
"role": "user"
}
] |
def set_middle_bits(n):
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1
def toggle_middle_bits(n):
if (n == 1):
return 1
return n ^ set_middle_bits(n)
|
[] |
[
"assert toggle_middle_bits(9) == 15",
"assert toggle_middle_bits(10) == 12",
"assert toggle_middle_bits(11) == 13",
"assert toggle_middle_bits(0b1000001) == 0b1111111",
"assert toggle_middle_bits(0b1001101) == 0b1110011"
] |
[
{
"content": "def set_middle_bits(n): \n n |= n >> 1; \n n |= n >> 2; \n n |= n >> 4; \n n |= n >> 8; \n n |= n >> 16; \n return (n >> 1) ^ 1\ndef toggle_middle_bits(n): \n if (n == 1): \n return 1\n return n ^ set_middle_bits(n) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 736
|
[
{
"content": "Write a function to locate the left insertion point for a specified value in sorted order. https://www.w3resource.com/python-exercises/data-structures-and-algorithms/python-data-structure-exercise-24.php",
"role": "user"
}
] |
import bisect
def left_insertion(a, x):
i = bisect.bisect_left(a, x)
return i
|
[] |
[
"assert left_insertion([1,2,4,5],6)==4",
"assert left_insertion([1,2,4,5],3)==2",
"assert left_insertion([1,2,4,5],7)==4"
] |
[
{
"content": "import bisect\ndef left_insertion(a, x):\n i = bisect.bisect_left(a, x)\n return i",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 737
|
[
{
"content": "Write a function to check whether the given string is starting with a vowel or not using regex.",
"role": "user"
}
] |
import re
regex = '^[aeiouAEIOU][A-Za-z0-9_]*'
def check_str(string):
return re.search(regex, string)
|
[] |
[
"assert check_str(\"annie\")",
"assert not check_str(\"dawood\")",
"assert check_str(\"Else\")"
] |
[
{
"content": "import re \nregex = '^[aeiouAEIOU][A-Za-z0-9_]*'\ndef check_str(string): \n\treturn re.search(regex, string)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 738
|
[
{
"content": "Write a function to calculate the geometric sum of n-1. https://www.w3resource.com/python-exercises/data-structures-and-algorithms/python-recursion-exercise-9.php",
"role": "user"
}
] |
def geometric_sum(n):
if n < 0:
return 0
else:
return 1 / (pow(2, n)) + geometric_sum(n - 1)
|
[] |
[
"assert geometric_sum(7) == 1.9921875",
"assert geometric_sum(4) == 1.9375",
"assert geometric_sum(8) == 1.99609375"
] |
[
{
"content": "def geometric_sum(n):\n if n < 0:\n return 0\n else:\n return 1 / (pow(2, n)) + geometric_sum(n - 1)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 739
|
[
{
"content": "Write a python function to find the index of smallest triangular number with n digits. https://www.geeksforgeeks.org/index-of-smallest-triangular-number-with-n-digits/",
"role": "user"
}
] |
import math
def find_Index(n):
x = math.sqrt(2 * math.pow(10,(n - 1)))
return round(x)
|
[] |
[
"assert find_Index(2) == 4",
"assert find_Index(3) == 14",
"assert find_Index(4) == 45"
] |
[
{
"content": "import math \ndef find_Index(n): \n x = math.sqrt(2 * math.pow(10,(n - 1)))\n return round(x)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 740
|
[
{
"content": "Write a function to convert the given tuple to a key-value dictionary using adjacent elements. https://www.geeksforgeeks.org/python-convert-tuple-to-adjacent-pair-dictionary/",
"role": "user"
}
] |
def tuple_to_dict(test_tup):
res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2))
return (res)
|
[] |
[
"assert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5}",
"assert tuple_to_dict((1, 2, 3, 4, 5, 6)) == {1: 2, 3: 4, 5: 6}",
"assert tuple_to_dict((7, 8, 9, 10, 11, 12)) == {7: 8, 9: 10, 11: 12}"
] |
[
{
"content": "def tuple_to_dict(test_tup):\n res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2))\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 741
|
[
{
"content": "Write a python function to check whether all the characters are same or not.",
"role": "user"
}
] |
def all_Characters_Same(s) :
n = len(s)
for i in range(1,n) :
if s[i] != s[0] :
return False
return True
|
[] |
[
"assert all_Characters_Same(\"python\") == False",
"assert all_Characters_Same(\"aaa\") == True",
"assert all_Characters_Same(\"data\") == False"
] |
[
{
"content": "def all_Characters_Same(s) :\n n = len(s)\n for i in range(1,n) :\n if s[i] != s[0] :\n return False\n return True",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 742
|
[
{
"content": "Write a function to caluclate the area of a tetrahedron.",
"role": "user"
}
] |
import math
def area_tetrahedron(side):
area = math.sqrt(3)*(side*side)
return area
|
[] |
[
"assert area_tetrahedron(3)==15.588457268119894",
"assert area_tetrahedron(20)==692.8203230275509",
"assert area_tetrahedron(10)==173.20508075688772"
] |
[
{
"content": "import math\ndef area_tetrahedron(side):\n area = math.sqrt(3)*(side*side)\n return area",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 743
|
[
{
"content": "Write a function to rotate a given list by specified number of items to the right direction. https://www.geeksforgeeks.org/python-program-right-rotate-list-n/",
"role": "user"
}
] |
def rotate_right(list, m):
result = list[-m:] + list[:-m]
return result
|
[] |
[
"assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3)==[8, 9, 10, 1, 2, 3, 4, 5, 6, 7]",
"assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2)==[9, 10, 1, 2, 3, 4, 5, 6, 7, 8]",
"assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],5)==[6, 7, 8, 9, 10, 1, 2, 3, 4, 5]"
] |
[
{
"content": "def rotate_right(list, m):\n result = list[-m:] + list[:-m]\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 744
|
[
{
"content": "Write a function to check if the given tuple has any none value or not.",
"role": "user"
}
] |
def check_none(test_tup):
res = any(map(lambda ele: ele is None, test_tup))
return res
|
[] |
[
"assert check_none((10, 4, 5, 6, None)) == True",
"assert check_none((7, 8, 9, 11, 14)) == False",
"assert check_none((1, 2, 3, 4, None)) == True"
] |
[
{
"content": "def check_none(test_tup):\n res = any(map(lambda ele: ele is None, test_tup))\n return res ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 745
|
[
{
"content": "Write a function to find numbers within a given range from startnum ti endnum where every number is divisible by every digit it contains. https://www.w3resource.com/python-exercises/lambda/python-lambda-exercise-24.php",
"role": "user"
}
] |
def divisible_by_digits(startnum, endnum):
return [n for n in range(startnum, endnum+1) \
if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))]
|
[] |
[
"assert divisible_by_digits(1,22)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]",
"assert divisible_by_digits(1,15)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15]",
"assert divisible_by_digits(20,25)==[22, 24]"
] |
[
{
"content": "def divisible_by_digits(startnum, endnum):\n return [n for n in range(startnum, endnum+1) \\\n if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 746
|
[
{
"content": "Write a function to find area of a sector. The function takes the radius and angle as inputs. Function should return None if the angle is larger than 360 degrees.",
"role": "user"
}
] |
import math
def sector_area(r,a):
if a > 360:
return None
return (math.pi*r**2) * (a/360)
|
[] |
[
"assert sector_area(4,45)==6.283185307179586",
"assert sector_area(9,45)==31.808625617596654",
"assert sector_area(9,361)==None"
] |
[
{
"content": "import math\ndef sector_area(r,a):\n if a > 360:\n return None\n return (math.pi*r**2) * (a/360)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 747
|
[
{
"content": "Write a function to find the longest common subsequence for the given three string sequence. https://www.geeksforgeeks.org/lcs-longest-common-subsequence-three-strings/",
"role": "user"
}
] |
def lcs_of_three(X, Y, Z):
m = len(X)
n = len(Y)
o = len(Z)
L = [[[0 for i in range(o+1)] for j in range(n+1)] for k in range(m+1)]
for i in range(m+1):
for j in range(n+1):
for k in range(o+1):
if (i == 0 or j == 0 or k == 0):
L[i][j][k] = 0
elif (X[i-1] == Y[j-1] and X[i-1] == Z[k-1]):
L[i][j][k] = L[i-1][j-1][k-1] + 1
else:
L[i][j][k] = max(max(L[i-1][j][k], L[i][j-1][k]), L[i][j][k-1])
return L[m][n][o]
|
[] |
[
"assert lcs_of_three('AGGT12', '12TXAYB', '12XBA') == 2",
"assert lcs_of_three('Reels', 'Reelsfor', 'ReelsforReels') == 5",
"assert lcs_of_three('abcd1e2', 'bc12ea', 'bd1ea') == 3"
] |
[
{
"content": "def lcs_of_three(X, Y, Z): \n m = len(X)\n n = len(Y)\n o = len(Z)\n L = [[[0 for i in range(o+1)] for j in range(n+1)] for k in range(m+1)]\n for i in range(m+1): \n\t for j in range(n+1): \n\t\t for k in range(o+1): \n\t\t\t if (i == 0 or j == 0 or k == 0): \n\t\t\t\t L[i][j][k] = 0\n\t\t\t elif (X[i-1] == Y[j-1] and X[i-1] == Z[k-1]): \n\t\t\t\t L[i][j][k] = L[i-1][j-1][k-1] + 1\n\t\t\t else: \n\t\t\t\t L[i][j][k] = max(max(L[i-1][j][k], L[i][j-1][k]), L[i][j][k-1]) \n return L[m][n][o]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 748
|
[
{
"content": "Write a function to put spaces between words starting with capital letters in a given string.",
"role": "user"
}
] |
import re
def capital_words_spaces(str1):
return re.sub(r"(\w)([A-Z])", r"\1 \2", str1)
|
[] |
[
"assert capital_words_spaces(\"Python\") == 'Python'",
"assert capital_words_spaces(\"PythonProgrammingExamples\") == 'Python Programming Examples'",
"assert capital_words_spaces(\"GetReadyToBeCodingFreak\") == 'Get Ready To Be Coding Freak'"
] |
[
{
"content": "import re\ndef capital_words_spaces(str1):\n return re.sub(r\"(\\w)([A-Z])\", r\"\\1 \\2\", str1)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 749
|
[
{
"content": "Write a function to sort a given list of strings of numbers numerically. https://www.geeksforgeeks.org/python-sort-numeric-strings-in-a-list/",
"role": "user"
}
] |
def sort_numeric_strings(nums_str):
result = [int(x) for x in nums_str]
result.sort()
return result
|
[] |
[
"assert sort_numeric_strings( ['4','12','45','7','0','100','200','-12','-500'])==[-500, -12, 0, 4, 7, 12, 45, 100, 200]",
"assert sort_numeric_strings(['2','3','8','4','7','9','8','2','6','5','1','6','1','2','3','4','6','9','1','2'])==[1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9, 9]",
"assert sort_numeric_strings(['1','3','5','7','1', '3','13', '15', '17','5', '7 ','9','1', '11'])==[1, 1, 1, 3, 3, 5, 5, 7, 7, 9, 11, 13, 15, 17]"
] |
[
{
"content": "def sort_numeric_strings(nums_str):\n result = [int(x) for x in nums_str]\n result.sort()\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 750
|
[
{
"content": "Write a function to add the given tuple to the given list.",
"role": "user"
}
] |
def add_tuple(test_list, test_tup):
test_list += test_tup
return test_list
|
[] |
[
"assert add_tuple([5, 6, 7], (9, 10)) == [5, 6, 7, 9, 10]",
"assert add_tuple([6, 7, 8], (10, 11)) == [6, 7, 8, 10, 11]",
"assert add_tuple([7, 8, 9], (11, 12)) == [7, 8, 9, 11, 12]"
] |
[
{
"content": "def add_tuple(test_list, test_tup):\n test_list += test_tup\n return test_list",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 751
|
[
{
"content": "Write a function to check if the given array represents min heap or not. https://www.geeksforgeeks.org/how-to-check-if-a-given-array-represents-a-binary-heap/",
"role": "user"
}
] |
def check_min_heap_helper(arr, i):
if 2 * i + 2 > len(arr):
return True
left_child = (arr[i] <= arr[2 * i + 1]) and check_min_heap_helper(arr, 2 * i + 1)
right_child = (2 * i + 2 == len(arr)) or (arr[i] <= arr[2 * i + 2]
and check_min_heap_helper(arr, 2 * i + 2))
return left_child and right_child
def check_min_heap(arr):
return check_min_heap_helper(arr, 0)
|
[] |
[
"assert check_min_heap([1, 2, 3, 4, 5, 6]) == True",
"assert check_min_heap([2, 3, 4, 5, 10, 15]) == True",
"assert check_min_heap([2, 10, 4, 5, 3, 15]) == False"
] |
[
{
"content": "def check_min_heap_helper(arr, i):\n if 2 * i + 2 > len(arr):\n return True\n left_child = (arr[i] <= arr[2 * i + 1]) and check_min_heap_helper(arr, 2 * i + 1)\n right_child = (2 * i + 2 == len(arr)) or (arr[i] <= arr[2 * i + 2] \n and check_min_heap_helper(arr, 2 * i + 2))\n return left_child and right_child\n\ndef check_min_heap(arr):\n return check_min_heap_helper(arr, 0)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 752
|
[
{
"content": "Write a function to find the nth jacobsthal number. https://www.geeksforgeeks.org/jacobsthal-and-jacobsthal-lucas-numbers/ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, 683, 1365, 2731, ...",
"role": "user"
}
] |
def jacobsthal_num(n):
dp = [0] * (n + 1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = dp[i - 1] + 2 * dp[i - 2]
return dp[n]
|
[] |
[
"assert jacobsthal_num(5) == 11",
"assert jacobsthal_num(2) == 1",
"assert jacobsthal_num(4) == 5",
"assert jacobsthal_num(13) == 2731"
] |
[
{
"content": "def jacobsthal_num(n): \n\tdp = [0] * (n + 1) \n\tdp[0] = 0\n\tdp[1] = 1\n\tfor i in range(2, n+1): \n\t\tdp[i] = dp[i - 1] + 2 * dp[i - 2] \n\treturn dp[n]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 753
|
[
{
"content": "Write a function to find minimum k records from tuple list. https://www.geeksforgeeks.org/python-find-minimum-k-records-from-tuple-list/ - in this case a verbatim copy of test cases",
"role": "user"
}
] |
def min_k(test_list, K):
res = sorted(test_list, key = lambda x: x[1])[:K]
return (res)
|
[] |
[
"assert min_k([('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)], 2) == [('Akash', 2), ('Akshat', 4)]",
"assert min_k([('Sanjeev', 11), ('Angat', 5), ('Akash', 3), ('Nepin', 9)], 3) == [('Akash', 3), ('Angat', 5), ('Nepin', 9)]",
"assert min_k([('tanmay', 14), ('Amer', 11), ('Ayesha', 9), ('SKD', 16)], 1) == [('Ayesha', 9)]"
] |
[
{
"content": "def min_k(test_list, K):\n res = sorted(test_list, key = lambda x: x[1])[:K]\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 754
|
[
{
"content": "We say that an element is common for lists l1, l2, l3 if it appears in all three lists under the same index. Write a function to find common elements from three lists. The function should return a list.",
"role": "user"
}
] |
def extract_index_list(l1, l2, l3):
result = []
for m, n, o in zip(l1, l2, l3):
if (m == n == o):
result.append(m)
return result
|
[] |
[
"assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 7]",
"assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 6, 5],[0, 1, 2, 3, 4, 6, 7])==[1, 6]",
"assert extract_index_list([1, 1, 3, 4, 6, 5, 6],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 5]",
"assert extract_index_list([1, 2, 3, 4, 6, 6, 6],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[]"
] |
[
{
"content": "def extract_index_list(l1, l2, l3):\n result = []\n for m, n, o in zip(l1, l2, l3):\n if (m == n == o):\n result.append(m)\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 755
|
[
{
"content": "Write a function to find the second smallest number in a list.",
"role": "user"
}
] |
def second_smallest(numbers):
unique_numbers = list(set(numbers))
unique_numbers.sort()
if len(unique_numbers) < 2:
return None
else:
return unique_numbers[1]
|
[] |
[
"assert second_smallest([1, 2, -8, -2, 0, -2])==-2",
"assert second_smallest([1, 1, -0.5, 0, 2, -2, -2])==-0.5",
"assert second_smallest([2,2])==None",
"assert second_smallest([2,2,2])==None"
] |
[
{
"content": "def second_smallest(numbers):\n unique_numbers = list(set(numbers))\n unique_numbers.sort()\n if len(unique_numbers) < 2:\n return None\n else:\n return unique_numbers[1]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 756
|
[
{
"content": "Write a function that matches a string that has an 'a' followed by one or more 'b's. https://www.w3resource.com/python-exercises/re/python-re-exercise-3.php",
"role": "user"
}
] |
import re
def text_match_zero_one(text):
patterns = 'ab+?'
if re.search(patterns, text):
return True
else:
return False
|
[] |
[
"assert text_match_zero_one(\"ac\")==False",
"assert text_match_zero_one(\"dc\")==False",
"assert text_match_zero_one(\"abbbba\")==True",
"assert text_match_zero_one(\"dsabbbba\")==True",
"assert text_match_zero_one(\"asbbbba\")==False",
"assert text_match_zero_one(\"abaaa\")==True"
] |
[
{
"content": "import re\ndef text_match_zero_one(text):\n patterns = 'ab+?'\n if re.search(patterns, text):\n return True\n else:\n return False",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 757
|
[
{
"content": "Write a function to count the pairs of reverse strings in the given string list. https://www.geeksforgeeks.org/python-program-to-count-the-pairs-of-reverse-strings/",
"role": "user"
}
] |
def count_reverse_pairs(test_list):
res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len(
test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))])
return res
|
[] |
[
"assert count_reverse_pairs([\"julia\", \"best\", \"tseb\", \"for\", \"ailuj\"])== 2",
"assert count_reverse_pairs([\"geeks\", \"best\", \"for\", \"skeeg\"]) == 1",
"assert count_reverse_pairs([\"makes\", \"best\", \"sekam\", \"for\", \"rof\"]) == 2"
] |
[
{
"content": "def count_reverse_pairs(test_list):\n res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len( \n\ttest_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))]) \n return res",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 758
|
[
{
"content": "Write a function to count lists within a list. The function should return a dictionary where every list is converted to a tuple and the value of such tuple is the number of its occurencies in the original list.",
"role": "user"
}
] |
def unique_sublists(list1):
result ={}
for l in list1:
result.setdefault(tuple(l), list()).append(1)
for a, b in result.items():
result[a] = sum(b)
return result
|
[] |
[
"assert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]] )=={(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1}",
"assert unique_sublists([['green', 'orange'], ['black'], ['green', 'orange'], ['white']])=={('green', 'orange'): 2, ('black',): 1, ('white',): 1}",
"assert unique_sublists([[10, 20, 30, 40], [60, 70, 50, 50], [90, 100, 200]])=={(10, 20, 30, 40): 1, (60, 70, 50, 50): 1, (90, 100, 200): 1}",
"assert unique_sublists([['john']])=={('john',): 1}"
] |
[
{
"content": "def unique_sublists(list1):\n result ={}\n for l in list1: \n result.setdefault(tuple(l), list()).append(1) \n for a, b in result.items(): \n result[a] = sum(b)\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 759
|
[
{
"content": "Write a function to check whether a given string is a decimal number with a precision of 2.",
"role": "user"
}
] |
def is_decimal(num):
import re
dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = dnumre.search(num)
return bool(result)
|
[] |
[
"assert is_decimal('123.11')==True",
"assert is_decimal('e666.86')==False",
"assert is_decimal('3.124587')==False",
"assert is_decimal('1.11')==True",
"assert is_decimal('1.1.11')==False"
] |
[
{
"content": "def is_decimal(num):\n import re\n dnumre = re.compile(r\"\"\"^[0-9]+(\\.[0-9]{1,2})?$\"\"\")\n result = dnumre.search(num)\n return bool(result)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 760
|
[
{
"content": "Write a python function to check whether a list of numbers contains only one distinct element or not.",
"role": "user"
}
] |
def unique_Element(arr):
s = set(arr)
return len(s) == 1
|
[] |
[
"assert unique_Element([1,1,1]) == True",
"assert unique_Element([1,2,1,2]) == False",
"assert unique_Element([1,2,3,4,5]) == False"
] |
[
{
"content": "def unique_Element(arr):\n s = set(arr)\n return len(s) == 1",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 762
|
[
{
"content": "Write a function to check whether the given month number contains 30 days or not. Months are given as number from 1 to 12.",
"role": "user"
}
] |
def check_monthnumber_number(monthnum3):
return monthnum3==4 or monthnum3==6 or monthnum3==9 or monthnum3==11
|
[] |
[
"assert check_monthnumber_number(6)==True",
"assert check_monthnumber_number(2)==False",
"assert check_monthnumber_number(12)==False"
] |
[
{
"content": "def check_monthnumber_number(monthnum3):\n return monthnum3==4 or monthnum3==6 or monthnum3==9 or monthnum3==11",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 763
|
[
{
"content": "Write a python function to find the minimum difference between any two elements in a given array. https://www.geeksforgeeks.org/find-minimum-difference-pair/",
"role": "user"
}
] |
def find_min_diff(arr,n):
arr = sorted(arr)
diff = 10**20
for i in range(n-1):
if arr[i+1] - arr[i] < diff:
diff = arr[i+1] - arr[i]
return diff
|
[] |
[
"assert find_min_diff((1,5,3,19,18,25),6) == 1",
"assert find_min_diff((4,3,2,6),4) == 1",
"assert find_min_diff((30,5,20,9),4) == 4"
] |
[
{
"content": "def find_min_diff(arr,n): \n arr = sorted(arr) \n diff = 10**20 \n for i in range(n-1): \n if arr[i+1] - arr[i] < diff: \n diff = arr[i+1] - arr[i] \n return diff ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 764
|
[
{
"content": "Write a python function to count number of digits in a given string.",
"role": "user"
}
] |
def number_ctr(str):
number_ctr= 0
for i in range(len(str)):
if str[i] >= '0' and str[i] <= '9': number_ctr += 1
return number_ctr
|
[] |
[
"assert number_ctr('program2bedone') == 1",
"assert number_ctr('3wonders') == 1",
"assert number_ctr('123') == 3",
"assert number_ctr('3wond-1ers2') == 3"
] |
[
{
"content": "def number_ctr(str):\n number_ctr= 0\n for i in range(len(str)):\n if str[i] >= '0' and str[i] <= '9': number_ctr += 1 \n return number_ctr",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 765
|
[
{
"content": "Write a function to find nth polite number. geeksforgeeks.org/n-th-polite-number/",
"role": "user"
}
] |
import math
def is_polite(n):
n = n + 1
return (int)(n+(math.log((n + math.log(n, 2)), 2)))
|
[] |
[
"assert is_polite(7) == 11",
"assert is_polite(4) == 7",
"assert is_polite(9) == 13"
] |
[
{
"content": "import math \ndef is_polite(n): \n\tn = n + 1\n\treturn (int)(n+(math.log((n + math.log(n, 2)), 2))) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 766
|
[
{
"content": "Write a function to return a list of all pairs of consecutive items in a given list.",
"role": "user"
}
] |
def pair_wise(l1):
temp = []
for i in range(len(l1) - 1):
current_element, next_element = l1[i], l1[i + 1]
x = (current_element, next_element)
temp.append(x)
return temp
|
[] |
[
"assert pair_wise([1,1,2,3,3,4,4,5])==[(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)]",
"assert pair_wise([1,5,7,9,10])==[(1, 5), (5, 7), (7, 9), (9, 10)]",
"assert pair_wise([5,1,9,7,10])==[(5, 1), (1, 9), (9, 7), (7, 10)]",
"assert pair_wise([1,2,3,4,5,6,7,8,9,10])==[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10)]"
] |
[
{
"content": "def pair_wise(l1):\n temp = []\n for i in range(len(l1) - 1):\n current_element, next_element = l1[i], l1[i + 1]\n x = (current_element, next_element)\n temp.append(x)\n return temp",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 767
|
[
{
"content": "Write a python function to count the number of pairs whose sum is equal to ‘sum’. The funtion gets as input a list of numbers and the sum,",
"role": "user"
}
] |
def get_pairs_count(arr, sum):
count = 0
for i in range(len(arr)):
for j in range(i + 1,len(arr)):
if arr[i] + arr[j] == sum:
count += 1
return count
|
[] |
[
"assert get_pairs_count([1,1,1,1],2) == 6",
"assert get_pairs_count([1,5,7,-1,5],6) == 3",
"assert get_pairs_count([1,-2,3],1) == 1",
"assert get_pairs_count([-1,-2,3],-3) == 1"
] |
[
{
"content": "def get_pairs_count(arr, sum):\n count = 0 \n for i in range(len(arr)):\n for j in range(i + 1,len(arr)):\n if arr[i] + arr[j] == sum:\n count += 1\n return count",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 769
|
[
{
"content": "Write a python function to get the difference between two lists.",
"role": "user"
}
] |
def Diff(li1,li2):
return list(set(li1)-set(li2)) + list(set(li2)-set(li1))
|
[] |
[
"assert (Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35])) == [10, 20, 30, 15]",
"assert (Diff([1,2,3,4,5], [6,7,1])) == [2,3,4,5,6,7]",
"assert (Diff([1,2,3], [6,7,1])) == [2,3,6,7]"
] |
[
{
"content": "def Diff(li1,li2):\n return list(set(li1)-set(li2)) + list(set(li2)-set(li1))\n ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 770
|
[
{
"content": "Write a python function to find the sum of fourth power of first n odd natural numbers.",
"role": "user"
}
] |
def odd_num_sum(n) :
j = 0
sm = 0
for i in range(1,n + 1) :
j = (2*i-1)
sm = sm + (j*j*j*j)
return sm
|
[] |
[
"assert odd_num_sum(2) == 82",
"assert odd_num_sum(3) == 707",
"assert odd_num_sum(4) == 3108"
] |
[
{
"content": "def odd_num_sum(n) : \n j = 0\n sm = 0\n for i in range(1,n + 1) : \n j = (2*i-1) \n sm = sm + (j*j*j*j) \n return sm ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 771
|
[
{
"content": "Write a function to check if the given expression is balanced or not. https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/",
"role": "user"
}
] |
from collections import deque
def check_expression(exp):
if len(exp) & 1:
return False
stack = deque()
for ch in exp:
if ch == '(' or ch == '{' or ch == '[':
stack.append(ch)
if ch == ')' or ch == '}' or ch == ']':
if not stack:
return False
top = stack.pop()
if (top == '(' and ch != ')') or (top == '{' and ch != '}' or (top == '[' and ch != ']')):
return False
return not stack
|
[] |
[
"assert check_expression(\"{()}[{}]\") == True",
"assert check_expression(\"{()}[{]\") == False",
"assert check_expression(\"{()}[{}][]({})\") == True"
] |
[
{
"content": "from collections import deque\ndef check_expression(exp):\n if len(exp) & 1:\n return False\n stack = deque()\n for ch in exp:\n if ch == '(' or ch == '{' or ch == '[':\n stack.append(ch)\n if ch == ')' or ch == '}' or ch == ']':\n if not stack:\n return False\n top = stack.pop()\n if (top == '(' and ch != ')') or (top == '{' and ch != '}' or (top == '[' and ch != ']')):\n return False\n return not stack",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 772
|
[
{
"content": "Write a function to remove all the words with k length in the given string.",
"role": "user"
}
] |
def remove_length(test_str, K):
temp = test_str.split()
res = [ele for ele in temp if len(ele) != K]
res = ' '.join(res)
return (res)
|
[] |
[
"assert remove_length('The person is most value tet', 3) == 'person is most value'",
"assert remove_length('If you told me about this ok', 4) == 'If you me about ok'",
"assert remove_length('Forces of darkeness is come into the play', 4) == 'Forces of darkeness is the'"
] |
[
{
"content": "def remove_length(test_str, K):\n temp = test_str.split()\n res = [ele for ele in temp if len(ele) != K]\n res = ' '.join(res)\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 773
|
[
{
"content": "Write a function to find the occurrence and position of the substrings within a string. Return None if there is no match.",
"role": "user"
}
] |
import re
def occurance_substring(text,pattern):
for match in re.finditer(pattern, text):
s = match.start()
e = match.end()
return (text[s:e], s, e)
|
[] |
[
"assert occurance_substring('python programming, python language','python')==('python', 0, 6)",
"assert occurance_substring('python programming,programming language','programming')==('programming', 7, 18)",
"assert occurance_substring('python programming,programming language','language')==('language', 31, 39)",
"assert occurance_substring('c++ programming, c++ language','python')==None"
] |
[
{
"content": "import re\ndef occurance_substring(text,pattern):\n for match in re.finditer(pattern, text):\n s = match.start()\n e = match.end()\n return (text[s:e], s, e)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 775
|
[
{
"content": "Write a python function to check whether every odd index contains odd numbers of a given list.",
"role": "user"
}
] |
def odd_position(nums):
return all(nums[i]%2==i%2 for i in range(len(nums)))
|
[] |
[
"assert odd_position([2,1,4,3,6,7,6,3]) == True",
"assert odd_position([4,1,2]) == True",
"assert odd_position([1,2,3]) == False"
] |
[
{
"content": "def odd_position(nums):\n\treturn all(nums[i]%2==i%2 for i in range(len(nums)))",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 776
|
[
{
"content": "Write a function to count those characters which have vowels as their neighbors in the given string.",
"role": "user"
}
] |
def count_vowels(test_str):
res = 0
vow_list = ['a', 'e', 'i', 'o', 'u']
for idx in range(1, len(test_str) - 1):
if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list):
res += 1
if test_str[0] not in vow_list and test_str[1] in vow_list:
res += 1
if test_str[-1] not in vow_list and test_str[-2] in vow_list:
res += 1
return (res)
|
[] |
[
"assert count_vowels('bestinstareels') == 7",
"assert count_vowels('partofthejourneyistheend') == 12",
"assert count_vowels('amazonprime') == 5"
] |
[
{
"content": "def count_vowels(test_str):\n res = 0\n vow_list = ['a', 'e', 'i', 'o', 'u']\n for idx in range(1, len(test_str) - 1):\n if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list):\n res += 1\n if test_str[0] not in vow_list and test_str[1] in vow_list:\n res += 1\n if test_str[-1] not in vow_list and test_str[-2] in vow_list:\n res += 1\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 777
|
[
{
"content": "Write a python function to find the sum of non-repeated elements in a given list.",
"role": "user"
}
] |
def find_sum(arr):
arr.sort()
sum = arr[0]
for i in range(len(arr)-1):
if (arr[i] != arr[i+1]):
sum = sum + arr[i+1]
return sum
|
[] |
[
"assert find_sum([1,2,3,1,1,4,5,6]) == 21",
"assert find_sum([1,10,9,4,2,10,10,45,4]) == 71",
"assert find_sum([12,10,9,45,2,10,10,45,10]) == 78"
] |
[
{
"content": "def find_sum(arr): \n arr.sort() \n sum = arr[0] \n for i in range(len(arr)-1): \n if (arr[i] != arr[i+1]): \n sum = sum + arr[i+1] \n return sum",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 778
|
[
{
"content": "Write a function to pack consecutive duplicates of a given list elements into sublists.",
"role": "user"
}
] |
from itertools import groupby
def pack_consecutive_duplicates(list1):
return [list(group) for key, group in groupby(list1)]
|
[] |
[
"assert pack_consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4])==[[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]]",
"assert pack_consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[[10, 10], [15], [19], [18, 18], [17], [26, 26], [17], [18], [10]]",
"assert pack_consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==[['a', 'a'], ['b'], ['c'], ['d', 'd']]"
] |
[
{
"content": "from itertools import groupby\ndef pack_consecutive_duplicates(list1):\n return [list(group) for key, group in groupby(list1)]",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 779
|
[
{
"content": "Write a function to count the number of lists within a list. The function should return a dictionary, where every list is turned to a tuple, and the value of the tuple is the number of its occurrences.",
"role": "user"
}
] |
def unique_sublists(list1):
result ={}
for l in list1:
result.setdefault(tuple(l), list()).append(1)
for a, b in result.items():
result[a] = sum(b)
return result
|
[] |
[
"assert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]])=={(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1}",
"assert unique_sublists([['green', 'orange'], ['black'], ['green', 'orange'], ['white']])=={('green', 'orange'): 2, ('black',): 1, ('white',): 1}",
"assert unique_sublists([[1, 2], [3, 4], [4, 5], [6, 7]])=={(1, 2): 1, (3, 4): 1, (4, 5): 1, (6, 7): 1}"
] |
[
{
"content": "def unique_sublists(list1):\n result ={}\n for l in list1: \n result.setdefault(tuple(l), list()).append(1) \n for a, b in result.items(): \n result[a] = sum(b)\n return result",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 780
|
[
{
"content": "Write a function to find the combinations of sums with tuples in the given tuple list. https://www.geeksforgeeks.org/python-combinations-of-sum-with-tuples-in-tuple-list/",
"role": "user"
}
] |
from itertools import combinations
def find_combinations(test_list):
res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)]
return (res)
|
[] |
[
"assert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)]",
"assert find_combinations([(3, 5), (7, 8), (6, 2), (7, 11)]) == [(10, 13), (9, 7), (10, 16), (13, 10), (14, 19), (13, 13)]",
"assert find_combinations([(4, 6), (8, 9), (7, 3), (8, 12)]) == [(12, 15), (11, 9), (12, 18), (15, 12), (16, 21), (15, 15)]"
] |
[
{
"content": "from itertools import combinations \ndef find_combinations(test_list):\n res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)]\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 781
|
[
{
"content": "Write a python function to check whether the count of divisors is even. https://www.w3resource.com/python-exercises/basic/python-basic-1-exercise-24.php",
"role": "user"
}
] |
import math
def count_divisors(n) :
count = 0
for i in range(1, (int)(math.sqrt(n)) + 2) :
if (n % i == 0) :
if( n // i == i) :
count = count + 1
else :
count = count + 2
return count % 2 == 0
|
[] |
[
"assert count_divisors(10)",
"assert not count_divisors(100)",
"assert count_divisors(125)"
] |
[
{
"content": "import math \ndef count_divisors(n) : \n count = 0\n for i in range(1, (int)(math.sqrt(n)) + 2) : \n if (n % i == 0) : \n if( n // i == i) : \n count = count + 1\n else : \n count = count + 2\n return count % 2 == 0",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 782
|
[
{
"content": "Write a python function to find the sum of all odd length subarrays. https://www.geeksforgeeks.org/sum-of-all-odd-length-subarrays/",
"role": "user"
}
] |
def odd_length_sum(arr):
Sum = 0
l = len(arr)
for i in range(l):
Sum += ((((i + 1) *(l - i) + 1) // 2) * arr[i])
return Sum
|
[] |
[
"assert odd_length_sum([1,2,4]) == 14",
"assert odd_length_sum([1,2,1,2]) == 15",
"assert odd_length_sum([1,7]) == 8"
] |
[
{
"content": "def odd_length_sum(arr):\n Sum = 0\n l = len(arr)\n for i in range(l):\n Sum += ((((i + 1) *(l - i) + 1) // 2) * arr[i])\n return Sum",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 783
|
[
{
"content": "Write a function to convert rgb color to hsv color. https://www.geeksforgeeks.org/program-change-rgb-color-model-hsv-color-model/",
"role": "user"
}
] |
def rgb_to_hsv(r, g, b):
r, g, b = r/255.0, g/255.0, b/255.0
mx = max(r, g, b)
mn = min(r, g, b)
df = mx-mn
if mx == mn:
h = 0
elif mx == r:
h = (60 * ((g-b)/df) + 360) % 360
elif mx == g:
h = (60 * ((b-r)/df) + 120) % 360
elif mx == b:
h = (60 * ((r-g)/df) + 240) % 360
if mx == 0:
s = 0
else:
s = (df/mx)*100
v = mx*100
return h, s, v
|
[] |
[
"assert rgb_to_hsv(255, 255, 255)==(0, 0.0, 100.0)",
"assert rgb_to_hsv(0, 215, 0)==(120.0, 100.0, 84.31372549019608)",
"assert rgb_to_hsv(10, 215, 110)==(149.26829268292684, 95.34883720930233, 84.31372549019608)"
] |
[
{
"content": "def rgb_to_hsv(r, g, b):\n r, g, b = r/255.0, g/255.0, b/255.0\n mx = max(r, g, b)\n mn = min(r, g, b)\n df = mx-mn\n if mx == mn:\n h = 0\n elif mx == r:\n h = (60 * ((g-b)/df) + 360) % 360\n elif mx == g:\n h = (60 * ((b-r)/df) + 120) % 360\n elif mx == b:\n h = (60 * ((r-g)/df) + 240) % 360\n if mx == 0:\n s = 0\n else:\n s = (df/mx)*100\n v = mx*100\n return h, s, v",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 784
|
[
{
"content": "Write a function to find the product of first even and odd number of a given list.",
"role": "user"
}
] |
def mul_even_odd(list1):
first_even = next((el for el in list1 if el%2==0),-1)
first_odd = next((el for el in list1 if el%2!=0),-1)
return (first_even*first_odd)
|
[] |
[
"assert mul_even_odd([1,3,5,7,4,1,6,8])==4",
"assert mul_even_odd([1,2,3,4,5,6,7,8,9,10])==2",
"assert mul_even_odd([1,5,7,9,10])==10"
] |
[
{
"content": "def mul_even_odd(list1):\n first_even = next((el for el in list1 if el%2==0),-1)\n first_odd = next((el for el in list1 if el%2!=0),-1)\n return (first_even*first_odd)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 785
|
[
{
"content": "Write a function to convert tuple string to integer tuple.",
"role": "user"
}
] |
def tuple_str_int(test_str):
res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', '))
return (res)
|
[] |
[
"assert tuple_str_int(\"(7, 8, 9)\") == (7, 8, 9)",
"assert tuple_str_int(\"(1, 2, 3)\") == (1, 2, 3)",
"assert tuple_str_int(\"(4, 5, 6)\") == (4, 5, 6)",
"assert tuple_str_int(\"(7, 81, 19)\") == (7, 81, 19)"
] |
[
{
"content": "def tuple_str_int(test_str):\n res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', '))\n return (res) ",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 786
|
[
{
"content": "Write a function to locate the right insertion point for a specified value in sorted order.",
"role": "user"
}
] |
import bisect
def right_insertion(a, x):
return bisect.bisect_right(a, x)
|
[] |
[
"assert right_insertion([1,2,4,5],6)==4",
"assert right_insertion([1,2,4,5],3)==2",
"assert right_insertion([1,2,4,5],7)==4"
] |
[
{
"content": "import bisect\ndef right_insertion(a, x):\n return bisect.bisect_right(a, x)",
"role": "assistant"
}
] |
Benchmark Questions Verification V2.ipynb
| 787
|
[
{
"content": "Write a function that matches a string that has an a followed by three 'b'.",
"role": "user"
}
] |
import re
def text_match_three(text):
patterns = 'ab{3}?'
return re.search(patterns, text)
|
[] |
[
"assert not text_match_three(\"ac\")",
"assert not text_match_three(\"dc\")",
"assert text_match_three(\"abbbba\")",
"assert text_match_three(\"caacabbbba\")"
] |
[
{
"content": "import re\ndef text_match_three(text):\n patterns = 'ab{3}?'\n return re.search(patterns, text)",
"role": "assistant"
}
] |
End of preview. Expand
in Data Studio
This is modifed from: google-research-datasets/mbpp
- Downloads last month
- 27