Dataset Viewer
task_id
stringlengths 15
17
| prompt
stringlengths 47
746
| code
stringlengths 42
900
| testcode
stringlengths 153
1.84k
| entry_point
stringlengths 1
30
|
|---|---|---|---|---|
bt_JHumanEval/0
|
ใชในใnumbersใฎไธญใซใไธใใใใthresholdใใ่ฟใ๏ผใคใฎๆฐๅคใๅญๅจใใใๅคๅฎใใ
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
|
from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.8) == False
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1) == True
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 1.0) == True
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1], 0.5) == False
candidate = has_close_elements
check(candidate)
|
has_close_elements
|
bt_JHumanEval/1
|
ใใฎ้ขๆฐใธใฎๅ
ฅๅใฏใๅ
ฅใๅญใซใชใฃใๆฌๅผงใ่คๆฐๅซใพใใๆๅญๅใงใใใ
ใใชใใฎ็ฎ็ใฏใใใใใฎๆฌๅผงใๅฅใ
ใฎๆๅญๅใซๅๅฒใใใใฎใชในใใ่ฟใใใจใงใใใ
ๅ้ขใใใๆฌๅผงใฏใใฉใณในใใจใใใคใพใใ้ใใๆฌๅผงใฏใใใใ้ฉๅใซ้ใใใใฆใใฆใ
ไบใใซๅ
ฅใๅญใซใชใฃใฆใใชใใๅผๆฐใฎๆๅญๅๅ
ใฎ็ฉบ็ฝใฏ็ก่ฆใใใ
>>> separate_paren_groups('( ) (( )) (( )( ))')
['()', '(())', '(()())']
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [
'(()())', '((()))', '()', '((())()())'
]
assert candidate('() (()) ((())) (((())))') == [
'()', '(())', '((()))', '(((())))'
]
assert candidate('(()(())((())))') == [
'(()(())((())))'
]
assert candidate('( ) (( )) (( )( ))') == ['()', '(())', '(()())']
candidate = separate_paren_groups
check(candidate)
|
separate_paren_groups
|
bt_JHumanEval/2
|
ๆญฃใฎๆตฎๅๅฐๆฐ็นๆฐใไธใใใใใจใใใใๆดๆฐ้จ๏ผไธใใใใๆฐใใๅฐใใๆๅคงใฎๆดๆฐ๏ผ
ใจๅฐๆฐ้จ๏ผๅธธใซ1ใใๅฐใใๆฎไฝ้จๅ๏ผใซๅ่งฃใใใใจใใงใใใ
้ขๆฐใฏใๆฐๅคใฎๅฐๆฐ้จใ่ฟใใ
>>> truncate_number(3.5)
0.5
|
def truncate_number(number: float) -> float:
return number % 1.0
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3.5) == 0.5
assert abs(candidate(1.33) - 0.33) < 1e-6
assert abs(candidate(123.456) - 0.456) < 1e-6
candidate = truncate_number
check(candidate)
|
truncate_number
|
bt_JHumanEval/3
|
้่กๅฃๅบงใซๅฏพใใๅ
ฅๅบ้ๆไฝใฎใชในใใไธใใใใพใใใใชใใฎใฟในใฏใฏใๆฎ้ซใผใญใใ
ๅงใพใฆใๅฃๅบงใฎๆฎ้ซใใผใญไปฅไธใซใชใฃใใใฉใใใๆคๅบใใใใฎๆ็นใง้ขๆฐใTrueใ
่ฟใใใใซใใใใจใงใใใใใงใชใใใฐFalseใ่ฟใใใใซใใฆใใ ใใใ
>>> below_zero([1, 2, 3])
False
>>> below_zero([1, 2, -4, 5])
True
|
from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == False
assert candidate([1, 2, -3, 1, 2, -3]) == False
assert candidate([1, 2, -4, 5, 6]) == True
assert candidate([1, -1, 2, -2, 5, -5, 4, -4]) == False
assert candidate([1, -1, 2, -2, 5, -5, 4, -5]) == True
assert candidate([1, -2, 2, -2, 5, -5, 4, -4]) == True
candidate = below_zero
check(candidate)
|
below_zero
|
bt_JHumanEval/4
|
็ฌฌไธๅผๆฐใฎๆฐๅคใชในใใซๅฏพใใฆใใใฎใใผใฟใปใใใฎๅนณๅๅคใไธญๅฟใจใใๅนณๅ็ตถๅฏพๅๅทฎ(MAD)ใ่จ็ฎใใใ
ๅนณๅ็ตถๅฏพๅๅทฎ(MAD)ใจใฏใๅ่ฆ็ด ใจไธญๅฟ็น๏ผใใฎๅ ดๅใฏๅนณๅๅค๏ผใจใฎๅทฎใฎ็ตถๅฏพๅคใฎๅนณๅใงใใ:
MAD = ๅนณๅ๏ฝx - x_mean๏ฝ
>>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
1.0
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert abs(candidate([1.0, 2.0, 3.0]) - 2.0/3.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0]) - 1.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0, 5.0]) - 6.0/5.0) < 1e-6
candidate = mean_absolute_deviation
check(candidate)
|
mean_absolute_deviation
|
bt_JHumanEval/5
|
ๆฐๅคใชในใ numbers ไธญใฎๅ
จใฆใฎ้ฃ็ถใใไบ่ฆ็ด ใฎ้ใซใ'delimeterใฎๅคใๆฟๅ
ฅใใ
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
|
from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 7) == []
assert candidate([5, 6, 3, 2], 8) == [5, 8, 6, 8, 3, 8, 2]
assert candidate([2, 2, 2], 2) == [2, 2, 2, 2, 2]
candidate = intersperse
check(candidate)
|
intersperse
|
bt_JHumanEval/6
|
ใใฎ้ขๆฐใฎๅ
ฅๅใฏใ็ฉบ็ฝใงๅบๅใใใ่คๆฐใฎๅ
ฅใๅญใซใชใฃใๆฌๅผงใฎใฐใซใผใใ่กจใๆๅญๅใงใใ
ๅใฐใซใผใใซใคใใฆใๆฌๅผงใฎๆใๆทฑใๅ
ฅใๅญใฎใฌใใซใๅบๅใใพใใ
ไพใใฐใ'(()())'ใฏๆๅคงใง2ใฌใใซใฎๅ
ฅใๅญใซใชใฃใฆใใพใใใ'((()))'ใฏ3ใฌใใซใงใใ
>>> parse_nested_parens('(()()) ((())) () ((())()())')
[2, 3, 1, 3]
|
from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
def parse_paren_group(s):
depth = 0
max_depth = 0
for c in s:
if c == '(':
depth += 1
max_depth = max(depth, max_depth)
else:
depth -= 1
return max_depth
return [parse_paren_group(x) for x in paren_string.split(' ') if x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [2, 3, 1, 3]
assert candidate('() (()) ((())) (((())))') == [1, 2, 3, 4]
assert candidate('(()(())((())))') == [4]
candidate = parse_nested_parens
check(candidate)
|
parse_nested_parens
|
bt_JHumanEval/7
|
ๆๅญๅใชในใstringsใใไธใใใ้จๅๆๅญๅsubstringใๅซใใใฎใ ใใซใใฃใซใฟใใ
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array']
|
from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
return [x for x in strings if substring in x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
assert candidate(['xxx', 'asd', 'aaaxxy', 'john doe', 'xxxAAA', 'xxx'], 'xx') == ['xxx', 'aaaxxy', 'xxxAAA', 'xxx']
assert candidate(['grunt', 'trumpet', 'prune', 'gruesome'], 'run') == ['grunt', 'prune']
candidate = filter_by_substring
check(candidate)
|
filter_by_substring
|
bt_JHumanEval/8
|
ไธใใใใๆดๆฐใชในใใซๅฏพใใฆใใชในใๅ
ใฎใในใฆใฎๆดๆฐใฎๅใจ็ฉใใใชใใฟใใซใ่ฟใใ
ใใ ใใ็ฉบใฎๅใฏ0ใ็ฉบใฎ็ฉใฏ1ใจใใใ
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24)
|
from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == (0, 1)
assert candidate([1, 1, 1]) == (3, 1)
assert candidate([100, 0]) == (100, 0)
assert candidate([3, 5, 7]) == (3 + 5 + 7, 3 * 5 * 7)
assert candidate([10]) == (10, 10)
candidate = sum_product
check(candidate)
|
sum_product
|
bt_JHumanEval/9
|
ไธใใใใๆดๆฐใชในใใใใๅ่ฆ็ด ใฎใใใพใงใฎๆๅคงๅค๏ผใญใผใชใณใฐๆๅคงๅค๏ผใฎใชในใใ็ๆใใใ
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
|
from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
running_max = None
result = []
for n in numbers:
if running_max is None:
running_max = n
else:
running_max = max(running_max, n)
result.append(running_max)
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
assert candidate([4, 3, 2, 1]) == [4, 4, 4, 4]
assert candidate([3, 2, 3, 100, 3]) == [3, 3, 3, 100, 100]
candidate = rolling_max
check(candidate)
|
rolling_max
|
bt_JHumanEval/10
|
ไธใใใใๆๅญๅใงๅงใพใๆ็ญใฎๅๆใ่ฆใคใใฆใใ ใใใ
ใขใซใดใชใบใ ใฎใขใคใใขใฏไปฅไธใฎ้ใใงใ๏ผ
- ไธใใใใๆๅญๅใฎไธญใงๆใ้ทใๅๆใจใชใๆฅๅฐพ่พใ่ฆใคใใพใใ
- ใใฎๅๆใฎๆฅๅฐพ่พใฎๅใซๆฅใๆฅ้ ญ่พใ้้ ใซใใฆใๆๅญๅใฎๆซๅฐพใซ่ฟฝๅ ใใพใใ
>>> make_palindrome('')
''
>>> make_palindrome('cat')
'catac'
>>> make_palindrome('cata')
'catac'
|
def is_palindrome(string: str) -> bool:
return string == string[::-1]
def make_palindrome(string: str) -> str:
if not string:
return ''
beginning_of_suffix = 0
while not is_palindrome(string[beginning_of_suffix:]):
beginning_of_suffix += 1
return string + string[:beginning_of_suffix][::-1]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('x') == 'x'
assert candidate('xyz') == 'xyzyx'
assert candidate('xyx') == 'xyx'
assert candidate('jerry') == 'jerryrrej'
candidate = make_palindrome
check(candidate)
|
make_palindrome
|
bt_JHumanEval/11
|
ๅผๆฐใฏ1ใจ0ใฎใฟใใใชใๆๅญๅaใจbใงใใใ
ใใใใฎๅผๆฐใซๅฏพใใฆๆไป่ซ็ๅ(XOR)ใๅฎ่กใใ็ตๆใๆๅญๅใจใใฆ่ฟใใ
>>> string_xor('010', '110')
'100'
|
from typing import List
def string_xor(a: str, b: str) -> str:
def xor(i, j):
if i == j:
return '0'
else:
return '1'
return ''.join(xor(x, y) for x, y in zip(a, b))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('111000', '101010') == '010010'
assert candidate('1', '1') == '0'
assert candidate('0101', '0000') == '0101'
candidate = string_xor
check(candidate)
|
string_xor
|
bt_JHumanEval/12
|
ๆๅญๅใฎใชในใใฎใใกใๆใ้ทใใใฎใ่ฟใใๅใ้ทใใฎๆๅญๅใ
่คๆฐใใๅ ดๅใฏๆๅใฎใใฎใ่ฟใใๅ
ฅๅใชในใใ็ฉบใฎๅ ดๅใฏ None ใ่ฟใใ
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a'
>>> longest(['a', 'bb', 'ccc'])
'ccc'
|
from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
if not strings:
return None
maxlen = max(len(x) for x in strings)
for s in strings:
if len(s) == maxlen:
return s
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == None
assert candidate(['x', 'y', 'z']) == 'x'
assert candidate(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc']) == 'zzzz'
candidate = longest
check(candidate)
|
longest
|
bt_JHumanEval/13
|
ๆดๆฐ a ใจ b ใฎๆๅคงๅ
ฌ็ดๆฐใ่ฟใ
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
|
def greatest_common_divisor(a: int, b: int) -> int:
while b:
a, b = b, a % b
return a
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3, 7) == 1
assert candidate(10, 15) == 5
assert candidate(49, 14) == 7
assert candidate(144, 60) == 12
candidate = greatest_common_divisor
check(candidate)
|
greatest_common_divisor
|
bt_JHumanEval/14
|
ๅผๆฐใงไธใใใใๆๅญๅใซๅฏพใใฆใ็ญใใใฎใใ้ทใใใฎใธใๅ
จใฆใฎๆฅ้ ญ่พใฎใชในใใ่ฟใ
>>> all_prefixes('abc')
['a', 'ab', 'abc']
|
from typing import List
def all_prefixes(string: str) -> List[str]:
result = []
for i in range(len(string)):
result.append(string[:i+1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('asdfgh') == ['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']
assert candidate('WWW') == ['W', 'WW', 'WWW']
candidate = all_prefixes
check(candidate)
|
all_prefixes
|
bt_JHumanEval/15
|
0ใใnใพใงใฎๆฐๅญใ็ฉบ็ฝๅบๅใใง้ฃ็ตใใๆๅญๅใง่ฟใใ
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
|
def string_sequence(n: int) -> str:
return ' '.join([str(x) for x in range(n + 1)])
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(0) == '0'
assert candidate(3) == '0 1 2 3'
assert candidate(10) == '0 1 2 3 4 5 6 7 8 9 10'
candidate = string_sequence
check(candidate)
|
string_sequence
|
bt_JHumanEval/16
|
ๆๅญๅใไธใใใใใจใใใใฎๆๅญๅใ๏ผๅคงๆๅญๅฐๆๅญใซ้ขไฟใชใ๏ผใใใคใฎ็ฐใชใๆๅญใๅซใพใใฆใใใๆฐใใ
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
|
def count_distinct_characters(string: str) -> int:
return len(set(string.lower()))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('abcde') == 5
assert candidate('abcde' + 'cade' + 'CADE') == 5
assert candidate('aaaaAAAAaaaa') == 1
assert candidate('Jerry jERRY JeRRRY') == 5
candidate = count_distinct_characters
check(candidate)
|
count_distinct_characters
|
bt_JHumanEval/17
|
ใใฎ้ขๆฐใฎๅผๆฐใฏใ็นๅฅใชASCIIๅฝขๅผใฎ้ณ็ฌฆใ่กจใๆๅญๅใงใใใใใชใใฎไปไบใฏใใใฎๆๅญๅใ่งฃๆใใฆใใใใใใฎ้ณ็ฌฆใไฝๆ็ถใใใซๅฏพๅฟใใๆดๆฐใฎใชในใใ่ฟใใใจใงใใใ
ใใใซๅกไพใใใ๏ผ
o' - ๅ
จ้ณ็ฌฆใ4ๆ็ถใ
o|' - 2ๅ้ณ็ฌฆใ2ๆ็ถใ
.|ใ-4ๅ้ณ็ฌฆใ1ๆ็ถใ
>>> parse_music('o o| .| o| o| .| .| .| .| o o')
[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
|
from typing import List
def parse_music(music_string: str) -> List[int]:
note_map = {'o': 4, 'o|': 2, '.|': 1}
return [note_map[x] for x in music_string.split(' ') if x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('o o o o') == [4, 4, 4, 4]
assert candidate('.| .| .| .|') == [1, 1, 1, 1]
assert candidate('o| o| .| .| o o o o') == [2, 2, 1, 1, 4, 4, 4, 4]
assert candidate('o| .| o| .| o o| o o|') == [2, 1, 2, 1, 4, 2, 4, 2]
candidate = parse_music
check(candidate)
|
parse_music
|
bt_JHumanEval/18
|
้จๅๆๅญๅsubstringใๆๅญๅstringใฎไธญใงไฝๅ่ฆใคใใใๆฐใใใ
้ใชใใฑใผในใใซใฆใณใใซๅซใพใใใ
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
|
def how_many_times(string: str, substring: str) -> int:
times = 0
for i in range(len(string) - len(substring) + 1):
if string[i:i+len(substring)] == substring:
times += 1
return times
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('', 'x') == 0
assert candidate('xyxyxyx', 'x') == 4
assert candidate('cacacacac', 'cac') == 4
assert candidate('john doe', 'john') == 1
candidate = how_many_times
check(candidate)
|
how_many_times
|
bt_JHumanEval/19
|
ๅผๆฐใฏ'zero'ใใ'nine'ใพใงใฎ่ฑๅ่ชใฎๆฐใ็ฉบ็ฝใงๅบๅใฃใๆๅญๅใงใใใ
ๆๅนใช่ฑๅ่ชใฏ''ใ'zero', 'one'ใ'two'ใ'three'ใ'four'ใ'five'ใ'six'ใ'seven'ใ'eight'ใ'nine'ใงใใใ
้ขๆฐใฏใ่ฑๅ่ชใฎๆฐใๅฐใใๆนใใๅคงใใๆนใธใจใฝใผใใใๆๅญๅใ่ฟใใ
>>> sort_numbers('three one five')
'one three five'
|
from typing import List
def sort_numbers(numbers: str) -> str:
value_map = {
'zero': 0,
'one': 1,
'two': 2,
'three': 3,
'four': 4,
'five': 5,
'six': 6,
'seven': 7,
'eight': 8,
'nine': 9
}
return ' '.join(sorted([x for x in numbers.split(' ') if x], key=lambda x: value_map[x]))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('three') == 'three'
assert candidate('three five nine') == 'three five nine'
assert candidate('five zero four seven nine eight') == 'zero four five seven eight nine'
assert candidate('six five four three two one zero') == 'zero one two three four five six'
candidate = sort_numbers
check(candidate)
|
sort_numbers
|
bt_JHumanEval/20
|
๏ผๅฐใชใใจใ้ทใ2ไปฅไธใฎ๏ผใชในใnumbersใใใไบใใซๆใ่ฟใใใฎใ2ใค้ธใณใ
้ ็ชใซ๏ผๅฐใใๆฐใๅคงใใๆฐ๏ผ่ฟใใ
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
(2.0, 2.0)
|
from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
closest_pair = None
distance = None
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
else:
new_distance = abs(elem - elem2)
if new_distance < distance:
distance = new_distance
closest_pair = tuple(sorted([elem, elem2]))
return closest_pair
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2]) == (3.9, 4.0)
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0]) == (5.0, 5.9)
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
assert candidate([1.1, 2.2, 3.1, 4.1, 5.1]) == (2.2, 3.1)
candidate = find_closest_elements
check(candidate)
|
find_closest_elements
|
bt_JHumanEval/21
|
(ๅฐใชใใจใ 2 ใคไปฅไธใฎ่ฆ็ด ใใใชใ) ใชในใnumbersใซ็ทๅฝขๅคๆใ้ฉ็จใใ
ๆๅฐใฎๆฐๅคใ 0 ใซใชใใๆๅคงใฎๆฐๅคใ 1 ใซใชใใชในใใ่ฟใ
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0]
|
from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
min_number = min(numbers)
max_number = max(numbers)
return [(x - min_number) / (max_number - min_number) for x in numbers]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([2.0, 49.9]) == [0.0, 1.0]
assert candidate([100.0, 49.9]) == [1.0, 0.0]
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
assert candidate([2.0, 1.0, 5.0, 3.0, 4.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]
assert candidate([12.0, 11.0, 15.0, 13.0, 14.0]) == [0.25, 0.0, 1.0, 0.5, 0.75]
candidate = rescale_to_unit
check(candidate)
|
rescale_to_unit
|
bt_JHumanEval/22
|
ไปปๆใฎ็จฎ้กใฎๅคใๅซใพใใใชในใใใๆดๆฐๅคใฎใฟๆฝๅบใใ
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
|
from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
return [x for x in values if isinstance(x, int)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([4, {}, [], 23.2, 9, 'adasd']) == [4, 9]
assert candidate([3, 'c', 3, 3, 'a', 'b']) == [3, 3, 3]
candidate = filter_integers
check(candidate)
|
filter_integers
|
bt_JHumanEval/23
|
ๅผๆฐใงไธใใใใๆๅญๅใฎ้ทใใ่ฟใ
>>> strlen('')
0
>>> strlen('abc')
3
|
def strlen(string: str) -> int:
return len(string)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('x') == 1
assert candidate('asdasnakj') == 9
candidate = strlen
check(candidate)
|
strlen
|
bt_JHumanEval/24
|
ไธใใใใๆฐnใซใคใใฆใnใฎ็ดๆฐใฎใใกใnใใๅฐใใๆๅคงใฎๆฐใๆฑใใ
>>> largest_divisor(15)
5
|
def largest_divisor(n: int) -> int:
for i in reversed(range(n)):
if n % i == 0:
return i
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3) == 1
assert candidate(7) == 1
assert candidate(10) == 5
assert candidate(100) == 50
assert candidate(49) == 7
candidate = largest_divisor
check(candidate)
|
largest_divisor
|
bt_JHumanEval/25
|
ไธใใใใๆดๆฐใฎ็ด ๅ ๆฐใฎใชในใใๅฐใใใใฎใใๅคงใใใใฎใฎ้ ใซ่ฟใใๅๅ ๆฐใฏใ
ๅ ๆฐๅ่งฃใง็พใใๅๆฐๅใใชในใใซ็ปๅ ดใใใๅผๆฐใฎๆดๆฐใฏๅ
จใฆใฎๅ ๆฐใฎ็ฉใซ็ญใใใช
ใใใฐใชใใชใใ
>>> factorize(8)
[2, 2, 2]
>>> factorize(25)
[5, 5]
>>> factorize(70)
[2, 5, 7]
|
from typing import List
def factorize(n: int) -> List[int]:
import math
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(2) == [2]
assert candidate(4) == [2, 2]
assert candidate(8) == [2, 2, 2]
assert candidate(3 * 19) == [3, 19]
assert candidate(3 * 19 * 3 * 19) == [3, 3, 19, 19]
assert candidate(3 * 19 * 3 * 19 * 3 * 19) == [3, 3, 3, 19, 19, 19]
assert candidate(3 * 19 * 19 * 19) == [3, 19, 19, 19]
assert candidate(3 * 2 * 3) == [2, 3, 3]
candidate = factorize
check(candidate)
|
factorize
|
bt_JHumanEval/26
|
ๆดๆฐใฎใชในใใใใ่คๆฐๅๅบ็พใใ่ฆ็ด ใใในใฆๅใ้คใใ
่ฆ็ด ใฎ้ ๅบใฏๅ
ฅๅใจๅใใใใซใใใ
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
|
from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
import collections
c = collections.Counter(numbers)
return [n for n in numbers if c[n] <= 1]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
assert candidate([1, 2, 3, 2, 4, 3, 5]) == [1, 4, 5]
candidate = remove_duplicates
check(candidate)
|
remove_duplicates
|
bt_JHumanEval/27
|
ไธใใใใๆๅญๅใซๅฏพใใฆใ่ฑๅฐๆๅญใ่ฑๅคงๆๅญใซใ่ฑๅคงๆๅญใ่ฑๅฐๆๅญใซๅคๆใใใ
>>> flip_case('Hello')
'hELLO'
|
def flip_case(string: str) -> str:
return string.swapcase()
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('Hello!') == 'hELLO!'
assert candidate('These violent delights have violent ends') == 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'
candidate = flip_case
check(candidate)
|
flip_case
|
bt_JHumanEval/28
|
ๆๅญๅใฎใชในใใ1ใคใฎๆๅญๅใซ้ฃ็ตใใ
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
|
from typing import List
def concatenate(strings: List[str]) -> str:
return ''.join(strings)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == ''
assert candidate(['x', 'y', 'z']) == 'xyz'
assert candidate(['x', 'y', 'z', 'w', 'k']) == 'xyzwk'
candidate = concatenate
check(candidate)
|
concatenate
|
bt_JHumanEval/29
|
ๆๅญๅใฎใชในใใใใๆๅฎใใใๆฅ้ ญ่พprefixใงๅงใพใใใฎใ ใใๅใๅบใใ
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
|
from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
return [x for x in strings if x.startswith(prefix)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
candidate = filter_by_prefix
check(candidate)
|
filter_by_prefix
|
bt_JHumanEval/30
|
ใชในใๅ
ใฎๆญฃใฎๆฐใ ใใ่ฟใใ
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
|
def get_positive(l: list):
return [e for e in l if e > 0]
|
METADATA = {}
def check(candidate):
assert candidate([-1, -2, 4, 5, 6]) == [4, 5, 6]
assert candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]
assert candidate([-1, -2]) == []
assert candidate([]) == []
candidate = get_positive
check(candidate)
|
get_positive
|
bt_JHumanEval/31
|
ไธใใใใๆฐใ็ด ๆฐใงใใใฐ็ใใใใใงใชใใใฐๅฝใ่ฟใใ
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
|
def is_prime(n):
if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate(6) == False
assert candidate(101) == True
assert candidate(11) == True
assert candidate(13441) == True
assert candidate(61) == True
assert candidate(4) == False
assert candidate(1) == False
assert candidate(5) == True
assert candidate(11) == True
assert candidate(17) == True
assert candidate(5 * 17) == False
assert candidate(11 * 7) == False
assert candidate(13441 * 19) == False
candidate = is_prime
check(candidate)
|
is_prime
|
bt_JHumanEval/32
|
xsใฏๅค้
ๅผใฎไฟๆฐใงใใใ
find_zero้ขๆฐใฏใpoly(x) = 0 ใจใชใ x ใ่ฆใคใใใ
find_zero้ขๆฐใฏใใใจใ่คๆฐ่งฃใใใฃใใจใใฆใ่งฃใใฒใจใคใฎใฟใ่ฟใใ
ใใใซใfind_zero้ขๆฐใฏใ่งฃใๆใคใใจใไฟ่จผใใใใใๅถๆฐๅใฎไฟๆฐxsใจ
ๆๅคงไฟๆฐใฏๅธธใซ0ใงใชใใจๆณๅฎใใใ
>>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-0.5
>>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
1.0
|
import math
def poly(xs: list, x: float):
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
begin, end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
|
METADATA = {}
def check(candidate):
import math
import random
rng = random.Random(42)
import copy
for _ in range(100):
ncoeff = 2 * rng.randint(1, 4)
coeffs = []
for _ in range(ncoeff):
coeff = rng.randint(-10, 10)
if coeff == 0:
coeff = 1
coeffs.append(coeff)
solution = candidate(copy.deepcopy(coeffs))
assert math.fabs(poly(coeffs, solution)) < 1e-4
candidate = find_zero
check(candidate)
|
find_zero
|
bt_JHumanEval/33
|
ใใฎ้ขๆฐใฏใชในใlใๅใๅใใl'ใ่ฟใใl'ใฏใใคใณใใใฏในใ3ใงๅฒใ
ๅใใชใๅ ดๅใฏlใจๅใใงใใใใใคใณใใใฏในใ3ใงๅฒใๅใใ่ฆ็ด ใฏ
ใฝใผใใใใฆใใใ
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_third([5, 6, 3, 4, 8, 9, 2])
[2, 6, 3, 4, 8, 9, 5]
|
def sort_third(l: list):
l = list(l)
l[::3] = sorted(l[::3])
return l
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple(sort_third([1, 2, 3]))
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple(sort_third([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]))
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple(sort_third([5, 8, -12, 4, 23, 2, 3, 11, 12, -10]))
assert tuple(candidate([5, 6, 3, 4, 8, 9, 2])) == tuple([2, 6, 3, 4, 8, 9, 5])
assert tuple(candidate([5, 8, 3, 4, 6, 9, 2])) == tuple([2, 8, 3, 4, 6, 9, 5])
assert tuple(candidate([5, 6, 9, 4, 8, 3, 2])) == tuple([2, 6, 9, 4, 8, 3, 5])
assert tuple(candidate([5, 6, 3, 4, 8, 9, 2, 1])) == tuple([2, 6, 3, 4, 8, 9, 5, 1])
candidate = sort_third
check(candidate)
|
sort_third
|
bt_JHumanEval/34
|
ใชในใๅ
ใฎใฆใใผใฏใช่ฆ็ด ใใฝใผใใใฆ่ฟใ
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
|
def unique(l: list):
return sorted(list(set(l)))
|
METADATA = {}
def check(candidate):
assert candidate([5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
candidate = unique
check(candidate)
|
unique
|
bt_JHumanEval/35
|
ใชในใๅ
ใฎๆๅคง่ฆ็ด ใ่ฟใใ
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
|
def max_element(l: list):
m = l[0]
for e in l:
if e > m:
m = e
return m
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 3]) == 3
assert candidate([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]) == 124
candidate = max_element
check(candidate)
|
max_element
|
bt_JHumanEval/36
|
11ใพใใฏ13ใงๅฒใๅใใnๆชๆบใฎๆดๆฐใฎไธญใซ7ใจใใๆฐๅญใ็พใใๅๆฐใ่ฟใใ
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
|
def fizz_buzz(n: int):
ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
|
METADATA = {}
def check(candidate):
assert candidate(50) == 0
assert candidate(78) == 2
assert candidate(79) == 3
assert candidate(100) == 3
assert candidate(200) == 6
assert candidate(4000) == 192
assert candidate(10000) == 639
assert candidate(100000) == 8026
candidate = fizz_buzz
check(candidate)
|
fizz_buzz
|
bt_JHumanEval/37
|
ใใฎ้ขๆฐใฏใชในใ l ใๅใๅใใl' ใ่ฟใใl'ใฏใใคใณใใใฏในใๅฅๆฐใฎ
ใจใใฏ l ใจๅใใงใใคใณใใใฏในใๅถๆฐใฎใจใใฏใฝใผใใใใฆใใใ
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4]
|
def sort_even(l: list):
evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple([1, 2, 3])
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple([-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123])
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple([-12, 8, 3, 4, 5, 2, 12, 11, 23, -10])
candidate = sort_even
check(candidate)
|
sort_even
|
bt_JHumanEval/38
|
encode_cyclic้ขๆฐใงใจใณใณใผใใใใๆๅญๅใๅผๆฐใซๅใใใใณใผใใใใๆๅญๅใ่ฟใใ
|
def encode_cyclic(s: str):
# ๆๅญๅ้ทใ3ใซใชใใใใซๆๅญๅใใฐใซใผใๅ
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ใฐใซใผใใฎ้ทใใ3ๆชๆบใงใชใ้ใใๅใฐใซใผใใๅพช็ฐใใใ
groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
return "".join(groups)
def decode_cyclic(s: str):
return encode_cyclic(encode_cyclic(s))
|
METADATA = {}
def check(candidate):
from random import randint, choice
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_cyclic(str)
assert candidate(encoded_str) == str
candidate = decode_cyclic
check(candidate)
|
decode_cyclic
|
bt_JHumanEval/39
|
prime_fib ใฏใใฃใใใใๆฐใงใใใค็ด ๆฐใงใใn็ช็ฎใฎๆฐใ่ฟใใ
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
|
def prime_fib(n: int):
import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
n -= 1
if n == 0:
return f[-1]
|
METADATA = {}
def check(candidate):
assert candidate(1) == 2
assert candidate(2) == 3
assert candidate(3) == 5
assert candidate(4) == 13
assert candidate(5) == 89
assert candidate(6) == 233
assert candidate(7) == 1597
assert candidate(8) == 28657
assert candidate(9) == 514229
assert candidate(10) == 433494437
candidate = prime_fib
check(candidate)
|
prime_fib
|
bt_JHumanEval/40
|
triples_sum_to_zero ใฏๆดๆฐใฎใชในใใๅผๆฐใซๅใใ
ใชในใใฎไธญใซๅใ0ใซใชใ๏ผใคใฎ่ฆ็ด ใใใใฐTrueใใ
ใใใงใชใใใฐFalseใ่ฟใใ
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True
>>> triples_sum_to_zero([1, 2, 3, 7])
False
>>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
True
>>> triples_sum_to_zero([1])
False
|
def triples_sum_to_zero(l: list):
for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, 5, -1]) == False
assert candidate([1, 3, -2, 1]) == True
assert candidate([1, 2, 3, 7]) == False
assert candidate([1, 2, 5, 7]) == False
assert candidate([2, 4, -5, 3, 9, 7]) == True
assert candidate([1]) == False
assert candidate([1, 3, 5, -100]) == False
assert candidate([100, 3, 5, -100]) == False
candidate = triples_sum_to_zero
check(candidate)
|
triples_sum_to_zero
|
bt_JHumanEval/41
|
ๅฎๅ
จใช็ด็ทใง็ก้ใซ้ทใ้่ทฏใๆณๅใใฆใปใใใ
nๅฐใฎ่ปใๅทฆใใๅณใซๅใใฃใฆ่ตฐใฃใฆใใใๅๆใซใๅฅใฎnๅฐใฎ่ปใ
ๅณใใๅทฆใซๅใใฃใฆ่ตฐใฃใฆใใใใใฎ2็ตใฎ่ปใฏใๆๅใฏไบใใซ้
ๅธธใซ้ขใใฆใใใใในใฆใฎ่ปใฏๅใ้ๅบฆใงๅใใ2ๅฐใฎ่ปใฏๆฌกใฎใ
ใใซ่ก็ชใใใๅทฆใใๅณใซๅใใฆใใ่ปใใๅณใใๅทฆใซๅใใฆใใ
่ปใซใถใคใใใใจใ
ใใใใ่ปใฏ้ใใชใ้ ไธใงๅผทใใใใใใ่ก็ชใใชใใฃใใใฎใ
ใใซใใใฎ่ป้ใ้ฒใฟ็ถใใใ
ใใฎ้ขๆฐใฏใใใฎใใใช่ก็ชใฎๅๆฐใๅบๅใใใ
|
def car_race_collision(n: int):
return n**2
|
METADATA = {}
def check(candidate):
assert candidate(2) == 4
assert candidate(3) == 9
assert candidate(4) == 16
assert candidate(8) == 64
assert candidate(10) == 100
candidate = car_race_collision
check(candidate)
|
car_race_collision
|
bt_JHumanEval/42
|
่ฆ็ด ใ1ใใคๅขใใใใชในใใ่ฟใใ
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
|
def incr_list(l: list):
return [(e + 1) for e in l]
|
METADATA = {}
def check(candidate):
assert candidate([]) == []
assert candidate([3, 2, 1]) == [4, 3, 2]
assert candidate([5, 2, 5, 2, 3, 3, 9, 0, 123]) == [6, 3, 6, 3, 4, 4, 10, 1, 124]
candidate = incr_list
check(candidate)
|
incr_list
|
bt_JHumanEval/43
|
pairs_sum_to_zero ใฏๆดๆฐใฎใชในใใๅผๆฐใซใจใใ
ใชในใใฎไธญใซ๏ผใคใฎ่ฆ็ด ใฎๅใใผใญใซใชใ่ฆ็ด ใใใใฐTrueใใ
ใใใงใชใใใฐFalseใ่ฟใใ
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_to_zero([1, 2, 3, 7])
False
>>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
True
>>> pairs_sum_to_zero([1])
False
|
def pairs_sum_to_zero(l):
for i, l1 in enumerate(l):
for j in range(i + 1, len(l)):
if l1 + l[j] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, -2, 1]) == False
assert candidate([1, 2, 3, 7]) == False
assert candidate([2, 4, -5, 3, 5, 7]) == True
assert candidate([1]) == False
assert candidate([-3, 9, -1, 3, 2, 30]) == True
assert candidate([-3, 9, -1, 3, 2, 31]) == True
assert candidate([-3, 9, -1, 4, 2, 30]) == False
assert candidate([-3, 9, -1, 4, 2, 31]) == False
candidate = pairs_sum_to_zero
check(candidate)
|
pairs_sum_to_zero
|
bt_JHumanEval/44
|
ๅผๆฐxใฎๅบๆฐใbaseใซๅคๆใใใ
่ฟใๅคใฏๅคๆๅพใฎๆๅญๅ่กจ็พใงใใใ
ๅบๆฐใฏ10ๆชๆบใงใใใ
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
|
def change_base(x: int, base: int):
ret = ""
while x > 0:
ret = str(x % base) + ret
x //= base
return ret
|
METADATA = {}
def check(candidate):
assert candidate(8, 3) == "22"
assert candidate(9, 3) == "100"
assert candidate(234, 2) == "11101010"
assert candidate(16, 2) == "10000"
assert candidate(8, 2) == "1000"
assert candidate(7, 2) == "111"
for x in range(2, 8):
assert candidate(x, x + 1) == str(x)
candidate = change_base
check(candidate)
|
change_base
|
bt_JHumanEval/45
|
ไธ่งๅฝขใฎไธ่พบใฎ้ทใใจ้ซใใไธใใใใใจใใ้ข็ฉใ่ฟใใ
>>> triangle_area(5, 3)
7.5
|
def triangle_area(a, h):
return a * h / 2.0
|
METADATA = {}
def check(candidate):
assert candidate(5, 3) == 7.5
assert candidate(2, 2) == 2.0
assert candidate(10, 8) == 40.0
candidate = triangle_area
check(candidate)
|
triangle_area
|
bt_JHumanEval/46
|
fib4ๆฐๅใฏใใฃใใใใๆฐๅใซไผผใๆฐๅใงใๆฌกใฎใใใซๅฎ็พฉใใใ๏ผ
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4ๆฐๅใฎn็ช็ฎใฎ่ฆ็ด ใๅน็็ใซ่จ็ฎใใ้ขๆฐใๆธใใๅๅธฐใฏไฝฟใใชใใใจใ
>>> fib4(5)
4
>>> fib4(6)
8
>>> fib4(7)
14
|
def fib4(n: int):
results = [0, 0, 2, 0]
if n < 4:
return results[n]
for _ in range(4, n + 1):
results.append(results[-1] + results[-2] + results[-3] + results[-4])
results.pop(0)
return results[-1]
|
METADATA = {}
def check(candidate):
assert candidate(5) == 4
assert candidate(8) == 28
assert candidate(10) == 104
assert candidate(12) == 386
candidate = fib4
check(candidate)
|
fib4
|
bt_JHumanEval/47
|
ใชในใ l ใฎ่ฆ็ด ใฎไธญๅคฎๅคใ่ฟใใ
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
|
def median(l: list):
l = sorted(l)
if len(l) % 2 == 1:
return l[len(l) // 2]
else:
return (l[len(l) // 2 - 1] + l[len(l) // 2]) / 2.0
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == 3
assert candidate([-10, 4, 6, 1000, 10, 20]) == 8.0
assert candidate([5]) == 5
assert candidate([6, 5]) == 5.5
assert candidate([8, 1, 3, 9, 9, 2, 7]) == 7
candidate = median
check(candidate)
|
median
|
bt_JHumanEval/48
|
ไธใใใใๆๅญๅใๅๆใใฉใใใๅคๅฎใใ
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
|
def is_palindrome(text: str):
for i in range(len(text)):
if text[i] != text[len(text) - 1 - i]:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate('') == True
assert candidate('aba') == True
assert candidate('aaaaa') == True
assert candidate('zbcd') == False
assert candidate('xywyx') == True
assert candidate('xywyz') == False
assert candidate('xywzx') == False
candidate = is_palindrome
check(candidate)
|
is_palindrome
|
bt_JHumanEval/49
|
2^n ใ p ใงๅฒใฃใใขใธใฅใญใ่ฟใใ่จ็ฎ็ฒพๅบฆใซๆณจๆใ
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
|
def modp(n: int, p: int):
ret = 1
for i in range(n):
ret = (2 * ret) % p
return ret
|
METADATA = {}
def check(candidate):
assert candidate(3, 5) == 3
assert candidate(1101, 101) == 2
assert candidate(0, 101) == 1
assert candidate(3, 11) == 8
assert candidate(100, 101) == 1
assert candidate(30, 5) == 4
assert candidate(31, 5) == 3
candidate = modp
check(candidate)
|
modp
|
bt_JHumanEval/50
|
encode_shift้ขๆฐใงใจใณใณใผใใใใๆๅญๅใๅผๆฐใซๅใใใใณใผใใใใๆๅญๅใ่ฟใใ
|
def encode_shift(s: str):
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
return "".join([chr(((ord(ch) - 5 - ord("a")) % 26) + ord("a")) for ch in s])
|
METADATA = {}
def check(candidate):
from random import randint, choice
import copy
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_shift(str)
assert candidate(copy.deepcopy(encoded_str)) == str
candidate = decode_shift
check(candidate)
|
decode_shift
|
bt_JHumanEval/51
|
remove_vowelsใฏๆๅญๅใๅผๆฐใซๅใใๆฏ้ณใ้คใใๆๅญๅใ่ฟใ้ขๆฐใงใใใ
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaBAA')
'B'
>>> remove_vowels('zbcd')
'zbcd'
|
def remove_vowels(text):
return "".join([s for s in text if s.lower() not in ["a", "e", "i", "o", "u"]])
|
METADATA = {}
def check(candidate):
assert candidate('') == ''
assert candidate("abcdef\nghijklm") == 'bcdf\nghjklm'
assert candidate('fedcba') == 'fdcb'
assert candidate('eeeee') == ''
assert candidate('acBAA') == 'cB'
assert candidate('EcBOO') == 'cB'
assert candidate('ybcd') == 'ybcd'
candidate = remove_vowels
check(candidate)
|
remove_vowels
|
bt_JHumanEval/52
|
ใชในใ l ๅ
ใฎๅ
จใฆใฎๆฐๅคใ้พๅค t ไปฅไธใฎๅ ดๅใTrueใ่ฟใใ
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
|
def below_threshold(l: list, t: int):
for e in l:
if e >= t:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10], 100)
assert not candidate([1, 20, 4, 10], 5)
assert candidate([1, 20, 4, 10], 21)
assert candidate([1, 20, 4, 10], 22)
assert candidate([1, 8, 4, 10], 11)
assert not candidate([1, 8, 4, 10], 10)
candidate = below_threshold
check(candidate)
|
below_threshold
|
bt_JHumanEval/53
|
2ใคใฎๆฐxใจyใ่ถณใ
>>> add(2, 3)
5
>>> add(5, 7)
12
|
def add(x: int, y: int):
return x + y
|
METADATA = {}
def check(candidate):
import random
assert candidate(0, 1) == 1
assert candidate(1, 0) == 1
assert candidate(2, 3) == 5
assert candidate(5, 7) == 12
assert candidate(7, 5) == 12
for i in range(100):
x, y = random.randint(0, 1000), random.randint(0, 1000)
assert candidate(x, y) == x + y
candidate = add
check(candidate)
|
add
|
bt_JHumanEval/54
|
2ใคใฎๅ่ชใๅใๆๅญใปใใใใๆงๆใใใใใฉใใๅคๅฎใใใ
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same_chars('abcd', 'dddddddabce')
False
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
False
|
def same_chars(s0: str, s1: str):
return set(s0) == set(s1)
|
METADATA = {}
def check(candidate):
assert candidate('eabcdzzzz', 'dddzzzzzzzddeddabc') == True
assert candidate('abcd', 'dddddddabc') == True
assert candidate('dddddddabc', 'abcd') == True
assert candidate('eabcd', 'dddddddabc') == False
assert candidate('abcd', 'dddddddabcf') == False
assert candidate('eabcdzzzz', 'dddzzzzzzzddddabc') == False
assert candidate('aabb', 'aaccc') == False
candidate = same_chars
check(candidate)
|
same_chars
|
bt_JHumanEval/55
|
n็ช็ฎใฎใใฃใใใใๆฐใ่ฟใใ
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
|
def fib(n: int):
if n == 0:
return 0
if n == 1:
return 1
return fib(n - 1) + fib(n - 2)
|
METADATA = {}
def check(candidate):
assert candidate(10) == 55
assert candidate(1) == 1
assert candidate(8) == 21
assert candidate(11) == 89
assert candidate(12) == 144
candidate = fib
check(candidate)
|
fib
|
bt_JHumanEval/56
|
ๅผๆฐbracketsใฏ"<"ใจ">"ใฎๆๅญๅใงใใใ
ใในใฆใฎ้ใๆฌๅผงใๅฏพๅฟใใ้ใๆฌๅผงใๆใคๅ ดๅใTrueใ่ฟใใ
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing("><<>")
False
|
def correct_bracketing(brackets: str):
depth = 0
for b in brackets:
if b == "<":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("<>")
assert candidate("<<><>>")
assert candidate("<><><<><>><>")
assert candidate("<><><<<><><>><>><<><><<>>>")
assert not candidate("<<<><>>>>")
assert not candidate("><<>")
assert not candidate("<")
assert not candidate("<<<<")
assert not candidate(">")
assert not candidate("<<>")
assert not candidate("<><><<><>><>><<>")
assert not candidate("<><><<><>><>>><>")
candidate = correct_bracketing
check(candidate)
|
correct_bracketing
|
bt_JHumanEval/57
|
ใชในใใฎ่ฆ็ด ใๅ่ชฟๅขๅ ใพใใฏๅ่ชฟๆธๅฐใใๅ ดๅใซTrueใ่ฟใใ
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
|
def monotonic(l: list):
if l == sorted(l) or l == sorted(l, reverse=True):
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10]) == True
assert candidate([1, 2, 4, 20]) == True
assert candidate([1, 20, 4, 10]) == False
assert candidate([4, 1, 0, -10]) == True
assert candidate([4, 1, 1, 0]) == True
assert candidate([1, 2, 3, 2, 5, 60]) == False
assert candidate([1, 2, 3, 4, 5, 60]) == True
assert candidate([9, 9, 9, 9]) == True
candidate = monotonic
check(candidate)
|
monotonic
|
bt_JHumanEval/58
|
2ใคใฎใชในใใซใคใใฆใใฆใใผใฏใชๅ
ฑ้่ฆ็ด ใใฝใผใใใฆ่ฟใใ
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
|
def common(l1: list, l2: list):
ret = set()
for e1 in l1:
for e2 in l2:
if e1 == e2:
ret.add(e1)
return sorted(list(ret))
|
METADATA = {}
def check(candidate):
assert candidate([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]) == [1, 5, 653]
assert candidate([5, 3, 2, 8], [3, 2]) == [2, 3]
assert candidate([4, 3, 2, 8], [3, 2, 4]) == [2, 3, 4]
assert candidate([4, 3, 2, 8], []) == []
candidate = common
check(candidate)
|
common
|
bt_JHumanEval/59
|
nใฎๆๅคงใจใชใ็ด ๅ ๆฐใ่ฟใใใใ ใใ n > 1 ใๅๆใจใใ็ด ๆฐใงใฏใชใใใฎใจใใใ
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
|
def largest_prime_factor(n: int):
def is_prime(k):
if k < 2:
return False
for i in range(2, k - 1):
if k % i == 0:
return False
return True
largest = 1
for j in range(2, n + 1):
if n % j == 0 and is_prime(j):
largest = max(largest, j)
return largest
|
METADATA = {}
def check(candidate):
assert candidate(15) == 5
assert candidate(27) == 3
assert candidate(63) == 7
assert candidate(330) == 11
assert candidate(13195) == 29
candidate = largest_prime_factor
check(candidate)
|
largest_prime_factor
|
bt_JHumanEval/60
|
sum_to_nใฏ1ใใnใพใงใฎ็ทๅใๆฑใใ้ขๆฐใงใใใ
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
|
def sum_to_n(n: int):
return sum(range(n + 1))
|
METADATA = {}
def check(candidate):
assert candidate(1) == 1
assert candidate(6) == 21
assert candidate(11) == 66
assert candidate(30) == 465
assert candidate(100) == 5050
candidate = sum_to_n
check(candidate)
|
sum_to_n
|
bt_JHumanEval/61
|
ๅผๆฐbracketsใฏ"("ใจ") "ใใใชใๆๅญๅใงใใใ
ใในใฆใฎ้ใๆฌๅผงใๅฏพๅฟใใ้ใๆฌๅผงใๆใคๅ ดๅใTrueใ่ฟใใ
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(")(()")
False
|
def correct_bracketing(brackets: str):
depth = 0
for b in brackets:
if b == "(":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("()")
assert candidate("(()())")
assert candidate("()()(()())()")
assert candidate("()()((()()())())(()()(()))")
assert not candidate("((()())))")
assert not candidate(")(()")
assert not candidate("(")
assert not candidate("((((")
assert not candidate(")")
assert not candidate("(()")
assert not candidate("()()(()())())(()")
assert not candidate("()()(()())()))()")
candidate = correct_bracketing
check(candidate)
|
correct_bracketing
|
bt_JHumanEval/62
|
xsใฏๅค้
ๅผใฎไฟๆฐๅใ่กจใใ
xs[0] + xs[1] * x + xs[2] * x^2 + ....
้ขๆฐใฏใใใฎๅค้
ๅผใฎๅฐ้ขๆฐใๅใๅฝขๅผใง่ฟใใ
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
|
def derivative(xs: list):
return [(i * x) for i, x in enumerate(xs)][1:]
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == [1, 4, 12, 20]
assert candidate([1, 2, 3]) == [2, 6]
assert candidate([3, 2, 1]) == [2, 2]
assert candidate([3, 2, 1, 0, 4]) == [2, 2, 0, 16]
assert candidate([1]) == []
candidate = derivative
check(candidate)
|
derivative
|
bt_JHumanEval/63
|
FibFibๆฐๅใฏใใฃใใใใๆฐๅใซไผผใๆฐๅใงใไปฅไธใฎใใใซๅฎ็พฉใใใ๏ผ
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfibๆฐๅใฎn็ช็ฎใฎ่ฆ็ด ใๅน็ใใ่จ็ฎใใ้ขๆฐใๆธใใฆใใ ใใใ
>>> fibfib(1)
0
>>> fibfib(5)
4
>>> fibfib(8)
24
|
def fibfib(n: int):
if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n - 1) + fibfib(n - 2) + fibfib(n - 3)
|
METADATA = {}
def check(candidate):
assert candidate(2) == 1
assert candidate(1) == 0
assert candidate(5) == 4
assert candidate(8) == 24
assert candidate(10) == 81
assert candidate(12) == 274
assert candidate(14) == 927
candidate = fibfib
check(candidate)
|
fibfib
|
bt_JHumanEval/64
|
ๅ่ชใ่กจใๆๅญๅใๅผๆฐใจใใใใฎๆๅญๅใซๅซใพใใๆฏ้ณใฎๆฐใ่ฟใ
้ขๆฐ vowels_count ใๆธใใชใใใใใฎๅ ดๅใฎๆฏ้ณใฏ'a', 'e', 'i', 'o', 'u'ใงใใใ
ใใใงใไธใใใใๅ่ชใฎๆซๅฐพใซใใๅ ดๅใฎใฟใ'y'ใๆฏ้ณใจใใใ
ไพ:
>>> vowels_count("abcde")
2
>>> vowels_count("ACEDY")
3
|
FIX = def vowels_count(s):
vowels = "aeiouAEIOU"
n_vowels = sum(c in vowels for c in s)
if s[-1] == 'y' or s[-1] == 'Y':
n_vowels += 1
return n_vowels
|
def check(candidate):
# Check some simple cases
assert candidate("abcde") == 2, "Test 1"
assert candidate("Alone") == 3, "Test 2"
assert candidate("key") == 2, "Test 3"
assert candidate("bye") == 1, "Test 4"
assert candidate("keY") == 2, "Test 5"
assert candidate("bYe") == 1, "Test 6"
assert candidate("ACEDY") == 3, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
candidate = vowels_count
check(candidate)
|
vowels_count
|
bt_JHumanEval/65
|
ๆดๆฐ x ใฎๆกใๅพช็ฐใทใใใใใshift ๅใ ใๆกใๅณใซใทใใใใ็ตๆใๆๅญๅใจใใฆ่ฟใใ
ใใใshift > ๆกๆฐใชใใๆกใๅ่ปขใใฆ่ฟใใ
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
|
def circular_shift(x, shift):
s = str(x)
if shift > len(s):
return s[::-1]
else:
return s[len(s) - shift:] + s[:len(s) - shift]
|
def check(candidate):
# Check some simple cases
assert candidate(100, 2) == "001"
assert candidate(12, 2) == "12"
assert candidate(97, 8) == "79"
assert candidate(12, 1) == "21", "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(11, 101) == "11", "This prints if this assert fails 2 (also good for debugging!)"
candidate = circular_shift
check(candidate)
|
circular_shift
|
bt_JHumanEval/66
|
ใฟในใฏ
ๆๅญๅใๅผๆฐใซใจใใ่ฑๅคงๆๅญใฎใฟใฎASCIIใณใผใใฎๅใ่ฟใ้ขๆฐใๆธใใ
Examples:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
digitSum("aAaaaXa") => 153
|
def digitSum(s):
if s == "": return 0
return sum(ord(char) if char.isupper() else 0 for char in s)
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate("") == 0, "Error"
assert candidate("abAB") == 131, "Error"
assert candidate("abcCd") == 67, "Error"
assert candidate("helloE") == 69, "Error"
assert candidate("woArBld") == 131, "Error"
assert candidate("aAaaaXa") == 153, "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(" How are yOu?") == 151, "Error"
assert candidate("You arE Very Smart") == 327, "Error"
candidate = digitSum
check(candidate)
|
digitSum
|
bt_JHumanEval/67
|
ใใฎ่ชฒ้กใงใฏใๆ็ฉใฎๅ
ฅใฃใใซใดใซ้
ใใใใชใณใดใจใชใฌใณใธใฎๆฐใ่กจใๆๅญๅใ
ไธใใใใใใฎใซใดใซใฏใชใณใดใใชใฌใณใธใใใณใดใผใฎๆๅฎใๅ
ฅใฃใฆใใใใชใฌใณใธ
ใจใชใณใดใฎ็ทๆฐใ่กจใๆๅญๅใจใใใใฎไธญใฎๆ็ฉใฎ็ทๆฐใ่กจใๆดๆฐใไธใใใใใใ
ใใใฎไธญใฎใใณใดใผใฎๆ็ฉใฎๆฐใ่ฟใใชใใใ
ใใจใใฐ:
fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
|
def fruit_distribution(s,n):
lis = list()
for i in s.split(' '):
if i.isdigit():
lis.append(int(i))
return n - sum(lis)
|
def check(candidate):
# Check some simple cases
assert candidate("5 apples and 6 oranges",19) == 8
assert candidate("5 apples and 6 oranges",21) == 10
assert candidate("0 apples and 1 oranges",3) == 2
assert candidate("1 apples and 0 oranges",3) == 2
assert candidate("2 apples and 3 oranges",100) == 95
assert candidate("2 apples and 3 oranges",5) == 0
assert candidate("1 apples and 100 oranges",120) == 19
candidate = fruit_distribution
check(candidate)
|
fruit_distribution
|
bt_JHumanEval/68
|
้่ฒ ๆดๆฐใฎใใผใใๆใคๆจใฎๆใ่กจใ้
ๅใไธใใใใใจใใใใใชใใฎไปไบใฏใ
ใใผใใฎ1ใคใๆใๅใใใใใ่ฟใใใจใงใใใ
ๆๅบใใใใใผใใฏใๆๅฐๅถๆฐๅคใๆใคใใผใใงใชใใใฐใชใใชใใ
ๅใๆๅฐๅถๆฐๅคใๆใคใใผใใ่คๆฐ่ฆใคใใฃใๅ ดๅใฏใๆๅฐใฎใคใณใใใฏในใๆใค
ใใผใใ่ฟใใ
ๆๅบใใใใใผใใฏ [ smalest_value, its index ] ใจใใใชในใใง่ฟใใใชใใใฐใชใใชใใ
ๅถๆฐๅคใใชใๅ ดๅใไธใใใใ้
ๅใ็ฉบใฎๅ ดๅใฏ [] ใ่ฟใใพใใ
ไพ 1:
ๅ
ฅๅ: [4,2,3]
ๅบๅ: [2, 1]
่งฃ่ชฌ: 2ใฏๆๅฐๅถๆฐๅคใๆใกใๆๅฐใคใณใใใฏในใๆใคใ
ไพ 2:
ๅ
ฅๅ: [1,2,3]
ๅบๅ: [2, 1]
่งฃ่ชฌ: 2ใๆๅฐๅถๆฐๅคใงใ2ใๆๅฐใคใณใใใฏในใๆใคใ
ไพ 3:
ๅ
ฅๅ: []
ๅบๅ: []
ไพ 4:
ๅ
ฅๅ: [5, 0, 3, 0, 4, 2]
ๅบๅ: [0, 1]
่งฃ่ชฌ: 0ใฏๆๅฐๅคใ ใใ0ใฏ2ใคใใใฎใงใๆๅฐใคใณใใใฏในใๆใคๆๅใฎ0ใ้ธใถใ
ๅถ็ด:
* 1 <= ใใผใใฎ้ทใ <= 10000
* 0 <= ใใผใใฎๅค
|
def pluck(arr):
if(len(arr) == 0): return []
evens = list(filter(lambda x: x%2 == 0, arr))
if(evens == []): return []
return [min(evens), arr.index(min(evens))]
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([4,2,3]) == [2, 1], "Error"
assert candidate([1,2,3]) == [2, 1], "Error"
assert candidate([]) == [], "Error"
assert candidate([5, 0, 3, 0, 4, 2]) == [0, 1], "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([1, 2, 3, 0, 5, 3]) == [0, 3], "Error"
assert candidate([5, 4, 8, 4 ,8]) == [4, 1], "Error"
assert candidate([7, 6, 7, 1]) == [6, 1], "Error"
assert candidate([7, 9, 7, 1]) == [], "Error"
candidate = pluck
check(candidate)
|
pluck
|
bt_JHumanEval/69
|
ๆญฃใฎๆดๆฐใฎ็ฉบใงใชใใชในใใไธใใใใใ0ใใๅคงใใใใใฎๆดๆฐ่ช่บซใฎๅคไปฅไธใฎ้ ปๅบฆใ
ๆใคๆๅคงใฎๆดๆฐใ่ฟใใๆดๆฐใฎ้ ปๅบฆใจใฏใใใใใชในใใซ็พใใๅๆฐใงใใใ
ใใฎใใใชๅคใๅญๅจใใชใๅ ดๅใฏ -1 ใ่ฟใใ
ไพ:
search([4, 1, 2, 2, 3, 1]) == 2
search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
search([5, 5, 4, 4, 4]) == -1
|
def search(lst):
frq = [0] * (max(lst) + 1)
for i in lst:
frq[i] += 1;
ans = -1
for i in range(1, len(frq)):
if frq[i] >= i:
ans = i
return ans
|
def check(candidate):
# manually generated tests
assert candidate([5, 5, 5, 5, 1]) == 1
assert candidate([4, 1, 4, 1, 4, 4]) == 4
assert candidate([3, 3]) == -1
assert candidate([8, 8, 8, 8, 8, 8, 8, 8]) == 8
assert candidate([2, 3, 3, 2, 2]) == 2
# automatically generated tests
assert candidate([2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1]) == 1
assert candidate([3, 2, 8, 2]) == 2
assert candidate([6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10]) == 1
assert candidate([8, 8, 3, 6, 5, 6, 4]) == -1
assert candidate([6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9]) == 1
assert candidate([1, 9, 10, 1, 3]) == 1
assert candidate([6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10]) == 5
assert candidate([1]) == 1
assert candidate([8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5]) == 4
assert candidate([2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10]) == 2
assert candidate([1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3]) == 1
assert candidate([9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4]) == 4
assert candidate([2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7]) == 4
assert candidate([9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1]) == 2
assert candidate([5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8]) == -1
assert candidate([10]) == -1
assert candidate([9, 7, 7, 2, 4, 7, 2, 10, 9, 7, 5, 7, 2]) == 2
assert candidate([5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8]) == 1
assert candidate([7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6]) == 1
assert candidate([3, 10, 10, 9, 2]) == -1
candidate = search
check(candidate)
|
search
|
bt_JHumanEval/70
|
ๆดๆฐใฎใชในใใไธใใใใใจใใใชในใใๅฅๅฆใช้ ๅบใง่ฟใใ
ๅฅๅฆใชใฝใผใใจใฏใๆๅฐๅคใใๅงใพใใๆฎใใฎๆดๆฐใฎๆๅคงๅคใๆๅฐๅคใฎ้ ใง
ใฝใผใใใใใจใงใใใ
ไพ:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
strange_sort_list([]) == []
|
def strange_sort_list(lst):
res, switch = [], True
while lst:
res.append(min(lst) if switch else max(lst))
lst.remove(res[-1])
switch = not switch
return res
|
def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4]) == [1, 4, 2, 3]
assert candidate([5, 6, 7, 8, 9]) == [5, 9, 6, 8, 7]
assert candidate([1, 2, 3, 4, 5]) == [1, 5, 2, 4, 3]
assert candidate([5, 6, 7, 8, 9, 1]) == [1, 9, 5, 8, 6, 7]
assert candidate([5, 5, 5, 5]) == [5, 5, 5, 5]
assert candidate([]) == []
assert candidate([1,2,3,4,5,6,7,8]) == [1, 8, 2, 7, 3, 6, 4, 5]
assert candidate([0,2,2,2,5,5,-5,-5]) == [-5, 5, -5, 5, 0, 2, 2, 2]
assert candidate([111111]) == [111111]
# Check some edge cases that are easy to work out by hand.
assert True
candidate = strange_sort_list
check(candidate)
|
strange_sort_list
|
bt_JHumanEval/71
|
ไธ่งๅฝขใฎ3่พบใฎ้ทใใไธใใใใใ3่พบใๆๅนใชไธ่งๅฝขใๅฝขๆใใฆใใใฐใ
ไธ่งๅฝขใฎ้ข็ฉใๅฐๆฐ็นไปฅไธ2ๆกใงๅๆจไบๅ
ฅใใฆ่ฟใใใใใงใชใๅ ดๅใฏ-1ใ
่ฟใใ
ไปปๆใฎ2่พบใฎๅใ3่พบใใๅคงใใใจใใ3่พบใฏๆๅนใชไธ่งๅฝขใจใชใใ
ไพ:
triangle_area(3, 4, 5) == 6.00
triangle_area(1, 2, 10) == -1
|
def triangle_area(a, b, c):
if a + b <= c or a + c <= b or b + c <= a:
return -1
s = (a + b + c)/2
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
area = round(area, 2)
return area
|
def check(candidate):
# Check some simple cases
assert candidate(3, 4, 5) == 6.00, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1, 2, 10) == -1
assert candidate(4, 8, 5) == 8.18
assert candidate(2, 2, 2) == 1.73
assert candidate(1, 2, 3) == -1
assert candidate(10, 5, 7) == 16.25
assert candidate(2, 6, 3) == -1
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1, 1) == 0.43, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(2, 2, 10) == -1
candidate = triangle_area
check(candidate)
|
triangle_area
|
bt_JHumanEval/72
|
็ฉไฝqใ้ฃในใฐTrueใใใใใงใชใใใฐFalseใ่ฟใ้ขๆฐใๆธใใ
็ฉไฝqใฏใใฉใณในใๅใใฆใใฆ๏ผใคใพใใใชในใใๅๆใงใใฃใฆ๏ผใใใฎ่ฆ็ด ใฎๅใ
ๆๅคง่ท้wไปฅไธใงใใใฐ้ฃใถใ
ไพ:
will_it_fly([1, 2], 5) โ False
# 1+2 ใฏๆๅคง่ท้ไปฅไธใงใใใใใใฉใณในใๅใใฆใใชใ
will_it_fly([3, 2, 3], 1) โ False
# ใใฉใณในใๅใใฆใใใใ3+2+3 ใฏๆๅคง่ท้ใ่ถ
ใใ
will_it_fly([3, 2, 3], 9) โ True
# 3+2+3 ใฏๆๅคง่ท้ไปฅไธใงใใใใใฉใณในใๅใใฆใใ
will_it_fly([3], 5) โ True
# 3 ใฏๆๅคง่ท้ไปฅไธใงใใใใใฉใณในใๅใใฆใใ
|
def will_it_fly(q,w):
if sum(q) > w:
return False
i, j = 0, len(q)-1
while i<j:
if q[i] != q[j]:
return False
i+=1
j-=1
return True
|
def check(candidate):
# Check some simple cases
assert candidate([3, 2, 3], 9) is True
assert candidate([1, 2], 5) is False
assert candidate([3], 5) is True
assert candidate([3, 2, 3], 1) is False
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3], 6) is False
assert candidate([5], 5) is True
candidate = will_it_fly
check(candidate)
|
will_it_fly
|
bt_JHumanEval/73
|
ๆดๆฐใฎ้
ๅarrใไธใใใใใจใใใใฎ้
ๅใๅๆ้
ๅใซใใใใใซ
ๅฟ
่ฆใช่ฆ็ด ใฎๆๅฐๆฐใๆฑใใใๅๆ้
ๅใจใฏใๅใใใๅพใใใๅใ
ใใใซใชใ้
ๅใฎใใจใงใใใ1ๅใฎๅคๆดใงใ1ใคใฎ่ฆ็ด ใไปใฎไปปๆใฎ
่ฆ็ด ใซๅคๆดใงใใใ
ไพใใฐ:
smallest_change([1,2,3,5,4,7,9,6]) == 4
smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
smallest_change([1, 2, 3, 2, 1]) == 0
|
def smallest_change(arr):
ans = 0
for i in range(len(arr) // 2):
if arr[i] != arr[len(arr) - i - 1]:
ans += 1
return ans
|
def check(candidate):
# Check some simple cases
assert candidate([1,2,3,5,4,7,9,6]) == 4
assert candidate([1, 2, 3, 4, 3, 2, 2]) == 1
assert candidate([1, 4, 2]) == 1
assert candidate([1, 4, 4, 2]) == 1
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3, 2, 1]) == 0
assert candidate([3, 1, 1, 3]) == 0
assert candidate([1]) == 0
assert candidate([0, 1]) == 1
candidate = smallest_change
check(candidate)
|
smallest_change
|
bt_JHumanEval/74
|
๏ผใคใฎๆๅญๅใชในใใๅใๅใใใชในใใฎๅ
จๆๅญๆฐใฎๅ่จใใใไธๆน
ใฎใชในใใใๅฐใชใใชในใใ่ฟใ้ขๆฐใๆธใใชใใใ
ใใ2ใคใฎใชในใใฎๆๅญๆฐใๅใใชใใๆๅใฎใชในใใ่ฟใใ
ไพ
total_match([], []) โ []
total_match(['hi', 'admin'], ['hI', 'Hi']) โ ['hI', 'Hi']
total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) โ ['hi', 'admin']
total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) โ ['hI', 'hi', 'hi']
total_match(['4'], ['1', '2', '3', '4', '5']) โ ['4']
|
def total_match(lst1, lst2):
l1 = 0
for st in lst1:
l1 += len(st)
l2 = 0
for st in lst2:
l2 += len(st)
if l1 <= l2:
return lst1
else:
return lst2
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([], []) == []
assert candidate(['hi', 'admin'], ['hi', 'hi']) == ['hi', 'hi']
assert candidate(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) == ['hi', 'admin']
assert candidate(['4'], ['1', '2', '3', '4', '5']) == ['4']
assert candidate(['hi', 'admin'], ['hI', 'Hi']) == ['hI', 'Hi']
assert candidate(['hi', 'admin'], ['hI', 'hi', 'hi']) == ['hI', 'hi', 'hi']
assert candidate(['hi', 'admin'], ['hI', 'hi', 'hii']) == ['hi', 'admin']
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([], ['this']) == []
assert candidate(['this'], []) == []
candidate = total_match
check(candidate)
|
total_match
|
bt_JHumanEval/75
|
ไธใใใใๆฐใ3ใคใฎ็ด ๆฐใฎๆใ็ฎใงใใใฐTrueใใใใใงใชใใใฐFalseใ่ฟใ
้ขๆฐใๆธใใชใใใ
ๅผๆฐ aใฏ100ไปฅไธใๆข็ฅใจใใฆใใใใ
ไพ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
|
def is_multiply_prime(a):
def is_prime(n):
for j in range(2,n):
if n%j == 0:
return False
return True
for i in range(2,101):
if not is_prime(i): continue
for j in range(2,101):
if not is_prime(j): continue
for k in range(2,101):
if not is_prime(k): continue
if i*j*k == a: return True
return False
|
def check(candidate):
assert candidate(5) == False
assert candidate(30) == True
assert candidate(8) == True
assert candidate(10) == False
assert candidate(125) == True
assert candidate(3 * 5 * 7) == True
assert candidate(3 * 6 * 7) == False
assert candidate(9 * 9 * 9) == False
assert candidate(11 * 9 * 9) == False
assert candidate(11 * 13 * 7) == True
candidate = is_multiply_prime
check(candidate)
|
is_multiply_prime
|
bt_JHumanEval/76
|
ใใชใใฎใฟในใฏใฏใใใๆฐxใnใฎๅ็ดใชในใไนใงใใๅ ดๅใซtrueใใ
ใใไปฅๅคใฎๅ ดๅใซfalseใ่ฟใ้ขๆฐใๆธใใใจใงใใใ
xใฏใn**int=xใฎใจใใnใฎๅ็ดใชในใไนใงใใใ
ไพใใฐ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_simple_power(3, 2) => false
is_simple_power(3, 1) => false
is_simple_power(5, 3) => false
|
def is_simple_power(x, n):
if (n == 1):
return (x == 1)
power = 1
while (power < x):
power = power * n
return (power == x)
|
def check(candidate):
# Check some simple cases
assert candidate(16, 2)== True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(143214, 16)== False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(4, 2)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(9, 3)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(16, 4)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(24, 2)==False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(128, 4)==False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(12, 6)==False, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1)==True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(1, 12)==True, "This prints if this assert fails 2 (also good for debugging!)"
candidate = is_simple_power
check(candidate)
|
is_simple_power
|
bt_JHumanEval/77
|
ๆดๆฐaใๅใๅใใใใฎๆดๆฐใใใๆดๆฐใฎ3ไนใงใใๅ ดๅใซTrue
ใ่ฟใ้ขๆฐใๆธใใชใใใ
ๆณจๆ๏ผๅ
ฅๅใฏๅธธใซๅฆ็ๅฏ่ฝใงใใใจไปฎๅฎใใฆใใใ
ไพ:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
iscube(180) ==> False
|
def iscube(a):
a = abs(a)
return int(round(a ** (1. / 3))) ** 3 == a
|
def check(candidate):
# Check some simple cases
assert candidate(1) == True, "First test error: " + str(candidate(1))
assert candidate(2) == False, "Second test error: " + str(candidate(2))
assert candidate(-1) == True, "Third test error: " + str(candidate(-1))
assert candidate(64) == True, "Fourth test error: " + str(candidate(64))
assert candidate(180) == False, "Fifth test error: " + str(candidate(180))
assert candidate(1000) == True, "Sixth test error: " + str(candidate(1000))
# Check some edge cases that are easy to work out by hand.
assert candidate(0) == True, "1st edge test error: " + str(candidate(0))
assert candidate(1729) == False, "2nd edge test error: " + str(candidate(1728))
candidate = iscube
check(candidate)
|
iscube
|
bt_JHumanEval/78
|
16้ฒๆฐใฎๆฐๅญใๆๅญๅใจใใฆๅใๅใใใใฎไธญใซๅซใพใใ็ด ๆฐใงใใ16้ฒๆฐใฎๆกๆฐใ
ใซใฆใณใใใ้ขๆฐใไฝๆใใใฟในใฏใไธใใใใพใใใ็ด ๆฐใจใฏใ1ใใๅคงใใใ
2ใคใฎใใๅฐใใ่ช็ถๆฐใฎ็ฉใงใชใ่ช็ถๆฐใงใใ
16้ฒๆฐใฎๆกใซใฏ0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, Fใใใใพใใ
็ด ๆฐใจใใฆใฏ2, 3, 5, 7, 11, 13, 17,...ใใใใพใใ
ใใใใฃใฆใๆฌกใฎๆฐๅญใฎใใใใใใใใคใใใใๅคๅฎใใๅฟ
่ฆใใใใพใ๏ผ
2, 3, 5, 7, B๏ผ=10้ฒๆฐใง11๏ผ, D๏ผ=10้ฒๆฐใง13๏ผ
ๆณจๆ๏ผๅ
ฅๅใฏๅธธใซๆญฃ็ขบใใพใใฏ็ฉบใฎๆๅญๅใงใใใ่จๅทA, B, C, D, E, Fใฏๅธธใซ
ๅคงๆๅญใงใใใจไปฎๅฎใใฆใใใงใใ
ไพ๏ผ
num = "AB" ใฎๅ ดๅใๅบๅใฏ 1 ใงใใ
num = "1077E" ใฎๅ ดๅใๅบๅใฏ 2 ใงใใ
num = "ABED1A33" ใฎๅ ดๅใๅบๅใฏ 4 ใงใใ
num = "123456789ABCDEF0" ใฎๅ ดๅใๅบๅใฏ 6 ใงใใ
num = "2020" ใฎๅ ดๅใๅบๅใฏ 2 ใงใใbe 2.
|
def hex_key(num):
primes = ('2', '3', '5', '7', 'B', 'D')
total = 0
for i in range(0, len(num)):
if num[i] in primes:
total += 1
return total
|
def check(candidate):
# Check some simple cases
assert candidate("AB") == 1, "First test error: " + str(candidate("AB"))
assert candidate("1077E") == 2, "Second test error: " + str(candidate("1077E"))
assert candidate("ABED1A33") == 4, "Third test error: " + str(candidate("ABED1A33"))
assert candidate("2020") == 2, "Fourth test error: " + str(candidate("2020"))
assert candidate("123456789ABCDEF0") == 6, "Fifth test error: " + str(candidate("123456789ABCDEF0"))
assert candidate("112233445566778899AABBCCDDEEFF00") == 12, "Sixth test error: " + str(candidate("112233445566778899AABBCCDDEEFF00"))
# Check some edge cases that are easy to work out by hand.
assert candidate([]) == 0
candidate = hex_key
check(candidate)
|
hex_key
|
bt_JHumanEval/79
|
10้ฒๆฐๅฝขๅผใฎๆฐๅคใไธใใใใใใชใใฎใฟในใฏใฏใใใ2้ฒๆฐๅฝขๅผใซๅคๆใใใใจใงใใใ
ใใฎ้ขๆฐใฏใๆๅญๅใ่ฟใใใใฎๅๆๅญใฏ2้ฒๆฐใ่กจใใๆๅญๅใฎๅๆๅญใฏ'0'ใ'1'ใงใใใ
ใชใใๆๅญๅใฎๆๅใจๆๅพใซใฏ'db'ใจใใไฝๅใชๆๅญใใคใใใ
ใใฎๆๅญใฏๆธๅผใๅฉใใใใใซใใใ
ไพ:
decimal_to_binary(15) # "db1111db"ใ่ฟใ
decimal_to_binary(32) # "db100000db"ใ่ฟใ
|
def decimal_to_binary(decimal):
return "db" + bin(decimal)[2:] + "db"
|
def check(candidate):
# Check some simple cases
assert candidate(0) == "db0db"
assert candidate(32) == "db100000db"
assert candidate(103) == "db1100111db"
assert candidate(15) == "db1111db", "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
candidate = decimal_to_binary
check(candidate)
|
decimal_to_binary
|
bt_JHumanEval/80
|
ใใชใใฏๆๅญๅsใไธใใใใใ
ใใชใใฎใฟในใฏใฏใใใฎๆๅญๅใๅนธใใใฉใใใใใงใใฏใใใใจใงใใใ
ๆๅญๅใฏๅนธใใจใฏใๆๅญๅใฎ้ทใใๅฐใชใใจใ3ไปฅไธใงใ้ฃ็ถใใ3ๆๅญใใในใฆ็ฐใชใๅ ดๅใงใใใ
ไพใใฐ:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => False
is_happy(adb) => True
is_happy(xyy) => False
|
def is_happy(s):
if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i+1] or s[i+1] == s[i+2] or s[i] == s[i+2]:
return False
return True
|
def check(candidate):
# Check some simple cases
assert candidate("a") == False , "a"
assert candidate("aa") == False , "aa"
assert candidate("abcd") == True , "abcd"
assert candidate("aabb") == False , "aabb"
assert candidate("adb") == True , "adb"
assert candidate("xyy") == False , "xyy"
assert candidate("iopaxpoi") == True , "iopaxpoi"
assert candidate("iopaxioi") == False , "iopaxioi"
candidate = is_happy
check(candidate)
|
is_happy
|
bt_JHumanEval/81
|
ๅญฆๆๆ็ต้ฑใๆๅธซใฏ็ๅพใซๆ็ธพใใคใใชใใใฐใชใใชใใๆๅธซใฏ็ฌ่ชใฎใขใซใดใชใบใ ใงๆก็นใใฆใใใ
ๅ้กใฏใๅฝผๅฅณใๆ็ธพ่ฉไพกใซไฝฟใฃใใณใผใใ็ดๅคฑใใฆใใพใฃใใใจใงใใ
ๅฝผๅฅณใฏไฝไบบใใฎ็ๅพใฎGPAใฎใชในใใใใชใใซๆธกใใใฎใงใใใชใใฏๆฌกใฎ่กจใไฝฟใฃใฆ่ฉ็นใฎใชในใใ
ๅบๅใงใใ้ขๆฐใๆธใใใจใซใชใใพใใใ
GPA | ่ฉ็น
4.0 A+
> 3.7 A
> 3.3 A-
> 3.0 B+
> 2.7 B
> 2.3 B-
> 2.0 C+
> 1.7 C
> 1.3 C-
> 1.0 D+
> 0.7 D
> 0.0 D-
0.0 E
ไพ:
grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
|
def numerical_letter_grade(grades):
letter_grade = []
for gpa in grades:
if gpa == 4.0:
letter_grade.append("A+")
elif gpa > 3.7:
letter_grade.append("A")
elif gpa > 3.3:
letter_grade.append("A-")
elif gpa > 3.0:
letter_grade.append("B+")
elif gpa > 2.7:
letter_grade.append("B")
elif gpa > 2.3:
letter_grade.append("B-")
elif gpa > 2.0:
letter_grade.append("C+")
elif gpa > 1.7:
letter_grade.append("C")
elif gpa > 1.3:
letter_grade.append("C-")
elif gpa > 1.0:
letter_grade.append("D+")
elif gpa > 0.7:
letter_grade.append("D")
elif gpa > 0.0:
letter_grade.append("D-")
else:
letter_grade.append("E")
return letter_grade
|
def check(candidate):
# Check some simple cases
assert candidate([4.0, 3, 1.7, 2, 3.5]) == ['A+', 'B', 'C-', 'C', 'A-']
assert candidate([1.2]) == ['D+']
assert candidate([0.5]) == ['D-']
assert candidate([0.0]) == ['E']
assert candidate([1, 0.3, 1.5, 2.8, 3.3]) == ['D', 'D-', 'C-', 'B', 'B+']
assert candidate([0, 0.7]) == ['E', 'D-']
# Check some edge cases that are easy to work out by hand.
assert True
candidate = numerical_letter_grade
check(candidate)
|
numerical_letter_grade
|
bt_JHumanEval/82
|
ๆๅญๅใๅใๅใใๆๅญๅใฎ้ทใใ็ด ๆฐใงใใใฐTrueใใใใใงใชใใใฐFalseใ่ฟใ้ขๆฐใๆธใใ
ไพ
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
|
def prime_length(string):
l = len(string)
if l == 0 or l == 1:
return False
for i in range(2, l):
if l % i == 0:
return False
return True
|
def check(candidate):
# Check some simple cases
assert candidate('Hello') == True
assert candidate('abcdcba') == True
assert candidate('kittens') == True
assert candidate('orange') == False
assert candidate('wow') == True
assert candidate('world') == True
assert candidate('MadaM') == True
assert candidate('Wow') == True
assert candidate('') == False
assert candidate('HI') == True
assert candidate('go') == True
assert candidate('gogo') == False
assert candidate('aaaaaaaaaaaaaaa') == False
# Check some edge cases that are easy to work out by hand.
assert candidate('Madam') == True
assert candidate('M') == False
assert candidate('0') == False
candidate = prime_length
check(candidate)
|
prime_length
|
bt_JHumanEval/83
|
ๆญฃใฎๆดๆฐ n ใไธใใใใใจใใn ๆกใฎๆญฃใฎๆดๆฐใง 1 ใงๅงใพใใ
ใใใใฏ็ตใใๆฐใฎใซใฆใณใใ่ฟใ
|
def starts_one_ends(n):
if n == 1: return 1
return 18 * (10 ** (n - 2))
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1) == 1
assert candidate(2) == 18
assert candidate(3) == 180
assert candidate(4) == 1800
assert candidate(5) == 18000
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
candidate = starts_one_ends
check(candidate)
|
starts_one_ends
|
bt_JHumanEval/84
|
ๆญฃใฎๆดๆฐ N ใไธใใใใๆใใใฎๆกใฎ็ทๅใ2้ฒๆฐใง่ฟใใ
ไพ
N = 1000ใฎใจใ, ๅๆกใฎ็ทๅใฏ1ใใ ใใ่ฟใๅคใฏ "1".
N = 150ใฎใจใ,ๅๆกใฎ็ทๅใฏ6ใ ใ ใใ่ฟใๅคใฏ "110".
N = 147ใฎใจใ,ๅๆกใฎ็ทๅใฏ12ใ ใ ใใ่ฟใๅคใฏ "1100".
ๅคๆฐ:
@N ๆดๆฐ
ๅถ็ด: 0 โค N โค 10000.
่ฟใๅค:
๏ผ้ฒๆฐ่กจ่จใฎๆๅญๅ
|
def solve(N):
return bin(sum(int(i) for i in str(N)))[2:]
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1000) == "1", "Error"
assert candidate(150) == "110", "Error"
assert candidate(147) == "1100", "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(333) == "1001", "Error"
assert candidate(963) == "10010", "Error"
candidate = solve
check(candidate)
|
solve
|
bt_JHumanEval/85
|
็ฉบใงใชใๆดๆฐใฎใชในใlstใไธใใใใใจใใๅฅๆฐใฎใคใณใใใฏในใซใใๅถๆฐใฎ่ฆ็ด ใๅ ใใใ
ไพ:
add([4, 2, 6, 7]) ==> 2
|
def add(lst):
return sum([lst[i] for i in range(1, len(lst), 2) if lst[i]%2 == 0])
|
def check(candidate):
# Check some simple cases
assert candidate([4, 88]) == 88
assert candidate([4, 5, 6, 7, 2, 122]) == 122
assert candidate([4, 0, 6, 7]) == 0
assert candidate([4, 4, 6, 8]) == 12
# Check some edge cases that are easy to work out by hand.
candidate = add
check(candidate)
|
add
|
bt_JHumanEval/86
|
ๆๅญๅใๅผๆฐใจใใฆๅใๅใใใใฎใ้ ๅบไปใใใใใใผใธใงใณใใ่ฟใ้ขๆฐใไฝๆใใฆใใ ใใใ
้ ๅบไปใใใใใใผใธใงใณใจใฏใๅๅ่ช๏ผ็ฉบ็ฝใงๅบๅใใใ๏ผใฎๆๅญใASCIIๅคใซๅบใฅใใฆๆ้ ใซ
ไธฆในๆฟใใใใๆฐใใๅ่ชใซ็ฝฎใๆใใใใๆๅญๅใงใใ
ๆณจๆ๏ผๆ็ซ ๅ
ใฎๅ่ชใจ็ฉบ็ฝใฎ้ ๅบใฏใใฎใพใพไฟใฃใฆใใ ใใใ
ไพใใฐ๏ผ
anti_shuffle('Hi') ใฏ 'Hi'ใ่ฟใ
anti_shuffle('hello') ใฏ 'ehllo'่ฟใ
anti_shuffle('Hello World!!!') ใฏ 'Hello !!!Wdlor'่ฟใ
|
def anti_shuffle(s):
return ' '.join([''.join(sorted(list(i))) for i in s.split(' ')])
|
def check(candidate):
# Check some simple cases
assert candidate('Hi') == 'Hi'
assert candidate('hello') == 'ehllo'
assert candidate('number') == 'bemnru'
assert candidate('abcd') == 'abcd'
assert candidate('Hello World!!!') == 'Hello !!!Wdlor'
assert candidate('') == ''
assert candidate('Hi. My name is Mister Robot. How are you?') == '.Hi My aemn is Meirst .Rboot How aer ?ouy'
# Check some edge cases that are easy to work out by hand.
assert True
candidate = anti_shuffle
check(candidate)
|
anti_shuffle
|
bt_JHumanEval/87
|
2ๆฌกๅ
ใฎใใผใฟใใในใใใใใชในใใจใใฆไธใใใใใใใใฏ่กๅใซไผผใฆใใใใ
่กๅใจใฏ็ฐใชใใๅ่กใฏ็ฐใชใๆฐใฎๅใๅซใใใจใใงใใใ
lstใจๆดๆฐxใไธใใใใใจใใใชในใๅ
ใฎๆดๆฐxใ่ฆใคใใๅใฟใใซใ0ใใๅงใพใ
ๅบงๆจ๏ผ่กใๅ๏ผใงใใใใใชใฟใใซใฎใชในใ[(x1, y1), (x2, y2) ...]ใ่ฟใใ
ๅบงๆจใๆๅใฏ่กใฎๆ้ ใงใฝใผใใใใ
ใพใใ่กใฎๅบงๆจใๅใฎ้้ ใงใฝใผใใใใ
ไพ:
get_row([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
get_row([], 1) == []
get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
|
def get_row(lst, x):
coords = [(i, j) for i in range(len(lst)) for j in range(len(lst[i])) if lst[i][j] == x]
return sorted(sorted(coords, key=lambda x: x[1], reverse=True), key=lambda x: x[0])
|
def check(candidate):
# Check some simple cases
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6]
], 2) == [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1)]
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,1,3,4,5,6],
[1,2,1,4,5,6],
[1,2,3,1,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 0), (2, 1), (2, 0), (3, 2), (3, 0), (4, 3), (4, 0), (5, 4), (5, 0), (6, 5), (6, 0)]
assert candidate([], 1) == []
assert candidate([[1]], 2) == []
assert candidate([[], [1], [1, 2, 3]], 3) == [(2, 2)]
# Check some edge cases that are easy to work out by hand.
assert True
candidate = get_row
check(candidate)
|
get_row
|
bt_JHumanEval/88
|
้่ฒ ใฎๆดๆฐใใใชใ้
ๅใไธใใใใๅ ดๅใ้
ๅใใฝใผใใใใณใใผใ่ฟใใฆใใ ใใใ
้
ๅใฎๆๅใฎ่ฆ็ด ใจๆๅพใฎ่ฆ็ด ใฎๅใๅฅๆฐใงใใใฐใ้
ๅใๆ้ ๏ผๅฐใใ้ ๏ผใซใฝใผใใใพใใ
ใใฎๅใๅถๆฐใงใใใฐใ้
ๅใ้้ ๏ผๅคงใใ้ ๏ผใซใฝใผใใใพใใ
ๆณจๆ็น๏ผ
* ไธใใใใ้
ๅ่ชไฝใๅคๆดใใชใใงใใ ใใใ
ไพ:
* sort_array([]) => []
* sort_array([5]) => [5]
* sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
* sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
|
def sort_array(array):
return [] if len(array) == 0 else sorted(array, reverse= (array[0]+array[-1]) % 2 == 0)
|
def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([]) == [], "Error"
assert candidate([5]) == [5], "Error"
assert candidate([2, 4, 3, 0, 1, 5]) == [0, 1, 2, 3, 4, 5], "Error"
assert candidate([2, 4, 3, 0, 1, 5, 6]) == [6, 5, 4, 3, 2, 1, 0], "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([2, 1]) == [1, 2], "Error"
assert candidate([15, 42, 87, 32 ,11, 0]) == [0, 11, 15, 32, 42, 87], "Error"
assert candidate([21, 14, 23, 11]) == [23, 21, 14, 11], "Error"
candidate = sort_array
check(candidate)
|
sort_array
|
bt_JHumanEval/89
|
ๆๅญๅใๅผๆฐใซใจใใใขใซใใกใใใใๅ่ปขใใใฆๆๅทๅใใ
ๆๅญๅใ่ฟใ้ขๆฐencryptใไฝๆใใใ
ใขใซใใกใใใใฏใๆๅญไฝ็ฝฎใ2ๅใใฆ2ใคไธใซใทใใใใใใใซ
ๅ่ปขใใใ
ไพ:
encrypt('hi') returns 'lm'
encrypt('asdfghjkl') returns 'ewhjklnop'
encrypt('gf') returns 'kj'
encrypt('et') returns 'ix'
|
def encrypt(s):
d = 'abcdefghijklmnopqrstuvwxyz'
out = ''
for c in s:
if c in d:
out += d[(d.index(c)+2*2) % 26]
else:
out += c
return out
|
def check(candidate):
# Check some simple cases
assert candidate('hi') == 'lm', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('asdfghjkl') == 'ewhjklnop', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('gf') == 'kj', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('et') == 'ix', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('faewfawefaewg')=='jeiajeaijeiak', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('hellomyfriend')=='lippsqcjvmirh', "This prints if this assert fails 2 (good for debugging!)"
assert candidate('dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh')=='hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl', "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('a')=='e', "This prints if this assert fails 2 (also good for debugging!)"
candidate = encrypt
check(candidate)
|
encrypt
|
bt_JHumanEval/90
|
ๆดๆฐใฎใชในใใไธใใใใใ
ใชในใใฎ2็ช็ฎใซๅฐใใ่ฆ็ด ใ่ฟใ้ขๆฐ next_smallest() ใๆธใใชใใใ
ใใฎใใใช่ฆ็ด ใใชใๅ ดๅใฏ None ใ่ฟใใ
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest([1, 1]) == None
|
def next_smallest(lst):
lst = sorted(set(lst))
return None if len(lst) < 2 else lst[1]
|
def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4, 5]) == 2
assert candidate([5, 1, 4, 3, 2]) == 2
assert candidate([]) == None
assert candidate([1, 1]) == None
assert candidate([1,1,1,1,0]) == 1
assert candidate([1, 0**0]) == None
assert candidate([-35, 34, 12, -45]) == -35
# Check some edge cases that are easy to work out by hand.
assert True
candidate = next_smallest
check(candidate)
|
next_smallest
|
bt_JHumanEval/91
|
ๅ่ชใฎๆๅญๅใไธใใใใใใชใใฎใฟในใฏใฏ้ๅฑๆๆฐใๆฐใใ
ใใจใงใใใ้ๅฑๆๆฐใจใฏใ"I "ใงๅงใพใๆใฎใใจใงใใใ
ๆใฏ'.'ใโ?โใ'!'ใฎใใใใใงๅบๅใใใใ
ไพใใฐ:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1
|
def is_bored(S):
import re
sentences = re.split(r'[.?!]\s*', S)
return sum(sentence[0:2] == 'I ' for sentence in sentences)
|
def check(candidate):
# Check some simple cases
assert candidate("Hello world") == 0, "Test 1"
assert candidate("Is the sky blue?") == 0, "Test 2"
assert candidate("I love It !") == 1, "Test 3"
assert candidate("bIt") == 0, "Test 4"
assert candidate("I feel good today. I will be productive. will kill It") == 2, "Test 5"
assert candidate("You and I are going for a walk") == 0, "Test 6"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
candidate = is_bored
check(candidate)
|
is_bored
|
bt_JHumanEval/92
|
3ใคใฎๆฐๅคใๅใๅใ้ขๆฐใไฝใใ
1ใคใฎๆฐๅคใไปใฎ2ใคใฎๆฐๅคใฎๅใจ็ญใใใใในใฆใฎๆฐๅคใๆดๆฐใงใใๅ ดๅใซTrueใ่ฟใใ
ใใไปฅๅคใฎๅ ดๅใฏFalseใ่ฟใใ
ไพ
any_int(5, 2, 7) โ True
any_int(3, 2, 2) โ False
any_int(3, -2, 1) โ True
any_int(3.6, -2.2, 2) โ False
|
def any_int(x, y, z):
if isinstance(x,int) and isinstance(y,int) and isinstance(z,int):
if (x+y==z) or (x+z==y) or (y+z==x):
return True
return False
return False
|
def check(candidate):
# Check some simple cases
assert candidate(2, 3, 1)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(2.5, 2, 3)==False, "This prints if this assert fails 2 (good for debugging!)"
assert candidate(1.5, 5, 3.5)==False, "This prints if this assert fails 3 (good for debugging!)"
assert candidate(2, 6, 2)==False, "This prints if this assert fails 4 (good for debugging!)"
assert candidate(4, 2, 2)==True, "This prints if this assert fails 5 (good for debugging!)"
assert candidate(2.2, 2.2, 2.2)==False, "This prints if this assert fails 6 (good for debugging!)"
assert candidate(-4, 6, 2)==True, "This prints if this assert fails 7 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(2,1,1)==True, "This prints if this assert fails 8 (also good for debugging!)"
assert candidate(3,4,7)==True, "This prints if this assert fails 9 (also good for debugging!)"
assert candidate(3.0,4,7)==False, "This prints if this assert fails 10 (also good for debugging!)"
candidate = any_int
check(candidate)
|
any_int
|
bt_JHumanEval/93
|
ใกใใปใผใธใๅใๅใใใในใฆใฎๆๅญใฎๅคงๆๅญใจๅฐๆๅญใๅ
ฅใๆฟใใ
ใกใใปใผใธไธญใฎใในใฆใฎๆฏ้ณใ่ฑ่ชใฎๆฏ้ณใฎ2ใคๅใซ็พใใๆๅญใซ็ฝฎ
ใๆใใใใใซใจใณใณใผใใใ้ขๆฐใๆธใใชใใใ
ๆๅญใ ใใๆณๅฎใใใ
ไพ
>>> encode('test')
'TGST'
>>> encode('This is a message')
'tHKS KS C MGSSCGG'
|
def encode(message):
vowels = "aeiouAEIOU"
vowels_replace = dict([(i, chr(ord(i) + 2)) for i in vowels])
message = message.swapcase()
return ''.join([vowels_replace[i] if i in vowels else i for i in message])
|
def check(candidate):
# Check some simple cases
assert candidate('TEST') == 'tgst', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('Mudasir') == 'mWDCSKR', "This prints if this assert fails 2 (good for debugging!)"
assert candidate('YES') == 'ygs', "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('This is a message') == 'tHKS KS C MGSSCGG', "This prints if this assert fails 2 (also good for debugging!)"
assert candidate("I DoNt KnOw WhAt tO WrItE") == 'k dQnT kNqW wHcT Tq wRkTg', "This prints if this assert fails 2 (also good for debugging!)"
candidate = encode
check(candidate)
|
encode
|
bt_JHumanEval/94
|
ๆดๆฐใฎใชในใใไธใใใใ
ๆๅคงใฎ็ด ๆฐใๆฑใใใใฎๆกๆฐใฎๅใ่ฟใๅฟ
่ฆใใใใ
ไพ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ใฎใจใใ่ฟใๅคใฏ10
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]ใฎใจใใ่ฟใๅคใฏ 25
lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]ใฎใจใใ่ฟใๅคใฏ13
lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6]ใฎใจใใ่ฟใๅคใฏ11
lst = [0,81,12,3,1,21]ใฎใจใใ่ฟใๅคใฏ3
lst = [0,8,1,2,1,7]ใฎใจใใ่ฟใๅคใฏ7
|
def skjkasdkd(lst):
def isPrime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
maxx = 0
i = 0
while i < len(lst):
if(lst[i] > maxx and isPrime(lst[i])):
maxx = lst[i]
i+=1
result = sum(int(digit) for digit in str(maxx))
return result
|
def check(candidate):
# Check some simple cases
assert candidate([0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]) == 10, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]) == 25, "This prints if this assert fails 2 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]) == 13, "This prints if this assert fails 3 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,724,32,71,99,32,6,0,5,91,83,0,5,6]) == 11, "This prints if this assert fails 4 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,81,12,3,1,21]) == 3, "This prints if this assert fails 5 (also good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0,8,1,2,1,7]) == 7, "This prints if this assert fails 6 (also good for debugging!)"
assert candidate([8191]) == 19, "This prints if this assert fails 7 (also good for debugging!)"
assert candidate([8191, 123456, 127, 7]) == 19, "This prints if this assert fails 8 (also good for debugging!)"
assert candidate([127, 97, 8192]) == 10, "This prints if this assert fails 9 (also good for debugging!)"
candidate = skjkasdkd
check(candidate)
|
skjkasdkd
|
bt_JHumanEval/95
|
่พๆธใไธใใใใใจใใใในใฆใฎใญใผใๅฐๆๅญใงใใใฐTrueใใ
ใในใฆใฎใญใผใๅคงๆๅญใฎๆๅญๅใงใใใฐFalseใ่ฟใใ
ไธใใใใ่พๆธใ็ฉบใฎๅ ดๅใใใฎ้ขๆฐใฏ False ใ่ฟใใ
ไพ:
check_dict_case({"a":"apple", "b":"banana"}) ใฏใ Trueใ่ฟใใ
check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) ใฏใ Falseใ่ฟใใ
check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) ใฏใ Falseใ่ฟใใ
check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) ใฏใ Falseใ่ฟใใ
check_dict_case({"STATE":"NC", "ZIP":"12345" }) ใฏใ Trueใ่ฟใใ
|
def check_dict_case(dict):
if len(dict.keys()) == 0:
return False
else:
state = "start"
for key in dict.keys():
if isinstance(key, str) == False:
state = "mixed"
break
if state == "start":
if key.isupper():
state = "upper"
elif key.islower():
state = "lower"
else:
break
elif (state == "upper" and not key.isupper()) or (state == "lower" and not key.islower()):
state = "mixed"
break
else:
break
return state == "upper" or state == "lower"
|
def check(candidate):
# Check some simple cases
assert candidate({"p":"pineapple", "b":"banana"}) == True, "First test error: " + str(candidate({"p":"pineapple", "b":"banana"}))
assert candidate({"p":"pineapple", "A":"banana", "B":"banana"}) == False, "Second test error: " + str(candidate({"p":"pineapple", "A":"banana", "B":"banana"}))
assert candidate({"p":"pineapple", 5:"banana", "a":"apple"}) == False, "Third test error: " + str(candidate({"p":"pineapple", 5:"banana", "a":"apple"}))
assert candidate({"Name":"John", "Age":"36", "City":"Houston"}) == False, "Fourth test error: " + str(candidate({"Name":"John", "Age":"36", "City":"Houston"}))
assert candidate({"STATE":"NC", "ZIP":"12345" }) == True, "Fifth test error: " + str(candidate({"STATE":"NC", "ZIP":"12345" }))
assert candidate({"fruit":"Orange", "taste":"Sweet" }) == True, "Fourth test error: " + str(candidate({"fruit":"Orange", "taste":"Sweet" }))
# Check some edge cases that are easy to work out by hand.
assert candidate({}) == False, "1st edge test error: " + str(candidate({}))
candidate = check_dict_case
check(candidate)
|
check_dict_case
|
bt_JHumanEval/96
|
้่ฒ ๆดๆฐใๅใๅใใ็ด ๆฐใงnใใๅฐใใๆๅใฎnๅใฎ
ๆดๆฐใฎ้
ๅใ่ฟใ้ขๆฐใๅฎ่ฃ
ใใใ
ไพใใฐ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1) => []
count_up_to(18) => [2,3,5,7,11,13,17]
|
def count_up_to(n):
primes = []
for i in range(2, n):
is_prime = True
for j in range(2, i):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
|
def check(candidate):
assert candidate(5) == [2,3]
assert candidate(6) == [2,3,5]
assert candidate(7) == [2,3,5]
assert candidate(10) == [2,3,5,7]
assert candidate(0) == []
assert candidate(22) == [2,3,5,7,11,13,17,19]
assert candidate(1) == []
assert candidate(18) == [2,3,5,7,11,13,17]
assert candidate(47) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
assert candidate(101) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
candidate = count_up_to
check(candidate)
|
count_up_to
|
bt_JHumanEval/97
|
2ใคใฎๆดๆฐใๅใๅใใใใฎ๏ผใฎไฝใฎๆฐใฎ็ฉใ่ฟใ้ขๆฐใๅฎๆใใใใ
ๅ
ฅๅใฏๅธธใซๆๅน็ฏๅฒใซใใใจใใใ
ไพ:
multiply(148, 412) ใฏ16ใ่ฟใใ
multiply(19, 28) ใฏ72ใ่ฟใใ
multiply(2020, 1851) ใฏ0ใ่ฟใใ
multiply(14,-15) ใฏ20ใ่ฟใใ
|
def multiply(a, b):
return abs(a % 10) * abs(b % 10)
|
def check(candidate):
# Check some simple cases
assert candidate(148, 412) == 16, "First test error: " + str(candidate(148, 412))
assert candidate(19, 28) == 72, "Second test error: " + str(candidate(19, 28))
assert candidate(2020, 1851) == 0, "Third test error: " + str(candidate(2020, 1851))
assert candidate(14,-15) == 20, "Fourth test error: " + str(candidate(14,-15))
assert candidate(76, 67) == 42, "Fifth test error: " + str(candidate(76, 67))
assert candidate(17, 27) == 49, "Sixth test error: " + str(candidate(17, 27))
# Check some edge cases that are easy to work out by hand.
assert candidate(0, 1) == 0, "1st edge test error: " + str(candidate(0, 1))
assert candidate(0, 0) == 0, "2nd edge test error: " + str(candidate(0, 0))
candidate = multiply
check(candidate)
|
multiply
|
bt_JHumanEval/98
|
ๆๅญๅ s ใไธใใใใใจใใๅถๆฐใฎใคใณใใใฏในใซๅซใพใใๅคงๆๅญใฎๆฏ้ณใฎๆฐใๆฐใใใ
ไพใใฐ:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
|
def count_upper(s):
count = 0
for i in range(0,len(s),2):
if s[i] in "AEIOU":
count += 1
return count
|
def check(candidate):
# Check some simple cases
assert candidate('aBCdEf') == 1
assert candidate('abcdefg') == 0
assert candidate('dBBE') == 0
assert candidate('B') == 0
assert candidate('U') == 1
assert candidate('') == 0
assert candidate('EEEE') == 2
# Check some edge cases that are easy to work out by hand.
assert True
candidate = count_upper
check(candidate)
|
count_upper
|
bt_JHumanEval/99
|
ๆฐๅคใ่กจใๆๅญๅvalueใๅใๅใใใใใซๆใ่ฟใๆดๆฐใ่ฟใ้ขๆฐใไฝใใ
ใใฎๆฐๅคใ2ใคใฎๆดๆฐใใ็ญ่ท้ขใซใใๅ ดๅใฏใใผใญใใๅๆจไบๅ
ฅใใใ
ไพ
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15
Note:
ใผใญใใใฎๅๆจไบๅ
ฅใจใฏใไธใใใใๆฐๅคใ2ใคใฎๆดๆฐใใ
็ญ่ท้ขใซใใๅ ดๅใใผใญใใ้ ใๆนใ่ฟใใจใใๆๅณใงใใใ
ไพใใฐใ close_integer("14.5")ใฏ15ใ่ฟใใclosest_integer("-14.5")ใฏ-15ใ่ฟใใ
|
def closest_integer(value):
from math import floor, ceil
if value.count('.') == 1:
# remove trailing zeros
while (value[-1] == '0'):
value = value[:-1]
num = float(value)
if value[-2:] == '.5':
if num > 0:
res = ceil(num)
else:
res = floor(num)
elif len(value) > 0:
res = int(round(num))
else:
res = 0
return res
|
def check(candidate):
# Check some simple cases
assert candidate("10") == 10, "Test 1"
assert candidate("14.5") == 15, "Test 2"
assert candidate("-15.5") == -16, "Test 3"
assert candidate("15.3") == 15, "Test 3"
# Check some edge cases that are easy to work out by hand.
assert candidate("0") == 0, "Test 0"
candidate = closest_integer
check(candidate)
|
closest_integer
|
End of preview. Expand
in Data Studio
- Downloads last month
- 10