Dataset Viewer
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"
]
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 38