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/100 | 正の整数nが与えられたとき、n段の石の山を作らなければならない。
最初の段にはn個の石がある。
次の段の石の数は
- nが奇数なら次の奇数。
- nが偶数なら次の偶数。
各段の石の数をリストで返す。インデックス i の要素は、段 (i+1) の石の
数を表すものとする。
例:
>>> make_a_pile(3)
[3, 5, 7] | def make_a_pile(n):
return [n + 2*i for i in range(n)]
| def check(candidate):
# Check some simple cases
assert candidate(3) == [3, 5, 7], "Test 3"
assert candidate(4) == [4,6,8,10], "Test 4"
assert candidate(5) == [5, 7, 9, 11, 13]
assert candidate(6) == [6, 8, 10, 12, 14, 16]
assert candidate(8) == [8, 10, 12, 14, 16, 18, 20, 22]
# 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 = make_a_pile
check(candidate) | make_a_pile |
bt_JHumanEval/101 | カンマまたは空白で区切られた単語の文字列が与えられる。あなたのタスクは、
文字列を単語に分割し、単語の配列を返すことである。
例えば:
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"] | def words_string(s):
if not s:
return []
s_list = []
for letter in s:
if letter == ',':
s_list.append(' ')
else:
s_list.append(letter)
s_list = "".join(s_list)
return s_list.split()
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
assert candidate("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
assert candidate("Hi, my name") == ["Hi", "my", "name"]
assert candidate("One,, two, three, four, five, six,") == ["One", "two", "three", "four", "five", "six"]
# 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("") == []
assert candidate("ahmed , gamal") == ["ahmed", "gamal"]
candidate = words_string
check(candidate) | words_string |
bt_JHumanEval/102 | この関数は2つの正の数xとyを受け取り、範囲[x, y]（両端を含む）に含まれる
最大の偶数整数を返す。そのような数がない場合、関数は-1を返す。
例えば:
choose_num(12, 15) = 14
choose_num(13, 12) = -1 | def choose_num(x, y):
if x > y:
return -1
if y % 2 == 0:
return y
if x == y:
return -1
return y - 1
| def check(candidate):
# Check some simple cases
assert candidate(12, 15) == 14
assert candidate(13, 12) == -1
assert candidate(33, 12354) == 12354
assert candidate(5234, 5233) == -1
assert candidate(6, 29) == 28
assert candidate(27, 10) == -1
# Check some edge cases that are easy to work out by hand.
assert candidate(7, 7) == -1
assert candidate(546, 546) == 546
candidate = choose_num
check(candidate) | choose_num |
bt_JHumanEval/103 | 2つの正の整数nとmが与えられており、あなたのタスクはnからmまでの
整数（nとmを含む）の平均を計算することである。
答えを最も近い整数に丸め、2進数に変換せよ。
nがmより大きい場合は-1を返す。
例:
rounded_avg(1, 5) => "0b11"
rounded_avg(7, 5) => -1
rounded_avg(10, 20) => "0b1111"
rounded_avg(20, 33) => "0b11010" | def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1)))
| def check(candidate):
# Check some simple cases
assert candidate(1, 5) == "0b11"
assert candidate(7, 13) == "0b1010"
assert candidate(964,977) == "0b1111001010"
assert candidate(996,997) == "0b1111100100"
assert candidate(560,851) == "0b1011000010"
assert candidate(185,546) == "0b101101110"
assert candidate(362,496) == "0b110101101"
assert candidate(350,902) == "0b1001110010"
assert candidate(197,233) == "0b11010111"
# Check some edge cases that are easy to work out by hand.
assert candidate(7, 5) == -1
assert candidate(5, 1) == -1
assert candidate(5, 5) == "0b101"
candidate = rounded_avg
check(candidate) | rounded_avg |
bt_JHumanEval/104 | 正の整数xのリストが与えられたとき、偶数桁の要素を持たない全ての
要素をソートしたリストを返す。
注意: 返されるリストは昇順にソートされていなければならない。
例えば:
>>> unique_digits([15, 33, 1422, 1])
[1, 15, 33]
>>> unique_digits([152, 323, 1422, 10])
[] | def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements)
| def check(candidate):
# Check some simple cases
assert candidate([15, 33, 1422, 1]) == [1, 15, 33]
assert candidate([152, 323, 1422, 10]) == []
assert candidate([12345, 2033, 111, 151]) == [111, 151]
assert candidate([135, 103, 31]) == [31, 135]
# Check some edge cases that are easy to work out by hand.
assert True
candidate = unique_digits
check(candidate) | unique_digits |
bt_JHumanEval/105 | 整数の配列が与えられたとき、1から9までの整数をソートし、
得られた配列を逆順にし、各桁を以下の数字に相当する名前に置き換える。
"One"、"Two"、"Three"、"Four"、"Five"、"Six"、"Seven"、"Eight"、"Nine "
例えば:
arr = [2, 1, 1, 4, 5, 8, 2, 3]
-> arrをソート -> [1, 1, 2, 2, 3, 4, 5, 8]
-> arrを逆順 -> [8, 5, 4, 3, 2, 2, 1, 1]
["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]を返す。
もし空配列なら、空配列を返す:
arr = []
return []
もし変な数値が配列に含まれていたら無視せよ:
arr = [1, -1 , 55]
-> arrをソート-> [-1, 1, 55]
-> rarrを逆順 -> [55, 1, -1]
['One']を返す。 | def by_length(arr):
dic = {
1: "One",
2: "Two",
3: "Three",
4: "Four",
5: "Five",
6: "Six",
7: "Seven",
8: "Eight",
9: "Nine",
}
sorted_arr = sorted(arr, reverse=True)
new_arr = []
for var in sorted_arr:
try:
new_arr.append(dic[var])
except:
pass
return new_arr
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([2, 1, 1, 4, 5, 8, 2, 3]) == ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"], "Error"
assert candidate([]) == [], "Error"
assert candidate([1, -1 , 55]) == ['One'], "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, -1, 3, 2]) == ["Three", "Two", "One"]
assert candidate([9, 4, 8]) == ["Nine", "Eight", "Four"]
candidate = by_length
check(candidate) | by_length |
bt_JHumanEval/106 | iは1から始まる。iの階乗は1からiまでの数の掛け算（1 * 2 * ... * i）である。
Example:
f(5) == [1, 2, 6, 24, 15] | def f(n):
ret = []
for i in range(1,n+1):
if i%2 == 0:
x = 1
for j in range(1,i+1): x *= j
ret += [x]
else:
x = 0
for j in range(1,i+1): x += j
ret += [x]
return ret
| def check(candidate):
assert candidate(5) == [1, 2, 6, 24, 15]
assert candidate(7) == [1, 2, 6, 24, 15, 720, 28]
assert candidate(1) == [1]
assert candidate(3) == [1, 2, 6]
candidate = f
check(candidate) | f |
bt_JHumanEval/107 | 与えられた正の整数 nに対して、範囲 1 から n まで（両端を含む）に存在する
偶数の回文数(integer palindrome)と奇数の回文数の個数をタプル形式で返す。
例 1:
入力: 3
出力: (1, 2)
解説:
回文数は1、2、3であり、そのうち1つは偶数、2つは奇数である。
例 2:
入力: 12
出力: (4, 6)
解説:
回文数は、1、2、3、4、5、6、7、8、9、11であり、そのうち4つは偶数、6つは奇数である。
ノート:
1. 1 <= n <= 10^3
2. 返されるタプルは、それぞれ偶数と奇数の回文数を持つ。 | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
even_palindrome_count += 1
return (even_palindrome_count, odd_palindrome_count)
| def check(candidate):
# Check some simple cases
assert candidate(123) == (8, 13)
assert candidate(12) == (4, 6)
assert candidate(3) == (1, 2)
assert candidate(63) == (6, 8)
assert candidate(25) == (5, 6)
assert candidate(19) == (4, 6)
assert candidate(9) == (4, 5), "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), "This prints if this assert fails 2 (also good for debugging!)"
candidate = even_odd_palindrome
check(candidate) | even_odd_palindrome |
bt_JHumanEval/108 | count_nums 関数は、整数の配列を引数として受け取り、その配列内の各整数の各桁の合計が
>0 となるような整数の個数を返す。負の数に関しては、最初の桁（符号付き桁）は負となる。
たとえば、−123 の符号付き桁は −1, 2, 3 である。
>>> count_nums([]) == 0
>> count_nums([-1, 11, -11]) == 1
>> count_nums([1, 1, 2]) == 3 | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr])))
| def check(candidate):
# Check some simple cases
assert candidate([]) == 0
assert candidate([-1, -2, 0]) == 0
assert candidate([1, 1, 2, -2, 3, 4, 5]) == 6
assert candidate([1, 6, 9, -6, 0, 1, 5]) == 5
assert candidate([1, 100, 98, -7, 1, -1]) == 4
assert candidate([12, 23, 34, -45, -56, 0]) == 5
assert candidate([-0, 1**0]) == 1
assert candidate([1]) == 1
# 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 = count_nums
check(candidate) | count_nums |
bt_JHumanEval/109 | N個の整数arr[1], arr[2], ..., arr[N]なる配列 'arr' があります。
この配列の数字はランダムな順番に並んでいます。あなたの課題は、以下の操作を何度でも行うことで、
配列を非減少.の順番にソートできるかどうかを判断することです。
操作として許されているのは「右シフト」です。
一回の「右シフト」操作とは、配列のすべての要素を右方向に一つずつずらすことを意味します。
配列の最後の要素は配列の先頭、すなわち0番目のインデックスに移動します。
上記の操作を行ってソートされた配列を得られる場合は True を、そうでない場合は False を返してください。
与えられた配列が空の場合は True を返してください。
注意：与えられたリストには一意の要素しか含まれていないことが保証されています。
例：
move_one_ball([3, 4, 5, 1, 2]) => True
説明：2回の右シフト操作を行うことで、与えられた配列を非減少の順序にすることができます。
move_one_ball([3, 5, 4, 1, 2]) => False
説明：どれだけ右シフト操作を行っても、与えられた配列を非減少の順序にすることはできません。 | def move_one_ball(arr):
if len(arr)==0:
return True
sorted_array=sorted(arr)
my_arr=[]
min_value=min(arr)
min_index=arr.index(min_value)
my_arr=arr[min_index:]+arr[0:min_index]
for i in range(len(arr)):
if my_arr[i]!=sorted_array[i]:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate([3, 4, 5, 1, 2])==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([3, 5, 10, 1, 2])==True
assert candidate([4, 3, 1, 2])==False
# Check some edge cases that are easy to work out by hand.
assert candidate([3, 5, 4, 1, 2])==False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([])==True
candidate = move_one_ball
check(candidate) | move_one_ball |
bt_JHumanEval/110 | この問題では、2つの数のリストを受け取り、lst1を偶数のみのリストに
するために、それらの間で要素の交換を行うことが可能かどうかを判断す
る関数を実装する。
lst1とlst2の間で交換される要素の数に制限はない。
lst1とlst2の間で要素の交換を行い、lst1の要素をすべて偶数にすることが
可能であれば、"YES "を返す。
そうでなければ "NO "を返す。
例えば:
exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
受け取るリストは空でないと前提してよい。 | def exchange(lst1, lst2):
odd = 0
even = 0
for i in lst1:
if i%2 == 1:
odd += 1
for i in lst2:
if i%2 == 0:
even += 1
if even >= odd:
return "YES"
return "NO"
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4], [1, 2, 3, 4]) == "YES"
assert candidate([1, 2, 3, 4], [1, 5, 3, 4]) == "NO"
assert candidate([1, 2, 3, 4], [2, 1, 4, 3]) == "YES"
assert candidate([5, 7, 3], [2, 6, 4]) == "YES"
assert candidate([5, 7, 3], [2, 6, 3]) == "NO"
assert candidate([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]) == "NO"
# Check some edge cases that are easy to work out by hand.
assert candidate([100, 200], [200, 200]) == "YES"
candidate = exchange
check(candidate) | exchange |
bt_JHumanEval/111 | 空白で区切られた小文字を表す文字列が与えられる。最も出現回数が多い文字と
対応するカウントの辞書を返す。
複数の文字が同じ出現回数を持つ場合、それらすべてを返す。
例:
histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
histogram('a b b a') == {'a': 2, 'b': 2}
histogram('a b c a b') == {'a': 2, 'b': 2}
histogram('b b b b a') == {'b': 4}
histogram('') == {} | def histogram(test):
dict1={}
list1=test.split(" ")
t=0
for i in list1:
if(list1.count(i)>t) and i!='':
t=list1.count(i)
if t>0:
for i in list1:
if(list1.count(i)==t):
dict1[i]=t
return dict1
| def check(candidate):
# Check some simple cases
assert candidate('a b b a') == {'a':2,'b': 2}, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('a b c a b') == {'a': 2, 'b': 2}, "This prints if this assert fails 2 (good for debugging!)"
assert candidate('a b c d g') == {'a': 1, 'b': 1, 'c': 1, 'd': 1, 'g': 1}, "This prints if this assert fails 3 (good for debugging!)"
assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 4 (good for debugging!)"
assert candidate('b b b b a') == {'b': 4}, "This prints if this assert fails 5 (good for debugging!)"
assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 6 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('') == {}, "This prints if this assert fails 7 (also good for debugging!)"
assert candidate('a') == {'a': 1}, "This prints if this assert fails 8 (also good for debugging!)"
candidate = histogram
check(candidate) | histogram |
bt_JHumanEval/112 | 課題
sとcの2つの文字列が与えられる。sに含まれる文字のうち、cに含まれる文字と
等しいものをすべて削除し、その結果の文字列が回文かどうかをチェックする。
文字列は、後ろから読んでも前から読んでも同じであれば回文と呼ばれる。
結果文字列とチェックのためのTrue/Falseを含むタプルを返す必要がある。
例
s = "abcde", c = "ae"のとき、結果は ('bcd',False)
s = "abcdef", c = "b" のとき、結果は ('acdef',False)
s = "abcdedcba", c = "ab", のとき、結果は ('cdedc',True) | def reverse_delete(s,c):
s = ''.join([char for char in s if char not in c])
return (s,s[::-1] == s)
| def check(candidate):
assert candidate("abcde","ae") == ('bcd',False)
assert candidate("abcdef", "b") == ('acdef',False)
assert candidate("abcdedcba","ab") == ('cdedc',True)
assert candidate("dwik","w") == ('dik',False)
assert candidate("a","a") == ('',True)
assert candidate("abcdedcba","") == ('abcdedcba',True)
assert candidate("abcdedcba","v") == ('abcdedcba',True)
assert candidate("vabba","v") == ('abba',True)
assert candidate("mamma", "mia") == ("", True)
candidate = reverse_delete
check(candidate) | reverse_delete |
bt_JHumanEval/113 | 数字のみで構成された文字列のリストを引数として受け取り、新しいリストを返します。
出力される新しいリストの各要素は、"the number of odd elements in the string i of the
input."となりますが、この文字列内のすべての 'i' は、入力リストのi番目の文字列に含ま
れる奇数の数に置き換えられます。
>>> odd_count(['1234567'])
["the number of odd elements 4n the str4ng 4 of the 4nput."]
>>> odd_count(['3',"11111111"])
["the number of odd elements 1n the str1ng 1 of the 1nput.",
"the number of odd elements 8n the str8ng 8 of the 8nput."] | def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res
| def check(candidate):
# Check some simple cases
assert candidate(['1234567']) == ["the number of odd elements 4n the str4ng 4 of the 4nput."], "Test 1"
assert candidate(['3',"11111111"]) == ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."], "Test 2"
assert candidate(['271', '137', '314']) == [
'the number of odd elements 2n the str2ng 2 of the 2nput.',
'the number of odd elements 3n the str3ng 3 of the 3nput.',
'the number of odd elements 2n the str2ng 2 of the 2nput.'
]
# 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 = odd_count
check(candidate) | odd_count |
bt_JHumanEval/114 | 整数の配列 nums が与えられたとき、nums の空でない部分配列の最小和を求めよ。
例:
minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
minSubArraySum([-1, -2, -3]) == -6 | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum
| def check(candidate):
# Check some simple cases
assert candidate([2, 3, 4, 1, 2, 4]) == 1, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1, -2, -3]) == -6
assert candidate([-1, -2, -3, 2, -10]) == -14
assert candidate([-9999999999999999]) == -9999999999999999
assert candidate([0, 10, 20, 1000000]) == 0
assert candidate([-1, -2, -3, 10, -5]) == -6
assert candidate([100, -1, -2, -3, 10, -5]) == -6
assert candidate([10, 11, 13, 8, 3, 4]) == 3
assert candidate([100, -33, 32, -1, 0, -2]) == -33
# Check some edge cases that are easy to work out by hand.
assert candidate([-10]) == -10, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([7]) == 7
assert candidate([1, -1]) == -1
candidate = minSubArraySum
check(candidate) | minSubArraySum |
bt_JHumanEval/115 | 長方形のグリッド状(grid)の井戸が与えられる。各行が1つの井戸を表し、
行の1が1単位の水を表す。
各井戸には，そこから水を汲み上げるのに使える対応するバケツがあり，
すべてのバケツ容量(capacity)は同じである．
あなたの仕事は，バケツを使って井戸を空にすることである．
バケツを降ろす回数を出力せよ．
例 1:
入力:
グリッド : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
バケツ容量 : 1
出力: 6
例 2:
入力:
グリッド : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
バケツ容量 : 2
出力: 5
例 3:
入力:
グリッド : [[0,0,0], [0,0,0]]
バケツ容量 : 5
出力: 0
制約:
* すべての井戸が同じ長さ
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10 | def max_fill(grid, capacity):
import math
return sum([math.ceil(sum(arr)/capacity) for arr in grid])
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([[0,0,1,0], [0,1,0,0], [1,1,1,1]], 1) == 6, "Error"
assert candidate([[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]], 2) == 5, "Error"
assert candidate([[0,0,0], [0,0,0]], 5) == 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([[1,1,1,1], [1,1,1,1]], 2) == 4, "Error"
assert candidate([[1,1,1,1], [1,1,1,1]], 9) == 2, "Error"
candidate = max_fill
check(candidate) | max_fill |
bt_JHumanEval/116 | この問題では、非負整数の配列を2進数表現における"1"の個数を昇順でソートする。
"1"の個数が同じ場合は，10進数に基づいてソートする。
次のように実装する：
>>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
>>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
>>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4] | def sort_array(arr):
return sorted(sorted(arr), key=lambda x: bin(x)[2:].count('1'))
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,5,2,3,4]) == [1, 2, 4, 3, 5]
assert candidate([-2,-3,-4,-5,-6]) == [-4, -2, -6, -5, -3]
assert candidate([1,0,2,3,4]) == [0, 1, 2, 4, 3]
assert candidate([]) == []
assert candidate([2,5,77,4,5,3,5,7,2,3,4]) == [2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]
assert candidate([3,6,44,12,32,5]) == [32, 3, 5, 6, 12, 44]
assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
# 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 = sort_array
check(candidate) | sort_array |
bt_JHumanEval/117 | ある文字列sと自然数nが与えらる。あなたに課せられたタスクは、文字列s
の中から、ちょうどn個の子音を含むすべての単語のリストを現れる順に返す
関数を実装することである。
注意：入力文字列には英文字と空白しか含まれないと仮定してもよい。
例:
select_words("Mary had a little lamb", 4) ==> ["little"]
select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
select_words("simple white space", 2) ==> []
select_words("Hello world", 4) ==> ["world"]
select_words("Uncle sam", 3) ==> ["Uncle"] | def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result
| def check(candidate):
# Check some simple cases
assert candidate("Mary had a little lamb", 4) == ["little"], "First test error: " + str(candidate("Mary had a little lamb", 4))
assert candidate("Mary had a little lamb", 3) == ["Mary", "lamb"], "Second test error: " + str(candidate("Mary had a little lamb", 3))
assert candidate("simple white space", 2) == [], "Third test error: " + str(candidate("simple white space", 2))
assert candidate("Hello world", 4) == ["world"], "Fourth test error: " + str(candidate("Hello world", 4))
assert candidate("Uncle sam", 3) == ["Uncle"], "Fifth test error: " + str(candidate("Uncle sam", 3))
# Check some edge cases that are easy to work out by hand.
assert candidate("", 4) == [], "1st edge test error: " + str(candidate("", 4))
assert candidate("a b c d e f", 1) == ["b", "c", "d", "f"], "2nd edge test error: " + str(candidate("a b c d e f", 1))
candidate = select_words
check(candidate) | select_words |
bt_JHumanEval/118 | 単語が与えられる。あなたの仕事は、単語の右側から2つの子音（大文字と
小文字を区別）の間に立っている最も近い母音を見つけることである。
最初と最後の母音はカウントされない。上記の条件を満たす母音が見つから
なかった場合は、空の文字列を返せ。
指定された文字列は英字のみを含むとみなしてよい。
例:
get_closest_vowel("yogurt") ==> "u"
get_closest_vowel("FULL") ==> "U"
get_closest_vowel("quick") ==> ""
get_closest_vowel("ab") ==> "" | def get_closest_vowel(word):
if len(word) < 3:
return ""
vowels = {"a", "e", "i", "o", "u", "A", "E", 'O', 'U', 'I'}
for i in range(len(word)-2, 0, -1):
if word[i] in vowels:
if (word[i+1] not in vowels) and (word[i-1] not in vowels):
return word[i]
return ""
| def check(candidate):
# Check some simple cases
assert candidate("yogurt") == "u"
assert candidate("full") == "u"
assert candidate("easy") == ""
assert candidate("eAsy") == ""
assert candidate("ali") == ""
assert candidate("bad") == "a"
assert candidate("most") == "o"
assert candidate("ab") == ""
assert candidate("ba") == ""
assert candidate("quick") == ""
assert candidate("anime") == "i"
assert candidate("Asia") == ""
assert candidate("Above") == "o"
# Check some edge cases that are easy to work out by hand.
assert True
candidate = get_closest_vowel
check(candidate) | get_closest_vowel |
bt_JHumanEval/119 | 2つの文字列からなるリストが与えられます。両方の文字列は開き括弧 '(' または
閉じ括弧 ')' のみで構成されています。
あなたの仕事は、2つの文字列を何らかの順序で結合して、「良い」文字列にすることが
可能かどうかを確認することです。
文字列Sが「良い」とは、文字列内のすべての括弧がバランスしている場合に限ります。
例えば、文字列 '(())()' は良いですが、文字列 '())' は良くありません。
良い文字列を作る方法がある場合は 'Yes' を返し、そうでない場合は 'No' を返してください。
例
match_parens(['()(', ')']) == 'Yes'
match_parens([')', ')']) == 'No' | def match_parens(lst):
def check(s):
val = 0
for i in s:
if i == '(':
val = val + 1
else:
val = val - 1
if val < 0:
return False
return True if val == 0 else False
S1 = lst[0] + lst[1]
S2 = lst[1] + lst[0]
return 'Yes' if check(S1) or check(S2) else 'No'
| def check(candidate):
# Check some simple cases
assert candidate(['()(', ')']) == 'Yes'
assert candidate([')', ')']) == 'No'
assert candidate(['(()(())', '())())']) == 'No'
assert candidate([')())', '(()()(']) == 'Yes'
assert candidate(['(())))', '(()())((']) == 'Yes'
assert candidate(['()', '())']) == 'No'
assert candidate(['(()(', '()))()']) == 'Yes'
assert candidate(['((((', '((())']) == 'No'
assert candidate([')(()', '(()(']) == 'No'
assert candidate([')(', ')(']) == 'No'
# Check some edge cases that are easy to work out by hand.
assert candidate(['(', ')']) == 'Yes'
assert candidate([')', '(']) == 'Yes'
candidate = match_parens
check(candidate) | match_parens |
bt_JHumanEval/120 | 整数の配列 arr と正の整数 k が与えられる。arr に含まれる大きい方から k 個の数を含む
長さ k のソート済みリストを返す。
例 1:
入力: arr = [-3, -4, 5], k = 3
出力: [-4, -3, 5]
例 2:
入力: arr = [4, -4, 4], k = 2
出力: [4, 4]
例 3:
入力: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
出力: [2]
ノート:
1. 配列の長さは[1, 1000]の範囲とする。
2. 配列の要素は [-1000, 1000] の範囲にある。
3. 0 <= k <= len(arr) | def maximum(arr, k):
if k == 0:
return []
arr.sort()
ans = arr[-k:]
return ans
| def check(candidate):
# Check some simple cases
assert candidate([-3, -4, 5], 3) == [-4, -3, 5]
assert candidate([4, -4, 4], 2) == [4, 4]
assert candidate([-3, 2, 1, 2, -1, -2, 1], 1) == [2]
assert candidate([123, -123, 20, 0 , 1, 2, -3], 3) == [2, 20, 123]
assert candidate([-123, 20, 0 , 1, 2, -3], 4) == [0, 1, 2, 20]
assert candidate([5, 15, 0, 3, -13, -8, 0], 7) == [-13, -8, 0, 0, 3, 5, 15]
assert candidate([-1, 0, 2, 5, 3, -10], 2) == [3, 5]
assert candidate([1, 0, 5, -7], 1) == [5]
assert candidate([4, -4], 2) == [-4, 4]
assert candidate([-10, 10], 2) == [-10, 10]
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3, -23, 243, -400, 0], 0) == []
candidate = maximum
check(candidate) | maximum |
bt_JHumanEval/121 | 整数の空でないリストが与えられた時、偶数の位置にある奇数の要素の合計を返す。
例
solution([5, 8, 7, 1]) ==> 12
solution([3, 3, 3, 3, 3]) ==> 9
solution([30, 13, 24, 321]) ==>0 | def solution(lst):
return sum([x for idx, x in enumerate(lst) if idx%2==0 and x%2==1])
| def check(candidate):
# Check some simple cases
assert candidate([5, 8, 7, 1]) == 12
assert candidate([3, 3, 3, 3, 3]) == 9
assert candidate([30, 13, 24, 321]) == 0
assert candidate([5, 9]) == 5
assert candidate([2, 4, 8]) == 0
assert candidate([30, 13, 23, 32]) == 23
assert candidate([3, 13, 2, 9]) == 3
# Check some edge cases that are easy to work out by hand.
candidate = solution
check(candidate) | solution |
bt_JHumanEval/122 | 整数の空でない配列 arr と整数 k が与えられたとき、
arr の最初の k 個の要素から高々 2 桁までの要素の和を返す。
例:
入力: arr = [111,21,3,4000,5,6,7,8,9], k = 4
出力: 24 # 21 + 3 の話
制約:
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr) | def add_elements(arr, k):
return sum(elem for elem in arr[:k] if len(str(elem)) <= 2)
| def check(candidate):
# Check some simple cases
assert candidate([1,-2,-3,41,57,76,87,88,99], 3) == -4
assert candidate([111,121,3,4000,5,6], 2) == 0
assert candidate([11,21,3,90,5,6,7,8,9], 4) == 125
assert candidate([111,21,3,4000,5,6,7,8,9], 4) == 24, "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) == 1, "This prints if this assert fails 2 (also good for debugging!)"
candidate = add_elements
check(candidate) | add_elements |
bt_JHumanEval/123 | 正の整数nが与えられたとき、コラッツ数列の奇数を持つソートされたリストを返す。
コラッツ予想とは数学の予想で、次のように定義される数列に関するものである：
任意の正の整数nから始め、各項は前の項から次のように求められる。
前の項が偶数なら、次の項は前の項の2分の1である。前の項が奇数の場合、次の項は前の項の3倍＋1である。
予想では、nがどのような値であっても、数列は必ず1に達する。
注：
1. Collatz(1)は[1]である。
2. 返されるリストは昇順にソートされている。
例えば:
get_odd_collatz(5) は [1, 5]を返す。つまり、5に対するコラッツ数列 は、[5, 16, 8, 4, 2, 1]であり、 奇数は 1 と 5 である。 | def get_odd_collatz(n):
if n%2==0:
odd_collatz = []
else:
odd_collatz = [n]
while n > 1:
if n % 2 == 0:
n = n/2
else:
n = n*3 + 1
if n%2 == 1:
odd_collatz.append(int(n))
return sorted(odd_collatz)
| def check(candidate):
# Check some simple cases
assert candidate(14) == [1, 5, 7, 11, 13, 17]
assert candidate(5) == [1, 5]
assert candidate(12) == [1, 3, 5], "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], "This prints if this assert fails 2 (also good for debugging!)"
candidate = get_odd_collatz
check(candidate) | get_odd_collatz |
bt_JHumanEval/124 | 与えられた日付文字列を検証し、その日付が有効であればTrueを、そうでなければFalseを返す関数を書く必要がある。
日付が有効であるのは、以下のルールがすべて満たされている場合である：
1. 日付文字列が空でない。
2. 日数が、月1,3,5,7,8,10,12の場合、1日以上31日以下である。また、月4,6,9,11については、日数が1以上30日以下である。また、月2については、日数が1以上29以下であること。
3. 月は1未満または12以上であってはならない。
4. 日付はmm-dd-yyyyの形式でなければならない。
例えば:
valid_date('03-11-2000') => True
valid_date('15-01-2012') => False
valid_date('04-0-2040') => False
valid_date('06-04-2020') => True
valid_date('06/04/2020') => False | def valid_date(date):
try:
date = date.strip()
month, day, year = date.split('-')
month, day, year = int(month), int(day), int(year)
if month < 1 or month > 12:
return False
if month in [1,3,5,7,8,10,12] and day < 1 or day > 31:
return False
if month in [4,6,9,11] and day < 1 or day > 30:
return False
if month == 2 and day < 1 or day > 29:
return False
except:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate('03-11-2000') == True
assert candidate('15-01-2012') == False
assert candidate('04-0-2040') == False
assert candidate('06-04-2020') == True
assert candidate('01-01-2007') == True
assert candidate('03-32-2011') == False
assert candidate('') == False
assert candidate('04-31-3000') == False
assert candidate('06-06-2005') == True
assert candidate('21-31-2000') == False
assert candidate('04-12-2003') == True
assert candidate('04122003') == False
assert candidate('20030412') == False
assert candidate('2003-04') == False
assert candidate('2003-04-12') == False
assert candidate('04-2003') == False
candidate = valid_date
check(candidate) | valid_date |
bt_JHumanEval/125 | 単語の文字列が与えられた場合、空白で分割された単語のリストを返す。
テキスト中に空白が存在しない場合は、カンマ ',' で分割する必要がある。カンマが存在しない場合は、
アルファベットの奇数順の小文字の数を返す必要がある。ord('a') = 0, ord('b') = 1, ... ord('z') = 25
例
split_words("Hello world!") ➞ ["Hello", "world!"]
split_words("Hello,world!") ➞ ["Hello", "world!"]
split_words("abcdef") == 3 | def split_words(txt):
if " " in txt:
return txt.split()
elif "," in txt:
return txt.replace(',',' ').split()
else:
return len([i for i in txt if i.islower() and ord(i)%2 == 0])
| def check(candidate):
assert candidate("Hello world!") == ["Hello","world!"]
assert candidate("Hello,world!") == ["Hello","world!"]
assert candidate("Hello world,!") == ["Hello","world,!"]
assert candidate("Hello,Hello,world !") == ["Hello,Hello,world","!"]
assert candidate("abcdef") == 3
assert candidate("aaabb") == 2
assert candidate("aaaBb") == 1
assert candidate("") == 0
candidate = split_words
check(candidate) | split_words |
bt_JHumanEval/126 | 数字のリストが与えられたとき、昇順に整列されているかどうかを返す。
リストに同じ数の重複が1つ以上ある場合は、Falseを返す。
負の数はなく、整数のみであると仮定する。
例
is_sorted([5]) ➞ True
is_sorted([1, 2, 3, 4, 5]) ➞ True
is_sorted([1, 3, 2, 4, 5]) ➞ False
is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
is_sorted([1, 2, 2, 2, 3, 4]) ➞ False | def is_sorted(lst):
count_digit = dict([(i, 0) for i in lst])
for i in lst:
count_digit[i]+=1
if any(count_digit[i] > 2 for i in lst):
return False
if all(lst[i-1] <= lst[i] for i in range(1, len(lst))):
return True
else:
return False
| def check(candidate):
# Check some simple cases
assert candidate([5]) == True
assert candidate([1, 2, 3, 4, 5]) == True
assert candidate([1, 3, 2, 4, 5]) == False
assert candidate([1, 2, 3, 4, 5, 6]) == True
assert candidate([1, 2, 3, 4, 5, 6, 7]) == True
assert candidate([1, 3, 2, 4, 5, 6, 7]) == False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([]) == True, "This prints if this assert fails 2 (good for debugging!)"
assert candidate([1]) == True, "This prints if this assert fails 3 (good for debugging!)"
assert candidate([3, 2, 1]) == False, "This prints if this assert fails 4 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 2, 2, 3, 4]) == False, "This prints if this assert fails 5 (good for debugging!)"
assert candidate([1, 2, 3, 3, 3, 4]) == False, "This prints if this assert fails 6 (good for debugging!)"
assert candidate([1, 2, 2, 3, 3, 4]) == True, "This prints if this assert fails 7 (good for debugging!)"
assert candidate([1, 2, 3, 4]) == True, "This prints if this assert fails 8 (good for debugging!)"
candidate = is_sorted
check(candidate) | is_sorted |
bt_JHumanEval/127 | 2つの区間が与えられます。
それぞれの区間は整数のペアで示されます。例えば、区間 = (start, end ) = (1, 2) です。
与えられた区間は閉区間であり、start と end の両端が含まれます。
各区間について、start は end 以下であると仮定します。
あなたの仕事は、これら2つの区間の交差部分の長さが素数であるかどうかを判断することです。
例えば、区間 (1, 3) と (2, 4) の交差部分は (2, 3) で、その長さは1ですが、これは素数ではありません。
交差部分の長さが素数であれば "YES" を返し、そうでなければ "NO" を返してください。
もし2つの区間が交差しない場合も "NO" を返してください。
[input/output] サンプル:
intersection((1, 2), (2, 3)) ==> "NO"
intersection((-1, 1), (0, 4)) ==> "NO"
intersection((-3, -1), (-5, 5)) ==> "YES" | def intersection(interval1, interval2):
def is_prime(num):
if num == 1 or num == 0:
return False
if num == 2:
return True
for i in range(2, num):
if num%i == 0:
return False
return True
l = max(interval1[0], interval2[0])
r = min(interval1[1], interval2[1])
length = r - l
if length > 0 and is_prime(length):
return "YES"
return "NO"
| def check(candidate):
# Check some simple cases
assert candidate((1, 2), (2, 3)) == "NO"
assert candidate((-1, 1), (0, 4)) == "NO"
assert candidate((-3, -1), (-5, 5)) == "YES"
assert candidate((-2, 2), (-4, 0)) == "YES"
# Check some edge cases that are easy to work out by hand.
assert candidate((-11, 2), (-1, -1)) == "NO"
assert candidate((1, 2), (3, 5)) == "NO"
assert candidate((1, 2), (1, 2)) == "NO"
assert candidate((-2, -2), (-3, -2)) == "NO"
candidate = intersection
check(candidate) | intersection |
bt_JHumanEval/128 | 整数の配列 arr が与えられます。この配列に含まれる各数値の絶対値の合計と、
各数値の符号（プラスは1、マイナスは-1、ゼロは0）の積を掛け合わせた値を
返してください。
注意：配列`arr`が空の場合は`None`を返してください。
例:
>>> prod_signs([1, 2, 2, -4]) == -9
>>> prod_signs([0, 1]) == 0
>>> prod_signs([]) == None | def prod_signs(arr):
if not arr: return None
prod = 0 if 0 in arr else (-1) ** len(list(filter(lambda x: x < 0, arr)))
return prod * sum([abs(i) for i in arr])
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1, 2, 2, -4]) == -9
assert candidate([0, 1]) == 0
assert candidate([1, 1, 1, 2, 3, -1, 1]) == -10
assert candidate([]) == None
assert candidate([2, 4,1, 2, -1, -1, 9]) == 20
assert candidate([-1, 1, -1, 1]) == 4
assert candidate([-1, 1, 1, 1]) == -4
assert candidate([-1, 1, 1, 0]) == 0
# 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 = prod_signs
check(candidate) | prod_signs |
bt_JHumanEval/129 | N行とN列 (N >= 2)) のグリッドと正の整数kが与えられた場合、各セルには値が含まれている。
範囲[1, N * N]（両端を含む）のすべての整数は、グリッドのセルに一度だけ表れる。
このグリッド内で長さkの最短の経路を見つける必要がある。任意のセルからスタートでき、
各ステップで隣接するセルに移動できる。言い換えれば、現在のセルと辺を共有するセルに
移動できる。長さkの経路とは、正確にk個のセル（必ずしも異なるとは限らない）を訪れる
ことを意味する。ただし、グリッドから出ることはない。
長さkの2つの経路AとBがある場合、AとBが通るセルの値を順番にリスト化したものを
それぞれlst_A、lst_Bと呼ぶ。lst_Aがlst_Bより辞書順で小さい場合、経路Aは経路Bよりも
小さいとする。つまり、整数インデックスi（ 1 <= i <= k ) が存在して、lst_A[i] < lst_B[i] となり、
任意の j（ 1 <= j < i ）に対して lst_A[j] = lst_B[j] が成立する。
答えは一意であることが保証されている。
最短の経路が通るセルの値の順番に並べたリストを返すようにせよ。
例：
入力：grid =[ [1,2,3], [4,5,6], [7,8,9]]. k = 3
出力：[1, 2, 1]
入力：grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
出力：[1] | def minPath(grid, k):
n = len(grid)
val = n * n + 1
for i in range(n):
for j in range(n):
if grid[i][j] == 1:
temp = []
if i != 0:
temp.append(grid[i - 1][j])
if j != 0:
temp.append(grid[i][j - 1])
if i != n - 1:
temp.append(grid[i + 1][j])
if j != n - 1:
temp.append(grid[i][j + 1])
val = min(temp)
ans = []
for i in range(k):
if i % 2 == 0:
ans.append(1)
else:
ans.append(val)
return ans
| def check(candidate):
# Check some simple cases
print
assert candidate([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3) == [1, 2, 1]
assert candidate([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1) == [1]
assert candidate([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 4) == [1, 2, 1, 2]
assert candidate([[6, 4, 13, 10], [5, 7, 12, 1], [3, 16, 11, 15], [8, 14, 9, 2]], 7) == [1, 10, 1, 10, 1, 10, 1]
assert candidate([[8, 14, 9, 2], [6, 4, 13, 15], [5, 7, 1, 12], [3, 10, 11, 16]], 5) == [1, 7, 1, 7, 1]
assert candidate([[11, 8, 7, 2], [5, 16, 14, 4], [9, 3, 15, 6], [12, 13, 10, 1]], 9) == [1, 6, 1, 6, 1, 6, 1, 6, 1]
assert candidate([[12, 13, 10, 1], [9, 3, 15, 6], [5, 16, 14, 4], [11, 8, 7, 2]], 12) == [1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6]
assert candidate([[2, 7, 4], [3, 1, 5], [6, 8, 9]], 8) == [1, 3, 1, 3, 1, 3, 1, 3]
assert candidate([[6, 1, 5], [3, 8, 9], [2, 7, 4]], 8) == [1, 5, 1, 5, 1, 5, 1, 5]
# Check some edge cases that are easy to work out by hand.
assert candidate([[1, 2], [3, 4]], 10) == [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
assert candidate([[1, 3], [3, 2]], 10) == [1, 3, 1, 3, 1, 3, 1, 3, 1, 3]
candidate = minPath
check(candidate) | minPath |
bt_JHumanEval/130 | フィボナッチ数列は、ここ数世紀の間に数学者によって深く研究され、誰もが知っている。
しかし、人々が知らないのはトリボナッチ数列である。
トリボナッチ数列は再帰によって定義される:
tri(1) = 3
tri(n) = 1 + n / 2, n が偶数の場合.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), n が奇数の場合d.
例えば:
tri(2) = 1 + (2 / 2) = 2
tri(4) = 3
tri(3) = tri(2) + tri(1) + tri(4)
= 2 + 3 + 3 = 8
あなたは非負の整数nが与えられるので、トリボナッチ数列の最初のn + 1個の数の
リストを返さなければならない。
例:
tri(3) = [1, 3, 2, 8] | def tri(n):
if n == 0:
return [1]
my_tri = [1, 3]
for i in range(2, n + 1):
if i % 2 == 0:
my_tri.append(i / 2 + 1)
else:
my_tri.append(my_tri[i - 1] + my_tri[i - 2] + (i + 3) / 2)
return my_tri
| def check(candidate):
# Check some simple cases
assert candidate(3) == [1, 3, 2.0, 8.0]
assert candidate(4) == [1, 3, 2.0, 8.0, 3.0]
assert candidate(5) == [1, 3, 2.0, 8.0, 3.0, 15.0]
assert candidate(6) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0]
assert candidate(7) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0]
assert candidate(8) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0]
assert candidate(9) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0]
assert candidate(20) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0, 6.0, 48.0, 7.0, 63.0, 8.0, 80.0, 9.0, 99.0, 10.0, 120.0, 11.0]
# Check some edge cases that are easy to work out by hand.
assert candidate(0) == [1]
assert candidate(1) == [1, 3]
candidate = tri
check(candidate) | tri |
bt_JHumanEval/131 | 正の整数 n が与えられた時、奇数桁数の積を返す。
全ての桁が偶数の場合は0を返す。
例えば:
digits(1) == 1
digits(4) == 0
digits(235) == 15 | def digits(n):
product = 1
odd_count = 0
for digit in str(n):
int_digit = int(digit)
if int_digit%2 == 1:
product= product*int_digit
odd_count+=1
if odd_count ==0:
return 0
else:
return product
| def check(candidate):
# Check some simple cases
assert candidate(5) == 5
assert candidate(54) == 5
assert candidate(120) ==1
assert candidate(5014) == 5
assert candidate(98765) == 315
assert candidate(5576543) == 2625
# Check some edge cases that are easy to work out by hand.
assert candidate(2468) == 0
candidate = digits
check(candidate) | digits |
bt_JHumanEval/132 | この関数は、角括弧だけを含む文字列を入力として受け取ります。括弧が有効な順序で
並んでいて、その中に少なくとも1つの括弧が入れ子になっている場合、関数はTrueを
返すようにしてください。
is_nested('[[]]') ➞ True
is_nested('[]]]]]]][[[[[]') ➞ False
is_nested('[][]') ➞ False
is_nested('[]') ➞ False
is_nested('[[][]]') ➞ True
is_nested('[[]][[') ➞ True | def is_nested(string):
opening_bracket_index = []
closing_bracket_index = []
for i in range(len(string)):
if string[i] == '[':
opening_bracket_index.append(i)
else:
closing_bracket_index.append(i)
closing_bracket_index.reverse()
cnt = 0
i = 0
l = len(closing_bracket_index)
for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
assert candidate('[]]]]]]]]]]') == False
assert candidate('[][][[]]') == True
assert candidate('[[]') == False
assert candidate('[]]') == False
assert candidate('[[]][[') == True
assert candidate('[[][]]') == True
# Check some edge cases that are easy to work out by hand.
assert candidate('') == False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate('[[[[[[[[') == False
assert candidate(']]]]]]]]') == False
candidate = is_nested
check(candidate) | is_nested |
bt_JHumanEval/133 | 数字のリストが与えられます。
与えられたリスト内の各数値をまず切り上げ（天井関数を使って最も近い整数に丸める）、
その後それぞれの数値を二乗した値の合計を返してください。
例:
lst = [1,2,3] のときの出力は 14
lst = [1,4,9] のときの出力は 98
lst = [1,3,5,7] のときの出力は 84
lst = [1.4,4.2,0] のときの出力は 29
lst = [-2.4,1,1] のときの出力は 6 | def sum_squares(lst):
import math
squared = 0
for i in lst:
squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.4,4.2,0])==29, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-2.4,1,1])==6, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([100,1,15,2])==10230, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([10000,10000])==200000000, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1.4,4.6,6.3])==75, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1.4,17.9,18.9,19.9])==1086, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0])==0, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([-1])==1, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([-1,1,0])==2, "This prints if this assert fails 2 (also good for debugging!)"
candidate = sum_squares
check(candidate) | sum_squares |
bt_JHumanEval/134 | 与えられた文字列の最後の文字がアルファベットであり、かつ単語の一部でなければTrueを、
そうでなければFalseを返す関数を作成せよ。
注意：単語とはスペースで区切られた文字の並びである。
例:
check_if_last_char_is_a_letter("apple pie") ➞ False
check_if_last_char_is_a_letter("apple pi e") ➞ True
check_if_last_char_is_a_letter("apple pi e ") ➞ False
check_if_last_char_is_a_letter("") ➞ False | def check_if_last_char_is_a_letter(txt):
check = txt.split(' ')[-1]
return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False
| def check(candidate):
# Check some simple cases
assert candidate("apple") == False
assert candidate("apple pi e") == True
assert candidate("eeeee") == False
assert candidate("A") == True
assert candidate("Pumpkin pie ") == False
assert candidate("Pumpkin pie 1") == False
assert candidate("") == False
assert candidate("eeeee e ") == False
assert candidate("apple pie") == False
assert candidate("apple pi e ") == False
# Check some edge cases that are easy to work out by hand.
assert True
candidate = check_if_last_char_is_a_letter
check(candidate) | check_if_last_char_is_a_letter |
bt_JHumanEval/135 | 直前の要素よりも大きくない要素の中で、最も大きなインデックスを持つ要素を探して
そのインデックスを返す関数を作成してください。そのような要素が存在しない場合は、
-1を返してください。与えられる配列には重複する値は含まれません。
例:
can_arrange([1,2,4,3,5]) = 3
can_arrange([1,2,3]) = -1 | def can_arrange(arr):
ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
candidate = can_arrange
check(candidate) | can_arrange |
bt_JHumanEval/136 | リストから最も大きな負の整数と最も小さな正の整数を見つけ、それらをタプル（a, b）
として返す関数を作成してください。リストに負の整数もしくは正の整数がない場合は、
代わりにNoneを返します。
例:
largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
largest_smallest_integers([]) == (None, None)
largest_smallest_integers([0]) == (None, None) | def largest_smallest_integers(lst):
smallest = list(filter(lambda x: x < 0, lst))
largest = list(filter(lambda x: x > 0, lst))
return (max(smallest) if smallest else None, min(largest) if largest else None)
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -9]) == (-9, 2)
assert candidate([]) == (None, None)
assert candidate([0]) == (None, None)
assert candidate([-1, -3, -5, -6]) == (-1, None)
assert candidate([-1, -3, -5, -6, 0]) == (-1, None)
assert candidate([-6, -4, -4, -3, 1]) == (-3, 1)
assert candidate([-6, -4, -4, -3, -100, 1]) == (-3, 1)
# Check some edge cases that are easy to work out by hand.
assert True
candidate = largest_smallest_integers
check(candidate) | largest_smallest_integers |
bt_JHumanEval/137 | 整数、浮動小数点数、または実数を表す文字列を引数として受け取り、その中で最も大きい値を
その元の型で返す関数を作成してください。もし値が同じであれば、Noneを返してください。
注意：実数が文字列として表されている場合、小数点はピリオド（.）またはカンマ（,）の可能性があります。
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3") ➞ "2,3"
compare_one("5,1", "6") ➞ "6"
compare_one("1", 1) ➞ None | def compare_one(a, b):
temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candidate("1", 1) == None
# Check some edge cases that are easy to work out by hand.
assert True
candidate = compare_one
check(candidate) | compare_one |
bt_JHumanEval/138 | 与えられた数値nが、ちょうど4つの正の偶数の合計として表現できるかどうかを評価してください。
例
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True | def is_equal_to_sum_even(n):
return n%2 == 0 and n >= 8
| def check(candidate):
assert candidate(4) == False
assert candidate(6) == False
assert candidate(8) == True
assert candidate(10) == True
assert candidate(11) == False
assert candidate(12) == True
assert candidate(13) == False
assert candidate(16) == True
candidate = is_equal_to_sum_even
check(candidate) | is_equal_to_sum_even |
bt_JHumanEval/139 | ブラジリアン階乗は次のように定義される：
brazilian_factorial(n) = n！* (n-1)! * (n-2)! * ... * 1!
ただし n > 0
例えば:
>>> special_factorial(4)
288
この関数は入力として整数を受け取り、整数の特殊な階乗を返す。 | def special_factorial(n):
fact_i = 1
special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
candidate = special_factorial
check(candidate) | special_factorial |
bt_JHumanEval/140 | 文字列テキストが与えられた場合、その中のすべての空白をアンダースコアに置換し、
文字列が2つ以上の連続した空白を持つ場合、すべての連続した空白を - に置換する
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example 3") == "_Example-3" | def fix_spaces(text):
new_text = ""
i = 0
start, end = 0, 0
while i < len(text):
if text[i] == " ":
end += 1
else:
if end - start > 2:
new_text += "-"+text[i]
elif end - start > 0:
new_text += "_"*(end - start)+text[i]
else:
new_text += text[i]
start, end = i+1, i+1
i+=1
if end - start > 2:
new_text += "-"
elif end - start > 0:
new_text += "_"
return new_text
| def check(candidate):
# Check some simple cases
assert candidate("Example") == "Example", "This prints if this assert fails 1 (good for debugging!)"
assert candidate("Mudasir Hanif ") == "Mudasir_Hanif_", "This prints if this assert fails 2 (good for debugging!)"
assert candidate("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow", "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate("Exa mple") == "Exa-mple", "This prints if this assert fails 4 (good for debugging!)"
assert candidate(" Exa 1 2 2 mple") == "-Exa_1_2_2_mple", "This prints if this assert fails 4 (good for debugging!)"
candidate = fix_spaces
check(candidate) | fix_spaces |
bt_JHumanEval/141 | ファイル名を表す文字列を受け取り、そのファイル名が有効であれば'Yes'を返し、そうでなければ'No'
を返す関数を作成する。ファイル名が有効であるとみなされるのは、
以下の条件をすべて満たす場合のみである：
- ファイル名に3桁以上の数字（'0'-'9'）があってはならない。
- ファイル名に含まれるドット '.' はひとつのみ。
- ドットの前の部分文字列は空であってはならず、英文字（'a'-'z'および'A'-'Z'）から始まる文字でなければならない。
- ドットの後の部分文字列は、以下のいずれかでなければならない： ['txt'、'exe'、'dll']。
例:
file_name_check("example.txt") # => 'Yes'
file_name_check("1example.dll") # => 'No' (名前は英文字で始まらないといけない） | def file_name_check(file_name):
suf = ['txt', 'exe', 'dll']
lst = file_name.split(sep='.')
if len(lst) != 2:
return 'No'
if not lst[1] in suf:
return 'No'
if len(lst[0]) == 0:
return 'No'
if not lst[0][0].isalpha():
return 'No'
t = len([x for x in lst[0] if x.isdigit()])
if t > 3:
return 'No'
return 'Yes'
| def check(candidate):
# Check some simple cases
assert candidate("example.txt") == 'Yes'
assert candidate("1example.dll") == 'No'
assert candidate('s1sdf3.asd') == 'No'
assert candidate('K.dll') == 'Yes'
assert candidate('MY16FILE3.exe') == 'Yes'
assert candidate('His12FILE94.exe') == 'No'
assert candidate('_Y.txt') == 'No'
assert candidate('?aREYA.exe') == 'No'
assert candidate('/this_is_valid.dll') == 'No'
assert candidate('this_is_valid.wow') == 'No'
assert candidate('this_is_valid.txt') == 'Yes'
assert candidate('this_is_valid.txtexe') == 'No'
assert candidate('#this2_i4s_5valid.ten') == 'No'
assert candidate('@this1_is6_valid.exe') == 'No'
assert candidate('this_is_12valid.6exe4.txt') == 'No'
assert candidate('all.exe.txt') == 'No'
assert candidate('I563_No.exe') == 'Yes'
assert candidate('Is3youfault.txt') == 'Yes'
assert candidate('no_one#knows.dll') == 'Yes'
assert candidate('1I563_Yes3.exe') == 'No'
assert candidate('I563_Yes3.txtt') == 'No'
assert candidate('final..txt') == 'No'
assert candidate('final132') == 'No'
assert candidate('_f4indsartal132.') == 'No'
# Check some edge cases that are easy to work out by hand.
assert candidate('.txt') == 'No'
assert candidate('s.') == 'No'
candidate = file_name_check
check(candidate) | file_name_check |
bt_JHumanEval/142 | "
この関数は整数のリストを受け取ります。リスト内の各要素に対して、そのインデックスが3の倍数で
あればその整数を二乗し、インデックスが4の倍数でかつ3の倍数でない場合はその整数を三乗します。
インデックスが3または4の倍数でない要素については、何も変更しません。最後に、すべての要素の
合計値を返します。
例:
lst = [1,2,3] の時、返り値は 6
lst = [] の時、返り値は 0
lst = [-1,-5,2,-1,-5] の時、返り値は -126 | def sum_squares(lst):
result =[]
for i in range(len(lst)):
if i %3 == 0:
result.append(lst[i]**2)
elif i % 4 == 0 and i%3 != 0:
result.append(lst[i]**3)
else:
result.append(lst[i])
return sum(result)
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3]) == 6
assert candidate([1,4,9]) == 14
assert candidate([]) == 0
assert candidate([1,1,1,1,1,1,1,1,1]) == 9
assert candidate([-1,-1,-1,-1,-1,-1,-1,-1,-1]) == -3
assert candidate([0]) == 0
assert candidate([-1,-5,2,-1,-5]) == -126
assert candidate([-56,-99,1,0,-2]) == 3030
assert candidate([-1,0,0,0,0,0,0,0,-1]) == 0
assert candidate([-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37]) == -14196
assert candidate([-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10]) == -1448
# Don't remove this line:
candidate = sum_squares
check(candidate) | sum_squares |
bt_JHumanEval/143 | 文を表す文字列が与えられ、その文には空白で区切られたいくつかの単語が含まれている。
元の文の単語を含みその長さが素数である文字列を返す必要がある。
新しい文字列の単語の順序は元の文字列と同じでなければならない。
例 1:
入力: sentence = "This is a test"
出力: "is"
例 2:
入力: sentence = "lets go for swimming"
出力: "go for"
制約:
* 1 <= len(sentence) <= 100
* sentence contains only letters | def words_in_sentence(sentence):
new_lst = []
for word in sentence.split():
flg = 0
if len(word) == 1:
flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| def check(candidate):
# Check some simple cases
assert candidate("This is a test") == "is"
assert candidate("lets go for swimming") == "go for"
assert candidate("there is no place available here") == "there is no place"
assert candidate("Hi I am Hussein") == "Hi am Hussein"
assert candidate("go for it") == "go for it"
# Check some edge cases that are easy to work out by hand.
assert candidate("here") == ""
assert candidate("here is") == "is"
candidate = words_in_sentence
check(candidate) | words_in_sentence |
bt_JHumanEval/144 | あなたの仕事は、式 x * n を簡単にする関数を実装することです。
この関数は、x * n が整数になる場合はTrueを、そうでない場合はFalseを
返します。xとnはともに分数の文字列表現であり、<分子>/<分母>という形式で、
分子と分母はともに正の整数です。
xとnが有効な分数であり、分母がゼロでないことは仮定してかまいません。
simplify("1/5", "5/1") = True
simplify("1/6", "2/1") = False
simplify("7/10", "10/2") = False | def simplify(x, n):
a, b = x.split("/")
c, d = n.split("/")
numerator = int(a) * int(c)
denom = int(b) * int(d)
if (numerator/denom == int(numerator/denom)):
return True
return False
| def check(candidate):
# Check some simple cases
assert candidate("1/5", "5/1") == True, 'test1'
assert candidate("1/6", "2/1") == False, 'test2'
assert candidate("5/1", "3/1") == True, 'test3'
assert candidate("7/10", "10/2") == False, 'test4'
assert candidate("2/10", "50/10") == True, 'test5'
assert candidate("7/2", "4/2") == True, 'test6'
assert candidate("11/6", "6/1") == True, 'test7'
assert candidate("2/3", "5/2") == False, 'test8'
assert candidate("5/2", "3/5") == False, 'test9'
assert candidate("2/4", "8/4") == True, 'test10'
# Check some edge cases that are easy to work out by hand.
assert candidate("2/4", "4/2") == True, 'test11'
assert candidate("1/5", "5/1") == True, 'test12'
assert candidate("1/5", "1/5") == False, 'test13'
candidate = simplify
check(candidate) | simplify |
bt_JHumanEval/145 | 各数字の桁の合計に基づいて、与えられた整数のリストを昇順に並べる
関数を作成してください。
注意：もし桁の合計が同じである複数の項目がある場合は、
元のリストでの位置に基づいて並べてください。
例えば
>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11].
>> order_by_points([]) == []. | def order_by_points(nums):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| def check(candidate):
# Check some simple cases
assert candidate([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
assert candidate([1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]) == [0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]
assert candidate([]) == []
assert candidate([1, -11, -32, 43, 54, -98, 2, -3]) == [-3, -32, -98, -11, 1, 2, 43, 54]
assert candidate([1,2,3,4,5,6,7,8,9,10,11]) == [1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]
assert candidate([0,6,6,-76,-21,23,4]) == [-76, -21, 0, 4, 23, 6, 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 = order_by_points
check(candidate) | order_by_points |
bt_JHumanEval/146 | 数値の配列を入力とし、配列中の要素のうち、10より大きく、
かつ数値の最初と最後の桁の両方が奇数（1, 3, 5, 7, 9）である要素の数を返す関数を書く。
例えば
specialFilter([15, -73, 14, -15]) => 1
specialFilter([33, -2, -3, 45, 21, 109]) => 2 | def specialFilter(nums):
count = 0
for num in nums:
if num > 10:
odd_digits = (1, 3, 5, 7, 9)
number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| def check(candidate):
# Check some simple cases
assert candidate([5, -2, 1, -5]) == 0
assert candidate([15, -73, 14, -15]) == 1
assert candidate([33, -2, -3, 45, 21, 109]) == 2
assert candidate([43, -12, 93, 125, 121, 109]) == 4
assert candidate([71, -2, -33, 75, 21, 19]) == 3
# Check some edge cases that are easy to work out by hand.
assert candidate([1]) == 0
assert candidate([]) == 0
candidate = specialFilter
check(candidate) | specialFilter |
bt_JHumanEval/147 | 正の整数 n が与えられるので、長さ n の整数配列 a を作成せよ。
各 i (1 ≤ i ≤ n) に対して、 a[i] = i * i - i + 1 とする。
i < j < k において、a[i] + a[j] + a[k] が3の倍数となるような三つ組 (a[i], a[j], a[k]) を返す。
例 :
入力: n = 5
出力t: 1
解説:
a = [1, 3, 7, 13, 21]
唯一の妥当な三つ組は (1, 7, 13)である。 | def get_max_triples(n):
A = [i*i - i + 1 for i in range(1,n+1)]
ans = []
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| def check(candidate):
assert candidate(5) == 1
assert candidate(6) == 4
assert candidate(10) == 36
assert candidate(100) == 53361
candidate = get_max_triples
check(candidate) | get_max_triples |
bt_JHumanEval/148 | 私たちの太陽系には8つの惑星があります：太陽に最も近いのはVenus, Earth, Mars, Jupiter, Saturn,
Uranus, Neptuneです。
planet1とplanet2という2つの惑星名を文字列として受け取る関数を作成してください。
この関数は、planet1の軌道とplanet2の軌道の間に位置するすべての惑星を太陽に近い順に並べたタプルを返すべきです。
planet1またはplanet2が正確な惑星名でない場合、関数は空のタプルを返すべきです。
例
bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
bf("Earth", "Mercury") ==> ("Venus")
bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn") | def bf(planet1, planet2):
planet_names = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
return ()
planet1_index = planet_names.index(planet1)
planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| def check(candidate):
# Check some simple cases
assert candidate("Jupiter", "Neptune") == ("Saturn", "Uranus"), "First test error: " + str(len(candidate("Jupiter", "Neptune")))
assert candidate("Earth", "Mercury") == ("Venus",), "Second test error: " + str(candidate("Earth", "Mercury"))
assert candidate("Mercury", "Uranus") == ("Venus", "Earth", "Mars", "Jupiter", "Saturn"), "Third test error: " + str(candidate("Mercury", "Uranus"))
assert candidate("Neptune", "Venus") == ("Earth", "Mars", "Jupiter", "Saturn", "Uranus"), "Fourth test error: " + str(candidate("Neptune", "Venus"))
# Check some edge cases that are easy to work out by hand.
assert candidate("Earth", "Earth") == ()
assert candidate("Mars", "Earth") == ()
assert candidate("Jupiter", "Makemake") == ()
candidate = bf
check(candidate) | bf |
bt_JHumanEval/149 | 文字列のリストを引数として受け取る関数を作成してください。
この関数は、リストから奇数の長さを持つ文字列を削除し、
結果として得られるリストを長さで昇順に並べ替えて返します。
リストは常に文字列のリストであり、数字の配列ではありません。
また、重複する文字列が含まれる可能性があります。
リストは各単語の長さで昇順に並べられるべきで、そのルールに従ってソートされたリストを返してください。
もし二つの単語が同じ長さであれば、リストをアルファベット順に並べ替えてください。
関数はソートされた順序で文字列のリストを返すべきです。
すべての単語が同じ長さを持つと仮定しても構いません。
例えば:
assert list_sort(["aa", "a", "aaa"]) => ["aa"]
assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"] | def sorted_list_sum(lst):
lst.sort()
new_lst = []
for i in lst:
if len(i)%2 == 0:
new_lst.append(i)
return sorted(new_lst, key=len)
| def check(candidate):
# Check some simple cases
assert candidate(["aa", "a", "aaa"]) == ["aa"]
assert candidate(["school", "AI", "asdf", "b"]) == ["AI", "asdf", "school"]
assert candidate(["d", "b", "c", "a"]) == []
assert candidate(["d", "dcba", "abcd", "a"]) == ["abcd", "dcba"]
# Check some edge cases that are easy to work out by hand.
assert candidate(["AI", "ai", "au"]) == ["AI", "ai", "au"]
assert candidate(["a", "b", "b", "c", "c", "a"]) == []
assert candidate(['aaaa', 'bbbb', 'dd', 'cc']) == ["cc", "dd", "aaaa", "bbbb"]
candidate = sorted_list_sum
check(candidate) | sorted_list_sum |
bt_JHumanEval/150 | 素数である場合はxの値を返し、それ以外の場合はyの値を返す簡単なプログラム。
例:
for x_or_y(7, 34, 12) == 34
for x_or_y(15, 8, 5) == 5 | def x_or_y(n, x, y):
if n == 1:
return y
for i in range(2, n):
if n % i == 0:
return y
break
else:
return x
| def check(candidate):
# Check some simple cases
assert candidate(7, 34, 12) == 34
assert candidate(15, 8, 5) == 5
assert candidate(3, 33, 5212) == 33
assert candidate(1259, 3, 52) == 3
assert candidate(7919, -1, 12) == -1
assert candidate(3609, 1245, 583) == 583
assert candidate(91, 56, 129) == 129
assert candidate(6, 34, 1234) == 1234
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 2, 0) == 0
assert candidate(2, 2, 0) == 2
candidate = x_or_y
check(candidate) | x_or_y |
bt_JHumanEval/151 | 数字のリストが与えられた場合、そのリスト内の奇数の数値の二乗の合計を返してください。
負の数や整数でない数は無視してください。
double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
double_the_difference([-1, -2, 0]) == 0
double_the_difference([9, -2]) == 81
double_the_difference([0]) == 0
入力リストが空の場合は0を返すようにしてください。 | def double_the_difference(lst):
return sum([i**2 for i in lst if i > 0 and i%2!=0 and "." not in str(i)])
| def check(candidate):
# Check some simple cases
assert candidate([]) == 0 , "This prints if this assert fails 1 (good for debugging!)"
assert candidate([5, 4]) == 25 , "This prints if this assert fails 2 (good for debugging!)"
assert candidate([0.1, 0.2, 0.3]) == 0 , "This prints if this assert fails 3 (good for debugging!)"
assert candidate([-10, -20, -30]) == 0 , "This prints if this assert fails 4 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([-1, -2, 8]) == 0, "This prints if this assert fails 5 (also good for debugging!)"
assert candidate([0.2, 3, 5]) == 34, "This prints if this assert fails 6 (also good for debugging!)"
lst = list(range(-99, 100, 2))
odd_sum = sum([i**2 for i in lst if i%2!=0 and i > 0])
assert candidate(lst) == odd_sum , "This prints if this assert fails 7 (good for debugging!)"
candidate = double_the_difference
check(candidate) | double_the_difference |
bt_JHumanEval/152 | 待ち望んでいた出来事の結果がようやく判明したときの感覚は、誰もが覚えていると思う。
その瞬間に抱いた感情や思考は、間違いなくメモして比較する価値がある。
あなたの仕事は、人がいくつかの試合の結果を正確に予想したかどうかを判断することです。
スコアと予想の2つの配列が等しい長さで与えられます。各インデックスは1つの試合を示しています。
各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。予想が正確であれば、
その値は0です。そうでなければ、その値は予想とスコアの絶対的な差です。
例:
compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6] | def compare(game,guess):
return [abs(x-y) for x,y in zip(game,guess)]
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3,4,5,1],[1,2,3,4,2,-2])==[0,0,0,0,3,3], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([0,0,0,0,0,0],[0,0,0,0,0,0])==[0,0,0,0,0,0], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,2,3],[-1,-2,-3])==[2,4,6], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,2,3,5],[-1,2,3,4])==[2,0,0,1], "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 = compare
check(candidate) | compare |
bt_JHumanEval/153 | クラスの名前（文字列）と拡張子のリストが与えられます。
この拡張子は、指定されたクラスに追加のクラスをロードするために使用されます。
拡張子の強度は次のように計算されます：CAPは拡張子の名前に含まれる
大文字の数、SMは小文字の数です。強度は、CAP - SM で与えられます。
最も強い拡張子を見つけて、この形式の文字列を返してください：ClassName.StrongestExtensionName。
同じ強度を持つ2つ以上の拡張子がある場合は、リストで最初に来るものを選びます。
例えば、"Slices"というクラスと、拡張子のリスト['SErviNGSliCes', 'Cheese', 'StuFfed'] が与えられた場合、'
SErviNGSliCes'が最も強い拡張子（強度は-1）となるため、'Slices.SErviNGSliCes'を返すべきです。
例：
Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA' | def Strongest_Extension(class_name, extensions):
strong = extensions[0]
my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
for s in extensions:
val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
if val > my_val:
strong = s
my_val = val
ans = class_name + "." + strong
return ans
| def check(candidate):
# Check some simple cases
assert candidate('Watashi', ['tEN', 'niNE', 'eIGHt8OKe']) == 'Watashi.eIGHt8OKe'
assert candidate('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']) == 'Boku123.YEs.WeCaNe'
assert candidate('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']) == '__YESIMHERE.NuLl__'
assert candidate('K', ['Ta', 'TAR', 't234An', 'cosSo']) == 'K.TAR'
assert candidate('__HAHA', ['Tab', '123', '781345', '-_-']) == '__HAHA.123'
assert candidate('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-']) == 'YameRore.okIWILL123'
assert candidate('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW']) == 'finNNalLLly.WoW'
# Check some edge cases that are easy to work out by hand.
assert candidate('_', ['Bb', '91245']) == '_.Bb'
assert candidate('Sp', ['671235', 'Bb']) == 'Sp.671235'
candidate = Strongest_Extension
check(candidate) | Strongest_Extension |
bt_JHumanEval/154 | 2つの単語が与えられる。2番目の単語またはその回転させた文字列が最初の単語の部分文字列である場合、Trueを返す必要がある。
cycpattern_check("abcd","abd") => False
cycpattern_check("hello","ell") => True
cycpattern_check("whassup","psus") => False
cycpattern_check("abab","baa") => True
cycpattern_check("efef","eeff") => False
cycpattern_check("himenss","simen") => True | def cycpattern_check(a , b):
l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
return True
return False
| def check(candidate):
# Check some simple cases
#assert True, "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!)"
assert candidate("xyzw","xyw") == False , "test #0"
assert candidate("yello","ell") == True , "test #1"
assert candidate("whattup","ptut") == False , "test #2"
assert candidate("efef","fee") == True , "test #3"
assert candidate("abab","aabb") == False , "test #4"
assert candidate("winemtt","tinem") == True , "test #5"
candidate = cycpattern_check
check(candidate) | cycpattern_check |
bt_JHumanEval/155 | 整数が与えられた場合、偶数桁数と奇数桁数をそれぞれ持つタプルを返す。
例:
even_odd_count(-12) ==> (1, 1)
even_odd_count(123) ==> (1, 2) | def even_odd_count(num):
even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| def check(candidate):
# Check some simple cases
assert candidate(7) == (0, 1)
assert candidate(-78) == (1, 1)
assert candidate(3452) == (2, 2)
assert candidate(346211) == (3, 3)
assert candidate(-345821) == (3, 3)
assert candidate(-2) == (1, 0)
assert candidate(-45347) == (2, 3)
assert candidate(0) == (1, 0)
# Check some edge cases that are easy to work out by hand.
assert True
candidate = even_odd_count
check(candidate) | even_odd_count |
bt_JHumanEval/156 | 正の整数が与えられたとき、ローマ数字に相当する文字列を小文字で返す。
制限事項1 <= num <= 1000
例:
>>> int_to_mini_roman(19) == 'xix'
>>> int_to_mini_roman(152) == 'clii'
>>> int_to_mini_roman(426) == 'cdxxvi' | def int_to_mini_roman(number):
num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
"L", "XC", "C", "CD", "D", "CM", "M"]
i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| def check(candidate):
# Check some simple cases
assert candidate(19) == 'xix'
assert candidate(152) == 'clii'
assert candidate(251) == 'ccli'
assert candidate(426) == 'cdxxvi'
assert candidate(500) == 'd'
assert candidate(1) == 'i'
assert candidate(4) == 'iv'
assert candidate(43) == 'xliii'
assert candidate(90) == 'xc'
assert candidate(94) == 'xciv'
assert candidate(532) == 'dxxxii'
assert candidate(900) == 'cm'
assert candidate(994) == 'cmxciv'
assert candidate(1000) == 'm'
# Check some edge cases that are easy to work out by hand.
assert True
candidate = int_to_mini_roman
check(candidate) | int_to_mini_roman |
bt_JHumanEval/157 | 三角形の3辺の長さを与える。三角形が直角三角形ならTrueを、そうでなければFalseを返す。
直角三角形とは、1つの角が直角または90度である三角形のことである。
例:
right_angle_triangle(3, 4, 5) == True
right_angle_triangle(1, 2, 3) == False | def right_angle_triangle(a, b, c):
return a*a == b*b + c*c or b*b == a*a + c*c or c*c == a*a + b*b
| def check(candidate):
# Check some simple cases
assert candidate(3, 4, 5) == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1, 2, 3) == False
assert candidate(10, 6, 8) == True
assert candidate(2, 2, 2) == False
assert candidate(7, 24, 25) == True
assert candidate(10, 5, 7) == False
assert candidate(5, 12, 13) == True
assert candidate(15, 8, 17) == True
assert candidate(48, 55, 73) == True
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1, 1) == False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(2, 2, 10) == False
candidate = right_angle_triangle
check(candidate) | right_angle_triangle |
bt_JHumanEval/158 | 文字列のリストを受け取る関数を書きなさい。
リストは異なる単語を含む。異なる固有の文字数が最も多い単語を返す。
複数の文字列が同じ文字数を持つ場合は、辞書順で最初に来るものを返すことにする。
find_max(["name", "of", "string"]) == "string"
find_max(["name", "enam", "game"]) == "enam"
find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa" | def find_max(words):
return sorted(words, key = lambda x: (-len(set(x)), x))[0]
| def check(candidate):
# Check some simple cases
assert (candidate(["name", "of", "string"]) == "string"), "t1"
assert (candidate(["name", "enam", "game"]) == "enam"), 't2'
assert (candidate(["aaaaaaa", "bb", "cc"]) == "aaaaaaa"), 't3'
assert (candidate(["abc", "cba"]) == "abc"), 't4'
assert (candidate(["play", "this", "game", "of","footbott"]) == "footbott"), 't5'
assert (candidate(["we", "are", "gonna", "rock"]) == "gonna"), 't6'
assert (candidate(["we", "are", "a", "mad", "nation"]) == "nation"), 't7'
assert (candidate(["this", "is", "a", "prrk"]) == "this"), 't8'
# Check some edge cases that are easy to work out by hand.
assert (candidate(["b"]) == "b"), 't9'
assert (candidate(["play", "play", "play"]) == "play"), 't10'
candidate = find_max
check(candidate) | find_max |
bt_JHumanEval/159 | あなたはお腹を空かせたウサギです。すでに一定数のニンジンを食べました。
これからさらにニンジンを食べなければその日の食事は完了しません。
あなたは [ 食事の後に食べたニンジンの総数, 食事の後に残ったニンジンの数 ] の配列を返してください。
もし残りのニンジンが十分でなければ、あなたは残りのニンジンをすべて食べますが、まだお腹が空いています。
例:
* eat(5, 6, 10) -> [11, 4]
* eat(4, 8, 9) -> [12, 1]
* eat(1, 10, 10) -> [11, 0]
* eat(2, 11, 5) -> [7, 0]
変数:
@number : 整数
食べたニンジンの数。
@need : 整数
にんじんを何本食べるか。
@remaining : 整数
残りのニンジンの在庫数
制約:
* 0 <= number <= 1000
* 0 <= need <= 1000
* 0 <= remaining <= 1000
楽しんで :) | def eat(number, need, remaining):
if(need <= remaining):
return [ number + need , remaining-need ]
else:
return [ number + remaining , 0]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(5, 6, 10) == [11, 4], "Error"
assert candidate(4, 8, 9) == [12, 1], "Error"
assert candidate(1, 10, 10) == [11, 0], "Error"
assert candidate(2, 11, 5) == [7, 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(4, 5, 7) == [9, 2], "Error"
assert candidate(4, 5, 1) == [5, 0], "Error"
candidate = eat
check(candidate) | eat |
bt_JHumanEval/160 | 演算子(operator)とオペランド(operand)の2つのリストが与えられる。ひとつ目のリストは
基本的な算術演算を持ち、二つ目のリストは整数のリストである。与えられた2つのリストを
使って算術式を構築し、その評価結果を返そう。
基本的な算術演算:
加算 ( + )
減算 ( - )
乗算 ( * )
階除算 ( // )
指数化 ( ** )
例:
operator['+', '*', '-']
array = [2, 3, 4, 5]
result = 2 + 3 * 4 - 5
=> result = 9
注：演算子のリストの長さは、オペランドのリストの長さから1を引いた長さに等しい。
オペランドは非負整数のリストである。
operator は少なくとも1つの演算子を持ち、operand は少なくとも2つのオペランドを持つ。 | def do_algebra(operator, operand):
expression = str(operand[0])
for oprt, oprn in zip(operator, operand[1:]):
expression+= oprt + str(oprn)
return eval(expression)
| def check(candidate):
# Check some simple cases
assert candidate(['**', '*', '+'], [2, 3, 4, 5]) == 37
assert candidate(['+', '*', '-'], [2, 3, 4, 5]) == 9
assert candidate(['//', '*'], [7, 3, 4]) == 8, "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 = do_algebra
check(candidate) | do_algebra |
bt_JHumanEval/161 | 文字列sが与えられます。
もしs[i]がアルファベットなら、その文字の大文字と小文字を反転させる。そうでない場合は、そのままにしておく。
もし文字列にアルファベットが一つも含まれていない場合は、文字列全体を逆順にする。
関数は結果の文字列を返すようにします。
例
solve("1234") = "4321"
solve("ab") = "AB"
solve("#a@C") = "#A@c" | def solve(s):
flg = 0
idx = 0
new_str = list(s)
for i in s:
if i.isalpha():
new_str[idx] = i.swapcase()
flg = 1
idx += 1
s = ""
for i in new_str:
s += i
if flg == 0:
return s[len(s)::-1]
return s
| def check(candidate):
# Check some simple cases
assert candidate("AsDf") == "aSdF"
assert candidate("1234") == "4321"
assert candidate("ab") == "AB"
assert candidate("#a@C") == "#A@c"
assert candidate("#AsdfW^45") == "#aSDFw^45"
assert candidate("#6@2") == "2@6#"
# Check some edge cases that are easy to work out by hand.
assert candidate("#$a^D") == "#$A^d"
assert candidate("#ccc") == "#CCC"
# Don't remove this line:
candidate = solve
check(candidate) | solve |
bt_JHumanEval/162 | 文字列 text が与えられたとき、その md5 ハッシュと等価な文字列を返す。
text' が空文字列の場合は None を返す。
>>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62' | def string_to_md5(text):
import hashlib
return hashlib.md5(text.encode('ascii')).hexdigest() if text else None
| def check(candidate):
# Check some simple cases
assert candidate('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
assert candidate('') == None
assert candidate('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'
assert candidate('password') == '5f4dcc3b5aa765d61d8327deb882cf99'
# Check some edge cases that are easy to work out by hand.
assert True
candidate = string_to_md5
check(candidate) | string_to_md5 |
bt_JHumanEval/163 | 正の整数aとbが与えられたとき、aとbの間にある偶数の数字を昇順で返してください。
例えば:
generate_integers(2, 8) => [2, 4, 6, 8]
generate_integers(8, 2) => [2, 4, 6, 8]
generate_integers(10, 14) => [] | def generate_integers(a, b):
lower = max(2, min(a, b))
upper = min(8, max(a, b))
return [i for i in range(lower, upper+1) if i % 2 == 0]
| def check(candidate):
# Check some simple cases
assert candidate(2, 10) == [2, 4, 6, 8], "Test 1"
assert candidate(10, 2) == [2, 4, 6, 8], "Test 2"
assert candidate(132, 2) == [2, 4, 6, 8], "Test 3"
assert candidate(17,89) == [], "Test 4"
# 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 = generate_integers
check(candidate) | generate_integers |