import_str listlengths 0 1 | doc_string stringclasses 164
values | suffix stringlengths 0 837 | compare_func listlengths 0 0 | data_id stringlengths 34 37 | task_name stringclasses 1
value | solution stringlengths 6 141 | demos listlengths 0 8 | prefix stringlengths 65 1.8k | dataset_name stringclasses 1
value | entry_func stringclasses 158
values | tgt_lang stringclasses 1
value | src_lang stringclasses 1
value | test_cases listlengths 0 100 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | for word in sentence.split():
flg = 0
if len(word) == 1:
flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L0 | code_infilling | new_lst = []
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | flg = 0
if len(word) == 1:
flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L1 | code_infilling | for word in sentence.split():
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | if len(word) == 1:
flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L2 | code_infilling | flg = 0
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L3 | code_infilling | if len(word) == 1:
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L4 | code_infilling | flg = 1
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L5 | code_infilling | for i in range(2, len(word)):
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L6 | code_infilling | if len(word)%i == 0:
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L7 | code_infilling | flg = 1
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | new_lst.append(word)
return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L8 | code_infilling | if flg == 0 or len(word) == 2:
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | return " ".join(new_lst)
| [] | SingleLineInfilling/HumanEval/143/L9 | code_infilling | new_lst.append(word)
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... |
[] | You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
... | [] | SingleLineInfilling/HumanEval/143/L10 | code_infilling | return " ".join(new_lst)
| [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
]
] |
def words_in_sentence(sentence):
"""
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new stri... | HumanEval_SingleLineInfillingLight | words_in_sentence | python | python | [
[
"\"This is a test\"",
"\"is\""
],
[
"\"lets go for swimming\"",
"\"go for\""
],
[
"\"there is no place available here\"",
"\"there is no place\""
],
[
"\"Hi I am Hussein\"",
"\"Hi am Hussein\""
],
[
"\"go for it\"",
"\"go for it\""
],
[
"\"here\"",
... | |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | c, d = n.split("/")
numerator = int(a) * int(c)
denom = int(b) * int(d)
if (numerator/denom == int(numerator/denom)):
return True
return False
| [] | SingleLineInfilling/HumanEval/144/L0 | code_infilling | a, b = x.split("/")
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | numerator = int(a) * int(c)
denom = int(b) * int(d)
if (numerator/denom == int(numerator/denom)):
return True
return False
| [] | SingleLineInfilling/HumanEval/144/L1 | code_infilling | c, d = n.split("/")
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | denom = int(b) * int(d)
if (numerator/denom == int(numerator/denom)):
return True
return False
| [] | SingleLineInfilling/HumanEval/144/L2 | code_infilling | numerator = int(a) * int(c)
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | if (numerator/denom == int(numerator/denom)):
return True
return False
| [] | SingleLineInfilling/HumanEval/144/L3 | code_infilling | denom = int(b) * int(d)
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | return True
return False
| [] | SingleLineInfilling/HumanEval/144/L4 | code_infilling | if (numerator/denom == int(numerator/denom)):
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | return False
| [] | SingleLineInfilling/HumanEval/144/L5 | code_infilling | return True
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... |
[] | Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominat... | [] | SingleLineInfilling/HumanEval/144/L6 | code_infilling | return False
| [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"7/10\", \"10/2\"",
"False"
]
] |
def simplify(x, n):
"""Your task is to implement a function that will simplify the expression
x * n. The function returns True if x * n evaluates to a whole number and False
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where ... | HumanEval_SingleLineInfillingLight | simplify | python | python | [
[
"\"1/5\", \"5/1\"",
"True"
],
[
"\"1/6\", \"2/1\"",
"False"
],
[
"\"5/1\", \"3/1\"",
"True"
],
[
"\"7/10\", \"10/2\"",
"False"
],
[
"\"2/10\", \"50/10\"",
"True"
],
[
"\"7/2\", \"4/2\"",
"True"
],
[
"\"11/6\", \"6/1\"",
"True"
],
... | |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L0 | code_infilling | def digits_sum(n):
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
| HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L1 | code_infilling | neg = 1
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
| HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L2 | code_infilling | if n < 0: n, neg = -1 * n, -1
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
... | HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L3 | code_infilling | n = [int(i) for i in str(n)]
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
... | HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | return sum(n)
return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L4 | code_infilling | n[0] = n[0] * neg
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
... | HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | return sorted(nums, key=digits_sum)
| [] | SingleLineInfilling/HumanEval/145/L5 | code_infilling | return sum(n)
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
... | HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... |
[] | Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list. | [] | SingleLineInfilling/HumanEval/145/L6 | code_infilling | return sorted(nums, key=digits_sum)
| [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[]",
"[]"
]
] |
def order_by_points(nums):
"""
Write a function which sorts the given list of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original list.
"""
def digits_sum(n):
... | HumanEval_SingleLineInfillingLight | order_by_points | python | python | [
[
"[1, 11, -1, -11, -12]",
"[-1, -11, 1, -12, 11]"
],
[
"[1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]",
"[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]"
],
[
"[]",
"[]"
],
[
"[1, -11, -32, 43, 54, -98, 2, -3]",
"[-3, -32, -98, -11, 1, 2, 43, 54]"... | |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | for num in nums:
if num > 10:
odd_digits = (1, 3, 5, 7, 9)
number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L1 | code_infilling | count = 0
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
| HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | if num > 10:
odd_digits = (1, 3, 5, 7, 9)
number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L2 | code_infilling | for num in nums:
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
| HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | odd_digits = (1, 3, 5, 7, 9)
number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L3 | code_infilling | if num > 10:
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
| HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L4 | code_infilling | odd_digits = (1, 3, 5, 7, 9)
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
if num > 10:
| HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L5 | code_infilling | number_as_string = str(num)
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
if num > 10:
... | HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | count += 1
return count
| [] | SingleLineInfilling/HumanEval/146/L6 | code_infilling | if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
if num > 10:
... | HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). |
return count
| [] | SingleLineInfilling/HumanEval/146/L7 | code_infilling | count += 1
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
if num > 10:
... | HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] |
[] | Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9). | [] | SingleLineInfilling/HumanEval/146/L9 | code_infilling | return count
| [
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
]
] |
def specialFilter(nums):
"""Write a function that takes an array of numbers as input and returns
the number of elements in the array that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
"""
count = 0
for num in nums:
if num > 10:
... | HumanEval_SingleLineInfillingLight | specialFilter | python | python | [
[
"[5, -2, 1, -5]",
"0"
],
[
"[15, -73, 14, -15]",
"1"
],
[
"[33, -2, -3, 45, 21, 109]",
"2"
],
[
"[43, -12, 93, 125, 121, 109]",
"4"
],
[
"[71, -2, -33, 75, 21, 19]",
"3"
],
[
"[1]",
"0"
],
[
"[]",
"0"
]
] | |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | ans = []
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L0 | code_infilling | A = [i*i - i + 1 for i in range(1,n+1)]
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L1 | code_infilling | ans = []
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | for j in range(i+1,n):
for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L2 | code_infilling | for i in range(n):
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L3 | code_infilling | for j in range(i+1,n):
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L4 | code_infilling | for k in range(j+1,n):
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | ans += [(A[i],A[j],A[k])]
return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L5 | code_infilling | if (A[i]+A[j]+A[k])%3 == 0:
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | return len(ans)
| [] | SingleLineInfilling/HumanEval/147/L6 | code_infilling | ans += [(A[i],A[j],A[k])]
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] |
[] | You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3. | [] | SingleLineInfilling/HumanEval/147/L7 | code_infilling | return len(ans)
| [
[
"5",
"1"
]
] |
def get_max_triples(n):
"""
You are given a positive integer n. You have to create an integer array a of length n.
For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
... | HumanEval_SingleLineInfillingLight | get_max_triples | python | python | [
[
"5",
"1"
],
[
"6",
"4"
],
[
"10",
"36"
],
[
"100",
"53361"
]
] | |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
return ()
planet1_index = planet_names.index(planet1)
planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
... | [] | SingleLineInfilling/HumanEval/148/L0 | code_infilling | planet_names = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | return ()
planet1_index = planet_names.index(planet1)
planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L1 | code_infilling | if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | planet1_index = planet_names.index(planet1)
planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L2 | code_infilling | return ()
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L3 | code_infilling | planet1_index = planet_names.index(planet1)
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L4 | code_infilling | planet2_index = planet_names.index(planet2)
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L5 | code_infilling | if planet1_index < planet2_index:
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | else:
return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L6 | code_infilling | return (planet_names[planet1_index + 1: planet2_index])
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | return (planet_names[planet2_index + 1 : planet1_index])
| [] | SingleLineInfilling/HumanEval/148/L7 | code_infilling | else:
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... |
[] | There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a tuple containing all planets whose orbi... | [] | SingleLineInfilling/HumanEval/148/L8 | code_infilling | return (planet_names[planet2_index + 1 : planet1_index])
| [
[
"\"Jupiter\", \"Neptune\"",
"> (\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"> (\"Venus\")"
],
[
"\"Mercury\", \"Uranus\"",
"> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
]
] |
def bf(planet1, planet2):
"""
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a ... | HumanEval_SingleLineInfillingLight | bf | python | python | [
[
"\"Jupiter\", \"Neptune\"",
"(\"Saturn\", \"Uranus\")"
],
[
"\"Earth\", \"Mercury\"",
"(\"Venus\",)"
],
[
"\"Mercury\", \"Uranus\"",
"(\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")"
],
[
"\"Neptune\", \"Venus\"",
"(\"Earth\", \"Mars\", \"Jupiter\", \"Saturn\"... | |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | new_lst = []
for i in lst:
if len(i)%2 == 0:
new_lst.append(i)
return sorted(new_lst, key=len)
| [] | SingleLineInfilling/HumanEval/149/L0 | code_infilling | lst.sort()
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | for i in lst:
if len(i)%2 == 0:
new_lst.append(i)
return sorted(new_lst, key=len)
| [] | SingleLineInfilling/HumanEval/149/L1 | code_infilling | new_lst = []
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | if len(i)%2 == 0:
new_lst.append(i)
return sorted(new_lst, key=len)
| [] | SingleLineInfilling/HumanEval/149/L2 | code_infilling | for i in lst:
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | new_lst.append(i)
return sorted(new_lst, key=len)
| [] | SingleLineInfilling/HumanEval/149/L3 | code_infilling | if len(i)%2 == 0:
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | return sorted(new_lst, key=len)
| [] | SingleLineInfilling/HumanEval/149/L4 | code_infilling | new_lst.append(i)
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... |
[] | Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
The order of the list should be asc... | [] | SingleLineInfilling/HumanEval/149/L5 | code_infilling | return sorted(new_lst, key=len)
| [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"ab\", \"a\", \"aaa\", \"cd\"]",
"[\"ab\", \"cd\"]"
]
] |
def sorted_list_sum(lst):
"""Write a function that accepts a list of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted list with a sorted order,
The list is always a list of strings and never an array of numbers,
and it may contain duplicates.
T... | HumanEval_SingleLineInfillingLight | sorted_list_sum | python | python | [
[
"[\"aa\", \"a\", \"aaa\"]",
"[\"aa\"]"
],
[
"[\"school\", \"AI\", \"asdf\", \"b\"]",
"[\"AI\", \"asdf\", \"school\"]"
],
[
"[\"d\", \"b\", \"c\", \"a\"]",
"[]"
],
[
"[\"d\", \"dcba\", \"abcd\", \"a\"]",
"[\"abcd\", \"dcba\"]"
],
[
"[\"AI\", \"ai\", \"au\"]",
... | |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | return y
for i in range(2, n):
if n % i == 0:
return y
break
else:
return x
| [] | SingleLineInfilling/HumanEval/150/L0 | code_infilling | if n == 1:
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | for i in range(2, n):
if n % i == 0:
return y
break
else:
return x
| [] | SingleLineInfilling/HumanEval/150/L1 | code_infilling | return y
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | if n % i == 0:
return y
break
else:
return x
| [] | SingleLineInfilling/HumanEval/150/L2 | code_infilling | for i in range(2, n):
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | return y
break
else:
return x
| [] | SingleLineInfilling/HumanEval/150/L3 | code_infilling | if n % i == 0:
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
for i in range(2, n):
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | break
else:
return x
| [] | SingleLineInfilling/HumanEval/150/L4 | code_infilling | return y
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
for i in range(2, n):
if n % i == 0:
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | else:
return x
| [] | SingleLineInfilling/HumanEval/150/L5 | code_infilling | break
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
for i in range(2, n):
if n % i == 0:
return y
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | return x
| [] | SingleLineInfilling/HumanEval/150/L6 | code_infilling | else:
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
for i in range(2, n):
if n % i == 0:
return y
break
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... |
[] | A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise. | [] | SingleLineInfilling/HumanEval/150/L7 | code_infilling | return x
| [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
]
] |
def x_or_y(n, x, y):
"""A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
"""
if n == 1:
return y
for i in range(2, n):
if n % i == 0:
return y
break
else:
| HumanEval_SingleLineInfillingLight | x_or_y | python | python | [
[
"7, 34, 12",
"34"
],
[
"15, 8, 5",
"5"
],
[
"3, 33, 5212",
"33"
],
[
"1259, 3, 52",
"3"
],
[
"7919, -1, 12",
"-1"
],
[
"3609, 1245, 583",
"583"
],
[
"91, 56, 129",
"129"
],
[
"6, 34, 1234",
"1234"
],
[
"1, 2, 0",
... | |
[] | Given a list of numbers, return the sum of squares of the numbers
in the list that are odd. Ignore numbers that are negative or not integers.
If the input list is empty, return 0. | [] | SingleLineInfilling/HumanEval/151/L0 | code_infilling | return sum([i**2 for i in lst if i > 0 and i%2!=0 and "." not in str(i)])
| [
[
"[1, 3, 2, 0]",
"1 + 9 + 0 + 0 = 10"
],
[
"[-1, -2, 0]",
"0"
],
[
"[9, -2]",
"81"
],
[
"[0]",
"0"
]
] |
def double_the_difference(lst):
"""
Given a list of numbers, return the sum of squares of the numbers
in the list that are odd. Ignore numbers that are negative or not integers.
If the input list is empty, return 0.
"""
| HumanEval_SingleLineInfillingLight | double_the_difference | python | python | [
[
"[]",
"0"
],
[
"[5, 4]",
"25"
],
[
"[0.1, 0.2, 0.3]",
"0"
],
[
"[-10, -20, -30]",
"0"
],
[
"[-1, -2, 8]",
"0"
],
[
"[0.2, 3, 5]",
"34"
]
] | |
[] | I think we all remember that feeling when the result of some long-awaited
event is finally known. The feelings and thoughts you have at that moment are
definitely worth noting down and comparing.
Your task is to determine if a person correctly guessed the results of a number of matches.
You are given tw... | [] | SingleLineInfilling/HumanEval/152/L0 | code_infilling | return [abs(x-y) for x,y in zip(game,guess)]
| [
[
"[1,2,3,4,5,1],[1,2,3,4,2,-2]",
"[0,0,0,0,3,3]"
],
[
"[0,5,0,0,0,4],[4,1,1,0,0,-2]",
"[4,4,1,0,0,6]"
]
] |
def compare(game,guess):
"""I think we all remember that feeling when the result of some long-awaited
event is finally known. The feelings and thoughts you have at that moment are
definitely worth noting down and comparing.
Your task is to determine if a person correctly guessed the results of a number... | HumanEval_SingleLineInfillingLight | compare | python | python | [
[
"[1,2,3,4,5,1], [1,2,3,4,2,-2]",
"[0,0,0,0,3,3]"
],
[
"[0,0,0,0,0,0], [0,0,0,0,0,0]",
"[0,0,0,0,0,0]"
],
[
"[1,2,3], [-1,-2,-3]",
"[2,4,6]"
],
[
"[1,2,3,5], [-1,2,3,4]",
"[2,0,0,1]"
]
] | |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
for s in extensions:
val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
if val > my_val:
... | [] | SingleLineInfilling/HumanEval/153/L0 | code_infilling | strong = extensions[0]
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | for s in extensions:
val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
if val > my_val:
strong = s
my_val = val
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L1 | code_infilling | my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
if val > my_val:
strong = s
my_val = val
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L2 | code_infilling | for s in extensions:
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | if val > my_val:
strong = s
my_val = val
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L3 | code_infilling | val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | strong = s
my_val = val
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L4 | code_infilling | if val > my_val:
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | my_val = val
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L5 | code_infilling | strong = s
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... |
ans = class_name + "." + strong
return ans
| [] | SingleLineInfilling/HumanEval/153/L6 | code_infilling | my_val = val
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | return ans
| [] | SingleLineInfilling/HumanEval/153/L8 | code_infilling | ans = class_name + "." + strong
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... |
[] | You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters... | [] | SingleLineInfilling/HumanEval/153/L9 | code_infilling | return ans
| [
[
"'my_class', ['AA', 'Be', 'CC']",
"'my_class.AA'"
]
] |
def Strongest_Extension(class_name, extensions):
"""You will be given the name of a class (a string) and a list of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extens... | HumanEval_SingleLineInfillingLight | Strongest_Extension | python | python | [
[
"'Watashi', ['tEN', 'niNE', 'eIGHt8OKe']",
"'Watashi.eIGHt8OKe'"
],
[
"'Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']",
"'Boku123.YEs.WeCaNe'"
],
[
"'__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']",
"'__YESIMHERE.NuLl__'"
],
[
"'K', ['... | |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
return True
return False
| [] | SingleLineInfilling/HumanEval/154/L0 | code_infilling | l = len(b)
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
return True
return False
| [] | SingleLineInfilling/HumanEval/154/L1 | code_infilling | pat = b + b
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
return True
return False
| [] | SingleLineInfilling/HumanEval/154/L2 | code_infilling | for i in range(len(a) - l + 1):
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
pat = b + b
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | if a[i:i+l] == pat[j:j+l]:
return True
return False
| [] | SingleLineInfilling/HumanEval/154/L3 | code_infilling | for j in range(l + 1):
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | return True
return False
| [] | SingleLineInfilling/HumanEval/154/L4 | code_infilling | if a[i:i+l] == pat[j:j+l]:
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | return False
| [] | SingleLineInfilling/HumanEval/154/L5 | code_infilling | return True
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
| HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] |
[] | You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word | [] | SingleLineInfilling/HumanEval/154/L6 | code_infilling | return False
| [
[
"\"abcd\",\"abd\"",
"False"
],
[
"\"hello\",\"ell\"",
"True"
],
[
"\"whassup\",\"psus\"",
"False"
],
[
"\"abab\",\"baa\"",
"True"
],
[
"\"efef\",\"eeff\"",
"False"
],
[
"\"himenss\",\"simen\"",
"True"
]
] |
def cycpattern_check(a , b):
"""You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
"""
l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
... | HumanEval_SingleLineInfillingLight | cycpattern_check | python | python | [
[
"\"xyzw\", \"xyw\"",
"False"
],
[
"\"yello\", \"ell\"",
"True"
],
[
"\"whattup\", \"ptut\"",
"False"
],
[
"\"efef\", \"fee\"",
"True"
],
[
"\"abab\", \"aabb\"",
"False"
],
[
"\"winemtt\", \"tinem\"",
"True"
]
] | |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L0 | code_infilling | even_count = 0
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L1 | code_infilling | odd_count = 0
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | if int(i)%2==0:
even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L2 | code_infilling | for i in str(abs(num)):
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L3 | code_infilling | if int(i)%2==0:
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
for i in str(abs(num)):
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | else:
odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L4 | code_infilling | even_count +=1
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | odd_count +=1
return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L5 | code_infilling | else:
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | return (even_count, odd_count)
| [] | SingleLineInfilling/HumanEval/155/L6 | code_infilling | odd_count +=1
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] |
[] | Given an integer. return a tuple that has the number of even and odd digits respectively. | [] | SingleLineInfilling/HumanEval/155/L7 | code_infilling | return (even_count, odd_count)
| [
[
"-12",
"> (1, 1)"
],
[
"123",
"> (1, 2)"
]
] |
def even_odd_count(num):
"""Given an integer. return a tuple that has the number of even and odd digits respectively.
"""
even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
odd_count +=1
| HumanEval_SingleLineInfillingLight | even_odd_count | python | python | [
[
"7",
"(0, 1)"
],
[
"-78",
"(1, 1)"
],
[
"3452",
"(2, 2)"
],
[
"346211",
"(3, 3)"
],
[
"-345821",
"(3, 3)"
],
[
"-2",
"(1, 0)"
],
[
"-45347",
"(2, 3)"
],
[
"0",
"(1, 0)"
]
] | |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | 100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
"L", "XC", "C", "CD", "D", "CM", "M"]
i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
... | [] | SingleLineInfilling/HumanEval/156/L0 | code_infilling | num = [1, 4, 5, 9, 10, 40, 50, 90,
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
| HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | sym = ["I", "IV", "V", "IX", "X", "XL",
"L", "XC", "C", "CD", "D", "CM", "M"]
i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L1 | code_infilling | 100, 400, 500, 900, 1000]
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
| HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | "L", "XC", "C", "CD", "D", "CM", "M"]
i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L2 | code_infilling | sym = ["I", "IV", "V", "IX", "X", "XL",
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
| HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L3 | code_infilling | "L", "XC", "C", "CD", "D", "CM", "M"]
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
| HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L4 | code_infilling | i = 12
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L5 | code_infilling | res = ''
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L6 | code_infilling | while number:
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L7 | code_infilling | div = number // num[i]
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L8 | code_infilling | number %= num[i]
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
[] | Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000 | res += sym[i]
div -= 1
i -= 1
return res.lower()
| [] | SingleLineInfilling/HumanEval/156/L9 | code_infilling | while div:
| [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"426",
"'cdxxvi'"
]
] |
def int_to_mini_roman(number):
"""
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
"""
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
... | HumanEval_SingleLineInfillingLight | int_to_mini_roman | python | python | [
[
"19",
"'xix'"
],
[
"152",
"'clii'"
],
[
"251",
"'ccli'"
],
[
"426",
"'cdxxvi'"
],
[
"500",
"'d'"
],
[
"1",
"'i'"
],
[
"4",
"'iv'"
],
[
"43",
"'xliii'"
],
[
"90",
"'xc'"
],
[
"94",
"'xciv'"
],
[
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.