task_id stringlengths 36 40 | entry_point stringclasses 158
values | prompt stringlengths 116 1.98k | suffix stringclasses 839
values | canonical_solution stringlengths 6 859 | test stringclasses 164
values |
|---|---|---|---|---|---|
MultiLineInfilling/HumanEval/132/L10_L13 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | i += 1
return cnt >= 2
| l = len(closing_bracket_index)
for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L10_L14 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| l = len(closing_bracket_index)
for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L10_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | l = len(closing_bracket_index)
for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/132/L11_L11 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| for idx in opening_bracket_index:
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L11_L12 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | cnt += 1
i += 1
return cnt >= 2
| for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L11_L13 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | i += 1
return cnt >= 2
| for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L11_L14 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L11_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/132/L12_L12 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | cnt += 1
i += 1
return cnt >= 2
| if i < l and idx < closing_bracket_index[i]:
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L12_L13 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | i += 1
return cnt >= 2
| if i < l and idx < closing_bracket_index[i]:
cnt += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L12_L14 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L12_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/132/L13_L13 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | i += 1
return cnt >= 2
| cnt += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L13_L14 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| cnt += 1
i += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L13_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/132/L14_L14 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| i += 1
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... |
MultiLineInfilling/HumanEval/132/L14_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/132/L15_L15 | is_nested |
def is_nested(string):
'''
Create a function that takes a string as input which contains only square brackets.
The function should return True if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested('[[]]') ➞ True
is_nested('[... | return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
a... | |
MultiLineInfilling/HumanEval/133/L0_L0 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared = 0
for i in lst:
squared += math.ceil(i)**2
return squared
| import math
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L0_L1 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | for i in lst:
squared += math.ceil(i)**2
return squared
| import math
squared = 0
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L0_L2 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared += math.ceil(i)**2
return squared
| import math
squared = 0
for i in lst:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L0_L3 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | return squared
| import math
squared = 0
for i in lst:
squared += math.ceil(i)**2
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L0_L4 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | import math
squared = 0
for i in lst:
squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... | |
MultiLineInfilling/HumanEval/133/L1_L1 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | for i in lst:
squared += math.ceil(i)**2
return squared
| squared = 0
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L1_L2 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared += math.ceil(i)**2
return squared
| squared = 0
for i in lst:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L1_L3 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | return squared
| squared = 0
for i in lst:
squared += math.ceil(i)**2
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L1_L4 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared = 0
for i in lst:
squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... | |
MultiLineInfilling/HumanEval/133/L2_L2 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared += math.ceil(i)**2
return squared
| for i in lst:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L2_L3 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | return squared
| for i in lst:
squared += math.ceil(i)**2
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L2_L4 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | for i in lst:
squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... | |
MultiLineInfilling/HumanEval/133/L3_L3 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | return squared
| squared += math.ceil(i)**2
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... |
MultiLineInfilling/HumanEval/133/L3_L4 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... | |
MultiLineInfilling/HumanEval/133/L4_L4 | sum_squares |
def sum_squares(lst):
"""You are given a list of numbers.
You need to return the sum of squared numbers in the given list,
round each element in the list to the upper int(Ceiling) first.
Examples:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst =... | return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (goo... | |
MultiLineInfilling/HumanEval/134/L1_L1 | check_if_last_char_is_a_letter |
def check_if_last_char_is_a_letter(txt):
'''
Create a function that returns True if the last character
of a given string is an alphabetical character and is not
a part of a word, and False otherwise.
Note: "word" is a group of characters separated by space.
Examples:
check_if_last_char_is_... | return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False
| check = txt.split(' ')[-1]
| def check(candidate):
# Check some simple cases
assert candidate("apple") == False
assert candidate("apple pi e") == True
assert candidate("eeeee") == False
assert candidate("A") == True
assert candidate("Pumpkin pie ") == False
assert candidate("Pumpkin pie 1") == False
assert candidat... |
MultiLineInfilling/HumanEval/134/L1_L2 | check_if_last_char_is_a_letter |
def check_if_last_char_is_a_letter(txt):
'''
Create a function that returns True if the last character
of a given string is an alphabetical character and is not
a part of a word, and False otherwise.
Note: "word" is a group of characters separated by space.
Examples:
check_if_last_char_is_... | check = txt.split(' ')[-1]
return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False
| def check(candidate):
# Check some simple cases
assert candidate("apple") == False
assert candidate("apple pi e") == True
assert candidate("eeeee") == False
assert candidate("A") == True
assert candidate("Pumpkin pie ") == False
assert candidate("Pumpkin pie 1") == False
assert candidat... | |
MultiLineInfilling/HumanEval/134/L2_L2 | check_if_last_char_is_a_letter |
def check_if_last_char_is_a_letter(txt):
'''
Create a function that returns True if the last character
of a given string is an alphabetical character and is not
a part of a word, and False otherwise.
Note: "word" is a group of characters separated by space.
Examples:
check_if_last_char_is_... | return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False
| def check(candidate):
# Check some simple cases
assert candidate("apple") == False
assert candidate("apple pi e") == True
assert candidate("eeeee") == False
assert candidate("A") == True
assert candidate("Pumpkin pie ") == False
assert candidate("Pumpkin pie 1") == False
assert candidat... | |
MultiLineInfilling/HumanEval/135/L0_L0 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| ind=-1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L1 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| ind=-1
i=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L2 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| ind=-1
i=1
while i<len(arr):
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L3 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=i
i+=1
return ind
| ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L4 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L0_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L1_L1 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| i=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L1_L2 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| i=1
while i<len(arr):
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L1_L3 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=i
i+=1
return ind
| i=1
while i<len(arr):
if arr[i]<arr[i-1]:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L1_L4 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L1_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L1_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L2_L2 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| while i<len(arr):
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L2_L3 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=i
i+=1
return ind
| while i<len(arr):
if arr[i]<arr[i-1]:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L2_L4 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L2_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L2_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L3_L3 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=i
i+=1
return ind
| if arr[i]<arr[i-1]:
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L3_L4 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| if arr[i]<arr[i-1]:
ind=i
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L3_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| if arr[i]<arr[i-1]:
ind=i
i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L3_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L4_L4 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| ind=i
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L4_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| ind=i
i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L4_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L5_L5 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| i+=1
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
|
MultiLineInfilling/HumanEval/135/L5_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/135/L6_L6 | can_arrange |
def can_arrange(arr):
"""Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given array will not contain
duplicate values.
Examples:
can_arrange([1,2,4,3,5]) =... | return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| |
MultiLineInfilling/HumanEval/136/L0_L0 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | largest = list(filter(lambda x: x > 0, lst))
return (max(smallest) if smallest else None, min(largest) if largest else None)
| smallest = list(filter(lambda x: x < 0, lst))
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... |
MultiLineInfilling/HumanEval/136/L0_L1 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | return (max(smallest) if smallest else None, min(largest) if largest else None)
| smallest = list(filter(lambda x: x < 0, lst))
largest = list(filter(lambda x: x > 0, lst))
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... |
MultiLineInfilling/HumanEval/136/L0_L2 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | smallest = list(filter(lambda x: x < 0, lst))
largest = list(filter(lambda x: x > 0, lst))
return (max(smallest) if smallest else None, min(largest) if largest else None)
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... | |
MultiLineInfilling/HumanEval/136/L1_L1 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | return (max(smallest) if smallest else None, min(largest) if largest else None)
| largest = list(filter(lambda x: x > 0, lst))
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... |
MultiLineInfilling/HumanEval/136/L1_L2 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | largest = list(filter(lambda x: x > 0, lst))
return (max(smallest) if smallest else None, min(largest) if largest else None)
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... | |
MultiLineInfilling/HumanEval/136/L2_L2 | largest_smallest_integers |
def largest_smallest_integers(lst):
'''
Create a function that returns a tuple (a, b), where 'a' is
the largest of negative integers, and 'b' is the smallest
of positive integers in a list.
If there is no negative or positive integers, return them as None.
Examples:
largest_smallest_intege... | return (max(smallest) if smallest else None, min(largest) if largest else None)
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -... | |
MultiLineInfilling/HumanEval/137/L0_L0 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| temp_a, temp_b = a, b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L0_L1 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L0_L2 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L0_L3 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | return a if float(temp_a) > float(temp_b) else b
| temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L0_L4 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... | |
MultiLineInfilling/HumanEval/137/L1_L1 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L1_L2 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L1_L3 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | return a if float(temp_a) > float(temp_b) else b
| if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L1_L4 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... | |
MultiLineInfilling/HumanEval/137/L2_L2 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L2_L3 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | return a if float(temp_a) > float(temp_b) else b
| if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L2_L4 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... | |
MultiLineInfilling/HumanEval/137/L3_L3 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | return a if float(temp_a) > float(temp_b) else b
| if float(temp_a) == float(temp_b): return None
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... |
MultiLineInfilling/HumanEval/137/L3_L4 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... | |
MultiLineInfilling/HumanEval/137/L4_L4 | compare_one |
def compare_one(a, b):
"""
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return None if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
... | return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candid... | |
MultiLineInfilling/HumanEval/138/L0_L0 | is_equal_to_sum_even |
def is_equal_to_sum_even(n):
"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
Example
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True
"""
| return n%2 == 0 and n >= 8
| def check(candidate):
assert candidate(4) == False
assert candidate(6) == False
assert candidate(8) == True
assert candidate(10) == True
assert candidate(11) == False
assert candidate(12) == True
assert candidate(13) == False
assert candidate(16) == True
| |
MultiLineInfilling/HumanEval/139/L0_L0 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| fact_i = 1
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L0_L1 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| fact_i = 1
special_fact = 1
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L0_L2 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | fact_i *= i
special_fact *= fact_i
return special_fact
| fact_i = 1
special_fact = 1
for i in range(1, n+1):
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L0_L3 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | special_fact *= fact_i
return special_fact
| fact_i = 1
special_fact = 1
for i in range(1, n+1):
fact_i *= i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L0_L4 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | return special_fact
| fact_i = 1
special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L0_L5 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | fact_i = 1
special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
| |
MultiLineInfilling/HumanEval/139/L1_L1 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| special_fact = 1
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L1_L2 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | fact_i *= i
special_fact *= fact_i
return special_fact
| special_fact = 1
for i in range(1, n+1):
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L1_L3 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | special_fact *= fact_i
return special_fact
| special_fact = 1
for i in range(1, n+1):
fact_i *= i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L1_L4 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | return special_fact
| special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L1_L5 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
| |
MultiLineInfilling/HumanEval/139/L2_L2 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | fact_i *= i
special_fact *= fact_i
return special_fact
| for i in range(1, n+1):
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L2_L3 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | special_fact *= fact_i
return special_fact
| for i in range(1, n+1):
fact_i *= i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
MultiLineInfilling/HumanEval/139/L2_L4 | special_factorial |
def special_factorial(n):
"""The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
... | return special_fact
| for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.