task_id int64 | code string | prompt string | source_file string | test_imports list | test_list list | test string |
|---|---|---|---|---|---|---|
2 |
def similar_elements(test_tup1, test_tup2):
return tuple(set(test_tup1) & set(test_tup2))
| Écrivez une fonction qui trouve les éléments communs des deux listes données. | Benchmark Questions Verification V2.ipynb | [] | [
"assert set(similar_elements((3, 4, 5, 6),(5, 7, 4, 10))) == set((4, 5))",
"assert set(similar_elements((1, 2, 3, 4),(5, 4, 3, 7))) == set((3, 4))",
"assert set(similar_elements((11, 12, 14, 13),(17, 15, 14, 13))) == set((13, 14))"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
3 |
import math
def is_not_prime(n):
if n == 1:
return True
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
return True
return False
| Écrivez une fonction Python qui identifie les nombres non premiers. | Benchmark Questions Verification V2.ipynb | [] | [
"assert is_not_prime(2) == False",
"assert is_not_prime(10) == True",
"assert is_not_prime(35) == True",
"assert is_not_prime(37) == False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
4 |
import heapq as hq
def heap_queue_largest(nums: list,n: int) -> list:
largest_nums = hq.nlargest(n, nums)
return largest_nums
| Écrivez une fonction qui trouve les n plus grands entiers d'une liste de nombres donnée, renvoyés dans l'ordre décroissant. | Benchmark Questions Verification V2.ipynb | [] | [
"assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]",
"assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],2)==[85, 75]",
"assert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],5)==[85, 75, 65, 58, 35]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
6 |
def is_Power_Of_Two(x: int):
return x > 0 and (x & (x - 1)) == 0
def differ_At_One_Bit_Pos(a: int,b: int):
return is_Power_Of_Two(a ^ b)
| Écrivez une fonction Python qui vérifie si les deux nombres diffèrent d'un seul bit ou non. | Benchmark Questions Verification V2.ipynb | [] | [
"assert differ_At_One_Bit_Pos(13,9) == True",
"assert differ_At_One_Bit_Pos(15,8) == False",
"assert differ_At_One_Bit_Pos(2,4) == False",
"assert differ_At_One_Bit_Pos(2, 3) == True",
"assert differ_At_One_Bit_Pos(5, 1) == True",
"assert differ_At_One_Bit_Pos(1, 5) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
7 |
import re
def find_char_long(text):
return (re.findall(r"\b\w{4,}\b", text))
| Écrivez une fonction qui trouve tous les mots d'au moins 4 caractères dans une chaîne de caractères. | Benchmark Questions Verification V2.ipynb | [] | [
"assert set(find_char_long('Please move back to stream')) == set(['Please', 'move', 'back', 'stream'])",
"assert set(find_char_long('Jing Eco and Tech')) == set(['Jing', 'Tech'])",
"assert set(find_char_long('Jhingai wulu road Zone 3')) == set(['Jhingai', 'wulu', 'road', 'Zone'])"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
8 |
def square_nums(nums):
return [i**2 for i in nums]
| Écrivez une fonction qui trouve les carrés de chaque élément d'une liste. | Benchmark Questions Verification V2.ipynb | [] | [
"assert square_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]",
"assert square_nums([10,20,30])==([100,400,900])",
"assert square_nums([12,15])==([144,225])"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
9 |
def find_Rotations(s):
n = len(s)
s += s
for i in range(1, n + 1):
if s[i: i + n] == s[0: n]:
return i
return n
| Écrivez une fonction Python qui trouve le nombre minimal de rotations (supérieur à 0) nécessaires pour obtenir la même chaîne de caractères. | Benchmark Questions Verification V2.ipynb | [] | [
"assert find_Rotations(\"aaaa\") == 1",
"assert find_Rotations(\"ab\") == 2",
"assert find_Rotations(\"abc\") == 3"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
11 |
def remove_Occ(s,ch):
s = s.replace(ch, '', 1)
s = s[::-1].replace(ch, '', 1)[::-1]
return s
| Écrivez une fonction Python qui supprime la première et la dernière occurrence d'un caractère donné dans la chaîne de caractères. | Benchmark Questions Verification V2.ipynb | [] | [
"assert remove_Occ(\"hello\",\"l\") == \"heo\"",
"assert remove_Occ(\"abcda\",\"a\") == \"bcd\"",
"assert remove_Occ(\"PHP\",\"P\") == \"H\""
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
12 |
def sort_matrix(M):
result = sorted(M, key=sum)
return result
| Écrivez une fonction qui trie une matrice donnée dans l'ordre croissant selon la somme de ses lignes. | Benchmark Questions Verification V2.ipynb | [] | [
"assert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]])==[[1, 1, 1], [1, 2, 3], [2, 4, 5]]",
"assert sort_matrix([[1, 2, 3], [-2, 4, -5], [1, -1, 1]])==[[-2, 4, -5], [1, -1, 1], [1, 2, 3]]",
"assert sort_matrix([[5,8,9],[6,4,3],[2,1,4]])==[[2, 1, 4], [6, 4, 3], [5, 8, 9]]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
14 |
def find_Volume(l,b,h) :
return ((l * b * h) / 2)
| Écrivez une fonction Python qui trouve le volume d'un prisme triangulaire. | Benchmark Questions Verification V2.ipynb | [] | [
"assert find_Volume(10,8,6) == 240",
"assert find_Volume(3,2,2) == 6",
"assert find_Volume(1,2,1) == 1"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
16 |
import re
def text_lowercase_underscore(text):
return bool(re.match('^[a-z]+(_[a-z]+)*$', text))
| Écrivez une fonction qui renvoie true si la chaîne de caractères en entrée contient des séquences de lettres minuscules jointes par un underscore, et false sinon. | Benchmark Questions Verification V2.ipynb | [] | [
"assert text_lowercase_underscore(\"aab_cbbbc\")==(True)",
"assert text_lowercase_underscore(\"aab_Abbbc\")==(False)",
"assert text_lowercase_underscore(\"Aaab_abbbc\")==(False)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
17 |
def square_perimeter(a):
return 4*a
| Écrivez une fonction qui renvoie le périmètre d'un carré à partir de la longueur de son côté fournie en entrée. | Benchmark Questions Verification V2.ipynb | [] | [
"assert square_perimeter(10)==40",
"assert square_perimeter(5)==20",
"assert square_perimeter(4)==16"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
18 |
def remove_dirty_chars(string, second_string):
for char in second_string:
string = string.replace(char, '')
return string
| Écrivez une fonction qui supprime de la première chaîne de caractères les caractères présents dans la seconde chaîne de caractères. | Benchmark Questions Verification V2.ipynb | [] | [
"assert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'",
"assert remove_dirty_chars(\"digitalindia\", \"talent\") == 'digiidi'",
"assert remove_dirty_chars(\"exoticmiles\", \"toxic\") == 'emles'"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
19 |
def test_duplicate(arraynums):
return len(arraynums) != len(set(arraynums))
| Écrivez une fonction qui détermine si un tableau d'entiers donné contient un élément en double. | Benchmark Questions Verification V2.ipynb | [] | [
"assert test_duplicate(([1,2,3,4,5]))==False",
"assert test_duplicate(([1,2,3,4, 4]))==True",
"assert test_duplicate([1,1,2,2,3,3,4,4,5])==True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
20 |
def is_woodall(x):
if not isinstance(x, int):
return False
if x <= 0 or x % 2 == 0:
return False
if (x == 1):
return True
x += 1
i = 0
while (x % 2 == 0):
x /= 2
i += 1
if (i == x):
return True
return False
| Écrivez une fonction qui vérifie si le nombre donné est un nombre woodball ou non. | Benchmark Questions Verification V2.ipynb | [] | [
"assert is_woodall(383) == True",
"assert is_woodall(254) == False",
"assert is_woodall(200) == False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
56 |
def check(n):
return n == 2 * int(str(n)[::-1]) - 1
| Écrivez une fonction Python qui vérifie si un nombre donné est égal au double de son inverse moins un. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert check(70) == False",
"assert check(23) == False",
"assert check(73) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
57 |
def find_Max_Num(arr) :
arr.sort(reverse = True)
return int("".join(map(str,arr)))
| Écrivez une fonction Python qui trouve le plus grand nombre pouvant être formé avec la liste de chiffres donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert find_Max_Num([1,2,3]) == 321",
"assert find_Max_Num([4,5,6,1]) == 6541",
"assert find_Max_Num([1,2,3,9]) == 9321"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
58 |
def opposite_Signs(x,y):
return ((x ^ y) < 0)
| Écrivez une fonction Python qui vérifie si les deux entiers donnés sont de signes opposés ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert opposite_Signs(1,-2) == True",
"assert opposite_Signs(3,2) == False",
"assert opposite_Signs(-10,-10) == False",
"assert opposite_Signs(-2,2) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
59 |
def is_octagonal(n):
return 3 * n * n - 2 * n
| Écrivez une fonction qui trouve le nième nombre octogonal. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_octagonal(5) == 65",
"assert is_octagonal(10) == 280",
"assert is_octagonal(15) == 645"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
61 |
from collections import defaultdict
def count_Substrings(s):
n, count, sum = len(s), 0, 0
mp = defaultdict(lambda : 0)
mp[0] += 1
for i in range(n):
sum += ord(s[i]) - ord('0')
count += mp[sum - i - 1]
mp[sum - i - 1] += 1
return count
| Écrivez une fonction Python qui compte le nombre de sous-chaînes dont la somme des chiffres est égale à leur longueur. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert count_Substrings('112112') == 6",
"assert count_Substrings('111') == 6",
"assert count_Substrings('1101112') == 12"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
62 |
def smallest_num(xs):
assert len(xs) > 0, "invalid inputs"
return min(xs)
| Écrivez une fonction Python qui trouve le plus petit nombre d'une liste. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert smallest_num([10, 20, 1, 45, 99]) == 1",
"assert smallest_num([1, 2, 3]) == 1",
"assert smallest_num([45, 46, 50, 60]) == 45"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
63 |
def max_difference(test_list):
return max(abs(a - b) for a, b in test_list)
| Écrivez une fonction qui trouve la différence maximale entre les paires disponibles dans la liste de tuples donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7",
"assert max_difference([(4, 6), (2, 17), (9, 13), (11, 12)]) == 15",
"assert max_difference([(12, 35), (21, 27), (13, 23), (41, 22)]) == 23"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
64 |
def subject_marks(subjectmarks):
#subject_marks = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])
subjectmarks.sort(key = lambda x: x[1])
return subjectmarks
| Écrivez une fonction qui trie une liste de tuples en utilisant la deuxième valeur de chaque tuple. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])==[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]",
"assert subject_marks([('Telugu',49),('Hindhi',54),('Social',33)])==([('Social',33),('Telugu',49),('Hindhi',54)])",
"assert subject_mark... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
65 |
def recursive_list_sum(data_list):
total = 0
for element in data_list:
if type(element) == type([]):
total = total + recursive_list_sum(element)
else:
total = total + element
return total
| Écrivez une fonction qui aplatit une liste et additionne tous ses éléments. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert recursive_list_sum(([1, 2, [3,4],[5,6]]))==21",
"assert recursive_list_sum(([7, 10, [15,14],[19,41]]))==106",
"assert recursive_list_sum(([10, 20, [30,40],[50,60]]))==210"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
66 |
def pos_count(l):
return len([x for x in l if x > 0])
| Écrivez une fonction Python qui compte le nombre de nombres positifs dans une liste. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert pos_count([1,-2,3,-4]) == 2",
"assert pos_count([3,4,5,-1]) == 3",
"assert pos_count([1,2,3,4]) == 4"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
67 |
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]
| Écrivez une fonction qui trouve le nombre de façons de partitionner un ensemble en utilisant les nombres de Bell. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert bell_number(2)==2",
"assert bell_number(10)==115975",
"assert bell_number(56)==6775685320645824322581483068371419745979053216268760300"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
68 |
def is_Monotonic(A):
return all(a <= b for a, b in zip(A, A[1:])) or all(a >= b for a, b in zip(A, A[1:]))
| Écrivez une fonction Python qui vérifie si le tableau donné est monotone ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_Monotonic([6, 5, 4, 4]) == True",
"assert is_Monotonic([1, 2, 2, 3]) == True",
"assert is_Monotonic([1, 3, 2]) == False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
69 |
def is_sublist(l, s):
if len(l) < len(s):
return False
return any(l[i:i+len(s)] == s for i in range(len(l)-len(s)+1))
| Écrivez une fonction qui vérifie si une liste contient la sous-liste donnée ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_sublist([2,4,3,5,7],[3,7])==False",
"assert is_sublist([2,4,3,5,7],[4,3])==True",
"assert is_sublist([2,4,3,5,7],[1,6])==False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
70 |
def get_equal(Input):
return len(set(len(item) for item in Input)) == 1
| Écrivez une fonction qui détermine si tous les tuples donnés ont la même longueur ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert get_equal([(11, 22, 33), (44, 55, 66)]) == True",
"assert get_equal([(1, 2, 3), (4, 5, 6, 7)]) == False",
"assert get_equal([(1, 2), (3, 4)]) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
71 |
def comb_sort(nums):
n = len(nums)
gap = n
shrink = 1.3
swapped = True
while gap > 1 or swapped:
gap = int(gap / shrink)
if gap < 1:
gap = 1
swapped = False
for i in range(n - gap):
if nums[i] > nums[i + gap]:
nums[i], nums[i +... | Écrivez une fonction qui trie une liste d'éléments. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]",
"assert comb_sort([41, 32, 15, 19, 22]) == [15, 19, 22, 32, 41]",
"assert comb_sort([99, 15, 13, 47]) == [13, 15, 47, 99]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
72 |
def dif_Square(n):
# see https://www.quora.com/Which-numbers-can-be-expressed-as-the-difference-of-two-squares
return n % 4 != 2
| Écrivez une fonction Python qui vérifie si le nombre donné peut être représenté comme la différence de deux carrés ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert dif_Square(5) == True",
"assert dif_Square(10) == False",
"assert dif_Square(15) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
74 |
def is_samepatterns(colors, patterns):
if len(colors) != len(patterns):
return False
pattern_color_dict = {pattern: set() for pattern in patterns}
for color, pattern in zip(colors, patterns):
pattern_color_dict[pattern].add(color)
return all(len(pattern_color_dict[pattern]) == 1... | Écrivez une fonction qui vérifie si elle suit la séquence donnée dans le tableau patterns. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_samepatterns([\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"])==True",
"assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\",\"b\"])==False",
"assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\"])==False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
75 |
def find_tuples(test_list, K):
res = [sub for sub in test_list if all(ele % K == 0 for ele in sub)]
return res
| Écrivez une fonction qui trouve les tuples dont tous les éléments sont divisibles par k dans la liste de tuples donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == [(6, 24, 12)]",
"assert find_tuples([(5, 25, 30), (4, 2, 3), (7, 8, 9)], 5) == [(5, 25, 30)]",
"assert find_tuples([(7, 9, 16), (8, 16, 4), (19, 17, 18)], 4) == [(8, 16, 4)]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
77 |
def is_Diff(n):
return n % 11 == 0
| Écrivez une fonction Python qui détermine si un nombre est divisible par 11. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_Diff (12345) == False",
"assert is_Diff(1212112) == True",
"assert is_Diff(1212) == False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
79 |
def word_len(s):
return len(s) % 2 == 1
| Écrivez une fonction Python qui vérifie si la longueur du mot est impaire ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert word_len(\"Hadoop\") == False",
"assert word_len(\"great\") == True",
"assert word_len(\"structure\") == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
80 |
def tetrahedral_number(n):
return (n * (n + 1) * (n + 2)) / 6
| Écrivez une fonction qui trouve le nième nombre tétraédrique. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert tetrahedral_number(5) == 35",
"assert tetrahedral_number(6) == 56",
"assert tetrahedral_number(7) == 84"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
82 |
import math
def volume_sphere(r):
return (4./3.) * math.pi * (r**3)
| Écrivez une fonction qui trouve le volume d'une sphère. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(volume_sphere(10), 4188.790204786391, rel_tol=0.001)",
"assert math.isclose(volume_sphere(25), 65449.84694978735, rel_tol=0.001)",
"assert math.isclose(volume_sphere(20), 33510.32163829113, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
84 |
def sequence(n):
if n == 1 or n == 2:
return 1
seq = [0] * (n + 1)
seq[1] = seq[2] = 1
for i in range(3, n + 1):
seq[i] = seq[seq[i - 1]] + seq[i - seq[i - 1]]
return seq[n]
| Écrivez une fonction qui trouve le nième nombre de la suite de Newman-Conway. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert sequence(10) == 6",
"assert sequence(2) == 1",
"assert sequence(3) == 2"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
85 |
import math
def surfacearea_sphere(r):
return 4 * math.pi * (r**2)
| Écrivez une fonction qui trouve la surface d'une sphère. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(surfacearea_sphere(10), 1256.6370614359173, rel_tol=0.001)",
"assert math.isclose(surfacearea_sphere(15), 2827.4333882308138, rel_tol=0.001)",
"assert math.isclose(surfacearea_sphere(20), 5026.548245743669, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
86 |
def centered_hexagonal_number(n):
return 3 * n * (n - 1) + 1
| Écrivez une fonction qui trouve le nième nombre hexagonal centré. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert centered_hexagonal_number(10) == 271",
"assert centered_hexagonal_number(2) == 7",
"assert centered_hexagonal_number(9) == 217"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
87 |
import collections as ct
def merge_dictionaries_three(dict1,dict2, dict3):
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict
| Écrivez une fonction qui fusionne trois dictionnaires en un seul dictionnaire. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{ \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}",
"assert merge_dictionaries_three({ \"R\": ... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
88 |
import collections
def freq_count(list1):
freq_count= collections.Counter(list1)
return freq_count
| Écrivez une fonction qui obtient la fréquence de tous les éléments d'une liste, renvoyée sous forme de dictionnaire. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert freq_count([10,10,10,10,20,20,20,20,40,40,50,50,30])==({10: 4, 20: 4, 40: 2, 50: 2, 30: 1})",
"assert freq_count([1,2,3,4,3,2,4,1,3,1,4])==({1:3, 2:2,3:3,4:3})",
"assert freq_count([5,6,7,4,9,10,4,5,6,7,9,5])==({10:1,5:3,6:2,7:2,4:2,9:2})"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
89 |
def closest_num(N):
return (N - 1)
| Écrivez une fonction qui trouve le nombre le plus proche et plus petit que n. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert closest_num(11) == 10",
"assert closest_num(7) == 6",
"assert closest_num(12) == 11"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
90 |
def len_log(list1):
return max(len(x) for x in list1)
| Écrivez une fonction Python qui trouve la longueur du mot le plus long. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert len_log([\"python\",\"PHP\",\"bigdata\"]) == 7",
"assert len_log([\"a\",\"ab\",\"abc\"]) == 3",
"assert len_log([\"small\",\"big\",\"tall\"]) == 5"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
91 |
def find_substring(str1, sub_str):
return any(sub_str in s for s in str1)
| Écrivez une fonction qui vérifie si une chaîne de caractères est présente comme sous-chaîne dans une liste de chaînes de caractères donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True",
"assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"abc\")==False",
"assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ange\")==True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
92 |
def is_undulating(n):
digits = [int(digit) for digit in str(n)]
if len(set(digits)) != 2:
return False
return all(a != b for a, b in zip(digits, digits[1:]))
| Écrivez une fonction qui vérifie si le nombre donné est ondulant ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert is_undulating(1212121) == True",
"assert is_undulating(1991) == False",
"assert is_undulating(121) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
93 |
def power(a, b):
return a ** b
| Écrivez une fonction qui calcule la valeur de 'a' à la puissance 'b'. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert power(3,4) == 81",
"assert power(2,3) == 8",
"assert power(5,5) == 3125"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
94 |
from operator import itemgetter
def index_minimum(test_list):
res = min(test_list, key = itemgetter(1))[0]
return (res)
| Étant donné une liste de tuples, écrivez une fonction qui renvoie la première valeur du tuple ayant la plus petite deuxième valeur. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'",
"assert index_minimum([('Yash', 185), ('Dawood', 125), ('Sanya', 175)]) == 'Dawood'",
"assert index_minimum([('Sai', 345), ('Salman', 145), ('Ayesha', 96)]) == 'Ayesha'"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
95 |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength
| Écrivez une fonction Python qui trouve la longueur de la plus petite liste dans une liste de listes. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert Find_Min_Length([[1],[1,2]]) == 1",
"assert Find_Min_Length([[1,2],[1,2,3],[1,2,3,4]]) == 2",
"assert Find_Min_Length([[3,3,3],[4,4,4,4]]) == 3"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
96 |
def divisor(n):
return sum(1 for i in range(1, n + 1) if n % i == 0)
| Écrivez une fonction Python qui trouve le nombre de diviseurs d'un entier donné. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert divisor(15) == 4",
"assert divisor(12) == 6",
"assert divisor(9) == 3"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
97 |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
return {x: list1.count(x) for x in list1}
| Écrivez une fonction qui trouve la fréquence de chaque élément dans une liste de listes aplatie, renvoyée dans un dictionnaire. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert frequency_lists([[1, 2, 3, 2], [4, 5, 6, 2], [7, 8, 9, 5]])=={1: 1, 2: 3, 3: 1, 4: 1, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1}",
"assert frequency_lists([[1,2,3,4],[5,6,7,8],[9,10,11,12]])=={1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1,10:1,11:1,12:1}",
"assert frequency_lists([[20,30,40,17],[18,16,14,13],... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
98 |
def multiply_num(numbers):
from functools import reduce
return reduce(lambda x, y: x * y, numbers) / len(numbers)
| Écrivez une fonction qui multiplie tous les nombres d'une liste et divise par la longueur de la liste. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(multiply_num((8, 2, 3, -1, 7)), -67.2, rel_tol=0.001)",
"assert math.isclose(multiply_num((-10,-20,-30)), -2000.0, rel_tol=0.001)",
"assert math.isclose(multiply_num((19,15,18)), 1710.0, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
99 |
def decimal_to_binary(n):
return bin(n).replace("0b","")
| Écrivez une fonction qui convertit le nombre décimal donné en son équivalent binaire, représenté sous forme de chaîne de caractères sans zéros en tête. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert decimal_to_binary(8) == '1000'",
"assert decimal_to_binary(18) == '10010'",
"assert decimal_to_binary(7) == '111'"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
100 |
def next_smallest_palindrome(num):
if all(digit == '9' for digit in str(num)):
return num + 2
else:
num = [int(digit) for digit in str(num)]
n = len(num)
mid = n // 2
left_smaller = False
# if n is odd, ignore the middle digit at first
i = mid - 1
... | Écrivez une fonction qui trouve le prochain plus petit palindrome d'un entier spécifié, renvoyé sous forme d'entier. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert next_smallest_palindrome(99)==101",
"assert next_smallest_palindrome(1221)==1331",
"assert next_smallest_palindrome(120)==121"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
101 |
def kth_element(arr, k):
return arr[k-1]
| Écrivez une fonction qui trouve le kième élément du tableau donné en utilisant une indexation à partir de 1. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert kth_element([12,3,5,7,19], 2) == 3",
"assert kth_element([17,24,8,23], 3) == 8",
"assert kth_element([16,21,25,36,4], 4) == 36"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
102 |
def snake_to_camel(word):
return ''.join(x.capitalize() or '_' for x in word.split('_'))
| Écrivez une fonction qui convertit une chaîne de caractères en snake case en une chaîne de caractères en camel case. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert snake_to_camel('python_program')=='PythonProgram'",
"assert snake_to_camel('python_language')==('PythonLanguage')",
"assert snake_to_camel('programming_language')==('ProgrammingLanguage')"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
103 |
def eulerian_num(n, m):
if (m >= n or n == 0):
return 0
if (m == 0):
return 1
return (n - m) * eulerian_num(n - 1, m - 1) + (m + 1) * eulerian_num(n - 1, m)
| Écrivez une fonction qui trouve le nombre eulérien a(n, m). | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert eulerian_num(3, 1) == 4",
"assert eulerian_num(4, 1) == 11",
"assert eulerian_num(5, 3) == 26"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
104 |
def sort_sublists(input_list):
return [sorted(x) for x in input_list]
| Écrivez une fonction qui trie chaque sous-liste de chaînes de caractères dans une liste de listes donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]))==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]",
"assert sort_sublists(([\" red \",\"green\" ],[\"blue \",\" black\"],[\" orange\",\"brown\"]))==[[' red ', 'green'], [' black', 'b... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
105 |
def count(lst):
return sum(lst)
| Écrivez une fonction Python qui compte les booléens true dans la liste donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert count([True,False,True]) == 2",
"assert count([False,False]) == 0",
"assert count([True,True,True]) == 3"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
106 |
def add_lists(test_list, test_tup):
return test_tup + tuple(test_list)
| Écrivez une fonction qui ajoute la liste donnée aux tuples donnés. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)",
"assert add_lists([6, 7, 8], (10, 11)) == (10, 11, 6, 7, 8)",
"assert add_lists([7, 8, 9], (11, 12)) == (11, 12, 7, 8, 9)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
108 |
import heapq
def merge_sorted_list(num1,num2,num3):
return sorted(num1 + num2 + num3)
| Écrivez une fonction qui fusionne trois listes en une seule liste triée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert merge_sorted_list([25, 24, 15, 4, 5, 29, 110],[19, 20, 11, 56, 25, 233, 154],[24, 26, 54, 48])==[4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233]",
"assert merge_sorted_list([1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12])==[1, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9, 11, 12]",
"a... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
109 |
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
| Écrivez une fonction Python qui trouve le nombre de nombres ayant une valeur impaire lorsqu'on effectue le nombre de rotations donné sur une chaîne binaire. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert odd_Equivalent(\"011001\",6) == 3",
"assert odd_Equivalent(\"11011\",5) == 4",
"assert odd_Equivalent(\"1010\",4) == 2"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
111 |
def common_in_nested_lists(nestedlist):
return list(set.intersection(*map(set, nestedlist)))
| Écrivez une fonction qui trouve les éléments communs dans les listes imbriquées données. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert set(common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]]))==set([18, 12])",
"assert set(common_in_nested_lists([[12, 5, 23, 25, 45], [7, 11, 5, 23, 28], [1, 5, 8, 18, 23, 16]]))==set([5,23])",
"assert set(common_in_nested_lists([[2, 3,4, 1], [4, 5], [6,4, 8],[4, ... | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
113 |
def check_integer(text):
text = text.strip()
if len(text) < 1:
return None
else:
if text[0] in '+-':
text = text[1:]
return text.isdigit()
| Écrivez une fonction qui vérifie si une chaîne de caractères représente un entier ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert check_integer(\"python\")==False",
"assert check_integer(\"1\")==True",
"assert check_integer(\"12345\")==True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
116 |
def tuple_to_int(nums):
return int(''.join(map(str,nums)))
| Écrivez une fonction qui convertit un tuple d'entiers positifs donné en un seul entier. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert tuple_to_int((1,2,3))==123",
"assert tuple_to_int((4,5,6))==456",
"assert tuple_to_int((5,6,7))==567"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
118 |
def string_to_list(string):
return string.split(" ")
| Écrivez une fonction qui convertit une chaîne de caractères en une liste de chaînes en la découpant sur le caractère d'espace. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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']"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
119 |
def search(arr):
n = len(arr)
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR)
| Écrivez une fonction Python qui trouve l'élément qui n'apparaît qu'une seule fois dans un tableau trié. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert search([1,1,2,2,3]) == 3",
"assert search([1,1,3,3,4,4,5,5,7,7,8]) == 8",
"assert search([1,2,2,3,3,4,4]) == 1"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
120 |
def max_product_tuple(list1):
return max(abs(x * y) for x, y in list1)
| Écrivez une fonction qui trouve le produit absolu maximal entre les nombres dans les paires de tuples d'une liste donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
123 |
def div_sum(num):
res = 1
i = 2
while i * i <= num:
if num % i == 0:
res += i
if i * i != num:
res += num / i
i += 1
return res
def amicable_numbers_sum(limit):
amicables = set()
for num in range(2, limit + 1):
if num in amicables:... | Écrivez une fonction qui additionne tous les nombres amiables de 1 jusqu'à un nombre spécifié. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert amicable_numbers_sum(999)==504",
"assert amicable_numbers_sum(9999)==31626",
"assert amicable_numbers_sum(99)==0"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
124 |
import cmath
def angle_complex(a,b):
angle=cmath.phase(a+b)
return angle
| Écrivez une fonction qui obtient l'argument d'un nombre complexe. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(angle_complex(0,1j), 1.5707963267948966, rel_tol=0.001)",
"assert math.isclose(angle_complex(2,1j), 0.4636476090008061, rel_tol=0.001)",
"assert math.isclose(angle_complex(0,2j), 1.5707963267948966, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
125 |
def find_length(string):
current_sum = 0
max_sum = 0
for c in string:
current_sum += 1 if c == '0' else -1
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum
| Écrivez une fonction qui trouve la différence maximale entre le nombre de 0 et le nombre de 1 dans n'importe quelle sous-chaîne de la chaîne binaire donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert find_length(\"11000010001\") == 6",
"assert find_length(\"10111\") == 1",
"assert find_length(\"11011101100101\") == 2"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
126 |
import math
def sum(a,b):
sum = 0
n = math.gcd(a, b)
N = int(math.sqrt(n)) + 1
for i in range (1, N):
if (n % i == 0):
sum += i
if (n / i != i):
sum += (n / i)
return sum
| Écrivez une fonction Python qui trouve la somme des diviseurs communs de deux nombres donnés. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert sum(10,15) == 6",
"assert sum(100,150) == 93",
"assert sum(4,6) == 3"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
127 |
def multiply_int(x, y):
return x * y
| Écrivez une fonction qui multiplie deux entiers. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert multiply_int(10,20)==200",
"assert multiply_int(5,10)==50",
"assert multiply_int(4,8)==32"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
128 |
def long_words(n, s):
return list(filter(lambda x: len(x) > n, s.split(' ')))
| Écrivez une fonction qui trouve les mots de plus de n caractères dans une liste de mots donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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']"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
129 |
def magic_square_test(my_matrix):
s = sum(my_matrix[0])
# row
if any(sum(row) != s for row in my_matrix):
return False
# column
if any(sum(row[i] for row in my_matrix) != s for i in range(len(my_matrix[0]))):
return False
# diagonal
if sum(my_matrix[i][i] for i in range(len(... | Écrivez une fonction qui détermine si la matrice est un carré magique. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
130 |
from collections import defaultdict
def max_occurrences(nums):
d = defaultdict(int)
for n in nums:
d[n] += 1
return max(d, key=d.get)
| Écrivez une fonction qui trouve l'élément ayant la fréquence maximale dans une liste donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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",
"assert max_occurrences([2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,18])==8",
"assert max_occurrences([10,20,20,30,40,90,80,50,30,20,50,10])==20"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
131 |
def reverse_vowels(str1):
is_vowel = lambda x: x in 'aeiouAEIOU'
pos = [i for i, c in enumerate(str1) if is_vowel(c)]
return ''.join(c if not is_vowel(c) else str1[pos.pop()] for c in str1)
| Écrivez une fonction Python qui inverse uniquement les voyelles d'une chaîne de caractères donnée (où y n'est pas une voyelle). | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert reverse_vowels(\"Python\") == \"Python\"",
"assert reverse_vowels(\"USA\") == \"ASU\"",
"assert reverse_vowels(\"ab\") == \"ab\""
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
132 |
def tup_string(tup1):
return ''.join(tup1)
| Écrivez une fonction qui convertit un tuple en une chaîne de caractères. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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\")"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
133 |
def sum_negativenum(nums):
return sum(x for x in nums if x < 0)
| Écrivez une fonction qui calcule la somme des nombres négatifs d'une liste de nombres donnée. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
135 |
def hexagonal_num(n):
return n * (2 * n - 1)
| Écrivez une fonction qui trouve le n-ième nombre hexagonal. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert hexagonal_num(10) == 190",
"assert hexagonal_num(5) == 45",
"assert hexagonal_num(7) == 91"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
137 |
def zero_count(nums):
if all(x == 0 for x in nums):
return float('inf')
return sum(x == 0 for x in nums) / sum(x != 0 for x in nums)
| Écrivez une fonction qui trouve le rapport entre les zéros et les non-zéros dans un tableau d'entiers. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8]), 0.181818, rel_tol=0.001)",
"assert math.isclose(zero_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8]), 0.00, rel_tol=0.001)",
"assert math.isclose(zero_count([2, 4, -6, -9, 11, -12, 14, -5, 17]), 0.00, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
138 |
def is_Sum_Of_Powers_Of_Two(n):
return n > 0 and n % 2 == 0
| Écrivez une fonction Python qui vérifie si le nombre donné peut être représenté comme une somme de puissances non nulles de 2 ou non. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
139 |
import math
def circle_circumference(r):
return 2 * math.pi * r
| Écrivez une fonction qui trouve la circonférence d'un cercle. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [
"import math"
] | [
"assert math.isclose(circle_circumference(10), 62.830000000000005, rel_tol=0.001)",
"assert math.isclose(circle_circumference(5), 31.415000000000003, rel_tol=0.001)",
"assert math.isclose(circle_circumference(4), 25.132, rel_tol=0.001)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
140 |
def extract_singly(test_list):
return set([item for sublist in test_list for item in sublist])
| Écrivez une fonction qui aplatit la liste de listes en un unique ensemble de nombres. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert set(extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)])) == set([3, 4, 5, 7, 1])",
"assert set(extract_singly([(1, 2, 3), (4, 2, 3), (7, 8)])) == set([1, 2, 3, 4, 7, 8])",
"assert set(extract_singly([(7, 8, 9), (10, 11, 12), (10, 11)])) == set([7, 8, 9, 10, 11, 12])"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
141 |
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
| Écrivez une fonction qui trie une liste d'éléments. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
142 |
def count_samepair(list1,list2,list3):
return sum(m == n == o for m, n, o in zip(list1,list2,list3))
| Écrivez une fonction qui compte le nombre d'éléments identiques à la même position dans trois listes données. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
145 |
def max_Abs_Diff(arr):
return max(arr) - min(arr)
| Écrivez une fonction Python qui trouve la différence maximale entre deux éléments quelconques d'un tableau donné. | Mike's Copy of Benchmark Questions Verification V2.ipynb | [] | [
"assert max_Abs_Diff((2,1,5,3)) == 4",
"assert max_Abs_Diff((9,3,2,5,1)) == 8",
"assert max_Abs_Diff((3,2,1)) == 2"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
160 |
def find_solution(a, b, n):
i = 0
while i * a <= n:
if (n - (i * a)) % b == 0:
return (i, (n - (i * a)) // b)
i = i + 1
return None
| Écrivez une fonction qui renvoie les entiers x et y qui satisfont ax + by = n sous forme de tuple, ou qui renvoie None si aucune solution n'existe. | Benchmark Questions Verification V2.ipynb | [] | [
"assert find_solution(2, 3, 7) == (2, 1)",
"assert find_solution(4, 2, 7) == None",
"assert find_solution(1, 13, 17) == (4, 1)"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
161 |
def remove_elements(list1, list2):
return [x for x in list1 if x not in list2]
| Écrivez une fonction qui supprime d'une liste donnée tous les éléments présents dans une autre liste. | Benchmark Questions Verification V2.ipynb | [] | [
"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]"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
162 |
def sum_series(n):
if n <= 0:
return 0
return sum(n - 2 * i for i in range(n // 2 + 1))
| Écrivez une fonction qui calcule la somme (n - 2*i) pour i allant de 0 à n // 2, par exemple n + (n-2) + (n-4)... (jusqu'à ce que n-x =< 0). | Benchmark Questions Verification V2.ipynb | [] | [
"assert sum_series(6) == 12",
"assert sum_series(10) == 30",
"assert sum_series(9) == 25"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
165 |
def count_char_position(str1):
return sum(ord(ch.lower()) - ord('a') == i for i, ch in enumerate(str1))
| Écrivez une fonction qui compte le nombre de caractères dans une chaîne qui occupent la même position dans la chaîne que dans l'alphabet anglais (insensible à la casse). | Benchmark Questions Verification V2.ipynb | [] | [
"assert count_char_position(\"xbcefg\") == 2",
"assert count_char_position(\"ABcED\") == 3",
"assert count_char_position(\"AbgdeF\") == 5"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
166 |
def find_even_pair(A):
if len(A) < 2:
return 0
return sum((a ^ b) % 2 == 0 for i, a in enumerate(A) for b in A[i + 1:])
| Écrivez une fonction qui compte le nombre de paires d'entiers dans une liste dont le xor donne un nombre pair. | Benchmark Questions Verification V2.ipynb | [] | [
"assert find_even_pair([5, 4, 7, 2, 1]) == 4",
"assert find_even_pair([7, 2, 8, 1, 0, 5, 11]) == 9",
"assert find_even_pair([1, 2, 3]) == 1"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
167 |
def next_power_of_2(n):
if n and not n & (n - 1):
return n
res = 1
while n != 0:
n >>= 1
res <<= 1
return res;
| Écrivez une fonction Python qui trouve la plus petite puissance de 2 supérieure ou égale à n. | Benchmark Questions Verification V2.ipynb | [] | [
"assert next_power_of_2(0) == 1",
"assert next_power_of_2(5) == 8",
"assert next_power_of_2(17) == 32"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
168 |
def frequency(a,x):
return a.count(x)
| Écrivez une fonction qui compte le nombre d'occurrences d'un nombre dans une liste donnée. | Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
170 |
def sum_range_list(list1, m, n):
return sum(list1[m : n + 1])
| Écrivez une fonction qui trouve la somme des nombres d'une liste dans une plage spécifiée par deux indices. | Benchmark Questions Verification V2.ipynb | [] | [
"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"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
171 |
def perimeter_pentagon(a):
return 5 * a
| Écrivez une fonction qui trouve le périmètre d'un pentagone régulier à partir de la longueur de ses côtés. | Benchmark Questions Verification V2.ipynb | [] | [
"assert perimeter_pentagon(5) == 25",
"assert perimeter_pentagon(10) == 50",
"assert perimeter_pentagon(15) == 75"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
172 |
def count_occurance(s):
return s.count('std')
| Écrivez une fonction qui compte le nombre d'occurrences de la chaîne 'std' dans une chaîne de caractères donnée. | Benchmark Questions Verification V2.ipynb | [] | [
"assert count_occurance(\"letstdlenstdporstd\") == 3",
"assert count_occurance(\"truststdsolensporsd\") == 1",
"assert count_occurance(\"makestdsostdworthit\") == 2",
"assert count_occurance(\"stds\") == 1",
"assert count_occurance(\"\") == 0"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
222 |
def check_type(test_tuple):
return all(isinstance(item, type(test_tuple[0])) for item in test_tuple)
| Écrivez une fonction qui vérifie si tous les éléments d'un tuple ont le même type de données ou non. | Benchmark Questions Verification V2.ipynb | [] | [
"assert check_type((5, 6, 7, 3, 5, 6) ) == True",
"assert check_type((1, 2, \"4\") ) == False",
"assert check_type((3, 2, 1, 4, 5) ) == True"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
223 |
from bisect import bisect_left, bisect_right
def is_majority(arr, n, x):
if x not in arr:
return False
l = bisect_left(arr, x)
r = bisect_right(arr, x)
return r - l > n / 2
| Écrivez une fonction qui prend un tableau trié, sa longueur (n) et un élément, et qui renvoie si l'élément est l'élément majoritaire du tableau trié donné. (L'élément majoritaire est l'élément qui apparaît plus de n/2 fois.) | Benchmark Questions Verification V2.ipynb | [] | [
"assert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True",
"assert is_majority([1, 1, 2, 4, 4, 4, 6, 6], 8, 4) == False",
"assert is_majority([1, 1, 1, 2, 2], 5, 1) == True",
"assert is_majority([1, 1, 2, 2], 5, 1) == False"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
224 |
def count_Set_Bits(n):
return bin(n)[2:].count('1')
| Écrivez une fonction Python qui compte le nombre de bits à 1 (chiffres binaires ayant la valeur 1) dans un nombre donné. | Benchmark Questions Verification V2.ipynb | [] | [
"assert count_Set_Bits(2) == 1",
"assert count_Set_Bits(4) == 1",
"assert count_Set_Bits(6) == 2"
] | import numpy as np
from math import inf
def is_floats(x) -> bool:
# check if it is float; List[float]; Tuple[float]
if isinstance(x, float):
return True
if isinstance(x, (list, tuple)):
return all(isinstance(i, float) for i in x)
if isinstance(x, np.ndarray):
return x.dtype == n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.