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, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | return [e for e i | n l if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
| [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/1 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | turn [e fo | r e in l if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
re | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/2 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | return [e for e in l | if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
| [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/3 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | eturn [e for e in l if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
r | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/4 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive | |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | e in l if e | > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
return [e for | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/5 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | n [e for e in l i | f e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
retur | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/6 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | e in l | if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
return [e for | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/7 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | return [ | e for e in l if e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
| [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/8 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | in l if | e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
return [e for e | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/9 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"[-1, -2, 4, 5, 6]",
"[4, 5, 6]"
],
[
"[5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 3, 9, 123, 1]"
],
[
"[-1, -2]",
"[]"
],
[
"[]",
"[]"
]
] | [] | urn [e for e in l if | e > 0]
| python | Return only positive numbers in the list. | [] |
def get_positive(l: list):
"""Return only positive numbers in the list.
"""
ret | [
[
"[-1, 2, -4, 5, 6]",
"[2, 5, 6]"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"[5, 3, 2, 3, 9, 123, 1]"
]
] | RandomSpanInfilling/HumanEval/30/10 | python | code_infilling | HumanEval_RandomSpanInfilling | get_positive |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | 1):
if n % k == 0:
return False
return Tr | ue
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for k in range(2, n - | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/1 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
retu | rn False
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
| [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/2 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | return False |
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
| [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/3 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | , n - 1):
if n % k == 0:
return False
| return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for k in range(2 | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/4 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | k in range(2, | n - 1):
if n % k == 0:
return False
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/5 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | n range(2, n - | 1):
if n % k == 0:
return False
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for k i | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/6 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | k == 0:
return False
| return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
return False
for k in range(2, n - 1):
if n % | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/7 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | return False
for k i | n range(2, n - 1):
if n % k == 0:
return False
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2:
| [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/8 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] |
return False
for k in | range(2, n - 1):
if n % k == 0:
return False
return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
if n < 2: | [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/9 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
],
[
"5",
"True"
],
[
"11",
"True"
],
[
"17",
"True"
],
[
"5 * 17... | [] | if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
return False
| return True
| python | Return true if a given number is prime, and false otherwise. | [] |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
"""
| [
[
"6",
"False"
],
[
"101",
"True"
],
[
"11",
"True"
],
[
"13441",
"True"
],
[
"61",
"True"
],
[
"4",
"False"
],
[
"1",
"False"
]
] | RandomSpanInfilling/HumanEval/31/10 | python | code_infilling | HumanEval_RandomSpanInfilling | is_prime |
[] | [
"import math"
] | poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
| else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/1 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
| center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/2 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | n) > 0:
begin = center
else: |
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/3 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | in, end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
cent | er = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/4 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | end - begin > 1e-10:
center = (be | gin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/5 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | 2.0
end *= 2.0
while end - begin > | 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/6 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | .0
| if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/7 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, | begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/8 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > | 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/9 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [
"import math"
] | center = (begin + end) / 2.0
if | poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| python | Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n | [] | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | [
[
"x",
"0."
],
[
"find_zero([1, 2]), 2) # f(x",
"1 + 2x"
],
[
"find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3",
"-6 + 11x - 6x^2 + x^3"
]
] | RandomSpanInfilling/HumanEval/32/10 | python | code_infilling | HumanEval_RandomSpanInfilling | find_zero |
[] | [] | list(l)
l[::3] = sor | ted(l[::3])
return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/1 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | l[::3] = sorted(l[::3])
retu | rn l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/2 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | (l)
l[::3] | = sorted(l[::3])
return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/3 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | sorted(l[::3])
| return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/4 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | (l)
l[::3] = sorted(l[::3])
| return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/5 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | = list(l)
l[::3] = sorte | d(l[::3])
return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/6 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | l[::3] = sorted(l[::3])
re | turn l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/7 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | l = list(l)
l[::3] = sorted(l[::3])
| return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
| [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/8 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | l = list(l)
l[:: | 3] = sorted(l[::3])
return l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
| [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/9 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[] | [] | ist(l)
l[::3] = sorted(l[::3])
return | l
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted. | [] |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
"""
l ... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4, 8, 9, 2]",
"[2, 6, 3, 4, 8, 9, 5]"
]
] | RandomSpanInfilling/HumanEval/33/10 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_third |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | return sorted(list(set(l) | ))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
| [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/1 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | return sorted(list(set(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
| [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/2 | python | code_infilling | HumanEval_RandomSpanInfilling | unique | |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | (list(set(l))) | python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
return sorted | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/3 | python | code_infilling | HumanEval_RandomSpanInfilling | unique | |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | sorted(li | st(set(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
return | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/4 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | e | t(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
return sorted(list(s | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/5 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | t(set | (l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
return sorted(lis | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/6 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | orted(list(set(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
return s | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/7 | python | code_infilling | HumanEval_RandomSpanInfilling | unique | |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | return sorted(li | st(set(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
| [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/8 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | eturn sorted(list(set( | l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
r | [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/9 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | [] | return sorte | d(list(set(l)))
| python | Return sorted unique elements in a list | [] |
def unique(l: list):
"""Return sorted unique elements in a list
"""
| [
[
"[5, 3, 5, 2, 3, 3, 9, 0, 123]",
"[0, 2, 3, 5, 9, 123]"
]
] | RandomSpanInfilling/HumanEval/34/10 | python | code_infilling | HumanEval_RandomSpanInfilling | unique |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | m = l[0]
for e in l:
if e > m:
m = e
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/1 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element | |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | in l:
if e > m:
| m = e
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e | [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/2 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | if e > m:
| m = e
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e in l:
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/3 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | rn m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e in l:
if e > m:
m = e
retu | [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/4 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element | |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | for e in l:
if e > m:
m = e
return m | python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/5 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element | |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | m = l[0]
for e in l:
if e > m:
m = e
ret | urn m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/6 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | m:
| m = e
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e in l:
if e > | [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/7 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | m = l[0]
for e in l:
if e > m:
m = e
return | m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/8 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | = e |
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e in l:
if e > m:
m | [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/9 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element |
[
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]",
"124"
]
] | [] | if e > m:
m = e
return m
| python | Return maximum element in the list. | [] |
def max_element(l: list):
"""Return maximum element in the list.
"""
m = l[0]
for e in l:
| [
[
"[1, 2, 3]",
"3"
],
[
"[5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]",
"123"
]
] | RandomSpanInfilling/HumanEval/35/10 | python | code_infilling | HumanEval_RandomSpanInfilling | max_element | |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | pen | d(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.ap | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/1 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | if i % 11 == 0 or i % 13 == | 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
| [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/2 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | r c in s | :
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
fo | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/3 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | st(map(str, ns)))
ans = 0
for c in s:
ans += (c | == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(li | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/4 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(ma | p(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
| [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/5 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] |
for i in range(n):
if i % | 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = [] | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/6 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
| return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/7 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns) | ))
ans = 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 == | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/8 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | oin(list(map(str, ns)))
ans = | 0
for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.j | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/9 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
],
[
"100",
"3"
],
[
"200",
"6"
],
[
"4000",
"192"
],
[
"10000",
"639"
],
[
"100000",
"8026"
]
] | [] | i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
| for c in s:
ans += (c == '7')
return ans
| python | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13. | [] |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
"""
ns = []
for i in range(n):
if | [
[
"50",
"0"
],
[
"78",
"2"
],
[
"79",
"3"
]
] | RandomSpanInfilling/HumanEval/36/10 | python | code_infilling | HumanEval_RandomSpanInfilling | fizz_buzz |
[] | [] | zip(evens, odds):
ans.extend([e, o])
if len(e | vens) > len(odds):
ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/1 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | []
fo | r e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/2 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | ans.extend([e, o])
if len(evens) > len(odds):
ans.append | (evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/3 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | ans.append(evens[-1])
| return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/4 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] |
evens.s | ort()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2] | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/5 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | in zip(evens, od | ds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/6 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | l[1::2]
evens.sort()
ans = []
for e, | o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/7 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | ens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append | (evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/8 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | t()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
| return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sor | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/9 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[] | [] | o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
| ans.append(evens[-1])
return ans
| python | This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted. | [] |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
"""
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []... | [
[
"[1, 2, 3]",
"[1, 2, 3]"
],
[
"[5, 6, 3, 4]",
"[3, 6, 5, 4]"
]
] | RandomSpanInfilling/HumanEval/37/10 | python | code_infilling | HumanEval_RandomSpanInfilling | sort_even |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | de_cyclic(s) | )
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/1 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | return encod | e_cyclic(encode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/2 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | return encode_cyclic(enc | ode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/3 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | n encod | e_cyclic(encode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/4 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | ycli | c(encode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/5 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | return encode_cyclic(encode_c | yclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/6 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | r | eturn encode_cyclic(encode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/7 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | ncode_cyclic(encode_cyclic(s)) | python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/8 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic | |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | encode_cyclic(encode_cyclic(s)) | python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/9 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic | |
[
[
"'eaztdrcpoojjs'",
"'zeartdocpjojs'"
],
[
"'fcsasgmhiqc'",
"'sfcgasimhqc'"
],
[
"'avmirjdeqbylxuau'",
"'mavjirqdelbyaxuu'"
],
[
"'azhacmsfsnfsg'",
"'hazmacssfsnfg'"
],
[
"'zbvkvwoatdccvw'",
"'vzbwkvtoacdcvw'"
],
[
"'mqzfshjknuz'",
"'zmqhfsnjkuz'"... | [] | de_cycl | ic(encode_cyclic(s))
| python | returns encoded string by cycling groups of three characters. | [] |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | [
[
"group",
"3 else group for group in groups]"
]
] | RandomSpanInfilling/HumanEval/38/10 | python | code_infilling | HumanEval_RandomSpanInfilling | decode_cyclic |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for k | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/1 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib | |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | ort math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= ... | return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
imp | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/2 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2] | )
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
| [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/3 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | alse
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
| return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return F | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/4 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | if p % k == 0:
return F | alse
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
| [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/5 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p | % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/6 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | return False
for k in range(2, min(int(math.s | qrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
| [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/7 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f | [-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/8 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] | import math
def is_prime(p):
if p < 2:
return False
fo | r k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
| [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/9 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
[
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
],
[
"6",
"233"
],
[
"7",
"1597"
],
[
"8",
"28657"
],
[
"9",
"514229"
],
[
"10",
"433494437"
]
] | [] |
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
| n -= 1
if n == 0:
return f[-1]
| python | prime_fib returns n-th number that is a Fibonacci number and it's also prime. | [] |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
"""
import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0: | [
[
"1",
"2"
],
[
"2",
"3"
],
[
"3",
"5"
],
[
"4",
"13"
],
[
"5",
"89"
]
] | RandomSpanInfilling/HumanEval/39/10 | python | code_infilling | HumanEval_RandomSpanInfilling | prime_fib |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.