dataset_name
string | data_id
int64 | src_lang
null | tgt_lang
string | task_name
string | doc_string
string | prefix
string | suffix
string | solution
string | demos
sequence | compare_func
string | test_cases
sequence | import_str
sequence | entry_func
string | type
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
MBPP_sanitized | 11 | null | python | code_generation | def remove_Occ(s, ch):
"""
Write a python function to remove first and last occurrence of a given character from the string.
"""
| def remove_Occ(s, ch):
"""
Write a python function to remove first and last occurrence of a given character from the string.
"""
for i in range(len(s)):
if s[i] == ch:
s = s[0:i] + s[i + 1:]
break
for i in range(len(s) - 1, -1, -1):
if s[i] == ch:
s = s[0:i] + s[i + 1:]
break
return s | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"hello\",\"l\"",
"\"heo\""
],
[
"\"abcda\",\"a\"",
"\"bcd\""
],
[
"\"PHP\",\"P\"",
"\"H\""
]
] | [] | remove_Occ | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": [
"str"
],
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"str"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 12 | null | python | code_generation | def sort_matrix(M):
"""
Write a function to sort a given matrix in ascending order according to the sum of its rows.
"""
| def sort_matrix(M):
"""
Write a function to sort a given matrix in ascending order according to the sum of its rows.
"""
result = sorted(M, key=sum)
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[[1, 2, 3], [2, 4, 5], [1, 1, 1]]",
"[[1, 1, 1], [1, 2, 3], [2, 4, 5]]"
],
[
"[[1, 2, 3], [-2, 4, -5], [1, -1, 1]]",
"[[-2, 4, -5], [1, -1, 1], [1, 2, 3]]"
],
[
"[[5,8,9],[6,4,3],[2,1,4]]",
"[[2, 1, 4], [6, 4, 3], [5, 8, 9]]"
]
] | [] | sort_matrix | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": [
"list"
],
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 14 | null | python | code_generation | def find_Volume(l, b, h):
"""
Write a python function to find the volume of a triangular prism.
"""
| def find_Volume(l, b, h):
"""
Write a python function to find the volume of a triangular prism.
"""
return l * b * h / 2 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10,8,6",
"240"
],
[
"3,2,2",
"6"
],
[
"1,2,1",
"1"
]
] | [] | find_Volume | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": [
"int"
],
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": [
"int"
],
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": [
"int"
],
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 16 | null | python | code_generation | import re
def text_lowercase_underscore(text):
"""
Write a function to that returns true if the input string contains sequences of lowercase letters joined with an underscore and false otherwise.
"""
| import re
def text_lowercase_underscore(text):
"""
Write a function to that returns true if the input string contains sequences of lowercase letters joined with an underscore and false otherwise.
"""
patterns = '^[a-z]+_[a-z]+$'
if re.search(patterns, text):
return True
else:
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"aab_cbbbc\"",
"(True)"
],
[
"\"aab_Abbbc\"",
"(False)"
],
[
"\"Aaab_abbbc\"",
"(False)"
]
] | [
"import re"
] | text_lowercase_underscore | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": [
"str"
],
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 17 | null | python | code_generation | def square_perimeter(a):
"""
Write a function that returns the perimeter of a square given its side length as input.
"""
| def square_perimeter(a):
"""
Write a function that returns the perimeter of a square given its side length as input.
"""
perimeter = 4 * a
return perimeter | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10",
"40"
],
[
"5",
"20"
],
[
"4",
"16"
]
] | [] | square_perimeter | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 18 | null | python | code_generation | NO_OF_CHARS = 256
def str_to_list(string):
temp = []
for x in string:
temp.append(x)
return temp
def lst_to_string(List):
return ''.join(List)
def get_char_count_array(string):
count = [0] * NO_OF_CHARS
for i in string:
count[ord(i)] += 1
return count
def remove_dirty_chars(string, second_string):
"""
Write a function to remove characters from the first string which are present in the second string.
"""
| NO_OF_CHARS = 256
def str_to_list(string):
temp = []
for x in string:
temp.append(x)
return temp
def lst_to_string(List):
return ''.join(List)
def get_char_count_array(string):
count = [0] * NO_OF_CHARS
for i in string:
count[ord(i)] += 1
return count
def remove_dirty_chars(string, second_string):
"""
Write a function to remove characters from the first string which are present in the second string.
"""
count = get_char_count_array(second_string)
ip_ind = 0
res_ind = 0
temp = ''
str_list = str_to_list(string)
while ip_ind != len(str_list):
temp = str_list[ip_ind]
if count[ord(temp)] == 0:
str_list[res_ind] = str_list[ip_ind]
res_ind += 1
ip_ind += 1
return lst_to_string(str_list[0:res_ind]) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"probasscurve\", \"pros\"",
"'bacuve'"
],
[
"\"digitalindia\", \"talent\"",
"'digiidi'"
],
[
"\"exoticmiles\", \"toxic\"",
"'emles'"
]
] | [] | remove_dirty_chars | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": [
"str"
],
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": [
"str"
],
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 19 | null | python | code_generation | def test_duplicate(arraynums):
"""
Write a function to find whether a given array of integers contains any duplicate element.
"""
| def test_duplicate(arraynums):
"""
Write a function to find whether a given array of integers contains any duplicate element.
"""
nums_set = set(arraynums)
return len(arraynums) != len(nums_set) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"([1,2,3,4,5])",
"False"
],
[
"([1,2,3,4, 4])",
"True"
],
[
"[1,1,2,2,3,3,4,4,5]",
"True"
]
] | [] | test_duplicate | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": [
"list"
],
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 20 | null | python | code_generation | def is_woodall(x):
"""
Write a function to check if the given number is woodball or not.
"""
| def is_woodall(x):
"""
Write a function to check if the given number is woodball or not.
"""
if x % 2 == 0:
return False
if x == 1:
return True
x = x + 1
p = 0
while x % 2 == 0:
x = x / 2
p = p + 1
if p == x:
return True
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"383",
"True"
],
[
"254",
"False"
],
[
"200",
"False"
]
] | [] | is_woodall | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": [
"int"
],
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 56 | null | python | code_generation | def rev(num):
rev_num = 0
while num > 0:
rev_num = rev_num * 10 + num % 10
num = num // 10
return rev_num
def check(n):
"""
Write a python function to check if a given number is one less than twice its reverse.
"""
| def rev(num):
rev_num = 0
while num > 0:
rev_num = rev_num * 10 + num % 10
num = num // 10
return rev_num
def check(n):
"""
Write a python function to check if a given number is one less than twice its reverse.
"""
return 2 * rev(n) == n + 1 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"70",
"False"
],
[
"23",
"False"
],
[
"73",
"True"
]
] | [] | check | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 57 | null | python | code_generation | def find_Max_Num(arr):
"""
Write a python function to find the largest number that can be formed with the given list of digits.
"""
| def find_Max_Num(arr):
"""
Write a python function to find the largest number that can be formed with the given list of digits.
"""
n = len(arr)
arr.sort(reverse=True)
num = arr[0]
for i in range(1, n):
num = num * 10 + arr[i]
return num | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1,2,3]",
"321"
],
[
"[4,5,6,1]",
"6541"
],
[
"[1,2,3,9]",
"9321"
]
] | [] | find_Max_Num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": [
"list"
],
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 58 | null | python | code_generation | def opposite_Signs(x, y):
"""
Write a python function to check whether the given two integers have opposite sign or not.
"""
| def opposite_Signs(x, y):
"""
Write a python function to check whether the given two integers have opposite sign or not.
"""
return x ^ y < 0 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"1,-2",
"True"
],
[
"3,2",
"False"
],
[
"-10,-10",
"False"
],
[
"-2,2",
"True"
]
] | [] | opposite_Signs | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": [
"int"
],
"xs": null,
"y": [
"int"
]
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 59 | null | python | code_generation | def is_octagonal(n):
"""
Write a function to find the nth octagonal number.
"""
| def is_octagonal(n):
"""
Write a function to find the nth octagonal number.
"""
return 3 * n * n - 2 * n | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"5",
"65"
],
[
"10",
"280"
],
[
"15",
"645"
]
] | [] | is_octagonal | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 61 | null | python | code_generation | from collections import defaultdict
def count_Substrings(s):
"""
Write a python function to count the number of substrings with the sum of digits equal to their length.
"""
| from collections import defaultdict
def count_Substrings(s):
"""
Write a python function to count the number of substrings with the sum of digits equal to their length.
"""
n = len(s)
(count, sum) = (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 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"'112112'",
"6"
],
[
"'111'",
"6"
],
[
"'1101112'",
"12"
]
] | [
"from collections import defaultdict"
] | count_Substrings | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"str"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 62 | null | python | code_generation | def smallest_num(xs):
"""
Write a python function to find smallest number in a list.
"""
| def smallest_num(xs):
"""
Write a python function to find smallest number in a list.
"""
return min(xs) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[10, 20, 1, 45, 99]",
"1"
],
[
"[1, 2, 3]",
"1"
],
[
"[45, 46, 50, 60]",
"45"
]
] | [] | smallest_num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": [
"list"
],
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 63 | null | python | code_generation | def max_difference(test_list):
"""
Write a function to find the maximum difference between available pairs in the given tuple list.
"""
| def max_difference(test_list):
"""
Write a function to find the maximum difference between available pairs in the given tuple list.
"""
temp = [abs(b - a) for (a, b) in test_list]
res = max(temp)
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[(3, 5), (1, 7), (10, 3), (1, 2)]",
"7"
],
[
"[(4, 6), (2, 17), (9, 13), (11, 12)]",
"15"
],
[
"[(12, 35), (21, 27), (13, 23), (41, 22)]",
"23"
]
] | [] | max_difference | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 64 | null | python | code_generation | def subject_marks(subjectmarks):
"""
Write a function to sort a list of tuples using the second value of each tuple.
"""
| def subject_marks(subjectmarks):
"""
Write a function to sort a list of tuples using the second value of each tuple.
"""
subjectmarks.sort(key=lambda x: x[1])
return subjectmarks | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]",
"[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]"
],
[
"[('Telugu',49),('Hindhi',54),('Social',33)]",
"([('Social',33),('Telugu',49),('Hindhi',54)])"
],
[
"[('Physics',96),('Chemistry',97),('Biology',45)]",
"([('Biology',45),('Physics',96),('Chemistry',97)])"
]
] | [] | subject_marks | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": [
"list"
],
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 65 | null | python | code_generation | def recursive_list_sum(data_list):
"""
Write a function to flatten a list and sum all of its elements.
"""
| def recursive_list_sum(data_list):
"""
Write a function to flatten a list and sum all of its elements.
"""
total = 0
for element in data_list:
if type(element) == type([]):
total = total + recursive_list_sum(element)
else:
total = total + element
return total | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"([1, 2, [3,4],[5,6]])",
"21"
],
[
"([7, 10, [15,14],[19,41]])",
"106"
],
[
"([10, 20, [30,40],[50,60]])",
"210"
]
] | [] | recursive_list_sum | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": [
"list"
],
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 66 | null | python | code_generation | def pos_count(list):
"""
Write a python function to count the number of positive numbers in a list.
"""
| def pos_count(list):
"""
Write a python function to count the number of positive numbers in a list.
"""
pos_count = 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1,-2,3,-4]",
"2"
],
[
"[3,4,5,-1]",
"3"
],
[
"[1,2,3,4]",
"4"
]
] | [] | pos_count | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": [
"list"
],
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 67 | null | python | code_generation | def bell_number(n):
"""
Write a function to find the number of ways to partition a set of Bell numbers.
"""
| def bell_number(n):
"""
Write a function to find the number of ways to partition a set of Bell numbers.
"""
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] | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"2",
"2"
],
[
"10",
"115975"
],
[
"56",
"6775685320645824322581483068371419745979053216268760300"
]
] | [] | bell_number | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 68 | null | python | code_generation | def is_Monotonic(A):
"""
Write a python function to check whether the given array is monotonic or not.
"""
| def is_Monotonic(A):
"""
Write a python function to check whether the given array is monotonic or not.
"""
return all((A[i] <= A[i + 1] for i in range(len(A) - 1))) or all((A[i] >= A[i + 1] for i in range(len(A) - 1))) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[6, 5, 4, 4]",
"True"
],
[
"[1, 2, 2, 3]",
"True"
],
[
"[1, 3, 2]",
"False"
]
] | [] | is_Monotonic | {
"input": {
"A": [
"list"
],
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 69 | null | python | code_generation | def is_sublist(l, s):
"""
Write a function to check whether a list contains the given sublist or not.
"""
| def is_sublist(l, s):
"""
Write a function to check whether a list contains the given sublist or not.
"""
sub_set = False
if s == []:
sub_set = True
elif s == l:
sub_set = True
elif len(s) > len(l):
sub_set = False
else:
for i in range(len(l)):
if l[i] == s[0]:
n = 1
while n < len(s) and l[i + n] == s[n]:
n += 1
if n == len(s):
sub_set = True
return sub_set | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[2,4,3,5,7],[3,7]",
"False"
],
[
"[2,4,3,5,7],[4,3]",
"True"
],
[
"[2,4,3,5,7],[1,6]",
"False"
]
] | [] | is_sublist | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": [
"list"
],
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"list"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 70 | null | python | code_generation | def find_equal_tuple(Input):
k = 0 if not Input else len(Input[0])
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
def get_equal(Input):
"""
Write a function to find whether all the given tuples have equal length or not.
"""
| def find_equal_tuple(Input):
k = 0 if not Input else len(Input[0])
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
def get_equal(Input):
"""
Write a function to find whether all the given tuples have equal length or not.
"""
return find_equal_tuple(Input) == 1 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[(11, 22, 33), (44, 55, 66)]",
"True"
],
[
"[(1, 2, 3), (4, 5, 6, 7)]",
"False"
],
[
"[(1, 2), (3, 4)]",
"True"
]
] | [] | get_equal | {
"input": {
"A": null,
"Input": [
"list"
],
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 71 | null | python | code_generation | def comb_sort(nums):
"""
Write a function to sort a list of elements.
"""
| def comb_sort(nums):
"""
Write a function to sort a list of elements.
"""
shrink_fact = 1.3
gaps = len(nums)
swapped = True
i = 0
while gaps > 1 or swapped:
gaps = int(float(gaps) / shrink_fact)
swapped = False
i = 0
while gaps + i < len(nums):
if nums[i] > nums[i + gaps]:
(nums[i], nums[i + gaps]) = (nums[i + gaps], nums[i])
swapped = True
i += 1
return nums | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[5, 15, 37, 25, 79]",
"[5, 15, 25, 37, 79]"
],
[
"[41, 32, 15, 19, 22]",
"[15, 19, 22, 32, 41]"
],
[
"[99, 15, 13, 47]",
"[13, 15, 47, 99]"
]
] | [] | comb_sort | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"list"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 72 | null | python | code_generation | def dif_Square(n):
"""
Write a python function to check whether the given number can be represented as the difference of two squares or not.
"""
| def dif_Square(n):
"""
Write a python function to check whether the given number can be represented as the difference of two squares or not.
"""
if n % 4 != 2:
return True
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"5",
"True"
],
[
"10",
"False"
],
[
"15",
"True"
]
] | [] | dif_Square | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 74 | null | python | code_generation | def is_samepatterns(colors, patterns):
"""
Write a function to check whether it follows the sequence given in the patterns array.
"""
| def is_samepatterns(colors, patterns):
"""
Write a function to check whether it follows the sequence given in the patterns array.
"""
if len(colors) != len(patterns):
return False
sdict = {}
pset = set()
sset = set()
for i in range(len(patterns)):
pset.add(patterns[i])
sset.add(colors[i])
if patterns[i] not in sdict.keys():
sdict[patterns[i]] = []
keys = sdict[patterns[i]]
keys.append(colors[i])
sdict[patterns[i]] = keys
if len(pset) != len(sset):
return False
for values in sdict.values():
for i in range(len(values) - 1):
if values[i] != values[i + 1]:
return False
return True | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"]",
"True"
],
[
"[\"red\",\"green\",\"greenn\"], [\"a\",\"b\",\"b\"]",
"False"
],
[
"[\"red\",\"green\",\"greenn\"], [\"a\",\"b\"]",
"False"
]
] | [] | is_samepatterns | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": [
"list"
],
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": [
"list"
],
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 75 | null | python | code_generation | def find_tuples(test_list, K):
"""
Write a function to find tuples which have all elements divisible by k from the given list of tuples.
"""
| def find_tuples(test_list, K):
"""
Write a function to find tuples which have all elements divisible by k from the given list of tuples.
"""
res = [sub for sub in test_list if all((ele % K == 0 for ele in sub))]
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6",
"[(6, 24, 12)]"
],
[
"[(5, 25, 30), (4, 2, 3), (7, 8, 9)], 5",
"[(5, 25, 30)]"
],
[
"[(7, 9, 16), (8, 16, 4), (19, 17, 18)], 4",
"[(8, 16, 4)]"
]
] | [] | find_tuples | {
"input": {
"A": null,
"Input": null,
"K": [
"int"
],
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 77 | null | python | code_generation | def is_Diff(n):
"""
Write a python function to find whether a number is divisible by 11.
"""
| def is_Diff(n):
"""
Write a python function to find whether a number is divisible by 11.
"""
return n % 11 == 0 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"1212112",
"True"
],
[
"1212",
"False"
]
] | [] | is_Diff | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 79 | null | python | code_generation | def word_len(s):
"""
Write a python function to check whether the length of the word is odd or not.
"""
| def word_len(s):
"""
Write a python function to check whether the length of the word is odd or not.
"""
s = s.split(' ')
for word in s:
if len(word) % 2 != 0:
return True
else:
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"Hadoop\"",
"False"
],
[
"\"great\"",
"True"
],
[
"\"structure\"",
"True"
]
] | [] | word_len | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"str"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 80 | null | python | code_generation | def tetrahedral_number(n):
"""
Write a function to find the nth tetrahedral number.
"""
| def tetrahedral_number(n):
"""
Write a function to find the nth tetrahedral number.
"""
return n * (n + 1) * (n + 2) / 6 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"5",
"35"
],
[
"6",
"56"
],
[
"7",
"84"
]
] | [] | tetrahedral_number | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 82 | null | python | code_generation | import math
def volume_sphere(r):
"""
Write a function to find the volume of a sphere.
"""
| import math
def volume_sphere(r):
"""
Write a function to find the volume of a sphere.
"""
volume = 4 / 3 * math.pi * r * r * r
return volume | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"10",
"4188.790204786391"
],
[
"25",
"65449.84694978735"
],
[
"20",
"33510.32163829113"
]
] | [
"import math"
] | volume_sphere | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": [
"int"
],
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 83 | null | python | code_generation | def get_Char(strr):
"""
Write a python function to find the character made by adding the ASCII value of all the characters of the given string modulo 26.
"""
| def get_Char(strr):
"""
Write a python function to find the character made by adding the ASCII value of all the characters of the given string modulo 26.
"""
summ = 0
for i in range(len(strr)):
summ += ord(strr[i]) - ord('a') + 1
if summ % 26 == 0:
return ord('z')
else:
summ = summ % 26
return chr(ord('a') + summ - 1) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"abc\"",
"\"f\""
],
[
"\"gfg\"",
"\"t\""
],
[
"\"ab\"",
"\"c\""
]
] | [] | get_Char | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": [
"str"
],
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 84 | null | python | code_generation | def sequence(n):
"""
Write a function to find the nth number in the newman conway sequence.
"""
| def sequence(n):
"""
Write a function to find the nth number in the newman conway sequence.
"""
if n == 1 or n == 2:
return 1
else:
return sequence(sequence(n - 1)) + sequence(n - sequence(n - 1)) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10",
"6"
],
[
"2",
"1"
],
[
"3",
"2"
]
] | [] | sequence | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 85 | null | python | code_generation | import math
def surfacearea_sphere(r):
"""
Write a function to find the surface area of a sphere.
"""
| import math
def surfacearea_sphere(r):
"""
Write a function to find the surface area of a sphere.
"""
surfacearea = 4 * math.pi * r * r
return surfacearea | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"10",
"1256.6370614359173"
],
[
"15",
"2827.4333882308138"
],
[
"20",
"5026.548245743669"
]
] | [
"import math"
] | surfacearea_sphere | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": [
"int"
],
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 86 | null | python | code_generation | def centered_hexagonal_number(n):
"""
Write a function to find nth centered hexagonal number.
"""
| def centered_hexagonal_number(n):
"""
Write a function to find nth centered hexagonal number.
"""
return 3 * n * (n - 1) + 1 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10",
"271"
],
[
"2",
"7"
],
[
"9",
"217"
]
] | [] | centered_hexagonal_number | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 87 | null | python | code_generation | import collections as ct
def merge_dictionaries_three(dict1, dict2, dict3):
"""
Write a function to merge three dictionaries into a single dictionary.
"""
| import collections as ct
def merge_dictionaries_three(dict1, dict2, dict3):
"""
Write a function to merge three dictionaries into a single dictionary.
"""
merged_dict = dict(ct.ChainMap({}, dict1, dict2, dict3))
return merged_dict | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"{ \"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'}"
],
[
"{ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{\"L\":\"lavender\",\"B\":\"Blue\"}",
"{'W': 'White', 'P': 'Pink', 'B': 'Black', 'R': 'Red', 'G': 'Green', 'L': 'lavender'}"
],
[
"{ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" },{\"L\":\"lavender\",\"B\":\"Blue\"},{ \"G\": \"Green\", \"W\": \"White\" }",
"{'B': 'Black', 'P': 'Pink', 'R': 'Red', 'G': 'Green', 'L': 'lavender', 'W': 'White'}"
]
] | [
"import collections as ct"
] | merge_dictionaries_three | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": [
"dict"
],
"dict2": [
"dict"
],
"dict3": [
"dict"
],
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"dict"
]
} |
||
MBPP_sanitized | 88 | null | python | code_generation | import collections
def freq_count(list1):
"""
Write a function to get the frequency of all the elements in a list, returned as a dictionary.
"""
| import collections
def freq_count(list1):
"""
Write a function to get the frequency of all the elements in a list, returned as a dictionary.
"""
freq_count = collections.Counter(list1)
return freq_count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[10,10,10,10,20,20,20,20,40,40,50,50,30]",
"({10: 4, 20: 4, 40: 2, 50: 2, 30: 1})"
],
[
"[1,2,3,4,3,2,4,1,3,1,4]",
"({1:3, 2:2,3:3,4:3})"
],
[
"[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 collections"
] | freq_count | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"dict"
]
} |
||
MBPP_sanitized | 89 | null | python | code_generation | def closest_num(N):
"""
Write a function to find the closest smaller number than n.
"""
| def closest_num(N):
"""
Write a function to find the closest smaller number than n.
"""
return N - 1 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"11",
"10"
],
[
"7",
"6"
],
[
"12",
"11"
]
] | [] | closest_num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": [
"int"
],
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 90 | null | python | code_generation | def len_log(list1):
"""
Write a python function to find the length of the longest word.
"""
| def len_log(list1):
"""
Write a python function to find the length of the longest word.
"""
max = len(list1[0])
for i in list1:
if len(i) > max:
max = len(i)
return max | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[\"python\",\"PHP\",\"bigdata\"]",
"7"
],
[
"[\"a\",\"ab\",\"abc\"]",
"3"
],
[
"[\"small\",\"big\",\"tall\"]",
"5"
]
] | [] | len_log | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 91 | null | python | code_generation | def find_substring(str1, sub_str):
"""
Write a function to check if a string is present as a substring in a given list of string values.
"""
| def find_substring(str1, sub_str):
"""
Write a function to check if a string is present as a substring in a given list of string values.
"""
if any((sub_str in s for s in str1)):
return True
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\"",
"True"
],
[
"[\"red\", \"black\", \"white\", \"green\", \"orange\"],\"abc\"",
"False"
],
[
"[\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ange\"",
"True"
]
] | [] | find_substring | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": [
"list"
],
"string": null,
"stringlist": null,
"strr": null,
"sub_str": [
"str"
],
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 92 | null | python | code_generation | def is_undulating(n):
"""
Write a function to check whether the given number is undulating or not.
"""
| def is_undulating(n):
"""
Write a function to check whether the given number is undulating or not.
"""
n = str(n)
if len(n) <= 2:
return False
for i in range(2, len(n)):
if n[i - 2] != n[i]:
return False
return True | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"1212121",
"True"
],
[
"1991",
"False"
],
[
"121",
"True"
]
] | [] | is_undulating | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 93 | null | python | code_generation | def power(a, b):
"""
Write a function to calculate the value of 'a' to the power 'b'.
"""
| def power(a, b):
"""
Write a function to calculate the value of 'a' to the power 'b'.
"""
if b == 0:
return 1
elif a == 0:
return 0
elif b == 1:
return a
else:
return a * power(a, b - 1) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"3,4",
"81"
],
[
"2,3",
"8"
],
[
"5,5",
"3125"
]
] | [] | power | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": [
"int"
],
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 94 | null | python | code_generation | from operator import itemgetter
def index_minimum(test_list):
"""
Given a list of tuples, write a function that returns the first value of the tuple with the smallest second value.
"""
| from operator import itemgetter
def index_minimum(test_list):
"""
Given a list of tuples, write a function that returns the first value of the tuple with the smallest second value.
"""
res = min(test_list, key=itemgetter(1))[0]
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]",
"'Varsha'"
],
[
"[('Yash', 185), ('Dawood', 125), ('Sanya', 175)]",
"'Dawood'"
],
[
"[('Sai', 345), ('Salman', 145), ('Ayesha', 96)]",
"'Ayesha'"
]
] | [
"from operator import itemgetter "
] | index_minimum | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 95 | null | python | code_generation | def Find_Min_Length(lst):
"""
Write a python function to find the length of the smallest list in a list of lists.
"""
| def Find_Min_Length(lst):
"""
Write a python function to find the length of the smallest list in a list of lists.
"""
minLength = min((len(x) for x in lst))
return minLength | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[[1],[1,2]]",
"1"
],
[
"[[1,2],[1,2,3],[1,2,3,4]]",
"2"
],
[
"[[3,3,3],[4,4,4,4]]",
"3"
]
] | [] | Find_Min_Length | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": [
"list"
],
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 96 | null | python | code_generation | def divisor(n):
"""
Write a python function to find the number of divisors of a given integer.
"""
| def divisor(n):
"""
Write a python function to find the number of divisors of a given integer.
"""
for i in range(n):
x = len([i for i in range(1, n + 1) if not n % i])
return x | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"15",
"4"
],
[
"12",
"6"
],
[
"9",
"3"
]
] | [] | divisor | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 97 | null | python | code_generation | def frequency_lists(list1):
"""
Write a function to find frequency of each element in a flattened list of lists, returned in a dictionary.
"""
| def frequency_lists(list1):
"""
Write a function to find frequency of each element in a flattened list of lists, returned in a dictionary.
"""
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[[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}"
],
[
"[[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}"
],
[
"[[20,30,40,17],[18,16,14,13],[10,20,30,40]]",
"{20:2,30:2,40:2,17: 1,18:1, 16: 1,14: 1,13: 1, 10: 1}"
]
] | [] | frequency_lists | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"dict"
]
} |
||
MBPP_sanitized | 98 | null | python | code_generation | def multiply_num(numbers):
"""
Write a function to multiply all the numbers in a list and divide with the length of the list.
"""
| def multiply_num(numbers):
"""
Write a function to multiply all the numbers in a list and divide with the length of the list.
"""
total = 1
for x in numbers:
total *= x
return total / len(numbers) | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"(8, 2, 3, -1, 7)",
"-67.2"
],
[
"(-10,-20,-30)",
"-2000.0"
],
[
"(19,15,18)",
"1710.0"
]
] | [] | multiply_num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": [
"int"
],
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 99 | null | python | code_generation | def decimal_to_binary(n):
"""
Write a function to convert the given decimal number to its binary equivalent, represented as a string with no leading zeros.
"""
| def decimal_to_binary(n):
"""
Write a function to convert the given decimal number to its binary equivalent, represented as a string with no leading zeros.
"""
return bin(n).replace('0b', '') | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"8",
"'1000'"
],
[
"18",
"'10010'"
],
[
"7",
"'111'"
]
] | [] | decimal_to_binary | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 100 | null | python | code_generation | import sys
def next_smallest_palindrome(num):
"""
Write a function to find the next smallest palindrome of a specified integer, returned as an integer.
"""
| import sys
def next_smallest_palindrome(num):
"""
Write a function to find the next smallest palindrome of a specified integer, returned as an integer.
"""
numstr = str(num)
for i in range(num + 1, sys.maxsize):
if str(i) == str(i)[::-1]:
return i | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"99",
"101"
],
[
"1221",
"1331"
],
[
"120",
"121"
]
] | [
"import sys"
] | next_smallest_palindrome | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": [
"int"
],
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 101 | null | python | code_generation | def kth_element(arr, k):
"""
Write a function to find the kth element in the given array using 1-based indexing.
"""
| def kth_element(arr, k):
"""
Write a function to find the kth element in the given array using 1-based indexing.
"""
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
(arr[j], arr[j + 1] == arr[j + 1], arr[j])
return arr[k - 1] | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[12,3,5,7,19], 2",
"3"
],
[
"[17,24,8,23], 3",
"8"
],
[
"[16,21,25,36,4], 4",
"36"
]
] | [] | kth_element | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": [
"list"
],
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": [
"int"
],
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 102 | null | python | code_generation | def snake_to_camel(word):
"""
Write a function to convert a snake case string to camel case string.
"""
| def snake_to_camel(word):
"""
Write a function to convert a snake case string to camel case string.
"""
import re
return ''.join((x.capitalize() or '_' for x in word.split('_'))) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"'python_program'",
"'PythonProgram'"
],
[
"'python_language'",
"('PythonLanguage')"
],
[
"'programming_language'",
"('ProgrammingLanguage')"
]
] | [
"import re"
] | snake_to_camel | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": [
"str"
],
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 103 | null | python | code_generation | def eulerian_num(n, m):
"""
Write a function to find the Eulerian number a(n, m).
"""
| def eulerian_num(n, m):
"""
Write a function to find the Eulerian number a(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) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"3, 1",
"4"
],
[
"4, 1",
"11"
],
[
"5, 3",
"26"
]
] | [] | eulerian_num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": [
"int"
],
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 104 | null | python | code_generation | def sort_sublists(input_list):
"""
Write a function to sort each sublist of strings in a given list of lists.
"""
| def sort_sublists(input_list):
"""
Write a function to sort each sublist of strings in a given list of lists.
"""
result = [sorted(x, key=lambda x: x[0]) for x in input_list]
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"])",
"[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]"
],
[
"([\" red \",\"green\" ],[\"blue \",\" black\"],[\" orange\",\"brown\"])",
"[[' red ', 'green'], [' black', 'blue '], [' orange', 'brown']]"
],
[
"([\"zilver\",\"gold\"], [\"magnesium\",\"aluminium\"], [\"steel\", \"bronze\"])",
"[['gold', 'zilver'],['aluminium', 'magnesium'], ['bronze', 'steel']]"
]
] | [] | sort_sublists | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": [
"list"
],
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 105 | null | python | code_generation | def count(lst):
"""
Write a python function to count true booleans in the given list.
"""
| def count(lst):
"""
Write a python function to count true booleans in the given list.
"""
return sum(lst) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[True,False,True]",
"2"
],
[
"[False,False]",
"0"
],
[
"[True,True,True]",
"3"
]
] | [] | count | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": [
"list"
],
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 106 | null | python | code_generation | def add_lists(test_list, test_tup):
"""
Write a function to append the given list to the given tuples.
"""
| def add_lists(test_list, test_tup):
"""
Write a function to append the given list to the given tuples.
"""
res = tuple(list(test_tup) + test_list)
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[5, 6, 7], (9, 10)",
"(9, 10, 5, 6, 7)"
],
[
"[6, 7, 8], (10, 11)",
"(10, 11, 6, 7, 8)"
],
[
"[7, 8, 9], (11, 12)",
"(11, 12, 7, 8, 9)"
]
] | [] | add_lists | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": [
"tuple"
],
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"tuple"
]
} |
||
MBPP_sanitized | 108 | null | python | code_generation | import heapq
def merge_sorted_list(num1, num2, num3):
"""
Write a function to merge three lists into a single sorted list.
"""
| import heapq
def merge_sorted_list(num1, num2, num3):
"""
Write a function to merge three lists into a single sorted list.
"""
num1 = sorted(num1)
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(num1, num2, num3)
return list(result) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[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]"
],
[
"[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]"
],
[
"[18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1],[25, 35, 22, 85, 14, 65, 75, 25, 58],[12, 74, 9, 50, 61, 41]",
"[1, 2, 3, 4, 7, 8, 9, 9, 9, 10, 12, 14, 14, 18, 22, 25, 25, 35, 41, 50, 58, 61, 65, 74, 75, 85]"
]
] | [
"import heapq"
] | merge_sorted_list | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": [
"list"
],
"num2": [
"list"
],
"num3": [
"list"
],
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 109 | null | python | code_generation | def odd_Equivalent(s, n):
"""
Write a python function to find the number of numbers with an odd value when rotating a binary string the given number of times.
"""
| def odd_Equivalent(s, n):
"""
Write a python function to find the number of numbers with an odd value when rotating a binary string the given number of times.
"""
count = 0
for i in range(0, n):
if s[i] == '1':
count = count + 1
return count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"011001\",6",
"3"
],
[
"\"11011\",5",
"4"
],
[
"\"1010\",4",
"2"
]
] | [] | odd_Equivalent | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"str"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 111 | null | python | code_generation | def common_in_nested_lists(nestedlist):
"""
Write a function to find the common elements in given nested lists.
"""
| def common_in_nested_lists(nestedlist):
"""
Write a function to find the common elements in given nested lists.
"""
result = list(set.intersection(*map(set, nestedlist)))
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]]",
"[18, 12]"
],
[
"[[12, 5, 23, 25, 45], [7, 11, 5, 23, 28], [1, 5, 8, 18, 23, 16]]",
"[5,23]"
],
[
"[[2, 3,4, 1], [4, 5], [6,4, 8],[4, 5], [6, 8,4]]",
"[4]"
]
] | [] | common_in_nested_lists | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": [
"list"
],
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"set"
]
} |
||
MBPP_sanitized | 113 | null | python | code_generation | def check_integer(text):
"""
Write a function to check if a string represents an integer or not.
"""
| def check_integer(text):
"""
Write a function to check if a string represents an integer or not.
"""
text = text.strip()
if len(text) < 1:
return None
elif all((text[i] in '0123456789' for i in range(len(text)))):
return True
elif text[0] in '+-' and all((text[i] in '0123456789' for i in range(1, len(text)))):
return True
else:
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"python\"",
"False"
],
[
"\"1\"",
"True"
],
[
"\"12345\"",
"True"
]
] | [] | check_integer | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": [
"str"
],
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 115 | null | python | code_generation | def empty_dit(list1):
"""
Write a function to check whether all dictionaries in a list are empty or not.
"""
| def empty_dit(list1):
"""
Write a function to check whether all dictionaries in a list are empty or not.
"""
empty_dit = all((not d for d in list1))
return empty_dit | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[{},{},{}]",
"True"
],
[
"[{1,2},{},{}]",
"False"
],
[
"{}",
"True"
]
] | [] | empty_dit | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 116 | null | python | code_generation | def tuple_to_int(nums):
"""
Write a function to convert a given tuple of positive integers into a single integer.
"""
| def tuple_to_int(nums):
"""
Write a function to convert a given tuple of positive integers into a single integer.
"""
result = int(''.join(map(str, nums)))
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"(1,2,3)",
"123"
],
[
"(4,5,6)",
"456"
],
[
"(5,6,7)",
"567"
]
] | [] | tuple_to_int | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"int"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 117 | null | python | code_generation | def list_to_float(test_list):
"""
Write a function to convert all possible convertible elements in a list of lists to floats.
"""
| def list_to_float(test_list):
"""
Write a function to convert all possible convertible elements in a list of lists to floats.
"""
res = []
for tup in test_list:
temp = []
for ele in tup:
if ele.isalpha():
temp.append(ele)
else:
temp.append(float(ele))
res.append((temp[0], temp[1]))
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
" [(\"3\", \"4\"), (\"1\", \"26.45\"), (\"7.32\", \"8\"), (\"4\", \"8\")] ",
"[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]"
],
[
" [(\"4\", \"4\"), (\"2\", \"27\"), (\"4.12\", \"9\"), (\"7\", \"11\")] ",
"[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]"
],
[
" [(\"6\", \"78\"), (\"5\", \"26.45\"), (\"1.33\", \"4\"), (\"82\", \"13\")] ",
"[(6.0, 78.0), (5.0, 26.45), (1.33, 4.0), (82.0, 13.0)]"
]
] | [] | list_to_float | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 118 | null | python | code_generation | def string_to_list(string):
"""
Write a function to convert a string to a list of strings split on the space character.
"""
| def string_to_list(string):
"""
Write a function to convert a string to a list of strings split on the space character.
"""
lst = list(string.split(' '))
return lst | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"python programming\"",
"['python','programming']"
],
[
"\"lists tuples strings\"",
"['lists','tuples','strings']"
],
[
"\"write a program\"",
"['write','a','program']"
]
] | [] | string_to_list | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": [
"str"
],
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 119 | null | python | code_generation | def search(arr):
"""
Write a python function to find the element that appears only once in a sorted array.
"""
| def search(arr):
"""
Write a python function to find the element that appears only once in a sorted array.
"""
n = len(arr)
XOR = 0
for i in range(n):
XOR = XOR ^ arr[i]
return XOR | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1,1,2,2,3]",
"3"
],
[
"[1,1,3,3,4,4,5,5,7,7,8]",
"8"
],
[
"[1,2,2,3,3,4,4]",
"1"
]
] | [] | search | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": [
"list"
],
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 120 | null | python | code_generation | def max_product_tuple(list1):
"""
Write a function to find the maximum absolute product between numbers in pairs of tuples within a given list.
"""
| def max_product_tuple(list1):
"""
Write a function to find the maximum absolute product between numbers in pairs of tuples within a given list.
"""
result_max = max([abs(x * y) for (x, y) in list1])
return result_max | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[(2, 7), (2, 6), (1, 8), (4, 9)] ",
"36"
],
[
"[(10,20), (15,2), (5,10)] ",
"200"
],
[
"[(11,44), (10,15), (20,5), (12, 9)] ",
"484"
]
] | [] | max_product_tuple | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 123 | null | python | code_generation | def amicable_numbers_sum(limit):
"""
Write a function to sum all amicable numbers from 1 to a specified number.
"""
| def amicable_numbers_sum(limit):
"""
Write a function to sum all amicable numbers from 1 to a specified number.
"""
if not isinstance(limit, int):
return 'Input is not an integer!'
if limit < 1:
return 'Input must be bigger than 0!'
amicables = set()
for num in range(2, limit + 1):
if num in amicables:
continue
sum_fact = sum([fact for fact in range(1, num) if num % fact == 0])
sum_fact2 = sum([fact for fact in range(1, sum_fact) if sum_fact % fact == 0])
if num == sum_fact2 and num != sum_fact:
amicables.add(num)
amicables.add(sum_fact2)
return sum(amicables) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"999",
"504"
],
[
"9999",
"31626"
],
[
"99",
"0"
]
] | [] | amicable_numbers_sum | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": [
"int"
],
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 124 | null | python | code_generation | import cmath
def angle_complex(a, b):
"""
Write a function to get the angle of a complex number.
"""
| import cmath
def angle_complex(a, b):
"""
Write a function to get the angle of a complex number.
"""
cn = complex(a, b)
angle = cmath.phase(a + b)
return angle | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"0,1j",
"1.5707963267948966"
],
[
"2,1j",
"0.4636476090008061"
],
[
"0,2j",
"1.5707963267948966"
]
] | [
"import cmath"
] | angle_complex | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": [
"complex"
],
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 125 | null | python | code_generation | def find_length(string):
"""
Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.
"""
| def find_length(string):
"""
Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.
"""
n = len(string)
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += 1 if string[i] == '0' else -1
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"11000010001\"",
"6"
],
[
"\"10111\"",
"1"
],
[
"\"11011101100101\"",
"2"
]
] | [] | find_length | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": [
"str"
],
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 126 | null | python | code_generation | def sum(a, b):
"""
Write a python function to find the sum of common divisors of two given numbers.
"""
| def sum(a, b):
"""
Write a python function to find the sum of common divisors of two given numbers.
"""
sum = 0
for i in range(1, min(a, b)):
if a % i == 0 and b % i == 0:
sum += i
return sum | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10,15",
"6"
],
[
"100,150",
"93"
],
[
"4,6",
"3"
]
] | [] | sum | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": [
"int"
],
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 127 | null | python | code_generation | def multiply_int(x, y):
"""
Write a function to multiply two integers.
"""
| def multiply_int(x, y):
"""
Write a function to multiply two integers.
"""
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10,20",
"200"
],
[
"5,10",
"50"
],
[
"4,8",
"32"
]
] | [] | multiply_int | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": [
"int"
],
"xs": null,
"y": [
"int"
]
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 128 | null | python | code_generation | def long_words(n, str):
"""
Write a function to find words that are longer than n characters from a given list of words.
"""
| def long_words(n, str):
"""
Write a function to find words that are longer than n characters from a given list of words.
"""
word_len = []
txt = str.split(' ')
for x in txt:
if len(x) > n:
word_len.append(x)
return word_len | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"3,\"python is a programming language\"",
"['python','programming','language']"
],
[
"2,\"writing a program\"",
"['writing','program']"
],
[
"5,\"sorting list\"",
"['sorting']"
]
] | [] | long_words | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": [
"str"
],
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 129 | null | python | code_generation | def magic_square_test(my_matrix):
"""
Write a function to calculate whether the matrix is a magic square.
"""
| def magic_square_test(my_matrix):
"""
Write a function to calculate whether the matrix is a magic square.
"""
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum((row[col] for row in my_matrix)))
result1 = 0
for i in range(0, iSize):
result1 += my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize - 1, -1, -1):
result2 += my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]]",
"True"
],
[
"[[2, 7, 6], [9, 5, 1], [4, 3, 8]]",
"True"
],
[
"[[2, 7, 6], [9, 5, 1], [4, 3, 7]]",
"False"
]
] | [] | magic_square_test | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": [
"list"
],
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 130 | null | python | code_generation | from collections import defaultdict
def max_occurrences(nums):
"""
Write a function to find the item with maximum frequency in a given list.
"""
| from collections import defaultdict
def max_occurrences(nums):
"""
Write a function to find the item with maximum frequency in a given list.
"""
dict = defaultdict(int)
for i in nums:
dict[i] += 1
result = max(dict.items(), key=lambda x: x[1])
return result[0] | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2]",
"2"
],
[
"[2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,18]",
"8"
],
[
"[10,20,20,30,40,90,80,50,30,20,50,10]",
"20"
]
] | [
"from collections import defaultdict"
] | max_occurrences | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"list"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 131 | null | python | code_generation | def reverse_vowels(str1):
"""
Write a python function to reverse only the vowels of a given string (where y is not a vowel).
"""
| def reverse_vowels(str1):
"""
Write a python function to reverse only the vowels of a given string (where y is not a vowel).
"""
vowels = ''
for char in str1:
if char in 'aeiouAEIOU':
vowels += char
result_string = ''
for char in str1:
if char in 'aeiouAEIOU':
result_string += vowels[-1]
vowels = vowels[:-1]
else:
result_string += char
return result_string | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"Python\"",
"\"Python\""
],
[
"\"USA\"",
"\"ASU\""
],
[
"\"ab\"",
"\"ab\""
]
] | [] | reverse_vowels | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": [
"str"
],
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 132 | null | python | code_generation | def tup_string(tup1):
"""
Write a function to convert a tuple to a string.
"""
| def tup_string(tup1):
"""
Write a function to convert a tuple to a string.
"""
str = ''.join(tup1)
return str | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's')",
"(\"exercises\")"
],
[
"('p','y','t','h','o','n')",
"(\"python\")"
],
[
"('p','r','o','g','r','a','m')",
"(\"program\")"
]
] | [] | tup_string | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": [
"str"
],
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
||
MBPP_sanitized | 133 | null | python | code_generation | def sum_negativenum(nums):
"""
Write a function to calculate the sum of the negative numbers of a given list of numbers.
"""
| def sum_negativenum(nums):
"""
Write a function to calculate the sum of the negative numbers of a given list of numbers.
"""
sum_negativenum = list(filter(lambda nums: nums < 0, nums))
return sum(sum_negativenum) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[2, 4, -6, -9, 11, -12, 14, -5, 17]",
"-32"
],
[
"[10,15,-14,13,-18,12,-20]",
"-52"
],
[
"[19, -65, 57, 39, 152,-639, 121, 44, 90, -190]",
"-894"
]
] | [] | sum_negativenum | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"list"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 135 | null | python | code_generation | def hexagonal_num(n):
"""
Write a function to find the nth hexagonal number.
"""
| def hexagonal_num(n):
"""
Write a function to find the nth hexagonal number.
"""
return n * (2 * n - 1) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10",
"190"
],
[
"5",
"45"
],
[
"7",
"91"
]
] | [] | hexagonal_num | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 137 | null | python | code_generation | from array import array
def zero_count(nums):
"""
Write a function to find the ratio of zeroes to non-zeroes in an array of integers.
"""
| from array import array
def zero_count(nums):
"""
Write a function to find the ratio of zeroes to non-zeroes in an array of integers.
"""
n = len(nums)
n1 = 0
for x in nums:
if x == 0:
n1 += 1
else:
None
return n1 / (n - n1) | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"[0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8]",
"0.181818"
],
[
"[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8]",
"0.00"
],
[
"[2, 4, -6, -9, 11, -12, 14, -5, 17]",
"0.00"
]
] | [
"from array import array"
] | zero_count | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"list"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 138 | null | python | code_generation | def is_Sum_Of_Powers_Of_Two(n):
"""
Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.
"""
| def is_Sum_Of_Powers_Of_Two(n):
"""
Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.
"""
if n % 2 == 1:
return False
else:
return True | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"10",
"True"
],
[
"7",
"False"
],
[
"14",
"True"
]
] | [] | is_Sum_Of_Powers_Of_Two | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 139 | null | python | code_generation | def circle_circumference(r):
"""
Write a function to find the circumference of a circle.
"""
| def circle_circumference(r):
"""
Write a function to find the circumference of a circle.
"""
perimeter = 2 * 3.1415 * r
return perimeter | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"10",
"62.830000000000005"
],
[
"5",
"31.415000000000003"
],
[
"4",
"25.132"
]
] | [] | circle_circumference | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": [
"int"
],
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 140 | null | python | code_generation | def extract_singly(test_list):
"""
Write a function to flatten the list of lists into a single set of numbers.
"""
| def extract_singly(test_list):
"""
Write a function to flatten the list of lists into a single set of numbers.
"""
res = []
temp = set()
for inner in test_list:
for ele in inner:
if not ele in temp:
temp.add(ele)
res.append(ele)
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[(3, 4, 5), (4, 5, 7), (1, 4)]",
"[3, 4, 5, 7, 1]"
],
[
"[(1, 2, 3), (4, 2, 3), (7, 8)]",
"[1, 2, 3, 4, 7, 8]"
],
[
"[(7, 8, 9), (10, 11, 12), (10, 11)]",
"[7, 8, 9, 10, 11, 12]"
]
] | [] | extract_singly | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": [
"list"
],
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"set"
]
} |
||
MBPP_sanitized | 141 | null | python | code_generation | def pancake_sort(nums):
"""
Write a function to sort a list of elements.
"""
| def pancake_sort(nums):
"""
Write a function to sort a list of elements.
"""
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 | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[15, 79, 25, 38, 69]",
"[15, 25, 38, 69, 79]"
],
[
"[98, 12, 54, 36, 85]",
"[12, 36, 54, 85, 98]"
],
[
"[41, 42, 32, 12, 23]",
"[12, 23, 32, 41, 42]"
]
] | [] | pancake_sort | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": [
"list"
],
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 142 | null | python | code_generation | def count_samepair(list1, list2, list3):
"""
Write a function to count number items that are identical in the same position of three given lists.
"""
| def count_samepair(list1, list2, list3):
"""
Write a function to count number items that are identical in the same position of three given lists.
"""
result = sum((m == n == o for (m, n, o) in zip(list1, list2, list3)))
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[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"
],
[
"[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"
],
[
"[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"
]
] | [] | count_samepair | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": [
"list"
],
"list3": [
"list"
],
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 143 | null | python | code_generation | def find_lists(Input):
"""
Write a function to find number of lists present in the given tuple.
"""
| def find_lists(Input):
"""
Write a function to find number of lists present in the given tuple.
"""
if isinstance(Input, list):
return 1
else:
return len(Input) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"([1, 2, 3, 4], [5, 6, 7, 8])",
"2"
],
[
"([1, 2], [3, 4], [5, 6])",
"3"
],
[
"([9, 8, 7, 6, 5, 4, 3, 2, 1])",
"1"
]
] | [] | find_lists | {
"input": {
"A": null,
"Input": [
"list"
],
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 145 | null | python | code_generation | def max_Abs_Diff(arr):
"""
Write a python function to find the maximum difference between any two elements in a given array.
"""
| def max_Abs_Diff(arr):
"""
Write a python function to find the maximum difference between any two elements in a given array.
"""
n = len(arr)
minEle = arr[0]
maxEle = arr[0]
for i in range(1, n):
minEle = min(minEle, arr[i])
maxEle = max(maxEle, arr[i])
return maxEle - minEle | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"(2,1,5,3)",
"4"
],
[
"(9,3,2,5,1)",
"8"
],
[
"(3,2,1)",
"2"
]
] | [] | max_Abs_Diff | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": [
"int"
],
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 160 | null | python | code_generation | def find_solution(a, b, n):
"""
Write a function that returns integers x and y that satisfy ax + by = n as a tuple, or return None if no solution exists.
"""
| def find_solution(a, b, n):
"""
Write a function that returns integers x and y that satisfy ax + by = n as a tuple, or return None if no solution exists.
"""
i = 0
while i * a <= n:
if (n - i * a) % b == 0:
return (i, (n - i * a) // b)
i = i + 1
return None | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"2, 3, 7",
"(2, 1)"
],
[
"4, 2, 7",
null
],
[
"1, 13, 17",
"(4, 1)"
]
] | [] | find_solution | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": [
"int"
],
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"tuple"
]
} |
||
MBPP_sanitized | 161 | null | python | code_generation | def remove_elements(list1, list2):
"""
Write a function to remove all elements from a given list present in another list.
"""
| def remove_elements(list1, list2):
"""
Write a function to remove all elements from a given list present in another list.
"""
result = [x for x in list1 if x not in list2]
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 4, 6, 8]",
"[1, 3, 5, 7, 9, 10]"
],
[
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 3, 5, 7]",
"[2, 4, 6, 8, 9, 10]"
],
[
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [5, 7]",
"[1, 2, 3, 4, 6, 8, 9, 10]"
]
] | [] | remove_elements | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": [
"list"
],
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"list"
]
} |
||
MBPP_sanitized | 162 | null | python | code_generation | def sum_series(n):
"""
Write a function to calculate the sum (n - 2*i) from i=0 to n // 2, for instance n + (n-2) + (n-4)... (until n-x =< 0).
"""
| def sum_series(n):
"""
Write a function to calculate the sum (n - 2*i) from i=0 to n // 2, for instance n + (n-2) + (n-4)... (until n-x =< 0).
"""
if n < 1:
return 0
else:
return n + sum_series(n - 2) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"6",
"12"
],
[
"10",
"30"
],
[
"9",
"25"
]
] | [] | sum_series | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 163 | null | python | code_generation | from math import tan, pi
def area_polygon(s, l):
"""
Write a function to calculate the area of a regular polygon given the length and number of its sides.
"""
| from math import tan, pi
def area_polygon(s, l):
"""
Write a function to calculate the area of a regular polygon given the length and number of its sides.
"""
area = s * l ** 2 / (4 * tan(pi / s))
return area | [] | import math
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assert math.isclose(candidate(*inp), exp, rel_tol=0.001) | [
[
"4, 20",
"400."
],
[
"10, 15",
"1731.197"
],
[
"9, 7",
"302.909"
]
] | [
"from math import tan, pi"
] | area_polygon | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": [
"int"
],
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"int"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"float"
]
} |
||
MBPP_sanitized | 164 | null | python | code_generation | import math
def div_sum(n):
total = 1
i = 2
while i * i <= n:
if n % i == 0:
total = total + i + math.floor(n / i)
i += 1
return total
def are_equivalent(num1, num2):
"""
Write a function to determine if the sum of the divisors of two integers are the same.
"""
| import math
def div_sum(n):
total = 1
i = 2
while i * i <= n:
if n % i == 0:
total = total + i + math.floor(n / i)
i += 1
return total
def are_equivalent(num1, num2):
"""
Write a function to determine if the sum of the divisors of two integers are the same.
"""
return div_sum(num1) == div_sum(num2) | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"36, 57",
"False"
],
[
"2, 4",
"False"
],
[
"23, 47",
"True"
]
] | [
"import math "
] | are_equivalent | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": [
"int"
],
"num2": [
"int"
],
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 165 | null | python | code_generation | def count_char_position(str1):
"""
Write a function to count the number of characters in a string that occur at the same position in the string as in the English alphabet (case insensitive).
"""
| def count_char_position(str1):
"""
Write a function to count the number of characters in a string that occur at the same position in the string as in the English alphabet (case insensitive).
"""
count_chars = 0
for i in range(len(str1)):
if i == ord(str1[i]) - ord('A') or i == ord(str1[i]) - ord('a'):
count_chars += 1
return count_chars | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"xbcefg\"",
"2"
],
[
"\"ABcED\"",
"3"
],
[
"\"AbgdeF\"",
"5"
]
] | [] | count_char_position | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": [
"str"
],
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 166 | null | python | code_generation | def find_even_pair(A):
"""
Write a function that counts the number of pairs of integers in a list that xor to an even number.
"""
| def find_even_pair(A):
"""
Write a function that counts the number of pairs of integers in a list that xor to an even number.
"""
count = 0
for i in range(0, len(A)):
for j in range(i + 1, len(A)):
if (A[i] ^ A[j]) % 2 == 0:
count += 1
return count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[5, 4, 7, 2, 1]",
"4"
],
[
"[7, 2, 8, 1, 0, 5, 11]",
"9"
],
[
"[1, 2, 3]",
"1"
]
] | [] | find_even_pair | {
"input": {
"A": [
"list"
],
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 167 | null | python | code_generation | def next_power_of_2(n):
"""
Write a python function to find the smallest power of 2 greater than or equal to n.
"""
| def next_power_of_2(n):
"""
Write a python function to find the smallest power of 2 greater than or equal to n.
"""
if n and (not n & n - 1):
return n
count = 0
while n != 0:
n >>= 1
count += 1
return 1 << count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"0",
"1"
],
[
"5",
"8"
],
[
"17",
"32"
]
] | [] | next_power_of_2 | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 168 | null | python | code_generation | def frequency(a, x):
"""
Write a function to count the number of occurrences of a number in a given list.
"""
| def frequency(a, x):
"""
Write a function to count the number of occurrences of a number in a given list.
"""
count = 0
for i in a:
if i == x:
count += 1
return count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1,2,3], 4",
"0"
],
[
"[1,2,2,3,3,3,4], 3",
"3"
],
[
"[0,1,2,3,1,2], 1",
"2"
]
] | [] | frequency | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"list"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": [
"int"
],
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 170 | null | python | code_generation | def sum_range_list(list1, m, n):
"""
Write a function to find the sum of numbers in a list within a range specified by two indices.
"""
| def sum_range_list(list1, m, n):
"""
Write a function to find the sum of numbers in a list within a range specified by two indices.
"""
sum_range = 0
for i in range(m, n + 1, 1):
sum_range += list1[i]
return sum_range | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[2,1,5,6,8,3,4,9,10,11,8,12], 8, 10",
"29"
],
[
"[2,1,5,6,8,3,4,9,10,11,8,12], 5, 7",
"16"
],
[
"[2,1,5,6,8,3,4,9,10,11,8,12], 7, 10",
"38"
]
] | [] | sum_range_list | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": [
"list"
],
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": [
"int"
],
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 171 | null | python | code_generation | import math
def perimeter_pentagon(a):
"""
Write a function to find the perimeter of a regular pentagon from the length of its sides.
"""
| import math
def perimeter_pentagon(a):
"""
Write a function to find the perimeter of a regular pentagon from the length of its sides.
"""
perimeter = 5 * a
return perimeter | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"5",
"25"
],
[
"10",
"50"
],
[
"15",
"75"
]
] | [
"import math"
] | perimeter_pentagon | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": [
"int"
],
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 172 | null | python | code_generation | def count_occurance(s):
"""
Write a function to count the number of occurence of the string 'std' in a given string.
"""
| def count_occurance(s):
"""
Write a function to count the number of occurence of the string 'std' in a given string.
"""
count = 0
for i in range(len(s) - 2):
if s[i] == 's' and s[i + 1] == 't' and (s[i + 2] == 'd'):
count = count + 1
return count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"\"letstdlenstdporstd\"",
"3"
],
[
"\"truststdsolensporsd\"",
"1"
],
[
"\"makestdsostdworthit\"",
"2"
],
[
"\"stds\"",
"1"
],
[
"\"\"",
"0"
]
] | [] | count_occurance | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": [
"str"
],
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 222 | null | python | code_generation | def check_type(test_tuple):
"""
Write a function to check if all the elements in tuple have same data type or not.
"""
| def check_type(test_tuple):
"""
Write a function to check if all the elements in tuple have same data type or not.
"""
res = True
for ele in test_tuple:
if not isinstance(ele, type(test_tuple[0])):
res = False
break
return res | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"(5, 6, 7, 3, 5, 6) ",
"True"
],
[
"(1, 2, \"4\") ",
"False"
],
[
"(3, 2, 1, 4, 5) ",
"True"
]
] | [] | check_type | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": [
"int"
],
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 223 | null | python | code_generation | def binary_search(arr, low, high, x):
if high >= low:
mid = (low + high) // 2
if (mid == 0 or x > arr[mid - 1]) and arr[mid] == x:
return mid
elif x > arr[mid]:
return binary_search(arr, mid + 1, high, x)
else:
return binary_search(arr, low, mid - 1, x)
return -1
def is_majority(arr, n, x):
"""
Write a function that takes in a sorted array, its length (n), and an element and returns whether the element is the majority element in the given sorted array. (The majority element is the element that occurs more than n/2 times.)
"""
| def binary_search(arr, low, high, x):
if high >= low:
mid = (low + high) // 2
if (mid == 0 or x > arr[mid - 1]) and arr[mid] == x:
return mid
elif x > arr[mid]:
return binary_search(arr, mid + 1, high, x)
else:
return binary_search(arr, low, mid - 1, x)
return -1
def is_majority(arr, n, x):
"""
Write a function that takes in a sorted array, its length (n), and an element and returns whether the element is the majority element in the given sorted array. (The majority element is the element that occurs more than n/2 times.)
"""
i = binary_search(arr, 0, n - 1, x)
if i == -1:
return False
if i + n // 2 <= n - 1 and arr[i + n // 2] == x:
return True
else:
return False | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"[1, 2, 3, 3, 3, 3, 10], 7, 3",
"True"
],
[
"[1, 1, 2, 4, 4, 4, 6, 6], 8, 4",
"False"
],
[
"[1, 1, 1, 2, 2], 5, 1",
"True"
],
[
"[1, 1, 2, 2], 5, 1",
"False"
]
] | [] | is_majority | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": [
"list"
],
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": [
"int"
],
"xs": null,
"y": null
},
"output": [
"bool"
]
} |
||
MBPP_sanitized | 224 | null | python | code_generation | def count_Set_Bits(n):
"""
Write a python function to count the number of set bits (binary digits with value 1) in a given number.
"""
| def count_Set_Bits(n):
"""
Write a python function to count the number of set bits (binary digits with value 1) in a given number.
"""
count = 0
while n:
count += n & 1
n >>= 1
return count | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"2",
"1"
],
[
"4",
"1"
],
[
"6",
"2"
]
] | [] | count_Set_Bits | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": [
"int"
],
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": null,
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"int"
]
} |
||
MBPP_sanitized | 226 | null | python | code_generation | def odd_values_string(str):
"""
Write a python function to remove the characters which have odd index values of a given string.
"""
| def odd_values_string(str):
"""
Write a python function to remove the characters which have odd index values of a given string.
"""
result = ''
for i in range(len(str)):
if i % 2 == 0:
result = result + str[i]
return result | [] | import numpy as np
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 == np.float64 or x.dtype == np.float32
return False
def assertion(out, exp, atol):
exact_match = out == exp
if atol == 0 and is_floats(exp):
atol = 1e-6
if not exact_match and atol != 0:
assert np.allclose(out, exp, rtol=1e-07, atol=atol)
else:
assert exact_match
inputs = {input_list}
results = {output_list}
candidate = {func_entry}
for i, (inp, exp) in enumerate(zip(inputs, results)):
assertion(candidate(*inp), exp, 0) | [
[
"'abcdef'",
"'ace'"
],
[
"'python'",
"'pto'"
],
[
"'data'",
"'dt'"
],
[
"'lambs'",
"'lms'"
]
] | [] | odd_values_string | {
"input": {
"A": null,
"Input": null,
"K": null,
"L": null,
"M": null,
"N": null,
"S": null,
"a": null,
"actual_cost": null,
"arr": null,
"array_nums1": null,
"array_nums2": null,
"arraynums": null,
"b": null,
"base1": null,
"base2": null,
"c": null,
"ch": null,
"char": null,
"colors": null,
"d": null,
"data_list": null,
"dict": null,
"dict1": null,
"dict2": null,
"dict3": null,
"dlist": null,
"dt": null,
"element": null,
"h": null,
"h_age": null,
"height": null,
"index": null,
"input_list": null,
"item": null,
"k": null,
"l": null,
"l1": null,
"l2": null,
"l3": null,
"limit": null,
"list": null,
"list1": null,
"list2": null,
"list3": null,
"list_": null,
"listval": null,
"lst": null,
"m": null,
"monthnum2": null,
"my_list": null,
"my_matrix": null,
"n": null,
"nestedlist": null,
"newch": null,
"num": null,
"num1": null,
"num2": null,
"num3": null,
"number": null,
"numbers": null,
"nums": null,
"nums1": null,
"nums2": null,
"patterns": null,
"r": null,
"ranges": null,
"rotations": null,
"s": null,
"sale_amount": null,
"second_string": null,
"stdata": null,
"step": null,
"str": [
"str"
],
"str1": null,
"string": null,
"stringlist": null,
"strr": null,
"sub_str": null,
"subjectmarks": null,
"test_list": null,
"test_list1": null,
"test_list2": null,
"test_tup": null,
"test_tup1": null,
"test_tup2": null,
"test_tuple": null,
"text": null,
"text1": null,
"tup": null,
"tup1": null,
"tuple1": null,
"tuplex": null,
"w": null,
"word": null,
"words": null,
"x": null,
"xs": null,
"y": null
},
"output": [
"str"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.