name
stringlengths 15
44
| language
stringclasses 1
value | prompt
stringlengths 131
1.66k
| doctests
stringclasses 1
value | original
stringlengths 130
159
| prompt_terminology
stringclasses 1
value | tests
stringlengths 171
4.32k
| stop_tokens
sequencelengths 1
1
|
|---|---|---|---|---|---|---|---|
HumanEval_103_rounded_avg | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_std_string_long{
std::string f0;
long f1; Union_std_string_long(std::string _f0) : f0(_f0) {}
Union_std_string_long(long _f1) : f1(_f1) {}
~Union_std_string_long() {}
bool operator==(std::string f) {
return f0 == f ;
} bool operator==(long f) {
return f1 == f ;
}
};
// 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"
Union_std_string_long rounded_avg(long n, long m) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_103_rounded_avg.py | reworded | }
int main() {
auto candidate = rounded_avg;
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");
assert(candidate((7), (5)) == -1);
assert(candidate((5), (1)) == -1);
assert(candidate((5), (5)) == "0b101");
}
| [
"\n}"
] |
HumanEval_104_unique_digits | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数xのリストが与えられたとき、偶数桁の要素を持たない全ての
// 要素をソートしたリストを返す。
// 注意: 返されるリストは昇順にソートされていなければならない。
// 例えば::
// >>> unique_digits((std::vector<long>({(long)15, (long)33, (long)1422, (long)1})))
// (std::vector<long>({(long)1, (long)15, (long)33}))
// >>> unique_digits((std::vector<long>({(long)152, (long)323, (long)1422, (long)10})))
// (std::vector<long>())
std::vector<long> unique_digits(std::vector<long> x) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py | reworded | }
int main() {
auto candidate = unique_digits;
assert(candidate((std::vector<long>({(long)15, (long)33, (long)1422, (long)1}))) == (std::vector<long>({(long)1, (long)15, (long)33})));
assert(candidate((std::vector<long>({(long)152, (long)323, (long)1422, (long)10}))) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)12345, (long)2033, (long)111, (long)151}))) == (std::vector<long>({(long)111, (long)151})));
assert(candidate((std::vector<long>({(long)135, (long)103, (long)31}))) == (std::vector<long>({(long)31, (long)135})));
}
| [
"\n}"
] |
HumanEval_105_by_length | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の配列が与えられたとき、1から9までの整数をソートし、
// 得られた配列を逆順にし、各桁を以下の数字に相当する名前に置き換える。
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// >>> by_length((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3})))
// (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (std::string)"One", (std::string)"One"}))
// If the vector is empty, return an empty vector:
// >>> by_length((std::vector<long>()))
// (std::vector<std::string>())
// If the vector has any strange number ignore it:
// >>> by_length((std::vector<long>({(long)1, (long)-1, (long)55})))
// (std::vector<std::string>({(std::string)"One"}))
std::vector<std::string> by_length(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | reworded | }
int main() {
auto candidate = by_length;
assert(candidate((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3}))) == (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (std::string)"One", (std::string)"One"})));
assert(candidate((std::vector<long>())) == (std::vector<std::string>()));
assert(candidate((std::vector<long>({(long)1, (long)-1, (long)55}))) == (std::vector<std::string>({(std::string)"One"})));
assert(candidate((std::vector<long>({(long)1, (long)-1, (long)3, (long)2}))) == (std::vector<std::string>({(std::string)"Three", (std::string)"Two", (std::string)"One"})));
assert(candidate((std::vector<long>({(long)9, (long)4, (long)8}))) == (std::vector<std::string>({(std::string)"Nine", (std::string)"Eight", (std::string)"Four"})));
}
| [
"\n}"
] |
HumanEval_106_f | cpp | #include<assert.h>
#include<bits/stdc++.h>
// iは1から始まる。iの階乗は1からiまでの数の掛け算（1 * 2 * ... * i）である。
// Example:
// >>> f((5))
// (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15}))
std::vector<long> f(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | reworded | }
int main() {
auto candidate = f;
assert(candidate((5)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15})));
assert(candidate((7)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15, (long)720, (long)28})));
assert(candidate((1)) == (std::vector<long>({(long)1})));
assert(candidate((3)) == (std::vector<long>({(long)1, (long)2, (long)6})));
}
| [
"\n}"
] |
HumanEval_107_even_odd_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた正の整数 nに対して、範囲 1 から n まで（両端を含む）に存在する
// 偶数の回文数(integer palindrome)と奇数の回文数の個数をタプル形式で返す。
// 例 1:
// >>> even_odd_palindrome((3))
// (std::make_tuple(1, 2))
// 解説:
// 回文数は1、2、3であり、そのうち1つは偶数、2つは奇数である。
// 例 2:
// >>> even_odd_palindrome((12))
// (std::make_tuple(4, 6))
// 解説:
// 回文数は、1、2、3、4、5、6、7、8、9、11であり、そのうち4つは偶数、6つは奇数である。
// ノート:
// 1. 1 <= n <= 10^3
// 2. 返されるタプルは、それぞれ偶数と奇数の回文数を持つ。
std::tuple<long, long> even_odd_palindrome(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | reworded | }
int main() {
auto candidate = even_odd_palindrome;
assert(candidate((123)) == (std::make_tuple(8, 13)));
assert(candidate((12)) == (std::make_tuple(4, 6)));
assert(candidate((3)) == (std::make_tuple(1, 2)));
assert(candidate((63)) == (std::make_tuple(6, 8)));
assert(candidate((25)) == (std::make_tuple(5, 6)));
assert(candidate((19)) == (std::make_tuple(4, 6)));
assert(candidate((9)) == (std::make_tuple(4, 5)));
assert(candidate((1)) == (std::make_tuple(0, 1)));
}
| [
"\n}"
] |
HumanEval_108_count_nums | cpp | #include<assert.h>
#include<bits/stdc++.h>
// count_nums 関数は、整数の配列を引数として受け取り、その配列内の各整数の各桁の合計が
// >0 となるような整数の個数を返す。負の数に関しては、最初の桁（符号付き桁）は負となる。
// たとえば、−123 の符号付き桁は −1, 2, 3 である。
// >>> count_nums((std::vector<long>()))
// (0)
// >>> count_nums((std::vector<long>({(long)-1, (long)11, (long)-11})))
// (1)
// >>> count_nums((std::vector<long>({(long)1, (long)1, (long)2})))
// (3)
long count_nums(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | reworded | }
int main() {
auto candidate = count_nums;
assert(candidate((std::vector<long>())) == (0));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)0}))) == (0));
assert(candidate((std::vector<long>({(long)1, (long)1, (long)2, (long)-2, (long)3, (long)4, (long)5}))) == (6));
assert(candidate((std::vector<long>({(long)1, (long)6, (long)9, (long)-6, (long)0, (long)1, (long)5}))) == (5));
assert(candidate((std::vector<long>({(long)1, (long)100, (long)98, (long)-7, (long)1, (long)-1}))) == (4));
assert(candidate((std::vector<long>({(long)12, (long)23, (long)34, (long)-45, (long)-56, (long)0}))) == (5));
assert(candidate((std::vector<long>({(long)0, (long)1}))) == (1));
assert(candidate((std::vector<long>({(long)1}))) == (1));
}
| [
"\n}"
] |
HumanEval_109_move_one_ball | cpp | #include<assert.h>
#include<bits/stdc++.h>
// N個の整数arr[1], arr[2], ..., arr[N]なる配列 'arr' があります。
// この配列の数字はランダムな順番に並んでいます。あなたの課題は、以下の操作を何度でも行うことで、
// 配列を非減少.の順番にソートできるかどうかを判断することです。
// 操作として許されているのは「右シフト」です。
// 一回の「右シフト」操作とは、配列のすべての要素を右方向に一つずつずらすことを意味します。
// 配列の最後の要素は配列の先頭、すなわち0番目のインデックスに移動します。
// 上記の操作を行ってソートされた配列を得られる場合は true を、そうでない場合は false を返してください。
// 与えられた配列が空の場合は true を返してください。
// 注意：与えられたリストには一意の要素しか含まれていないことが保証されています。
// 例：
// >>> move_one_ball((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2})))
// (true)
// 説明：2回の右シフト操作を行うことで、与えられた配列を非減少の順序にすることができます。
// >>> move_one_ball((std::vector<long>({(long)3, (long)5, (long)4, (long)1, (long)2})))
// 説明：どれだけ右シフト操作を行っても、与えられた配列を非減少の順序にすることはできません。
bool move_one_ball(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | reworded | }
int main() {
auto candidate = move_one_ball;
assert(candidate((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)3, (long)5, (long)10, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)1, (long)2}))) == (false));
assert(candidate((std::vector<long>({(long)3, (long)5, (long)4, (long)1, (long)2}))) == (false));
assert(candidate((std::vector<long>())) == (true));
}
| [
"\n}"
] |
HumanEval_110_exchange | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この問題では、2つの数のリストを受け取り、lst1を偶数のみのリストに
// するために、それらの間で要素の交換を行うことが可能かどうかを判断す
// る関数を実装する。
// lst1とlst2の間で交換される要素の数に制限はない。
// lst1とlst2の間で要素の交換を行い、lst1の要素をすべて偶数にすることが
// 可能であれば、"YES "を返す。
// そうでなければ "NO "を返す。
// 例えば:
// >>> exchange((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// ("YES")
// >>> exchange((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)5, (long)3, (long)4})))
// ("NO")
// 受け取るリストは空でないと前提してよい。
std::string exchange(std::vector<long> lst1, std::vector<long> lst2) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded | }
int main() {
auto candidate = exchange;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == ("YES"));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)5, (long)3, (long)4}))) == ("NO"));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)2, (long)1, (long)4, (long)3}))) == ("YES"));
assert(candidate((std::vector<long>({(long)5, (long)7, (long)3})), (std::vector<long>({(long)2, (long)6, (long)4}))) == ("YES"));
assert(candidate((std::vector<long>({(long)5, (long)7, (long)3})), (std::vector<long>({(long)2, (long)6, (long)3}))) == ("NO"));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)6, (long)1, (long)8, (long)9})), (std::vector<long>({(long)3, (long)5, (long)5, (long)1, (long)1, (long)1}))) == ("NO"));
assert(candidate((std::vector<long>({(long)100, (long)200})), (std::vector<long>({(long)200, (long)200}))) == ("YES"));
}
| [
"\n}"
] |
HumanEval_111_histogram | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 空白で区切られた小文字を表す文字列が与えられる。最も出現回数が多い文字と
// 対応するカウントの辞書を返す。
// 複数の文字が同じ出現回数を持つ場合、それらすべてを返す。
// 例:
// >>> histogram(("a b c"))
// (std::map<std::string,long>({{"a", 1}, {"b", 1}, {"c", 1}}))
// >>> histogram(("a b b a"))
// (std::map<std::string,long>({{"a", 2}, {"b", 2}}))
// >>> histogram(("a b c a b"))
// (std::map<std::string,long>({{"a", 2}, {"b", 2}}))
// >>> histogram(("b b b b a"))
// (std::map<std::string,long>({{"b", 4}}))
// >>> histogram((""))
// (std::map<std::string,long>())
std::map<std::string,long> histogram(std::string test) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded | }
int main() {
auto candidate = histogram;
assert(candidate(("a b b a")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c a b")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c d g")) == (std::map<std::string,long>({{"a", 1}, {"b", 1}, {"c", 1}, {"d", 1}, {"g", 1}})));
assert(candidate(("r t g")) == (std::map<std::string,long>({{"r", 1}, {"t", 1}, {"g", 1}})));
assert(candidate(("b b b b a")) == (std::map<std::string,long>({{"b", 4}})));
assert(candidate(("r t g")) == (std::map<std::string,long>({{"r", 1}, {"t", 1}, {"g", 1}})));
assert(candidate(("")) == (std::map<std::string,long>()));
assert(candidate(("a")) == (std::map<std::string,long>({{"a", 1}})));
}
| [
"\n}"
] |
HumanEval_112_reverse_delete | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 課題
// sとcの2つの文字列が与えられる。sに含まれる文字のうち、cに含まれる文字と
// 等しいものをすべて削除し、その結果の文字列が回文かどうかをチェックする。
// 文字列は、後ろから読んでも前から読んでも同じであれば回文と呼ばれる。
// 結果文字列とチェックのためのtrue/falseを含むタプルを返す必要がある。
// 例
// >>> reverse_delete(("abcde"), ("ae"))
// (std::make_tuple("bcd", false))
// >>> reverse_delete(("abcdef"), ("b"))
// (std::make_tuple("acdef", false))
// >>> reverse_delete(("abcdedcba"), ("ab"))
// (std::make_tuple("cdedc", true))
std::tuple<std::string, bool> reverse_delete(std::string s, std::string c) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded | }
int main() {
auto candidate = reverse_delete;
assert(candidate(("abcde"), ("ae")) == (std::make_tuple("bcd", false)));
assert(candidate(("abcdef"), ("b")) == (std::make_tuple("acdef", false)));
assert(candidate(("abcdedcba"), ("ab")) == (std::make_tuple("cdedc", true)));
assert(candidate(("dwik"), ("w")) == (std::make_tuple("dik", false)));
assert(candidate(("a"), ("a")) == (std::make_tuple("", true)));
assert(candidate(("abcdedcba"), ("")) == (std::make_tuple("abcdedcba", true)));
assert(candidate(("abcdedcba"), ("v")) == (std::make_tuple("abcdedcba", true)));
assert(candidate(("vabba"), ("v")) == (std::make_tuple("abba", true)));
assert(candidate(("mamma"), ("mia")) == (std::make_tuple("", true)));
}
| [
"\n}"
] |
HumanEval_113_odd_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数字のみで構成された文字列のリストを引数として受け取り、新しいリストを返します。
// 出力される新しいリストの各要素は、"the number of odd elements in the string i of the
// input."となりますが、この文字列内のすべての 'i' は、入力リストのi番目の文字列に含ま
// れる奇数の数に置き換えられます。
// >>> odd_count((std::vector<std::string>({(std::string)"1234567"})))
// (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."}))
// >>> odd_count((std::vector<std::string>({(std::string)"3", (std::string)"11111111"})))
// (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."}))
std::vector<std::string> odd_count(std::vector<std::string> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded | }
int main() {
auto candidate = odd_count;
assert(candidate((std::vector<std::string>({(std::string)"1234567"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."})));
assert(candidate((std::vector<std::string>({(std::string)"3", (std::string)"11111111"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."})));
assert(candidate((std::vector<std::string>({(std::string)"271", (std::string)"137", (std::string)"314"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 2n the str2ng 2 of the 2nput.", (std::string)"the number of odd elements 3n the str3ng 3 of the 3nput.", (std::string)"the number of odd elements 2n the str2ng 2 of the 2nput."})));
}
| [
"\n}"
] |
HumanEval_114_minSubArraySum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の配列 nums が与えられたとき、nums の空でない部分配列の最小和を求めよ。
// 例:
// >>> minSubArraySum((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4})))
// (1)
// >>> minSubArraySum((std::vector<long>({(long)-1, (long)-2, (long)-3})))
// (-6)
long minSubArraySum(std::vector<long> nums) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded | }
int main() {
auto candidate = minSubArraySum;
assert(candidate((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4}))) == (1));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3}))) == (-6));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3, (long)2, (long)-10}))) == (-14));
assert(candidate((std::vector<long>({(long)-9999999999999999}))) == (-9999999999999999));
assert(candidate((std::vector<long>({(long)0, (long)10, (long)20, (long)1000000}))) == (0));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3, (long)10, (long)-5}))) == (-6));
assert(candidate((std::vector<long>({(long)100, (long)-1, (long)-2, (long)-3, (long)10, (long)-5}))) == (-6));
assert(candidate((std::vector<long>({(long)10, (long)11, (long)13, (long)8, (long)3, (long)4}))) == (3));
assert(candidate((std::vector<long>({(long)100, (long)-33, (long)32, (long)-1, (long)0, (long)-2}))) == (-33));
assert(candidate((std::vector<long>({(long)-10}))) == (-10));
assert(candidate((std::vector<long>({(long)7}))) == (7));
assert(candidate((std::vector<long>({(long)1, (long)-1}))) == (-1));
}
| [
"\n}"
] |
HumanEval_115_max_fill | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 長方形のグリッド状(grid)の井戸が与えられる。各行が1つの井戸を表し、
// 行の1が1単位の水を表す。
// 各井戸には，そこから水を汲み上げるのに使える対応するバケツがあり，
// すべてのバケツ容量(capacity)は同じである．
// あなたの仕事は，バケツを使って井戸を空にすることである．
// バケツを降ろす回数を出力せよ．
// 例 1:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (1))
// (6)
// 例 2:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)1, (long)1})})), (2))
// (5)
// 例 3:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0})})), (5))
// (0)
// 制約:
// * 全ての井戸が同じ長さ
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
long max_fill(std::vector<std::vector<long>> grid, long capacity) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded | }
int main() {
auto candidate = max_fill;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (1)) == (6));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)1, (long)1})})), (2)) == (5));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0})})), (5)) == (0));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (2)) == (4));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (9)) == (2));
}
| [
"\n}"
] |
HumanEval_116_sort_array | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この問題では、非負整数の配列を2進数表現における"1"の個数を昇順でソートする。
// "1"の個数が同じ場合は，10進数に基づいてソートする。
// 次のように実装する：
// >>> sort_array((std::vector<long>({(long)1, (long)5, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))
// >>> sort_array((std::vector<long>({(long)-2, (long)-3, (long)-4, (long)-5, (long)-6})))
// (std::vector<long>({(long)-6, (long)-5, (long)-4, (long)-3, (long)-2}))
// >>> sort_array((std::vector<long>({(long)1, (long)0, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4}))
std::vector<long> sort_array(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | reworded | }
int main() {
auto candidate = sort_array;
assert(candidate((std::vector<long>({(long)1, (long)5, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5})));
assert(candidate((std::vector<long>({(long)-2, (long)-3, (long)-4, (long)-5, (long)-6}))) == (std::vector<long>({(long)-4, (long)-2, (long)-6, (long)-5, (long)-3})));
assert(candidate((std::vector<long>({(long)1, (long)0, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)0, (long)1, (long)2, (long)4, (long)3})));
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)2, (long)5, (long)77, (long)4, (long)5, (long)3, (long)5, (long)7, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)2, (long)2, (long)4, (long)4, (long)3, (long)3, (long)5, (long)5, (long)5, (long)7, (long)77})));
assert(candidate((std::vector<long>({(long)3, (long)6, (long)44, (long)12, (long)32, (long)5}))) == (std::vector<long>({(long)32, (long)3, (long)5, (long)6, (long)12, (long)44})));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32}))) == (std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32})));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32}))) == (std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32})));
}
| [
"\n}"
] |
HumanEval_117_select_words | cpp | #include<assert.h>
#include<bits/stdc++.h>
// ある文字列sと自然数nが与えらる。あなたに課せられたタスクは、文字列s
// の中から、ちょうどn個の子音を含むすべての単語のリストを現れる順に返す
// 関数を実装することである。
// 注意：入力文字列には英文字と空白しか含まれないと仮定してもよい。
// 例:
// >>> select_words(("Mary had a little lamb"), (4))
// (std::vector<std::string>({(std::string)"little"}))
// >>> select_words(("Mary had a little lamb"), (3))
// (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"}))
// >>> select_words(("simple white space"), (2))
// (std::vector<std::string>())
// >>> select_words(("Hello world"), (4))
// (std::vector<std::string>({(std::string)"world"}))
// >>> select_words(("Uncle sam"), (3))
// (std::vector<std::string>({(std::string)"Uncle"}))
std::vector<std::string> select_words(std::string s, long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded | }
int main() {
auto candidate = select_words;
assert(candidate(("Mary had a little lamb"), (4)) == (std::vector<std::string>({(std::string)"little"})));
assert(candidate(("Mary had a little lamb"), (3)) == (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"})));
assert(candidate(("simple white space"), (2)) == (std::vector<std::string>()));
assert(candidate(("Hello world"), (4)) == (std::vector<std::string>({(std::string)"world"})));
assert(candidate(("Uncle sam"), (3)) == (std::vector<std::string>({(std::string)"Uncle"})));
assert(candidate((""), (4)) == (std::vector<std::string>()));
assert(candidate(("a b c d e f"), (1)) == (std::vector<std::string>({(std::string)"b", (std::string)"c", (std::string)"d", (std::string)"f"})));
}
| [
"\n}"
] |
HumanEval_118_get_closest_vowel | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 単語が与えられる。あなたの仕事は、単語の右側から2つの子音（大文字と
// 小文字を区別）の間に立っている最も近い母音を見つけることである。
// 最初と最後の母音はカウントされない。上記の条件を満たす母音が見つから
// なかった場合は、空の文字列を返せ。
// 指定された文字列は英字のみを含むとみなしてよい。
// 例:
// >>> get_closest_vowel(("yogurt"))
// ("u")
// >>> get_closest_vowel(("FULL"))
// ("U")
// >>> get_closest_vowel(("quick"))
// ("")
// >>> get_closest_vowel(("ab"))
// ("")
std::string get_closest_vowel(std::string word) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded | }
int main() {
auto candidate = get_closest_vowel;
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"));
}
| [
"\n}"
] |
HumanEval_119_match_parens | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つの文字列からなるリストが与えられます。両方の文字列は開き括弧 '(' または
// 閉じ括弧 ')' のみで構成されています。
// あなたの仕事は、2つの文字列を何らかの順序で結合して、「良い」文字列にすることが
// 可能かどうかを確認することです。
// 文字列Sが「良い」とは、文字列内のすべての括弧がバランスしている場合に限ります。
// 例えば、文字列 '(())()' は良いですが、文字列 '())' は良くありません。
// 良い文字列を作る方法がある場合は 'Yes' を返し、そうでない場合は 'No' を返してください。
// 例
// >>> match_parens((std::vector<std::string>({(std::string)"()(", (std::string)")"})))
// ("Yes")
// >>> match_parens((std::vector<std::string>({(std::string)")", (std::string)")"})))
// ("No")
std::string match_parens(std::vector<std::string> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded | }
int main() {
auto candidate = match_parens;
assert(candidate((std::vector<std::string>({(std::string)"()(", (std::string)")"}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)")", (std::string)")"}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)"(()(())", (std::string)"())())"}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)")())", (std::string)"(()()("}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)"(())))", (std::string)"(()())(("}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)"()", (std::string)"())"}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)"(()(", (std::string)"()))()"}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)"((((", (std::string)"((())"}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)")(()", (std::string)"(()("}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)")(", (std::string)")("}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)"(", (std::string)")"}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)")", (std::string)"("}))) == ("Yes"));
}
| [
"\n}"
] |
HumanEval_120_maximum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の配列 arr と正の整数 k が与えられる。arr に含まれる大きい方から k 個の数を含む
// 長さ k のソート済みリストを返す。
// 例 1:
// >>> maximum((std::vector<long>({(long)-3, (long)-4, (long)5})), (3))
// (std::vector<long>({(long)-4, (long)-3, (long)5}))
// 例 2:
// >>> maximum((std::vector<long>({(long)4, (long)-4, (long)4})), (2))
// (std::vector<long>({(long)4, (long)4}))
// 例 3:
// >>> maximum((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1))
// (std::vector<long>({(long)2}))
// ノート:
// 1. 配列の長さは[1, 1000]の範囲とする。
// 2. 配列の要素は [-1000, 1000] の範囲にある。
// 3. 0 <= k <= len(arr)
std::vector<long> maximum(std::vector<long> arr, long k) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded | }
int main() {
auto candidate = maximum;
assert(candidate((std::vector<long>({(long)-3, (long)-4, (long)5})), (3)) == (std::vector<long>({(long)-4, (long)-3, (long)5})));
assert(candidate((std::vector<long>({(long)4, (long)-4, (long)4})), (2)) == (std::vector<long>({(long)4, (long)4})));
assert(candidate((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1)) == (std::vector<long>({(long)2})));
assert(candidate((std::vector<long>({(long)123, (long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (3)) == (std::vector<long>({(long)2, (long)20, (long)123})));
assert(candidate((std::vector<long>({(long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (4)) == (std::vector<long>({(long)0, (long)1, (long)2, (long)20})));
assert(candidate((std::vector<long>({(long)5, (long)15, (long)0, (long)3, (long)-13, (long)-8, (long)0})), (7)) == (std::vector<long>({(long)-13, (long)-8, (long)0, (long)0, (long)3, (long)5, (long)15})));
assert(candidate((std::vector<long>({(long)-1, (long)0, (long)2, (long)5, (long)3, (long)-10})), (2)) == (std::vector<long>({(long)3, (long)5})));
assert(candidate((std::vector<long>({(long)1, (long)0, (long)5, (long)-7})), (1)) == (std::vector<long>({(long)5})));
assert(candidate((std::vector<long>({(long)4, (long)-4})), (2)) == (std::vector<long>({(long)-4, (long)4})));
assert(candidate((std::vector<long>({(long)-10, (long)10})), (2)) == (std::vector<long>({(long)-10, (long)10})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)-23, (long)243, (long)-400, (long)0})), (0)) == (std::vector<long>()));
}
| [
"\n}"
] |
HumanEval_121_solution | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の空でないリストが与えられた時、偶数の位置にある奇数の要素の合計を返す。
// 例
// >>> solution((std::vector<long>({(long)5, (long)8, (long)7, (long)1})))
// (12)
// >>> solution((std::vector<long>({(long)3, (long)3, (long)3, (long)3, (long)3})))
// (9)
// >>> solution((std::vector<long>({(long)30, (long)13, (long)24, (long)321})))
// (0)
long solution(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded | }
int main() {
auto candidate = solution;
assert(candidate((std::vector<long>({(long)5, (long)8, (long)7, (long)1}))) == (12));
assert(candidate((std::vector<long>({(long)3, (long)3, (long)3, (long)3, (long)3}))) == (9));
assert(candidate((std::vector<long>({(long)30, (long)13, (long)24, (long)321}))) == (0));
assert(candidate((std::vector<long>({(long)5, (long)9}))) == (5));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)8}))) == (0));
assert(candidate((std::vector<long>({(long)30, (long)13, (long)23, (long)32}))) == (23));
assert(candidate((std::vector<long>({(long)3, (long)13, (long)2, (long)9}))) == (3));
}
| [
"\n}"
] |
HumanEval_122_add_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の空でない配列 arr と整数 k が与えられたとき、
// arr の最初の k 個の要素から高々 2 桁までの要素の和を返す。
// 例:
// >>> add_elements((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4))
// (24)
// 制約:
// 1. 1 <= len(arr) <= 100
// 2. 1 <= k <= len(arr)
long add_elements(std::vector<long> arr, long k) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded | }
int main() {
auto candidate = add_elements;
assert(candidate((std::vector<long>({(long)1, (long)-2, (long)-3, (long)41, (long)57, (long)76, (long)87, (long)88, (long)99})), (3)) == (-4));
assert(candidate((std::vector<long>({(long)111, (long)121, (long)3, (long)4000, (long)5, (long)6})), (2)) == (0));
assert(candidate((std::vector<long>({(long)11, (long)21, (long)3, (long)90, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (125));
assert(candidate((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (24));
assert(candidate((std::vector<long>({(long)1})), (1)) == (1));
}
| [
"\n}"
] |
HumanEval_123_get_odd_collatz | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数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 である。:
// get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
// >>> get_odd_collatz((5))
// (std::vector<long>({(long)1, (long)5}))
std::vector<long> get_odd_collatz(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded | }
int main() {
auto candidate = get_odd_collatz;
assert(candidate((14)) == (std::vector<long>({(long)1, (long)5, (long)7, (long)11, (long)13, (long)17})));
assert(candidate((5)) == (std::vector<long>({(long)1, (long)5})));
assert(candidate((12)) == (std::vector<long>({(long)1, (long)3, (long)5})));
assert(candidate((1)) == (std::vector<long>({(long)1})));
}
| [
"\n}"
] |
HumanEval_124_valid_date | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた日付文字列を検証し、その日付が有効であれば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)
bool valid_date(std::string date) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded | }
int main() {
auto candidate = valid_date;
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));
}
| [
"\n}"
] |
HumanEval_125_split_words | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_std_vector_std_string__long{
std::vector<std::string> f0;
long f1; Union_std_vector_std_string__long(std::vector<std::string> _f0) : f0(_f0) {}
Union_std_vector_std_string__long(long _f1) : f1(_f1) {}
~Union_std_vector_std_string__long() {}
bool operator==(std::vector<std::string> f) {
return f0 == f ;
} bool operator==(long f) {
return f1 == f ;
}
};
// 単語の文字列が与えられた場合、空白で分割された単語のリストを返す。
// テキスト中に空白が存在しない場合は、カンマ ',' で分割する必要がある。カンマが存在しない場合は、
// アルファベットの奇数順の小文字の数を返す必要がある。ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// 例
// >>> split_words(("Hello world!"))
// std::vector<std::string>({(std::string)"Hello", (std::string)"world!"})
// >>> split_words(("Hello,world!"))
// std::vector<std::string>({(std::string)"Hello", (std::string)"world!"})
// >>> split_words(("abcdef"))
// 3
Union_std_vector_std_string__long split_words(std::string txt) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py | reworded | }
int main() {
auto candidate = split_words;
assert(candidate(("Hello world!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world!"}));
assert(candidate(("Hello,world!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world!"}));
assert(candidate(("Hello world,!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world,!"}));
assert(candidate(("Hello,Hello,world !")) == std::vector<std::string>({(std::string)"Hello,Hello,world", (std::string)"!"}));
assert(candidate(("abcdef")) == 3);
assert(candidate(("aaabb")) == 2);
assert(candidate(("aaaBb")) == 1);
assert(candidate(("")) == 0);
}
| [
"\n}"
] |
HumanEval_126_is_sorted | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数字のリストが与えられたとき、昇順に整列されているかどうかを返す。
// リストに同じ数の重複が1つ以上ある場合は、falseを返す。
// 負の数はなく、整数のみであると仮定する。
// 例
// >>> is_sorted((std::vector<long>({(long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)7})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)4})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)2, (long)3, (long)4})))
// (false)
bool is_sorted(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded | }
int main() {
auto candidate = is_sorted;
assert(candidate((std::vector<long>({(long)5}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)7}))) == (false));
assert(candidate((std::vector<long>())) == (true));
assert(candidate((std::vector<long>({(long)1}))) == (true));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)2, (long)3, (long)4}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)3, (long)3, (long)4}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)4}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (true));
}
| [
"\n}"
] |
HumanEval_127_intersection | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つの区間が与えられます。
// それぞれの区間は整数のペアで示されます。例えば、区間 = (start, end ) = (1, 2) です。
// 与えられた区間は閉区間であり、start と end の両端が含まれます。
// 各区間について、start は end 以下であると仮定します。
// あなたの仕事は、これら2つの区間の交差部分の長さが素数であるかどうかを判断することです。
// 例えば、区間 (1, 3) と (2, 4) の交差部分は (2, 3) で、その長さは1ですが、これは素数ではありません。
// 交差部分の長さが素数であれば "YES" を返し、そうでなければ "NO" を返してください。
// もし2つの区間が交差しない場合も "NO" を返してください。
// [input/output] サンプル:
// >>> intersection((std::make_tuple(1, 2)), (std::make_tuple(2, 3)))
// ("NO")
// >>> intersection((std::make_tuple(-1, 1)), (std::make_tuple(0, 4)))
// ("NO")
// >>> intersection((std::make_tuple(-3, -1)), (std::make_tuple(-5, 5)))
// ("YES")
std::string intersection(std::tuple<long, long> interval1, std::tuple<long, long> interval2) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded | }
int main() {
auto candidate = intersection;
assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(2, 3))) == ("NO"));
assert(candidate((std::make_tuple(-1, 1)), (std::make_tuple(0, 4))) == ("NO"));
assert(candidate((std::make_tuple(-3, -1)), (std::make_tuple(-5, 5))) == ("YES"));
assert(candidate((std::make_tuple(-2, 2)), (std::make_tuple(-4, 0))) == ("YES"));
assert(candidate((std::make_tuple(-11, 2)), (std::make_tuple(-1, -1))) == ("NO"));
assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(3, 5))) == ("NO"));
assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(1, 2))) == ("NO"));
assert(candidate((std::make_tuple(-2, -2)), (std::make_tuple(-3, -2))) == ("NO"));
}
| [
"\n}"
] |
HumanEval_128_prod_signs | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の配列 arr が与えられます。この配列に含まれる各数値の絶対値の合計と、
// 各数値の符号（プラスは1、マイナスは-1、ゼロは0）の積を掛け合わせた値を
// 返してください。
// 注意：配列`arr`が空の場合は`None`を返してください。
// 例::
// >>> prod_signs((std::vector<long>({(long)1, (long)2, (long)2, (long)-4})))
// 9
// >>> prod_signs((std::vector<long>({(long)0, (long)1})))
// 0
// >>> prod_signs((std::vector<long>()))
// std::nullopt
std::optional<long> prod_signs(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | reworded | }
int main() {
auto candidate = prod_signs;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)-4}))) == -9);
assert(candidate((std::vector<long>({(long)0, (long)1}))) == 0);
assert(candidate((std::vector<long>({(long)1, (long)1, (long)1, (long)2, (long)3, (long)-1, (long)1}))) == -10);
assert(candidate((std::vector<long>())) == std::nullopt);
assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)2, (long)-1, (long)-1, (long)9}))) == 20);
assert(candidate((std::vector<long>({(long)-1, (long)1, (long)-1, (long)1}))) == 4);
assert(candidate((std::vector<long>({(long)-1, (long)1, (long)1, (long)1}))) == -4);
assert(candidate((std::vector<long>({(long)-1, (long)1, (long)1, (long)0}))) == 0);
}
| [
"\n}"
] |
HumanEval_129_minPath | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 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] が成立する。
// 答えは一意であることが保証されている。
// 最短の経路が通るセルの値の順番に並べたリストを返すようにせよ。
// 例：
// >>> minPath((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)9})})), (3))
// (std::vector<long>({(long)1, (long)2, (long)1}))
// >>> minPath((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1))
// (std::vector<long>({(long)1}))
std::vector<long> minPath(std::vector<std::vector<long>> grid, long k) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded | }
int main() {
auto candidate = minPath;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)9})})), (3)) == (std::vector<long>({(long)1, (long)2, (long)1})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1)) == (std::vector<long>({(long)1})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4}), (std::vector<long>)std::vector<long>({(long)5, (long)6, (long)7, (long)8}), (std::vector<long>)std::vector<long>({(long)9, (long)10, (long)11, (long)12}), (std::vector<long>)std::vector<long>({(long)13, (long)14, (long)15, (long)16})})), (4)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)10}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)12, (long)1}), (std::vector<long>)std::vector<long>({(long)3, (long)16, (long)11, (long)15}), (std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2})})), (7)) == (std::vector<long>({(long)1, (long)10, (long)1, (long)10, (long)1, (long)10, (long)1})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2}), (std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)15}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)1, (long)12}), (std::vector<long>)std::vector<long>({(long)3, (long)10, (long)11, (long)16})})), (5)) == (std::vector<long>({(long)1, (long)7, (long)1, (long)7, (long)1})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1})})), (9)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2})})), (12)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4}), (std::vector<long>)std::vector<long>({(long)3, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)6, (long)8, (long)9})})), (8)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)3, (long)8, (long)9}), (std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4})})), (8)) == (std::vector<long>({(long)1, (long)5, (long)1, (long)5, (long)1, (long)5, (long)1, (long)5})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2}), (std::vector<long>)std::vector<long>({(long)3, (long)4})})), (10)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)3}), (std::vector<long>)std::vector<long>({(long)3, (long)2})})), (10)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
}
| [
"\n}"
] |
HumanEval_130_tri | cpp | #include<assert.h>
#include<bits/stdc++.h>
// フィボナッチ数列は、ここ数世紀の間に数学者によって深く研究され、誰もが知っている。
// しかし、人々が知らないのはトリボナッチ数列である。
// トリボナッチ数列は再帰によって定義される:
// 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))
// (std::vector<long>({(long)1, (long)3, (long)2, (long)8}))
std::vector<long> tri(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded | }
int main() {
auto candidate = tri;
assert(candidate((3)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8})));
assert(candidate((4)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3})));
assert(candidate((5)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15})));
assert(candidate((6)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4})));
assert(candidate((7)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24})));
assert(candidate((8)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5})));
assert(candidate((9)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35})));
assert(candidate((20)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35, (long)6, (long)48, (long)7, (long)63, (long)8, (long)80, (long)9, (long)99, (long)10, (long)120, (long)11})));
assert(candidate((0)) == (std::vector<long>({(long)1})));
assert(candidate((1)) == (std::vector<long>({(long)1, (long)3})));
}
| [
"\n}"
] |
HumanEval_131_digits | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数 n が与えられた時、奇数桁数の積を返す。
// 全ての桁が偶数の場合は0を返す。
// 例えば:
// >>> digits((1))
// (1)
// >>> digits((4))
// (0)
// >>> digits((235))
// (15)
long digits(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded | }
int main() {
auto candidate = digits;
assert(candidate((5)) == (5));
assert(candidate((54)) == (5));
assert(candidate((120)) == (1));
assert(candidate((5014)) == (5));
assert(candidate((98765)) == (315));
assert(candidate((5576543)) == (2625));
assert(candidate((2468)) == (0));
}
| [
"\n}"
] |
HumanEval_132_is_nested | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数は、角括弧だけを含む文字列を入力として受け取ります。括弧が有効な順序で
// 並んでいて、その中に少なくとも1つの括弧が入れ子になっている場合、関数はtrueを
// 返すようにしてください。
// >>> is_nested(("[[]]"))
// (true)
// >>> is_nested(("[]]]]]]][[[[[]"))
// (false)
// >>> is_nested(("[][]"))
// (false)
// >>> is_nested(("[]"))
// (false)
// >>> is_nested(("[[][]]"))
// (true)
// >>> is_nested(("[[]][["))
// (true)
bool is_nested(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded | }
int main() {
auto candidate = is_nested;
assert(candidate(("[[]]")) == (true));
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));
assert(candidate(("")) == (false));
assert(candidate(("[[[[[[[[")) == (false));
assert(candidate(("]]]]]]]]")) == (false));
}
| [
"\n}"
] |
HumanEval_133_sum_squares | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数字のリストが与えられます。
// 与えられたリスト内の各数値をまず切り上げ（天井関数を使って最も近い整数に丸める）、
// その後それぞれの数値を二乗した値の合計を返してください。
// 例:
// >>> lst((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})))
// (14)
// >>> lst((std::vector<float>({(float)1.0f, (float)4.0f, (float)9.0f})))
// (98)
// >>> lst((std::vector<float>({(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f})))
// (84)
// >>> lst((std::vector<float>({(float)1.4f, (float)4.2f, (float)0.0f})))
// (29)
// >>> lst((std::vector<float>({(float)-2.4f, (float)1.0f, (float)1.0f})))
// (6)
long sum_squares(std::vector<float> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded | }
int main() {
auto candidate = sum_squares;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f}))) == (14));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f}))) == (14));
assert(candidate((std::vector<float>({(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f}))) == (84));
assert(candidate((std::vector<float>({(float)1.4f, (float)4.2f, (float)0.0f}))) == (29));
assert(candidate((std::vector<float>({(float)-2.4f, (float)1.0f, (float)1.0f}))) == (6));
assert(candidate((std::vector<float>({(float)100.0f, (float)1.0f, (float)15.0f, (float)2.0f}))) == (10230));
assert(candidate((std::vector<float>({(float)10000.0f, (float)10000.0f}))) == (200000000));
assert(candidate((std::vector<float>({(float)-1.4f, (float)4.6f, (float)6.3f}))) == (75));
assert(candidate((std::vector<float>({(float)-1.4f, (float)17.9f, (float)18.9f, (float)19.9f}))) == (1086));
assert(candidate((std::vector<float>({(float)0.0f}))) == (0));
assert(candidate((std::vector<float>({(float)-1.0f}))) == (1));
assert(candidate((std::vector<float>({(float)-1.0f, (float)1.0f, (float)0.0f}))) == (2));
}
| [
"\n}"
] |
HumanEval_134_check_if_last_char_is_a_letter | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた文字列の最後の文字がアルファベットであり、かつ単語の一部でなければ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)
bool check_if_last_char_is_a_letter(std::string txt) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded | }
int main() {
auto candidate = check_if_last_char_is_a_letter;
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));
}
| [
"\n}"
] |
HumanEval_135_can_arrange | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 直前の要素よりも大きくない要素の中で、最も大きなインデックスを持つ要素を探して
// そのインデックスを返す関数を作成してください。そのような要素が存在しない場合は、
// -1を返してください。与えられる配列には重複する値は含まれません。
// 例:
// >>> can_arrange((std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5})))
// (3)
// >>> can_arrange((std::vector<long>({(long)1, (long)2, (long)3})))
// (-1)
long can_arrange(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded | }
int main() {
auto candidate = can_arrange;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5}))) == (3));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)5}))) == (-1));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)2, (long)5, (long)6, (long)7, (long)8, (long)9, (long)10}))) == (2));
assert(candidate((std::vector<long>({(long)4, (long)8, (long)5, (long)7, (long)3}))) == (4));
assert(candidate((std::vector<long>())) == (-1));
}
| [
"\n}"
] |
HumanEval_136_largest_smallest_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リストから最も大きな負の整数と最も小さな正の整数を見つけ、それらをタプル（a, b）
// として返す関数を作成してください。リストに負の整数もしくは正の整数がない場合は、
// 代わりにNoneを返します。
// 例:
// >>> largest_smallest_integers((std::vector<long>({(long)2, (long)4, (long)1, (long)3, (long)5, (long)7})))
// std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(1))
// >>> largest_smallest_integers((std::vector<long>()))
// std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt))
// >>> largest_smallest_integers((std::vector<long>({(long)0})))
// std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt))
std::tuple<std::optional<long>, std::optional<long>> largest_smallest_integers(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded | }
int main() {
auto candidate = largest_smallest_integers;
assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)3, (long)5, (long)7}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(1)));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)3, (long)5, (long)7, (long)0}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(1)));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)-2}))) == std::make_tuple(-2, 1));
assert(candidate((std::vector<long>({(long)4, (long)5, (long)3, (long)6, (long)2, (long)7, (long)-7}))) == std::make_tuple(-7, 2));
assert(candidate((std::vector<long>({(long)7, (long)3, (long)8, (long)4, (long)9, (long)2, (long)5, (long)-9}))) == std::make_tuple(-9, 2));
assert(candidate((std::vector<long>())) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt)));
assert(candidate((std::vector<long>({(long)0}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt)));
assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)-5, (long)-6}))) == std::make_tuple(std::optional<long>(-1), std::optional<long>(std::nullopt)));
assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)-5, (long)-6, (long)0}))) == std::make_tuple(std::optional<long>(-1), std::optional<long>(std::nullopt)));
assert(candidate((std::vector<long>({(long)-6, (long)-4, (long)-4, (long)-3, (long)1}))) == std::make_tuple(-3, 1));
assert(candidate((std::vector<long>({(long)-6, (long)-4, (long)-4, (long)-3, (long)-100, (long)1}))) == std::make_tuple(-3, 1));
}
| [
"\n}"
] |
HumanEval_137_compare_one | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_long_float_std_string{
long f0;
float f1;
std::string f2; Union_long_float_std_string(long _f0) : f0(_f0) {}
Union_long_float_std_string(float _f1) : f1(_f1) {}
Union_long_float_std_string(std::string _f2) : f2(_f2) {}
~Union_long_float_std_string() {}
bool operator==(long f) {
return f0 == f ;
} bool operator==(float f) {
return f1 == f ;
} bool operator==(std::string f) {
return f2 == f ;
}
};
union Union_long_float_std_string_std_nullopt{
long f0;
float f1;
std::string f2;
std::nullopt f3; Union_long_float_std_string_std_nullopt(long _f0) : f0(_f0) {}
Union_long_float_std_string_std_nullopt(float _f1) : f1(_f1) {}
Union_long_float_std_string_std_nullopt(std::string _f2) : f2(_f2) {}
Union_long_float_std_string_std_nullopt(std::nullopt _f3) : f3(_f3) {}
~Union_long_float_std_string_std_nullopt() {}
bool operator==(long f) {
return f0 == f ;
} bool operator==(float f) {
return f1 == f ;
} bool operator==(std::string f) {
return f2 == f ;
} bool operator==(std::nullopt f) {
return f3 == f ;
}
};
// 整数、浮動小数点数、または実数を表す文字列を引数として受け取り、その中で最も大きい値を
// その元の型で返す関数を作成してください。もし値が同じであれば、Noneを返してください。
// 注意：実数が文字列として表されている場合、小数点はピリオド（.）またはカンマ（,）の可能性があります。
// >>> compare_one(1, 2.5f)
// 2.5f
// >>> compare_one(1, "2,3")
// "2,3"
// >>> compare_one("5,1", "6")
// "6"
// >>> compare_one("1", 1)
// std::nullopt
Union_long_float_std_string_std_nullopt compare_one(Union_long_float_std_string a, Union_long_float_std_string b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_137_compare_one.py | reworded | }
int main() {
auto candidate = compare_one;
assert(candidate(1, 2) == 2);
assert(candidate(1, 2.5f) == 2.5f);
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) == std::nullopt);
}
| [
"\n}"
] |
HumanEval_138_is_equal_to_sum_even | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた数値nが、ちょうど4つの正の偶数の合計として表現できるかどうかを評価してください。
// 例
// >>> is_equal_to_sum_even((4))
// (false)
// >>> is_equal_to_sum_even((6))
// (false)
// >>> is_equal_to_sum_even((8))
// (true)
bool is_equal_to_sum_even(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded | }
int main() {
auto candidate = is_equal_to_sum_even;
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));
}
| [
"\n}"
] |
HumanEval_139_special_factorial | cpp | #include<assert.h>
#include<bits/stdc++.h>
// ブラジリアン階乗は次のように定義される：
// brazilian_factorial(n) = n！* (n-1)! * (n-2)! * ... * 1!
// ただし n > 0
// 例えば::
// >>> special_factorial((4))
// (288)
// The function will receive an integer as input and should return the special
// factorial of this integer.
long special_factorial(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded | }
int main() {
auto candidate = special_factorial;
assert(candidate((4)) == (288));
assert(candidate((5)) == (34560));
assert(candidate((7)) == (125411328000));
assert(candidate((1)) == (1));
}
| [
"\n}"
] |
HumanEval_140_fix_spaces | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列テキストが与えられた場合、その中のすべての空白をアンダースコアに置換し、
// 文字列が2つ以上の連続した空白を持つ場合、すべての連続した空白を - に置換する
// >>> fix_spaces((" Example"))
// ("Example")
// >>> fix_spaces((" Example 1"))
// ("Example_1")
// >>> fix_spaces((" Example 2"))
// ("_Example_2")
// >>> fix_spaces((" Example 3"))
// ("_Example-3")
std::string fix_spaces(std::string text) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded | }
int main() {
auto candidate = fix_spaces;
assert(candidate(("Example")) == ("Example"));
assert(candidate(("Mudasir Hanif ")) == ("Mudasir_Hanif_"));
assert(candidate(("Yellow Yellow Dirty Fellow")) == ("Yellow_Yellow__Dirty__Fellow"));
assert(candidate(("Exa mple")) == ("Exa-mple"));
assert(candidate((" Exa 1 2 2 mple")) == ("-Exa_1_2_2_mple"));
}
| [
"\n}"
] |
HumanEval_141_file_name_check | cpp | #include<assert.h>
#include<bits/stdc++.h>
// ファイル名を表す文字列を受け取り、そのファイル名が有効であれば'Yes'を返し、そうでなければ'No'
// を返す関数を作成する。ファイル名が有効であるとみなされるのは、
// 以下の条件をすべて満たす場合のみである：
// - ファイル名に3桁以上の数字（'0'-'9'）があってはならない。
// - ファイル名に含まれるドット '.' はひとつのみ。
// - ドットの前の部分文字列は空であってはならず、英文字（'a'-'z'および'A'-'Z'）から始まる文字でなければならない。
// - ドットの後の部分文字列は、以下のいずれかでなければならない： ['txt'、'exe'、'dll']。
// 例:
// >>> file_name_check(("example.txt"))
// ("Yes")
// >>> file_name_check(("1example.dll"))
// ("No")
std::string file_name_check(std::string file_name) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded | }
int main() {
auto candidate = file_name_check;
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"));
assert(candidate((".txt")) == ("No"));
assert(candidate(("s.")) == ("No"));
}
| [
"\n}"
] |
HumanEval_142_sum_squares | cpp | #include<assert.h>
#include<bits/stdc++.h>
// "
// この関数は整数のリストを受け取ります。リスト内の各要素に対して、そのインデックスが3の倍数で
// あればその整数を二乗し、インデックスが4の倍数でかつ3の倍数でない場合はその整数を三乗します。
// インデックスが3または4の倍数でない要素については、何も変更しません。最後に、すべての要素の
// 合計値を返します。
// 例:
// >>> lst
// (long({(long)1, (long)2, (long)3}))
// >>> lst
// (long())
// >>> lst
// (long({(long)-1, (long)-5, (long)2, (long)-1, (long)-5}))
long sum_squares(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded | }
int main() {
auto candidate = sum_squares;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (6));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)9}))) == (14));
assert(candidate((std::vector<long>())) == (0));
assert(candidate((std::vector<long>({(long)1, (long)1, (long)1, (long)1, (long)1, (long)1, (long)1, (long)1, (long)1}))) == (9));
assert(candidate((std::vector<long>({(long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1}))) == (-3));
assert(candidate((std::vector<long>({(long)0}))) == (0));
assert(candidate((std::vector<long>({(long)-1, (long)-5, (long)2, (long)-1, (long)-5}))) == (-126));
assert(candidate((std::vector<long>({(long)-56, (long)-99, (long)1, (long)0, (long)-2}))) == (3030));
assert(candidate((std::vector<long>({(long)-1, (long)0, (long)0, (long)0, (long)0, (long)0, (long)0, (long)0, (long)-1}))) == (0));
assert(candidate((std::vector<long>({(long)-16, (long)-9, (long)-2, (long)36, (long)36, (long)26, (long)-20, (long)25, (long)-40, (long)20, (long)-4, (long)12, (long)-26, (long)35, (long)37}))) == (-14196));
assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)17, (long)-1, (long)-15, (long)13, (long)-1, (long)14, (long)-14, (long)-12, (long)-5, (long)14, (long)-14, (long)6, (long)13, (long)11, (long)16, (long)16, (long)4, (long)10}))) == (-1448));
}
| [
"\n}"
] |
HumanEval_143_words_in_sentence | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文を表す文字列が与えられ、その文には空白で区切られたいくつかの単語が含まれている。
// 元の文の単語を含みその長さが素数である文字列を返す必要がある。
// 新しい文字列の単語の順序は元の文字列と同じでなければならない。
// 例 1:
// >>> words_in_sentence(("This is a test"))
// ("is")
// 例 2:
// >>> words_in_sentence(("lets go for swimming"))
// ("go for")
// 制約:
// * 1 <= len(sentence) <= 100
// * sentence contains only letters
std::string words_in_sentence(std::string sentence) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded | }
int main() {
auto candidate = words_in_sentence;
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"));
assert(candidate(("here")) == (""));
assert(candidate(("here is")) == ("is"));
}
| [
"\n}"
] |
HumanEval_144_simplify | cpp | #include<assert.h>
#include<bits/stdc++.h>
// あなたの仕事は、式 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)
bool simplify(std::string x, std::string n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded | }
int main() {
auto candidate = simplify;
assert(candidate(("1/5"), ("5/1")) == (true));
assert(candidate(("1/6"), ("2/1")) == (false));
assert(candidate(("5/1"), ("3/1")) == (true));
assert(candidate(("7/10"), ("10/2")) == (false));
assert(candidate(("2/10"), ("50/10")) == (true));
assert(candidate(("7/2"), ("4/2")) == (true));
assert(candidate(("11/6"), ("6/1")) == (true));
assert(candidate(("2/3"), ("5/2")) == (false));
assert(candidate(("5/2"), ("3/5")) == (false));
assert(candidate(("2/4"), ("8/4")) == (true));
assert(candidate(("2/4"), ("4/2")) == (true));
assert(candidate(("1/5"), ("5/1")) == (true));
assert(candidate(("1/5"), ("1/5")) == (false));
}
| [
"\n}"
] |
HumanEval_145_order_by_points | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 各数字の桁の合計に基づいて、与えられた整数のリストを昇順に並べる
// 関数を作成してください。
// 注意：もし桁の合計が同じである複数の項目がある場合は、
// 元のリストでの位置に基づいて並べてください。
// 例えば
// >>> order_by_points((std::vector<long>({(long)1, (long)11, (long)-1, (long)-11, (long)-12})))
// (std::vector<long>({(long)-1, (long)-11, (long)1, (long)-12, (long)11}))
// >>> order_by_points((std::vector<long>()))
// (std::vector<long>())
std::vector<long> order_by_points(std::vector<long> nums) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded | }
int main() {
auto candidate = order_by_points;
assert(candidate((std::vector<long>({(long)1, (long)11, (long)-1, (long)-11, (long)-12}))) == (std::vector<long>({(long)-1, (long)-11, (long)1, (long)-12, (long)11})));
assert(candidate((std::vector<long>({(long)1234, (long)423, (long)463, (long)145, (long)2, (long)423, (long)423, (long)53, (long)6, (long)37, (long)3457, (long)3, (long)56, (long)0, (long)46}))) == (std::vector<long>({(long)0, (long)2, (long)3, (long)6, (long)53, (long)423, (long)423, (long)423, (long)1234, (long)145, (long)37, (long)46, (long)56, (long)463, (long)3457})));
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)1, (long)-11, (long)-32, (long)43, (long)54, (long)-98, (long)2, (long)-3}))) == (std::vector<long>({(long)-3, (long)-32, (long)-98, (long)-11, (long)1, (long)2, (long)43, (long)54})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9, (long)10, (long)11}))) == (std::vector<long>({(long)1, (long)10, (long)2, (long)11, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9})));
assert(candidate((std::vector<long>({(long)0, (long)6, (long)6, (long)-76, (long)-21, (long)23, (long)4}))) == (std::vector<long>({(long)-76, (long)-21, (long)0, (long)4, (long)23, (long)6, (long)6})));
}
| [
"\n}"
] |
HumanEval_146_specialFilter | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数値の配列を入力とし、配列中の要素のうち、10より大きく、
// かつ数値の最初と最後の桁の両方が奇数（1, 3, 5, 7, 9）である要素の数を返す関数を書く。
// 例えば
// >>> specialFilter((std::vector<long>({(long)15, (long)-73, (long)14, (long)-15})))
// (1)
// >>> specialFilter((std::vector<long>({(long)33, (long)-2, (long)-3, (long)45, (long)21, (long)109})))
// (2)
long specialFilter(std::vector<long> nums) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded | }
int main() {
auto candidate = specialFilter;
assert(candidate((std::vector<long>({(long)5, (long)-2, (long)1, (long)-5}))) == (0));
assert(candidate((std::vector<long>({(long)15, (long)-73, (long)14, (long)-15}))) == (1));
assert(candidate((std::vector<long>({(long)33, (long)-2, (long)-3, (long)45, (long)21, (long)109}))) == (2));
assert(candidate((std::vector<long>({(long)43, (long)-12, (long)93, (long)125, (long)121, (long)109}))) == (4));
assert(candidate((std::vector<long>({(long)71, (long)-2, (long)-33, (long)75, (long)21, (long)19}))) == (3));
assert(candidate((std::vector<long>({(long)1}))) == (0));
assert(candidate((std::vector<long>())) == (0));
}
| [
"\n}"
] |
HumanEval_147_get_max_triples | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数 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]) を返す。
// 例 :
// >>> get_max_triples((5))
// (1)
// 解説:
// a = [1, 3, 7, 13, 21]
// 唯一の妥当な三つ組は (1, 7, 13)である。
long get_max_triples(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded | }
int main() {
auto candidate = get_max_triples;
assert(candidate((5)) == (1));
assert(candidate((6)) == (4));
assert(candidate((10)) == (36));
assert(candidate((100)) == (53361));
}
| [
"\n}"
] |
HumanEval_148_bf | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 私たちの太陽系には8つの惑星があります：太陽に最も近いのはVenus, Earth, Mars, Jupiter, Saturn,
// Uranus, Neptuneです。
// planet1とplanet2という2つの惑星名を文字列として受け取る関数を作成してください。
// この関数は、planet1の軌道とplanet2の軌道の間に位置するすべての惑星を太陽に近い順に並べたタプルを返すべきです。
// planet1またはplanet2が正確な惑星名でない場合、関数は空のタプルを返すべきです。
// 例
// >>> bf(("Jupiter"), ("Neptune"))
// (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"}))
// >>> bf(("Earth"), ("Mercury"))
// (std::vector<std::string>("Venus"))
// >>> bf(("Mercury"), ("Uranus"))
// (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"}))
std::vector<std::string> bf(std::string planet1, std::string planet2) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded | }
int main() {
auto candidate = bf;
assert(candidate(("Jupiter"), ("Neptune")) == (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"})));
assert(candidate(("Earth"), ("Mercury")) == (std::vector<std::string>({(std::string)"Venus"})));
assert(candidate(("Mercury"), ("Uranus")) == (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"})));
assert(candidate(("Neptune"), ("Venus")) == (std::vector<std::string>({(std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn", (std::string)"Uranus"})));
assert(candidate(("Earth"), ("Earth")) == (std::vector<std::string>()));
assert(candidate(("Mars"), ("Earth")) == (std::vector<std::string>()));
assert(candidate(("Jupiter"), ("Makemake")) == (std::vector<std::string>()));
}
| [
"\n}"
] |
HumanEval_149_sorted_list_sum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列のリストを引数として受け取る関数を作成してください。
// この関数は、リストから奇数の長さを持つ文字列を削除し、
// 結果として得られるリストを長さで昇順に並べ替えて返します。
// リストは常に文字列のリストであり、数字の配列ではありません。
// また、重複する文字列が含まれる可能性があります。
// リストは各単語の長さで昇順に並べられるべきで、そのルールに従ってソートされたリストを返してください。
// もし二つの単語が同じ長さであれば、リストをアルファベット順に並べ替えてください。
// 関数はソートされた順序で文字列のリストを返すべきです。
// すべての単語が同じ長さを持つと仮定しても構いません。
// 例えば:
// >>> list_sort((std::vector<std::string>({(std::string)"aa", (std::string)"a", (std::string)"aaa"})))
// (std::vector<std::string>({(std::string)"aa"}))
// >>> list_sort((std::vector<std::string>({(std::string)"ab", (std::string)"a", (std::string)"aaa", (std::string)"cd"})))
// (std::vector<std::string>({(std::string)"ab", (std::string)"cd"}))
std::vector<std::string> sorted_list_sum(std::vector<std::string> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded | }
int main() {
auto candidate = sorted_list_sum;
assert(candidate((std::vector<std::string>({(std::string)"aa", (std::string)"a", (std::string)"aaa"}))) == (std::vector<std::string>({(std::string)"aa"})));
assert(candidate((std::vector<std::string>({(std::string)"school", (std::string)"AI", (std::string)"asdf", (std::string)"b"}))) == (std::vector<std::string>({(std::string)"AI", (std::string)"asdf", (std::string)"school"})));
assert(candidate((std::vector<std::string>({(std::string)"d", (std::string)"b", (std::string)"c", (std::string)"a"}))) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"d", (std::string)"dcba", (std::string)"abcd", (std::string)"a"}))) == (std::vector<std::string>({(std::string)"abcd", (std::string)"dcba"})));
assert(candidate((std::vector<std::string>({(std::string)"AI", (std::string)"ai", (std::string)"au"}))) == (std::vector<std::string>({(std::string)"AI", (std::string)"ai", (std::string)"au"})));
assert(candidate((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"b", (std::string)"c", (std::string)"c", (std::string)"a"}))) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"aaaa", (std::string)"bbbb", (std::string)"dd", (std::string)"cc"}))) == (std::vector<std::string>({(std::string)"cc", (std::string)"dd", (std::string)"aaaa", (std::string)"bbbb"})));
}
| [
"\n}"
] |
HumanEval_150_x_or_y | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 素数である場合はxの値を返し、それ以外の場合はyの値を返す簡単なプログラム。
// 例:
// >>> x_or_y((7), (34), (12))
// (34)
// >>> x_or_y((15), (8), (5))
// (5)
long x_or_y(long n, long x, long y) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded | }
int main() {
auto candidate = x_or_y;
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));
assert(candidate((1), (2), (0)) == (0));
assert(candidate((2), (2), (0)) == (2));
}
| [
"\n}"
] |
HumanEval_151_double_the_difference | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数字のリストが与えられた場合、そのリスト内の奇数の数値の二乗の合計を返してください。
// 負の数や整数でない数は無視してください。
// >>> double_the_difference((std::vector<float>({(long)1, (long)3, (long)2, (long)0})))
// (10)
// >>> double_the_difference((std::vector<float>({(long)-1, (long)-2, (long)0})))
// (0)
// >>> double_the_difference((std::vector<float>({(long)9, (long)-2})))
// (81)
// >>> double_the_difference((std::vector<float>({(long)0})))
// (0)
// 入力リストが空の場合は0を返すようにしてください。
long double_the_difference(std::vector<float> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded | }
int main() {
auto candidate = double_the_difference;
assert(candidate((std::vector<float>())) == (0));
assert(candidate((std::vector<float>({(float)5.0f, (float)4.0f}))) == (25));
assert(candidate((std::vector<float>({(float)0.1f, (float)0.2f, (float)0.3f}))) == (0));
assert(candidate((std::vector<float>({(float)-10.0f, (float)-20.0f, (float)-30.0f}))) == (0));
assert(candidate((std::vector<float>({(float)-1.0f, (float)-2.0f, (float)8.0f}))) == (0));
assert(candidate((std::vector<float>({(float)0.2f, (float)3.0f, (float)5.0f}))) == (34));
assert(candidate((std::vector<float>({(float)-9.0f, (float)-7.0f, (float)-5.0f, (float)-3.0f, (float)-1.0f, (float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f, (float)9.0f}))) == (165));
}
| [
"\n}"
] |
HumanEval_152_compare | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 待ち望んでいた出来事の結果がようやく判明したときの感覚は、誰もが覚えていると思う。
// その瞬間に抱いた感情や思考は、間違いなくメモして比較する価値がある。
// あなたの仕事は、人がいくつかの試合の結果を正確に予想したかどうかを判断することです。
// スコアと予想の2つの配列が等しい長さで与えられます。各インデックスは1つの試合を示しています。
// 各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。予想が正確であれば、
// その値は0です。そうでなければ、その値は予想とスコアの絶対的な差です。
// 例:
// >>> compare((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)2, (long)-2})))
// (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)3, (long)3}))
// >>> compare((std::vector<long>({(long)0, (long)5, (long)0, (long)0, (long)0, (long)4})), (std::vector<long>({(long)4, (long)1, (long)1, (long)0, (long)0, (long)-2})))
// (std::vector<long>({(long)4, (long)4, (long)1, (long)0, (long)0, (long)6}))
std::vector<long> compare(std::vector<long> game, std::vector<long> guess) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded | }
int main() {
auto candidate = compare;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)2, (long)-2}))) == (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)3, (long)3})));
assert(candidate((std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0})), (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0}))) == (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3})), (std::vector<long>({(long)-1, (long)-2, (long)-3}))) == (std::vector<long>({(long)2, (long)4, (long)6})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5})), (std::vector<long>({(long)-1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)2, (long)0, (long)0, (long)1})));
}
| [
"\n}"
] |
HumanEval_153_Strongest_Extension | cpp | #include<assert.h>
#include<bits/stdc++.h>
// クラスの名前（文字列）と拡張子のリストが与えられます。
// この拡張子は、指定されたクラスに追加のクラスをロードするために使用されます。
// 拡張子の強度は次のように計算されます：CAPは拡張子の名前に含まれる
// 大文字の数、SMは小文字の数です。強度は、CAP - SM で与えられます。
// 最も強い拡張子を見つけて、この形式の文字列を返してください：ClassName.StrongestExtensionName。
// 同じ強度を持つ2つ以上の拡張子がある場合は、リストで最初に来るものを選びます。
// 例えば、"Slices"というクラスと、拡張子のリスト['SErviNGSliCes', 'Cheese', 'StuFfed'] が与えられた場合、'
// SErviNGSliCes'が最も強い拡張子（強度は-1）となるため、'Slices.SErviNGSliCes'を返すべきです。
// 例：
// >>> Strongest_Extension(("my_class"), (std::vector<std::string>({(std::string)"AA", (std::string)"Be", (std::string)"CC"})))
// ("my_class.AA")
std::string Strongest_Extension(std::string class_name, std::vector<std::string> extensions) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded | }
int main() {
auto candidate = Strongest_Extension;
assert(candidate(("Watashi"), (std::vector<std::string>({(std::string)"tEN", (std::string)"niNE", (std::string)"eIGHt8OKe"}))) == ("Watashi.eIGHt8OKe"));
assert(candidate(("Boku123"), (std::vector<std::string>({(std::string)"nani", (std::string)"NazeDa", (std::string)"YEs.WeCaNe", (std::string)"32145tggg"}))) == ("Boku123.YEs.WeCaNe"));
assert(candidate(("__YESIMHERE"), (std::vector<std::string>({(std::string)"t", (std::string)"eMptY", (std::string)"nothing", (std::string)"zeR00", (std::string)"NuLl__", (std::string)"123NoooneB321"}))) == ("__YESIMHERE.NuLl__"));
assert(candidate(("K"), (std::vector<std::string>({(std::string)"Ta", (std::string)"TAR", (std::string)"t234An", (std::string)"cosSo"}))) == ("K.TAR"));
assert(candidate(("__HAHA"), (std::vector<std::string>({(std::string)"Tab", (std::string)"123", (std::string)"781345", (std::string)"-_-"}))) == ("__HAHA.123"));
assert(candidate(("YameRore"), (std::vector<std::string>({(std::string)"HhAas", (std::string)"okIWILL123", (std::string)"WorkOut", (std::string)"Fails", (std::string)"-_-"}))) == ("YameRore.okIWILL123"));
assert(candidate(("finNNalLLly"), (std::vector<std::string>({(std::string)"Die", (std::string)"NowW", (std::string)"Wow", (std::string)"WoW"}))) == ("finNNalLLly.WoW"));
assert(candidate(("_"), (std::vector<std::string>({(std::string)"Bb", (std::string)"91245"}))) == ("_.Bb"));
assert(candidate(("Sp"), (std::vector<std::string>({(std::string)"671235", (std::string)"Bb"}))) == ("Sp.671235"));
}
| [
"\n}"
] |
HumanEval_154_cycpattern_check | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 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)
bool cycpattern_check(std::string a, std::string b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded | }
int main() {
auto candidate = cycpattern_check;
assert(candidate(("xyzw"), ("xyw")) == (false));
assert(candidate(("yello"), ("ell")) == (true));
assert(candidate(("whattup"), ("ptut")) == (false));
assert(candidate(("efef"), ("fee")) == (true));
assert(candidate(("abab"), ("aabb")) == (false));
assert(candidate(("winemtt"), ("tinem")) == (true));
}
| [
"\n}"
] |
HumanEval_155_even_odd_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数が与えられた場合、偶数桁数と奇数桁数をそれぞれ持つタプルを返す。
// 例:
// >>> even_odd_count((-12))
// (std::make_tuple(1, 1))
// >>> even_odd_count((123))
// (std::make_tuple(1, 2))
std::tuple<long, long> even_odd_count(long num) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded | }
int main() {
auto candidate = even_odd_count;
assert(candidate((7)) == (std::make_tuple(0, 1)));
assert(candidate((-78)) == (std::make_tuple(1, 1)));
assert(candidate((3452)) == (std::make_tuple(2, 2)));
assert(candidate((346211)) == (std::make_tuple(3, 3)));
assert(candidate((-345821)) == (std::make_tuple(3, 3)));
assert(candidate((-2)) == (std::make_tuple(1, 0)));
assert(candidate((-45347)) == (std::make_tuple(2, 3)));
assert(candidate((0)) == (std::make_tuple(1, 0)));
}
| [
"\n}"
] |
HumanEval_156_int_to_mini_roman | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数が与えられたとき、ローマ数字に相当する文字列を小文字で返す。
// 制限事項1 <= num <= 1000
// 例:s:
// >>> int_to_mini_roman((19))
// ("xix")
// >>> int_to_mini_roman((152))
// ("clii")
// >>> int_to_mini_roman((426))
// ("cdxxvi")
std::string int_to_mini_roman(long number) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded | }
int main() {
auto candidate = int_to_mini_roman;
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"));
}
| [
"\n}"
] |
HumanEval_157_right_angle_triangle | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 三角形の3辺の長さを与える。三角形が直角三角形ならtrueを、そうでなければfalseを返す。
// 直角三角形とは、1つの角が直角または90度である三角形のことである。
// 例:
// >>> right_angle_triangle((3), (4), (5))
// (true)
// >>> right_angle_triangle((1), (2), (3))
// (false)
bool right_angle_triangle(long a, long b, long c) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded | }
int main() {
auto candidate = right_angle_triangle;
assert(candidate((3), (4), (5)) == (true));
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));
assert(candidate((1), (1), (1)) == (false));
assert(candidate((2), (2), (10)) == (false));
}
| [
"\n}"
] |
HumanEval_158_find_max | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列のリストを受け取る関数を書きなさい。
// リストは異なる単語を含む。異なる固有の文字数が最も多い単語を返す。
// 複数の文字列が同じ文字数を持つ場合は、辞書順で最初に来るものを返すことにする。
// >>> find_max((std::vector<std::string>({(std::string)"name", (std::string)"of", (std::string)"string"})))
// ("string")
// >>> find_max((std::vector<std::string>({(std::string)"name", (std::string)"enam", (std::string)"game"})))
// ("enam")
// >>> find_max((std::vector<std::string>({(std::string)"aaaaaaa", (std::string)"bb", (std::string)"cc"})))
// ("aaaaaaa")
std::string find_max(std::vector<std::string> words) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded | }
int main() {
auto candidate = find_max;
assert(candidate((std::vector<std::string>({(std::string)"name", (std::string)"of", (std::string)"string"}))) == ("string"));
assert(candidate((std::vector<std::string>({(std::string)"name", (std::string)"enam", (std::string)"game"}))) == ("enam"));
assert(candidate((std::vector<std::string>({(std::string)"aaaaaaa", (std::string)"bb", (std::string)"cc"}))) == ("aaaaaaa"));
assert(candidate((std::vector<std::string>({(std::string)"abc", (std::string)"cba"}))) == ("abc"));
assert(candidate((std::vector<std::string>({(std::string)"play", (std::string)"this", (std::string)"game", (std::string)"of", (std::string)"footbott"}))) == ("footbott"));
assert(candidate((std::vector<std::string>({(std::string)"we", (std::string)"are", (std::string)"gonna", (std::string)"rock"}))) == ("gonna"));
assert(candidate((std::vector<std::string>({(std::string)"we", (std::string)"are", (std::string)"a", (std::string)"mad", (std::string)"nation"}))) == ("nation"));
assert(candidate((std::vector<std::string>({(std::string)"this", (std::string)"is", (std::string)"a", (std::string)"prrk"}))) == ("this"));
assert(candidate((std::vector<std::string>({(std::string)"b"}))) == ("b"));
assert(candidate((std::vector<std::string>({(std::string)"play", (std::string)"play", (std::string)"play"}))) == ("play"));
}
| [
"\n}"
] |
HumanEval_159_eat | cpp | #include<assert.h>
#include<bits/stdc++.h>
// あなたはお腹を空かせたウサギです。すでに一定数のニンジンを食べました。
// これからさらにニンジンを食べなければその日の食事は完了しません。
// あなたは [ 食事の後に食べたニンジンの総数, 食事の後に残ったニンジンの数 ] の配列を返してください。
// もし残りのニンジンが十分でなければ、あなたは残りのニンジンをすべて食べますが、まだお腹が空いています。
// 例:
// >>> eat((5), (6), (10))
// (std::vector<long>({(long)11, (long)4}))
// >>> eat((4), (8), (9))
// (std::vector<long>({(long)12, (long)1}))
// >>> eat((1), (10), (10))
// (std::vector<long>({(long)11, (long)0}))
// >>> eat((2), (11), (5))
// (std::vector<long>({(long)7, (long)0}))
// 変数:
// @number : 整数
// 食べたニンジンの数。
// @need : 整数
// にんじんを何本食べるか。
// @remaining : 整数
// the number of remaining carrots thet exist in stock
// 制約:
// * 0 <= number <= 1000
// * 0 <= need <= 1000
// * 0 <= remaining <= 1000
// 楽しんで :)
std::vector<long> eat(long number, long need, long remaining) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded | }
int main() {
auto candidate = eat;
assert(candidate((5), (6), (10)) == (std::vector<long>({(long)11, (long)4})));
assert(candidate((4), (8), (9)) == (std::vector<long>({(long)12, (long)1})));
assert(candidate((1), (10), (10)) == (std::vector<long>({(long)11, (long)0})));
assert(candidate((2), (11), (5)) == (std::vector<long>({(long)7, (long)0})));
assert(candidate((4), (5), (7)) == (std::vector<long>({(long)9, (long)2})));
assert(candidate((4), (5), (1)) == (std::vector<long>({(long)5, (long)0})));
}
| [
"\n}"
] |
HumanEval_160_do_algebra | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 演算子(operator)とオペランド(operand)の2つのリストが与えられる。ひとつ目のリストは
// 基本的な算術演算を持ち、二つ目のリストは整数のリストである。与えられた2つのリストを
// 使って算術式を構築し、その評価結果を返そう。
// 基本的な算術演算:
// 加算 ( + )
// 減算 ( - )
// 乗算 ( * )
// 階除算 ( // )
// 指数化 ( ** )
// 例:
// operator['+', '*', '-']
// vector = [2, 3, 4, 5]
// result = 2 + 3 * 4 - 5
// => result = 9
// 注：演算子のリストの長さは、オペランドのリストの長さから1を引いた長さに等しい。
// オペランドは非負整数のリストである。
// operator は少なくとも1つの演算子を持ち、operand は少なくとも2つのオペランドを持つ。
// "":
// operator['+', '*', '-']
// vector = [2, 3, 4, 5]
// result = 2 + 3 * 4 - 5
// => result = 9
// Note:
// The length of operator vector is equal to the length of operand vector minus one.
// Operand is a vector of of non-negative integers.
// Operator vector has at least one operator, and operand vector has at least two operands.
long do_algebra(std::vector<std::string> op, std::vector<long> operand) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded | }
int main() {
auto candidate = do_algebra;
assert(candidate((std::vector<std::string>({(std::string)"**", (std::string)"*", (std::string)"+"})), (std::vector<long>({(long)2, (long)3, (long)4, (long)5}))) == (37));
assert(candidate((std::vector<std::string>({(std::string)"+", (std::string)"*", (std::string)"-"})), (std::vector<long>({(long)2, (long)3, (long)4, (long)5}))) == (9));
assert(candidate((std::vector<std::string>({(std::string)"//", (std::string)"*"})), (std::vector<long>({(long)7, (long)3, (long)4}))) == (8));
}
| [
"\n}"
] |
HumanEval_161_solve | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列sが与えられます。
// もしs[i]がアルファベットなら、その文字の大文字と小文字を反転させる。そうでない場合は、そのままにしておく。
// もし文字列にアルファベットが一つも含まれていない場合は、文字列全体を逆順にする。
// 関数は結果の文字列を返すようにします。
// 例
// >>> solve(("1234"))
// ("4321")
// >>> solve(("ab"))
// ("AB")
// >>> solve(("#a@C"))
// ("#A@c")
std::string solve(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded | }
int main() {
auto candidate = solve;
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#"));
assert(candidate(("#$a^D")) == ("#$A^d"));
assert(candidate(("#ccc")) == ("#CCC"));
}
| [
"\n}"
] |
HumanEval_162_string_to_md5 | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列 text が与えられたとき、その md5 ハッシュと等価な文字列を返す。
// text' が空文字列の場合は None を返す。
// >>> string_to_md5(("Hello world"))
// "3e25960a79dbc69b674cd4ec67a72c62"
std::optional<std::string> string_to_md5(std::string text) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | reworded | }
int main() {
auto candidate = string_to_md5;
assert(candidate(("Hello world")) == "3e25960a79dbc69b674cd4ec67a72c62");
assert(candidate(("")) == std::nullopt);
assert(candidate(("A B C")) == "0ef78513b0cb8cef12743f5aeb35f888");
assert(candidate(("password")) == "5f4dcc3b5aa765d61d8327deb882cf99");
}
| [
"\n}"
] |
HumanEval_163_generate_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数aとbが与えられたとき、aとbの間にある偶数の数字を昇順で返してください。
// 例えば:
// >>> generate_integers((2), (8))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((8), (2))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((10), (14))
// (std::vector<long>())
std::vector<long> generate_integers(long a, long b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded | }
int main() {
auto candidate = generate_integers;
assert(candidate((2), (10)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
assert(candidate((10), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
assert(candidate((132), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
assert(candidate((17), (89)) == (std::vector<long>()));
}
| [
"\n}"
] |
Subsets and Splits