test_cases listlengths 0 100 | import_str listlengths 0 1 | solution stringlengths 0 620 | suffix stringlengths 0 655 | tgt_lang stringclasses 1
value | doc_string stringclasses 164
values | compare_func listlengths 0 0 | prefix stringlengths 65 1.63k | demos listlengths 0 8 | data_id stringlengths 33 36 | src_lang stringclasses 1
value | task_name stringclasses 1
value | dataset_name stringclasses 1
value | entry_func stringclasses 158
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(... | air
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/1 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | closest_pair = None
distance = None
for idx, elem in enumerate(numbers):
for idx2 | , elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance ... | python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
| [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/2 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | e:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
| new_distance = abs(elem - elem2)
if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/3 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
c | losest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/4 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | lem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = a | bs(elem - elem2)
if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/5 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | elem in enumerate(numbers):
for idx2, elem2 in enumer | ate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance < distance:
... | python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/6 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | new_distance = abs(elem - elem2)
if new_distance < distance:
distance = new_ | distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/7 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | merate(num | bers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance < distance:
... | python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/8 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem ... | if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/9 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[1.0, 2.0, 3.9, 4.0, 5.0, 2.2]",
"(3.9, 4.0)"
],
[
"[1.0, 2.0, 5.9, 4.0, 5.0]",
"(5.0, 5.9)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
],
[
"[1.1, 2.2, 3.1, 4.1, 5.1]",
"(2.2, 3.1)"
]
] | [
"from typing import List, Tuple"
] | or idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_di... | t_pair = tuple(sorted([elem, elem2]))
return closest_pair
| python | From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number). | [] | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
"""
closest_pair = None... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.2]",
"(2.0, 2.2)"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0, 2.0]",
"(2.0, 2.0)"
]
] | RandomSpanInfilling/HumanEval/20/10 | python | code_infilling | HumanEval_RandomSpanInfilling | find_closest_elements |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | for x in | numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_number = max(nu... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/1 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | max(numbers)
return [(x - min_number) | / (max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_number = | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/2 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | for x in nu | mbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_number = max(nu... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/3 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | = min(numbers)
max_number = max(numbers)
retu | rn [(x - min_number) / (max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/4 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | numbers)
max_number = max(numbers)
return [(x - min_number) / ( | max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min( | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/5 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | - min_numb | er) / (max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_number = max(nu... | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/6 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | )
max_number = max(numbers)
retu | rn [(x - min_number) / (max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/7 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | max(numbers)
return [(x - min_number) / (m | ax_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_number = | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/8 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | number = max(numbers)
return [(x - min_num | ber) / (max_number - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
max_ | [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/9 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[2.0, 49.9]",
"[0.0, 1.0]"
],
[
"[100.0, 49.9]",
"[1.0, 0.0]"
],
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
],
[
"[2.0, 1.0, 5.0, 3.0, 4.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]"
],
[
"[12.0, 11.0, 15.0, 13.0, 14.0]",
"[0.25, 0.0, 1.0, 0.5, 0.75]... | [
"from typing import List"
] | max_number = max(numbers)
return [(x - min_number) / (max_num | ber - min_number) for x in numbers]
| python | Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1 | [] | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
"""
min_number = min(numbers)
| [
[
"[1.0, 2.0, 3.0, 4.0, 5.0]",
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
] | RandomSpanInfilling/HumanEval/21/10 | python | code_infilling | HumanEval_RandomSpanInfilling | rescale_to_unit |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | if isi | nstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
return [x for x in values | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/1 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | n [x for x in | values if isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
retur | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/2 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | return [x for x in values if isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
| [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/3 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers | |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | is | instance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
return [x for x in values if | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/4 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | if isinstance(x, int) | ]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
return [x for x in values | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/5 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | n [x for | x in values if isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
retur | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/6 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | return [x for x in values i | f isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
| [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/7 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | return [x for x in values if isinstance( | x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
| [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/8 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | return [x f | or x in values if isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
| [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/9 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"[]",
"[]"
],
[
"[4, {}, [], 23.2, 9, 'adasd']",
"[4, 9]"
],
[
"[3, 'c', 3, 3, 'a', 'b']",
"[3, 3, 3]"
]
] | [
"from typing import List, Any"
] | or x in | values if isinstance(x, int)]
| python | Filter given list of any python values only for integers | [] | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
"""
return [x f | [
[
"['a', 3.14, 5]",
"[5]"
],
[
"[1, 2, 3, 'abc', {}, []]",
"[1, 2, 3]"
]
] | RandomSpanInfilling/HumanEval/22/10 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_integers |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | return len(string) | python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/1 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen | |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | tri | ng)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
return len(s | [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/2 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
return | [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/3 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen | |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | return len(st | ring)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/4 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | return len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/5 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen | |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | len(str | ing)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
return | [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/6 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | return | len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/7 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | return len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/8 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen | |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | ret | urn len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
| [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/9 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"''",
"0"
],
[
"'x'",
"1"
],
[
"'asdasnakj'",
"9"
]
] | [] | n | len(string)
| python | Return length of given string | [] |
def strlen(string: str) -> int:
""" Return length of given string
"""
retur | [
[
"''",
"0"
],
[
"'abc'",
"3"
]
] | RandomSpanInfilling/HumanEval/23/10 | python | code_infilling | HumanEval_RandomSpanInfilling | strlen |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | n)):
if | n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i in reversed(range( | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/1 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | n | reversed(range(n)):
if n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i i | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/2 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | for i in reversed(range(n)):
if n | % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
| [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/3 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | i in reversed(range(n)):
| if n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/4 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | ge(n)):
if n % i == 0:
retur | n i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i in reversed(ran | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/5 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | r i in reversed(range(n)):
| if n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
fo | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/6 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i in reversed(range(n)):
if n % i == 0:
| [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/7 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor | |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | n)):
if n % i == 0:
return | i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i in reversed(range( | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/8 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | d(range(n)):
| if n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i in reverse | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/9 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"3",
"1"
],
[
"7",
"1"
],
[
"10",
"5"
],
[
"100",
"50"
],
[
"49",
"7"
]
] | [] | in reversed(range(n)):
| if n % i == 0:
return i
| python | For a given number n, find the largest number that divides n evenly, smaller than n | [] |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
"""
for i | [
[
"15",
"5"
]
] | RandomSpanInfilling/HumanEval/24/10 | python | code_infilling | HumanEval_RandomSpanInfilling | largest_divisor |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] |
fact.append(i)
n //= i
else:
i += 1
if n > 1:
| fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/1 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | else:
i += 1
if n | > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/2 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | += 1
if n > 1:
fact.append(n)
ret | urn fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/3 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | = 2
while i <= int(math.sqrt(n) + 1):
if n % i == | 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/4 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | append(n)
return | fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/5 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | == 0:
fact.append(i)
n //= i
| else:
i += 1
if n > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/6 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | else:
i += 1
if | n > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/7 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
| return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/8 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | math
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
| fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/9 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"2",
"[2]"
],
[
"4",
"[2, 2]"
],
[
"8",
"[2, 2, 2]"
],
[
"3 * 19",
"[3, 19]"
],
[
"3 * 19 * 3 * 19",
"[3, 3, 19, 19]"
],
[
"3 * 19 * 3 * 19 * 3 * 19",
"[3, 3, 3, 19, 19, 19]"
],
[
"3 * 19 * 19 * 19",
"[3, 19, 19, 19]"
],
[
"3 ... | [
"from typing import List"
] | ath
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
| if n > 1:
fact.append(n)
return fact
| python | Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors | [] | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | [
[
"8",
"[2, 2, 2]"
],
[
"25",
"[5, 5]"
],
[
"70",
"[2, 5, 7]"
]
] | RandomSpanInfilling/HumanEval/25/10 | python | code_infilling | HumanEval_RandomSpanInfilling | factorize |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] |
c = collections.Counter(numbers)
return [n for n in numbe | rs if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collections | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/1 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | <= 1] | python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collections
c = collections.Counter(numbers)
return [n for n in numbers i... | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/2 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates | |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | ctions
c | = collections.Counter(numbers)
return [n for n in numbers if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import colle | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/3 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | return [n for n in | numbers if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collections
c = collections.Counter(numbers)
| [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/4 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | mbe | rs if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collections
c = collections.Counter(numbers)
return [n for n in nu | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/5 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | ollections
c = collections.Counter(numbers | )
return [n for n in numbers if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import c | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/6 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | ions
c = collections.Count | er(numbers)
return [n for n in numbers if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collect | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/7 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | collections
c = collections.Counter(numbers)
return [n for n in numbers if c[n] | <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/8 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | return [n for n in numbers if c[n] <= 1] | python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collections
c = collections.Counter(numbers)
| [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/9 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates | |
[
[
"[]",
"[]"
],
[
"[1, 2, 3, 4]",
"[1, 2, 3, 4]"
],
[
"[1, 2, 3, 2, 4, 3, 5]",
"[1, 4, 5]"
]
] | [
"from typing import List"
] | ions
c = collections.Counter(numbers)
return [n f | or n in numbers if c[n] <= 1]
| python | From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input. | [] | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
"""
import collect | [
[
"[1, 2, 3, 2, 4]",
"[1, 3, 4]"
]
] | RandomSpanInfilling/HumanEval/26/10 | python | code_infilling | HumanEval_RandomSpanInfilling | remove_duplicates |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | tu | rn string.swapcase()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
re | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/1 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | ring.swapcase( | )
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return st | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/2 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | s | wapcase()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return string. | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/3 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | ing.swapcas | e()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return str | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/4 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | ng.sw | apcase()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return stri | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/5 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | return string.swapcase()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
| [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/6 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case | |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | string.swapca | se()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/7 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | wapcase | ()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return string.s | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/8 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | return string.sw | apcase()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
| [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/9 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"''",
"''"
],
[
"'Hello!'",
"'hELLO!'"
],
[
"'These violent delights have violent ends'",
"'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'"
]
] | [] | ap | case()
| python | For a given string, flip lowercase characters to uppercase and uppercase to lowercase. | [] |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
"""
return string.sw | [
[
"'Hello'",
"'hELLO'"
]
] | RandomSpanInfilling/HumanEval/27/10 | python | code_infilling | HumanEval_RandomSpanInfilling | flip_case |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | oin(strin | gs)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
return ''.j | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/1 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | turn ' | '.join(strings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
re | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/2 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | n ''.join(s | trings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
retur | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/3 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | turn ''.join(string | s)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
re | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/4 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | .join(string | s)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
return '' | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/5 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | return ''.join(strings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
| [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/6 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate | |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | ings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
return ''.join(str | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/7 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate | |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | ''.join(strings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
return | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/8 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate | |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | joi | n(strings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
return ''. | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/9 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[]",
"''"
],
[
"['x', 'y', 'z']",
"'xyz'"
],
[
"['x', 'y', 'z', 'w', 'k']",
"'xyzwk'"
]
] | [
"from typing import List"
] | rn | ''.join(strings)
| python | Concatenate list of strings into a single string | [] | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
"""
retu | [
[
"[]",
"''"
],
[
"['a', 'b', 'c']",
"'abc'"
]
] | RandomSpanInfilling/HumanEval/28/10 | python | code_infilling | HumanEval_RandomSpanInfilling | concatenate |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | n [x for x in strings if x.startsw | ith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
retur | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/1 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | r x in strings if x.s | tartswith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
return [x fo | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/2 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | turn [x for x in strings if x.startswit | h(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
re | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/3 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | x for x in strings if x.sta | rtswith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
return [ | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/4 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | rn [x for x in strings if x.start | swith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
retu | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/5 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | ings if x.startswith(pr | efix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
return [x for x in str | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/6 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | return [x for x in strings if x.startswith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
| [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/7 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix | |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | gs if x. | startswith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
return [x for x in strin | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/8 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | x in strings if x.s | tartswith(prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
return [x for | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/9 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
[
[
"[], 'john'",
"[]"
],
[
"['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx'",
"['xxx', 'xxxAAA', 'xxx']"
]
] | [
"from typing import List"
] | urn [x for x in strings if x.startswith( | prefix)]
| python | Filter an input list of strings only for ones that start with a given prefix. | [] | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
"""
ret | [
[
"[], 'a'",
"[]"
],
[
"['abc', 'bcd', 'cde', 'array'], 'a'",
"['abc', 'array']"
]
] | RandomSpanInfilling/HumanEval/29/10 | python | code_infilling | HumanEval_RandomSpanInfilling | filter_by_prefix |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.