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:
... |
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,... | 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
... |
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [
'(()())', '((()))', '()', '((())()())'
]
assert candidate('() (()) ((())) (((())))') == [
'()', '(())', '((()))', '(((())))'
]
assert 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... | 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(ca... | 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
... |
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... | 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_pro... | 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_... |
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_c... | 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| .| ... | 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 num... |
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 ... | 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:
... |
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,... | 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.... | 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 * ... | 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 ca... | 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 ... | 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)... |
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:
co... | 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(so... | 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_buz... | 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, 1... | 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: st... |
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
c... | 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_p... |
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
... | 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... | 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
asser... | 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_ze... | 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
asser... | 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, ... | 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_pa... | 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.dee... | 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'... | 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... | 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)
a... | 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('eab... | 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
asse... | 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("<<<<")
... | 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
ass... | 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(candida... | 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(l... |
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("((((")
... | 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"
a... | 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 han... | 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 candi... | 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... | 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",10... | fruit_distribution |
bt_JHumanEval/68 | ้่ฒ ๆดๆฐใฎใใผใใๆใคๆจใฎๆใ่กจใ้
ๅใไธใใใใใจใใใใใชใใฎไปไบใฏใ
ใใผใใฎ1ใคใๆใๅใใใใใ่ฟใใใจใงใใใ
ๆๅบใใใใใผใใฏใๆๅฐๅถๆฐๅคใๆใคใใผใใงใชใใใฐใชใใชใใ
ๅใๆๅฐๅถๆฐๅคใๆใคใใผใใ่คๆฐ่ฆใคใใฃใๅ ดๅใฏใๆๅฐใฎใคใณใใใฏในใๆใค
ใใผใใ่ฟใใ
ๆๅบใใใใใผใใฏ [ smalest_value, its index ] ใจใใใชในใใง่ฟใใใชใใใฐใชใใชใใ
ๅถๆฐๅคใใชใๅ ดๅใไธใใใใ้
ๅใ็ฉบใฎๅ ดๅใฏ [] ใ่ฟใใพใใ
ไพ 1:
ๅ
ฅๅ: [4,2,3]
ๅบๅ: [2, 1]
่งฃ่ชฌ: 2ใฏๆ... | 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], "... | 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... | 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]) == [... | 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... | 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 ใฏๆๅคง่ท้ไปฅไธใงใใใใใฉใณ... | 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... | 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... | 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', 'h... | 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... | 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)... | 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
asser... | 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 (... | 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... | 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๏ผ
ๆณจๆ๏ผๅ
ฅๅใฏๅธธใซๆญฃ็ขบใใพใใฏ็ฉบ... | 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"))
... | 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 wor... | 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"
... | is_happy |
bt_JHumanEval/81 | ๅญฆๆๆ็ต้ฑใๆๅธซใฏ็ๅพใซๆ็ธพใใคใใชใใใฐใชใใชใใๆๅธซใฏ็ฌ่ชใฎใขใซใดใชใบใ ใงๆก็นใใฆใใใ
ๅ้กใฏใๅฝผๅฅณใๆ็ธพ่ฉไพกใซไฝฟใฃใใณใผใใ็ดๅคฑใใฆใใพใฃใใใจใงใใ
ๅฝผๅฅณใฏไฝไบบใใฎ็ๅพใฎGPAใฎใชในใใใใชใใซๆธกใใใฎใงใใใชใใฏๆฌกใฎ่กจใไฝฟใฃใฆ่ฉ็นใฎใชในใใ
ๅบๅใงใใ้ขๆฐใๆธใใใจใซใชใใพใใใ
GPA | ่ฉ็น
4.0 A+
> 3.7 A
> 3.3 A-
> 3.0 ... | 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.a... | 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+']
... | 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') == Tr... | 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 ar... | 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 h... | 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(candidat... | 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 candidat... | 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, ... | 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],
... | 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, ... | 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, ... | 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... | 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, 1... | 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. wil... | 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 fa... | 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 asse... | 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
... | 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 d... | 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]... | 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ใ่ฟใใ
... | 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():
... | 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",... | 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]... | 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(c... | 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 th... | 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 = ... | 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... | closest_integer |
End of preview. Expand in Data Studio
- Downloads last month
- 9