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_0_has_close_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リストnumbersの中に、与えられたthresholdより近い２つの数値が存在するか判定する
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})), (0.5f))
// (false)
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.8f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.3f))
// (true)
bool has_close_elements(std::vector<float> numbers, float threshold) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_0_has_close_elements.py | reworded | }
int main() {
auto candidate = has_close_elements;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.05f)) == (false));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.95f)) == (true));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.8f)) == (false));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.1f)) == (true));
assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (1.0f)) == (true));
assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (0.5f)) == (false));
}
| [
"\n}"
] |
HumanEval_1_separate_paren_groups | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数への入力は、入れ子になった括弧が複数含まれる文字列である。
// あなたの目的は、これらの括弧を別々の文字列に分割し、そのリストを返すことである。
// 分離された括弧はバランスがとれ、つまり、開いた括弧はそれぞれ適切に閉じられていて、
// 互いに入れ子になっていない。引数の文字列内の空白は無視せよ。
// >>> separate_paren_groups(("( ) (( )) (( )( ))"))
// (std::vector<std::string>({(std::string)"()", (std::string)"(())", (std::string)"(()())"}))
std::vector<std::string> separate_paren_groups(std::string paren_string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py | reworded | }
int main() {
auto candidate = separate_paren_groups;
assert(candidate(("(()()) ((())) () ((())()())")) == (std::vector<std::string>({(std::string)"(()())", (std::string)"((()))", (std::string)"()", (std::string)"((())()())"})));
assert(candidate(("() (()) ((())) (((())))")) == (std::vector<std::string>({(std::string)"()", (std::string)"(())", (std::string)"((()))", (std::string)"(((())))"})));
assert(candidate(("(()(())((())))")) == (std::vector<std::string>({(std::string)"(()(())((())))"})));
assert(candidate(("( ) (( )) (( )( ))")) == (std::vector<std::string>({(std::string)"()", (std::string)"(())", (std::string)"(()())"})));
}
| [
"\n}"
] |
HumanEval_2_truncate_number | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の浮動小数点数が与えられると、それを整数部（与えられた数より小さい最大の整数）
// と小数部（常に1より小さい残余部分）に分解することができる。
// 関数は、数値の小数部を返す。
// >>> truncate_number((3.5f))
// (0.5f)
float truncate_number(float number) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py | reworded | }
int main() {
auto candidate = truncate_number;
assert(candidate((3.5f)) == (0.5f));
assert(candidate((1.25f)) == (0.25f));
assert(candidate((123.0f)) == (0.0f));
}
| [
"\n}"
] |
HumanEval_3_below_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 銀行口座に対する入出金操作のリストが与えられます。あなたのタスクは、残高ゼロから
// 始まて、口座の残高がゼロ未満になったかどうかを検出し、その時点で関数がtrueを
// 返すようにすることです。そうでなければfalseを返すようにしてください。
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)3})))
// (false)
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)-4, (long)5})))
// (true)
bool below_zero(std::vector<long> operations) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py | reworded | }
int main() {
auto candidate = below_zero;
assert(candidate((std::vector<long>())) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)-3, (long)1, (long)2, (long)-3}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)-4, (long)5, (long)6}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-5}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)-2, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (true));
}
| [
"\n}"
] |
HumanEval_4_mean_absolute_deviation | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 第一引数の数値リストに対して、このデータセットの平均値を中心とした平均絶対偏差(MAD)を計算する。
// 平均絶対偏差(MAD)とは、各要素と中心点（この場合は平均値）との差の絶対値の平均である:
// MAD = 平均｜x - x_mean｜
// >>> mean_absolute_deviation((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f})))
// (1.0f)
float mean_absolute_deviation(std::vector<float> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py | reworded | }
int main() {
auto candidate = mean_absolute_deviation;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f}))) == (0.5f));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f}))) == (1.0f));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (1.2f));
}
| [
"\n}"
] |
HumanEval_5_intersperse | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数値リスト numbers 中の全ての連続する二要素の間に、'delimeterの値を挿入する
// >>> intersperse((std::vector<long>()), (4))
// (std::vector<long>())
// >>> intersperse((std::vector<long>({(long)1, (long)2, (long)3})), (4))
// (std::vector<long>({(long)1, (long)4, (long)2, (long)4, (long)3}))
std::vector<long> intersperse(std::vector<long> numbers, long delimeter) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py | reworded | }
int main() {
auto candidate = intersperse;
assert(candidate((std::vector<long>()), (7)) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)2})), (8)) == (std::vector<long>({(long)5, (long)8, (long)6, (long)8, (long)3, (long)8, (long)2})));
assert(candidate((std::vector<long>({(long)2, (long)2, (long)2})), (2)) == (std::vector<long>({(long)2, (long)2, (long)2, (long)2, (long)2})));
}
| [
"\n}"
] |
HumanEval_6_parse_nested_parens | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数の入力は、空白で区切られた複数の入れ子になった括弧のグループを表す文字列です。
// 各グループについて、括弧の最も深い入れ子のレベルを出力します。
// 例えば、'(()())'は最大で2レベルの入れ子になっていますが、'((()))'は3レベルです。
// >>> parse_nested_parens(("(()()) ((())) () ((())()())"))
// (std::vector<long>({(long)2, (long)3, (long)1, (long)3}))
std::vector<long> parse_nested_parens(std::string paren_string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_6_parse_nested_parens.py | reworded | }
int main() {
auto candidate = parse_nested_parens;
assert(candidate(("(()()) ((())) () ((())()())")) == (std::vector<long>({(long)2, (long)3, (long)1, (long)3})));
assert(candidate(("() (()) ((())) (((())))")) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
assert(candidate(("(()(())((())))")) == (std::vector<long>({(long)4})));
}
| [
"\n}"
] |
HumanEval_7_filter_by_substring | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列リストstringsを、与えれた部分文字列substringを含むものだけにフィルタする
// >>> filter_by_substring((std::vector<std::string>()), ("a"))
// (std::vector<std::string>())
// >>> filter_by_substring((std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"cde", (std::string)"array"})), ("a"))
// (std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"array"}))
std::vector<std::string> filter_by_substring(std::vector<std::string> strings, std::string substring) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | reworded | }
int main() {
auto candidate = filter_by_substring;
assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xxx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"xxxAAA", (std::string)"xxx"})));
assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"aaaxxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"aaaxxy", (std::string)"xxxAAA", (std::string)"xxx"})));
assert(candidate((std::vector<std::string>({(std::string)"grunt", (std::string)"trumpet", (std::string)"prune", (std::string)"gruesome"})), ("run")) == (std::vector<std::string>({(std::string)"grunt", (std::string)"prune"})));
}
| [
"\n}"
] |
HumanEval_8_sum_product | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた整数リストに対して、リスト内のすべての整数の和と積からなるタプルを返す。
// ただし、空の和は0、空の積は1とする。
// >>> sum_product((std::vector<long>()))
// (std::make_tuple(0, 1))
// >>> sum_product((std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// (std::make_tuple(10, 24))
std::tuple<long, long> sum_product(std::vector<long> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | reworded | }
int main() {
auto candidate = sum_product;
assert(candidate((std::vector<long>())) == (std::make_tuple(0, 1)));
assert(candidate((std::vector<long>({(long)1, (long)1, (long)1}))) == (std::make_tuple(3, 1)));
assert(candidate((std::vector<long>({(long)100, (long)0}))) == (std::make_tuple(100, 0)));
assert(candidate((std::vector<long>({(long)3, (long)5, (long)7}))) == (std::make_tuple(15, 105)));
assert(candidate((std::vector<long>({(long)10}))) == (std::make_tuple(10, 10)));
}
| [
"\n}"
] |
HumanEval_9_rolling_max | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた整数リストから、各要素のそこまでの最大値（ローリング最大値）のリストを生成する。
// >>> rolling_max((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)3, (long)4, (long)2})))
// (std::vector<long>({(long)1, (long)2, (long)3, (long)3, (long)3, (long)4, (long)4}))
std::vector<long> rolling_max(std::vector<long> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | reworded | }
int main() {
auto candidate = rolling_max;
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)1}))) == (std::vector<long>({(long)4, (long)4, (long)4, (long)4})));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)3, (long)100, (long)3}))) == (std::vector<long>({(long)3, (long)3, (long)3, (long)100, (long)100})));
}
| [
"\n}"
] |
HumanEval_10_make_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた文字列で始まる最短の回文を見つけてください。
// アルゴリズムのアイデアは以下の通りです：
// - 与えられた文字列の中で最も長い回文となる接尾辞を見つけます。
// - その回文の接尾辞の前に来る接頭辞を逆順にして、文字列の末尾に追加します。
// >>> make_palindrome((""))
// ("")
// >>> make_palindrome(("cat"))
// ("catac")
// >>> make_palindrome(("cata"))
// ("catac")
std::string make_palindrome(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_10_make_palindrome.py | reworded | }
int main() {
auto candidate = make_palindrome;
assert(candidate(("")) == (""));
assert(candidate(("x")) == ("x"));
assert(candidate(("xyz")) == ("xyzyx"));
assert(candidate(("xyx")) == ("xyx"));
assert(candidate(("jerry")) == ("jerryrrej"));
}
| [
"\n}"
] |
HumanEval_11_string_xor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数は1と0のみからなる文字列aとbである。
// これらの引数に対して排他論理和(XOR)を実行し、結果を文字列として返す。
// >>> string_xor(("010"), ("110"))
// ("100")
std::string string_xor(std::string a, std::string b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py | reworded | }
int main() {
auto candidate = string_xor;
assert(candidate(("111000"), ("101010")) == ("010010"));
assert(candidate(("1"), ("1")) == ("0"));
assert(candidate(("0101"), ("0000")) == ("0101"));
}
| [
"\n}"
] |
HumanEval_12_longest | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列のリストのうち、最も長いものを返す。同じ長さの文字列が
// 複数ある場合は最初のものを返す。入力リストが空の場合は None を返す。
// >>> longest((std::vector<std::string>()))
// std::nullopt
// >>> longest((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"c"})))
// "a"
// >>> longest((std::vector<std::string>({(std::string)"a", (std::string)"bb", (std::string)"ccc"})))
// "ccc"
std::optional<std::string> longest(std::vector<std::string> strings) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py | reworded | }
int main() {
auto candidate = longest;
assert(candidate((std::vector<std::string>())) == std::nullopt);
assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z"}))) == "x");
assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"yyy", (std::string)"zzzz", (std::string)"www", (std::string)"kkkk", (std::string)"abc"}))) == "zzzz");
}
| [
"\n}"
] |
HumanEval_13_greatest_common_divisor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数 a と b の最大公約数を返す
// >>> greatest_common_divisor((3), (5))
// (1)
// >>> greatest_common_divisor((25), (15))
// (5)
long greatest_common_divisor(long a, long b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py | reworded | }
int main() {
auto candidate = greatest_common_divisor;
assert(candidate((3), (7)) == (1));
assert(candidate((10), (15)) == (5));
assert(candidate((49), (14)) == (7));
assert(candidate((144), (60)) == (12));
}
| [
"\n}"
] |
HumanEval_14_all_prefixes | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数で与えられた文字列に対して、短いものから長いものへ、全ての接頭辞のリストを返す
// >>> all_prefixes(("abc"))
// (std::vector<std::string>({(std::string)"a", (std::string)"ab", (std::string)"abc"}))
std::vector<std::string> all_prefixes(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py | reworded | }
int main() {
auto candidate = all_prefixes;
assert(candidate(("")) == (std::vector<std::string>()));
assert(candidate(("asdfgh")) == (std::vector<std::string>({(std::string)"a", (std::string)"as", (std::string)"asd", (std::string)"asdf", (std::string)"asdfg", (std::string)"asdfgh"})));
assert(candidate(("WWW")) == (std::vector<std::string>({(std::string)"W", (std::string)"WW", (std::string)"WWW"})));
}
| [
"\n}"
] |
HumanEval_15_string_sequence | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 0からnまでの数字を空白区切りで連結した文字列で返す。
// >>> string_sequence((0))
// ("0")
// >>> string_sequence((5))
// ("0 1 2 3 4 5")
std::string string_sequence(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py | reworded | }
int main() {
auto candidate = string_sequence;
assert(candidate((0)) == ("0"));
assert(candidate((3)) == ("0 1 2 3"));
assert(candidate((10)) == ("0 1 2 3 4 5 6 7 8 9 10"));
}
| [
"\n}"
] |
HumanEval_16_count_distinct_characters | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列が与えられたとき、その文字列が（大文字小文字に関係なく）いくつの異なる文字が含まれているか数える
// >>> count_distinct_characters(("xyzXYZ"))
// (3)
// >>> count_distinct_characters(("Jerry"))
// (4)
long count_distinct_characters(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_16_count_distinct_characters.py | reworded | }
int main() {
auto candidate = count_distinct_characters;
assert(candidate(("")) == (0));
assert(candidate(("abcde")) == (5));
assert(candidate(("abcdecadeCADE")) == (5));
assert(candidate(("aaaaAAAAaaaa")) == (1));
assert(candidate(("Jerry jERRY JeRRRY")) == (5));
}
| [
"\n}"
] |
HumanEval_17_parse_music | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数の引数は、特別なASCII形式の音符を表す文字列である。あなたの仕事は、この文字列を解析して、それぞれの音符が何拍続くかに対応する整数のリストを返すことである。
// ここに凡例がある：
// o' - 全音符、4拍続く
// o|' - 2分音符、2拍続く
// .|」-4分音符、1拍続く
// >>> parse_music(("o o| .| o| o| .| .| .| .| o o"))
// (std::vector<long>({(long)4, (long)2, (long)1, (long)2, (long)2, (long)1, (long)1, (long)1, (long)1, (long)4, (long)4}))
std::vector<long> parse_music(std::string music_string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py | reworded | }
int main() {
auto candidate = parse_music;
assert(candidate(("")) == (std::vector<long>()));
assert(candidate(("o o o o")) == (std::vector<long>({(long)4, (long)4, (long)4, (long)4})));
assert(candidate((".| .| .| .|")) == (std::vector<long>({(long)1, (long)1, (long)1, (long)1})));
assert(candidate(("o| o| .| .| o o o o")) == (std::vector<long>({(long)2, (long)2, (long)1, (long)1, (long)4, (long)4, (long)4, (long)4})));
assert(candidate(("o| .| o| .| o o| o o|")) == (std::vector<long>({(long)2, (long)1, (long)2, (long)1, (long)4, (long)2, (long)4, (long)2})));
}
| [
"\n}"
] |
HumanEval_18_how_many_times | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 部分文字列substringが文字列stringの中で何回見つかるか数える。
// 重なるケースもカウントに含まれる。
// >>> how_many_times((""), ("a"))
// (0)
// >>> how_many_times(("aaa"), ("a"))
// (3)
// >>> how_many_times(("aaaa"), ("aa"))
// (3)
long how_many_times(std::string string, std::string substring) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_18_how_many_times.py | reworded | }
int main() {
auto candidate = how_many_times;
assert(candidate((""), ("x")) == (0));
assert(candidate(("xyxyxyx"), ("x")) == (4));
assert(candidate(("cacacacac"), ("cac")) == (4));
assert(candidate(("john doe"), ("john")) == (1));
}
| [
"\n}"
] |
HumanEval_19_sort_numbers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数は'zero'から'nine'までの英単語の数を空白で区切った文字列である。
// 有効な英単語は''、'zero', 'one'、'two'、'three'、'four'、'five'、'six'、'seven'、'eight'、'nine'である。
// 関数は、英単語の数を小さい方から大きい方へとソートした文字列を返す。
// >>> sort_numbers(("three one five"))
// ("one three five")
std::string sort_numbers(std::string numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_19_sort_numbers.py | reworded | }
int main() {
auto candidate = sort_numbers;
assert(candidate(("")) == (""));
assert(candidate(("three")) == ("three"));
assert(candidate(("three five nine")) == ("three five nine"));
assert(candidate(("five zero four seven nine eight")) == ("zero four five seven eight nine"));
assert(candidate(("six five four three two one zero")) == ("zero one two three four five six"));
}
| [
"\n}"
] |
HumanEval_20_find_closest_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// （少なくとも長さ2以上の）リストnumbersから、互いに最も近いものを2つ選び、
// 順番に（小さい数、大きい数）返す。
// >>> find_closest_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f})))
// (std::make_tuple(2.0f, 2.2f))
// >>> find_closest_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})))
// (std::make_tuple(2.0f, 2.0f))
std::tuple<float, float> find_closest_elements(std::vector<float> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py | reworded | }
int main() {
auto candidate = find_closest_elements;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f}))) == (std::make_tuple(3.9f, 4.0f)));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f}))) == (std::make_tuple(5.0f, 5.9f)));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f}))) == (std::make_tuple(2.0f, 2.2f)));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f}))) == (std::make_tuple(2.0f, 2.0f)));
assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f}))) == (std::make_tuple(2.2f, 3.1f)));
}
| [
"\n}"
] |
HumanEval_21_rescale_to_unit | cpp | #include<assert.h>
#include<bits/stdc++.h>
// (少なくとも 2 つ以上の要素からなる) リストnumbersに線形変換を適用し、
// 最小の数値が 0 になり、最大の数値が 1 になるリストを返す
// >>> rescale_to_unit((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f})))
// (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))
std::vector<float> rescale_to_unit(std::vector<float> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py | reworded | }
int main() {
auto candidate = rescale_to_unit;
assert(candidate((std::vector<float>({(float)2.0f, (float)49.9f}))) == (std::vector<float>({(float)0.0f, (float)1.0f})));
assert(candidate((std::vector<float>({(float)100.0f, (float)49.9f}))) == (std::vector<float>({(float)1.0f, (float)0.0f})));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f})));
assert(candidate((std::vector<float>({(float)2.0f, (float)1.0f, (float)5.0f, (float)3.0f, (float)4.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
assert(candidate((std::vector<float>({(float)12.0f, (float)11.0f, (float)15.0f, (float)13.0f, (float)14.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
}
| [
"\n}"
] |
HumanEval_22_filter_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 任意の種類の値が含まれるリストから整数値のみ抽出する
// >>> filter_integers((std::vector<std::any>({(std::string)"a", (std::string)3.14f, (std::string)5})))
// (std::vector<long>({(long)5}))
// >>> filter_integers((std::vector<std::any>({1, 2, 3, "abc", std::map<long,long>(), std::vector<long>()})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
std::vector<long> filter_integers(std::vector<std::any> values) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py | reworded | }
int main() {
auto candidate = filter_integers;
assert(candidate((std::vector<std::any>())) == (std::vector<long>()));
assert(candidate((std::vector<std::any>({4, std::map<long,long>(), std::vector<long>(), 23.2f, 9, "adasd"}))) == (std::vector<long>({(long)4, (long)9})));
assert(candidate((std::vector<std::any>({3, "c", 3, 3, "a", "b"}))) == (std::vector<long>({(long)3, (long)3, (long)3})));
}
| [
"\n}"
] |
HumanEval_23_strlen | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数で与えられた文字列の長さを返す
// >>> string_length((""))
// (0)
// >>> string_length(("abc"))
// (3)
long string_length(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_23_strlen.py | reworded | }
int main() {
auto candidate = string_length;
assert(candidate(("")) == (0));
assert(candidate(("x")) == (1));
assert(candidate(("asdasnakj")) == (9));
}
| [
"\n}"
] |
HumanEval_24_largest_divisor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた数nについて、nの約数のうち、nより小さい最大の数を求める
// >>> largest_divisor((15))
// (5)
long largest_divisor(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_24_largest_divisor.py | reworded | }
int main() {
auto candidate = largest_divisor;
assert(candidate((3)) == (1));
assert(candidate((7)) == (1));
assert(candidate((10)) == (5));
assert(candidate((100)) == (50));
assert(candidate((49)) == (7));
}
| [
"\n}"
] |
HumanEval_25_factorize | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた整数の素因数のリストを小さいものから大きいものの順に返す。各因数は、
// 因数分解で現れる回数分、リストに登場する。引数の整数は全ての因数の積に等しくな
// ければならない。
// >>> factorize((8))
// (std::vector<long>({(long)2, (long)2, (long)2}))
// >>> factorize((25))
// (std::vector<long>({(long)5, (long)5}))
// >>> factorize((70))
// (std::vector<long>({(long)2, (long)5, (long)7}))
std::vector<long> factorize(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py | reworded | }
int main() {
auto candidate = factorize;
assert(candidate((2)) == (std::vector<long>({(long)2})));
assert(candidate((4)) == (std::vector<long>({(long)2, (long)2})));
assert(candidate((8)) == (std::vector<long>({(long)2, (long)2, (long)2})));
assert(candidate((57)) == (std::vector<long>({(long)3, (long)19})));
assert(candidate((3249)) == (std::vector<long>({(long)3, (long)3, (long)19, (long)19})));
assert(candidate((185193)) == (std::vector<long>({(long)3, (long)3, (long)3, (long)19, (long)19, (long)19})));
assert(candidate((20577)) == (std::vector<long>({(long)3, (long)19, (long)19, (long)19})));
assert(candidate((18)) == (std::vector<long>({(long)2, (long)3, (long)3})));
}
| [
"\n}"
] |
HumanEval_26_remove_duplicates | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数のリストから、複数回出現する要素をすべて取り除く。
// 要素の順序は入力と同じようにする。
// >>> remove_duplicates((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4})))
// (std::vector<long>({(long)1, (long)3, (long)4}))
std::vector<long> remove_duplicates(std::vector<long> numbers) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py | reworded | }
int main() {
auto candidate = remove_duplicates;
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4, (long)3, (long)5}))) == (std::vector<long>({(long)1, (long)4, (long)5})));
}
| [
"\n}"
] |
HumanEval_27_flip_case | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた文字列に対して、英小文字を英大文字に、英大文字を英小文字に変換する。
// >>> flip_case(("Hello"))
// ("hELLO")
std::string flip_case(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py | reworded | }
int main() {
auto candidate = flip_case;
assert(candidate(("")) == (""));
assert(candidate(("Hello!")) == ("hELLO!"));
assert(candidate(("These violent delights have violent ends")) == ("tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS"));
}
| [
"\n}"
] |
HumanEval_28_concatenate | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列のリストを1つの文字列に連結する
// >>> concatenate((std::vector<std::string>()))
// ("")
// >>> concatenate((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"c"})))
// ("abc")
std::string concatenate(std::vector<std::string> strings) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py | reworded | }
int main() {
auto candidate = concatenate;
assert(candidate((std::vector<std::string>())) == (""));
assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z"}))) == ("xyz"));
assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z", (std::string)"w", (std::string)"k"}))) == ("xyzwk"));
}
| [
"\n}"
] |
HumanEval_29_filter_by_prefix | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列のリストから、指定された接頭辞prefixで始まるものだけを取り出す。
// >>> filter_by_prefix((std::vector<std::string>()), ("a"))
// (std::vector<std::string>())
// >>> filter_by_prefix((std::vector<std::string>({(std::string)"abc", (std::string)"bcd", (std::string)"cde", (std::string)"array"})), ("a"))
// (std::vector<std::string>({(std::string)"abc", (std::string)"array"}))
std::vector<std::string> filter_by_prefix(std::vector<std::string> strings, std::string prefix) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py | reworded | }
int main() {
auto candidate = filter_by_prefix;
assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xxx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"xxxAAA", (std::string)"xxx"})));
}
| [
"\n}"
] |
HumanEval_30_get_positive | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リスト内の正の数だけを返す。
// >>> get_positive((std::vector<long>({(long)-1, (long)2, (long)-4, (long)5, (long)6})))
// (std::vector<long>({(long)2, (long)5, (long)6}))
// >>> get_positive((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10})))
// (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)9, (long)123, (long)1}))
std::vector<long> get_positive(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py | reworded | }
int main() {
auto candidate = get_positive;
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)4, (long)5, (long)6}))) == (std::vector<long>({(long)4, (long)5, (long)6})));
assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10}))) == (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)3, (long)9, (long)123, (long)1})));
assert(candidate((std::vector<long>({(long)-1, (long)-2}))) == (std::vector<long>()));
assert(candidate((std::vector<long>())) == (std::vector<long>()));
}
| [
"\n}"
] |
HumanEval_31_is_prime | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた数が素数であれば真を、そうでなければ偽を返す。
// >>> is_prime((6))
// (false)
// >>> is_prime((101))
// (true)
// >>> is_prime((11))
// (true)
// >>> is_prime((13441))
// (true)
// >>> is_prime((61))
// (true)
// >>> is_prime((4))
// (false)
// >>> is_prime((1))
// (false)
bool is_prime(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py | reworded | }
int main() {
auto candidate = is_prime;
assert(candidate((6)) == (false));
assert(candidate((101)) == (true));
assert(candidate((11)) == (true));
assert(candidate((13441)) == (true));
assert(candidate((61)) == (true));
assert(candidate((4)) == (false));
assert(candidate((1)) == (false));
assert(candidate((5)) == (true));
assert(candidate((11)) == (true));
assert(candidate((17)) == (true));
assert(candidate((85)) == (false));
assert(candidate((77)) == (false));
assert(candidate((255379)) == (false));
}
| [
"\n}"
] |
HumanEval_33_sort_third | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数はリストlを受け取り、l'を返す。l'は、インデックスが3で割り
// 切れない場合はlと同じであるが、インデックスが3で割り切れる要素は
// ソートされている。
// >>> sort_third((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
// >>> sort_third((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2})))
// (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5}))
std::vector<long> sort_third(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py | reworded | }
int main() {
auto candidate = sort_third;
assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5})));
assert(candidate((std::vector<long>({(long)5, (long)8, (long)3, (long)4, (long)6, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)8, (long)3, (long)4, (long)6, (long)9, (long)5})));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)9, (long)4, (long)8, (long)3, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)9, (long)4, (long)8, (long)3, (long)5})));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2, (long)1}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5, (long)1})));
}
| [
"\n}"
] |
HumanEval_34_unique | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リスト内のユニークな要素をソートして返す
// >>> unique((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123})))
// (std::vector<long>({(long)0, (long)2, (long)3, (long)5, (long)9, (long)123}))
std::vector<long> unique(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_34_unique.py | reworded | }
int main() {
auto candidate = unique;
assert(candidate((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123}))) == (std::vector<long>({(long)0, (long)2, (long)3, (long)5, (long)9, (long)123})));
}
| [
"\n}"
] |
HumanEval_35_max_element | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リスト内の最大要素を返す。
// >>> max_element((std::vector<long>({(long)1, (long)2, (long)3})))
// (3)
// >>> max_element((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10})))
// (123)
long max_element(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_35_max_element.py | reworded | }
int main() {
auto candidate = max_element;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (3));
assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)124, (long)1, (long)-10}))) == (124));
}
| [
"\n}"
] |
HumanEval_36_fizz_buzz | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられたn未満の整数の中で、11または13で割り切れる数の中に'7'という数字が何回現れるかを返す
// >>> fizz_buzz((50))
// (0)
// >>> fizz_buzz((78))
// (2)
// >>> fizz_buzz((79))
// (3)
long fizz_buzz(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py | reworded | }
int main() {
auto candidate = fizz_buzz;
assert(candidate((50)) == (0));
assert(candidate((78)) == (2));
assert(candidate((79)) == (3));
assert(candidate((100)) == (3));
assert(candidate((200)) == (6));
assert(candidate((4000)) == (192));
assert(candidate((10000)) == (639));
assert(candidate((100000)) == (8026));
}
| [
"\n}"
] |
HumanEval_37_sort_even | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数はリスト l を受け取り、l' を返す。l'は、インデックスが奇数の
// ときは l と同じで、インデックスが偶数のときはソートされている。
// >>> sort_even((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
// >>> sort_even((std::vector<long>({(long)5, (long)6, (long)3, (long)4})))
// (std::vector<long>({(long)3, (long)6, (long)5, (long)4}))
std::vector<long> sort_even(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py | reworded | }
int main() {
auto candidate = sort_even;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)1, (long)2, (long)3})));
assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10}))) == (std::vector<long>({(long)-10, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)5, (long)0, (long)9, (long)1, (long)123})));
assert(candidate((std::vector<long>({(long)5, (long)8, (long)-12, (long)4, (long)23, (long)2, (long)3, (long)11, (long)12, (long)-10}))) == (std::vector<long>({(long)-12, (long)8, (long)3, (long)4, (long)5, (long)2, (long)12, (long)11, (long)23, (long)-10})));
}
| [
"\n}"
] |
HumanEval_39_prime_fib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// prime_fib はフィボナッチ数で、かつ素数であるn番目の数を返す。
// >>> prime_fib((1))
// (2)
// >>> prime_fib((2))
// (3)
// >>> prime_fib((3))
// (5)
// >>> prime_fib((4))
// (13)
// >>> prime_fib((5))
// (89)
long prime_fib(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py | reworded | }
int main() {
auto candidate = prime_fib;
assert(candidate((1)) == (2));
assert(candidate((2)) == (3));
assert(candidate((3)) == (5));
assert(candidate((4)) == (13));
assert(candidate((5)) == (89));
assert(candidate((6)) == (233));
assert(candidate((7)) == (1597));
assert(candidate((8)) == (28657));
assert(candidate((9)) == (514229));
assert(candidate((10)) == (433494437));
}
| [
"\n}"
] |
HumanEval_40_triples_sum_to_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// triples_sum_to_zero は整数のリストを引数に取り、
// リストの中に和が0になる３つの要素があればtrueを、
// そうでなければfalseを返す。
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)-2, (long)1})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)2, (long)3, (long)7})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1})))
// (false)
bool triples_sum_to_zero(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py | reworded | }
int main() {
auto candidate = triples_sum_to_zero;
assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)0}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-1}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)-2, (long)1}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)7}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)5, (long)7}))) == (false));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7}))) == (true));
assert(candidate((std::vector<long>({(long)1}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-100}))) == (false));
assert(candidate((std::vector<long>({(long)100, (long)3, (long)5, (long)-100}))) == (false));
}
| [
"\n}"
] |
HumanEval_41_car_race_collision | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 完全な直線で無限に長い道路を想像してほしい。
// n台の車が左から右に向かって走っている。同時に、別のn台の車が
// 右から左に向かって走っている。この2組の車は、最初は互いに非
// 常に離れている。すべての車は同じ速度で動く。2台の車は次のよ
// うに衝突する。左から右に動いている車が、右から左に動いている
// 車にぶつかること。
// しかし、車は限りなく頑丈で強い。あたかも衝突しなかったかのよ
// うに、その軌道を進み続ける。
// この関数は、このような衝突の回数を出力する。
long car_race_collision(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py | reworded | }
int main() {
auto candidate = car_race_collision;
assert(candidate((2)) == (4));
assert(candidate((3)) == (9));
assert(candidate((4)) == (16));
assert(candidate((8)) == (64));
assert(candidate((10)) == (100));
}
| [
"\n}"
] |
HumanEval_42_incr_list | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 要素を1ずつ増やしたリストを返す。
// >>> incr_list((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)3, (long)4}))
// >>> incr_list((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123})))
// (std::vector<long>({(long)6, (long)4, (long)6, (long)3, (long)4, (long)4, (long)10, (long)1, (long)124}))
std::vector<long> incr_list(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py | reworded | }
int main() {
auto candidate = incr_list;
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (std::vector<long>({(long)4, (long)3, (long)2})));
assert(candidate((std::vector<long>({(long)5, (long)2, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123}))) == (std::vector<long>({(long)6, (long)3, (long)6, (long)3, (long)4, (long)4, (long)10, (long)1, (long)124})));
}
| [
"\n}"
] |
HumanEval_43_pairs_sum_to_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// pairs_sum_to_zero は整数のリストを引数にとる。
// リストの中に２つの要素の和がゼロになる要素があればtrueを、
// そうでなければfalseを返す。
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)-2, (long)1})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)2, (long)3, (long)7})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)5, (long)7})))
// (true)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1})))
// (false)
bool pairs_sum_to_zero(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py | reworded | }
int main() {
auto candidate = pairs_sum_to_zero;
assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)0}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)-2, (long)1}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)7}))) == (false));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)5, (long)7}))) == (true));
assert(candidate((std::vector<long>({(long)1}))) == (false));
assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)3, (long)2, (long)30}))) == (true));
assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)3, (long)2, (long)31}))) == (true));
assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)4, (long)2, (long)30}))) == (false));
assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)4, (long)2, (long)31}))) == (false));
}
| [
"\n}"
] |
HumanEval_44_change_base | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数xの基数をbaseに変換する。
// 返り値は変換後の文字列表現である。
// 基数は10未満である。
// >>> change_base((8), (3))
// ("22")
// >>> change_base((8), (2))
// ("1000")
// >>> change_base((7), (2))
// ("111")
std::string change_base(long x, long base) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py | reworded | }
int main() {
auto candidate = change_base;
assert(candidate((8), (3)) == ("22"));
assert(candidate((9), (3)) == ("100"));
assert(candidate((234), (2)) == ("11101010"));
assert(candidate((16), (2)) == ("10000"));
assert(candidate((8), (2)) == ("1000"));
assert(candidate((7), (2)) == ("111"));
assert(candidate((2), (3)) == ("2"));
assert(candidate((3), (4)) == ("3"));
assert(candidate((4), (5)) == ("4"));
assert(candidate((5), (6)) == ("5"));
assert(candidate((6), (7)) == ("6"));
assert(candidate((7), (8)) == ("7"));
}
| [
"\n}"
] |
HumanEval_45_triangle_area | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 三角形の一辺の長さと高さが与えられたとき、面積を返す。
// >>> triangle_area((5), (3))
// (7.5f)
float triangle_area(long a, long h) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py | reworded | }
int main() {
auto candidate = triangle_area;
assert(candidate((5), (3)) == (7.5f));
assert(candidate((2), (2)) == (2.0f));
assert(candidate((10), (8)) == (40.0f));
}
| [
"\n}"
] |
HumanEval_46_fib4 | cpp | #include<assert.h>
#include<bits/stdc++.h>
// fib4数列はフィボナッチ数列に似た数列で、次のように定義される：
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// fib4数列のn番目の要素を効率的に計算する関数を書け。再帰は使わないこと。
// >>> fib4((5))
// (4)
// >>> fib4((6))
// (8)
// >>> fib4((7))
// (14)
long fib4(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py | reworded | }
int main() {
auto candidate = fib4;
assert(candidate((5)) == (4));
assert(candidate((8)) == (28));
assert(candidate((10)) == (104));
assert(candidate((12)) == (386));
}
| [
"\n}"
] |
HumanEval_47_median | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リスト l の要素の中央値を返す。
// >>> median((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (float(3))
// >>> median((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20})))
// (15.0f)
float median(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py | reworded | }
int main() {
auto candidate = median;
assert(candidate((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5}))) == (float(3)));
assert(candidate((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20}))) == (8.0f));
assert(candidate((std::vector<long>({(long)5}))) == (float(5)));
assert(candidate((std::vector<long>({(long)6, (long)5}))) == (5.5f));
assert(candidate((std::vector<long>({(long)8, (long)1, (long)3, (long)9, (long)9, (long)2, (long)7}))) == (float(7)));
}
| [
"\n}"
] |
HumanEval_48_is_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた文字列が回文かどうかを判定する
// >>> is_palindrome((""))
// (true)
// >>> is_palindrome(("aba"))
// (true)
// >>> is_palindrome(("aaaaa"))
// (true)
// >>> is_palindrome(("zbcd"))
// (false)
bool is_palindrome(std::string text) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py | reworded | }
int main() {
auto candidate = is_palindrome;
assert(candidate(("")) == (true));
assert(candidate(("aba")) == (true));
assert(candidate(("aaaaa")) == (true));
assert(candidate(("zbcd")) == (false));
assert(candidate(("xywyx")) == (true));
assert(candidate(("xywyz")) == (false));
assert(candidate(("xywzx")) == (false));
}
| [
"\n}"
] |
HumanEval_49_modp | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2^n を p で割ったモジュロを返す。計算精度に注意。
// >>> modp((3), (5))
// (3)
// >>> modp((1101), (101))
// (2)
// >>> modp((0), (101))
// (1)
// >>> modp((3), (11))
// (8)
// >>> modp((100), (101))
// (1)
long modp(long n, long p) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py | reworded | }
int main() {
auto candidate = modp;
assert(candidate((3), (5)) == (3));
assert(candidate((1101), (101)) == (2));
assert(candidate((0), (101)) == (1));
assert(candidate((3), (11)) == (8));
assert(candidate((100), (101)) == (1));
assert(candidate((30), (5)) == (4));
assert(candidate((31), (5)) == (3));
}
| [
"\n}"
] |
HumanEval_51_remove_vowels | cpp | #include<assert.h>
#include<bits/stdc++.h>
// remove_vowelsは文字列を引数に取り、母音を除いた文字列を返す関数である。
// >>> remove_vowels((""))
// ("")
// >>> remove_vowels(("abcdef"))
// ("bcdf")
// >>> remove_vowels(("aaaaa"))
// ("")
// >>> remove_vowels(("aaBAA"))
// ("B")
// >>> remove_vowels(("zbcd"))
// ("zbcd")
std::string remove_vowels(std::string text) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py | reworded | }
int main() {
auto candidate = remove_vowels;
assert(candidate(("")) == (""));
assert(candidate(("abcdef\nghijklm")) == ("bcdf\nghjklm"));
assert(candidate(("fedcba")) == ("fdcb"));
assert(candidate(("eeeee")) == (""));
assert(candidate(("acBAA")) == ("cB"));
assert(candidate(("EcBOO")) == ("cB"));
assert(candidate(("ybcd")) == ("ybcd"));
}
| [
"\n}"
] |
HumanEval_52_below_threshold | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リスト l 内の全ての数値が閾値 t 未満の場合、trueを返す。
// >>> below_threshold((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100))
// (true)
// >>> below_threshold((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5))
// (false)
bool below_threshold(std::vector<long> l, long t) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py | reworded | }
int main() {
auto candidate = below_threshold;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5)) == (false));
assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (21)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (22)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (11)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (10)) == (false));
}
| [
"\n}"
] |
HumanEval_53_add | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つの数xとyを足す
// >>> add((2), (3))
// (5)
// >>> add((5), (7))
// (12)
long add(long x, long y) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py | reworded | }
int main() {
auto candidate = add;
assert(candidate((0), (1)) == (1));
assert(candidate((1), (0)) == (1));
assert(candidate((2), (3)) == (5));
assert(candidate((5), (7)) == (12));
assert(candidate((7), (5)) == (12));
}
| [
"\n}"
] |
HumanEval_54_same_chars | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つの単語が同じ文字セットから構成されるかどうか判定する。
// >>> same_chars(("eabcdzzzz"), ("dddzzzzzzzddeddabc"))
// (true)
// >>> same_chars(("abcd"), ("dddddddabc"))
// (true)
// >>> same_chars(("dddddddabc"), ("abcd"))
// (true)
// >>> same_chars(("eabcd"), ("dddddddabc"))
// (false)
// >>> same_chars(("abcd"), ("dddddddabce"))
// (false)
// >>> same_chars(("eabcdzzzz"), ("dddzzzzzzzddddabc"))
// (false)
bool same_chars(std::string s0, std::string s1) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py | reworded | }
int main() {
auto candidate = same_chars;
assert(candidate(("eabcdzzzz"), ("dddzzzzzzzddeddabc")) == (true));
assert(candidate(("abcd"), ("dddddddabc")) == (true));
assert(candidate(("dddddddabc"), ("abcd")) == (true));
assert(candidate(("eabcd"), ("dddddddabc")) == (false));
assert(candidate(("abcd"), ("dddddddabcf")) == (false));
assert(candidate(("eabcdzzzz"), ("dddzzzzzzzddddabc")) == (false));
assert(candidate(("aabb"), ("aaccc")) == (false));
}
| [
"\n}"
] |
HumanEval_55_fib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// n番目のフィボナッチ数を返す。
// >>> fib((10))
// (55)
// >>> fib((1))
// (1)
// >>> fib((8))
// (21)
long fib(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py | reworded | }
int main() {
auto candidate = fib;
assert(candidate((10)) == (55));
assert(candidate((1)) == (1));
assert(candidate((8)) == (21));
assert(candidate((11)) == (89));
assert(candidate((12)) == (144));
}
| [
"\n}"
] |
HumanEval_56_correct_bracketing | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数bracketsは"<"と">"の文字列である。
// すべての開き括弧が対応する閉じ括弧を持つ場合、trueを返す。
// >>> correct_bracketing(("<"))
// (false)
// >>> correct_bracketing(("<>"))
// (true)
// >>> correct_bracketing(("<<><>>"))
// (true)
// >>> correct_bracketing(("><<>"))
// (false)
bool correct_bracketing(std::string brackets) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_56_correct_bracketing.py | reworded | }
int main() {
auto candidate = correct_bracketing;
assert(candidate(("<>")) == (true));
assert(candidate(("<<><>>")) == (true));
assert(candidate(("<><><<><>><>")) == (true));
assert(candidate(("<><><<<><><>><>><<><><<>>>")) == (true));
assert(candidate(("<<<><>>>>")) == (false));
assert(candidate(("><<>")) == (false));
assert(candidate(("<")) == (false));
assert(candidate(("<<<<")) == (false));
assert(candidate((">")) == (false));
assert(candidate(("<<>")) == (false));
assert(candidate(("<><><<><>><>><<>")) == (false));
assert(candidate(("<><><<><>><>>><>")) == (false));
}
| [
"\n}"
] |
HumanEval_57_monotonic | cpp | #include<assert.h>
#include<bits/stdc++.h>
// リストの要素が単調増加または単調減少する場合にtrueを返す。
// >>> monotonic((std::vector<long>({(long)1, (long)2, (long)4, (long)20})))
// (true)
// >>> monotonic((std::vector<long>({(long)1, (long)20, (long)4, (long)10})))
// (false)
// >>> monotonic((std::vector<long>({(long)4, (long)1, (long)0, (long)-10})))
// (true)
bool monotonic(std::vector<long> l) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_57_monotonic.py | reworded | }
int main() {
auto candidate = monotonic;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)20}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10}))) == (false));
assert(candidate((std::vector<long>({(long)4, (long)1, (long)0, (long)-10}))) == (true));
assert(candidate((std::vector<long>({(long)4, (long)1, (long)1, (long)0}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)5, (long)60}))) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)60}))) == (true));
assert(candidate((std::vector<long>({(long)9, (long)9, (long)9, (long)9}))) == (true));
}
| [
"\n}"
] |
HumanEval_58_common | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つのリストについて、ユニークな共通要素をソートして返す。
// >>> common((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121})))
// (std::vector<long>({(long)1, (long)5, (long)653}))
// >>> common((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2})))
// (std::vector<long>({(long)2, (long)3}))
std::vector<long> common(std::vector<long> l1, std::vector<long> l2) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_58_common.py | reworded | }
int main() {
auto candidate = common;
assert(candidate((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121}))) == (std::vector<long>({(long)1, (long)5, (long)653})));
assert(candidate((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2}))) == (std::vector<long>({(long)2, (long)3})));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2, (long)4}))) == (std::vector<long>({(long)2, (long)3, (long)4})));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>())) == (std::vector<long>()));
}
| [
"\n}"
] |
HumanEval_59_largest_prime_factor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// nの最大となる素因数を返す。ただし、 n > 1 を前提とし、素数ではないものとする。
// >>> largest_prime_factor((13195))
// (29)
// >>> largest_prime_factor((2048))
// (2)
long largest_prime_factor(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py | reworded | }
int main() {
auto candidate = largest_prime_factor;
assert(candidate((15)) == (5));
assert(candidate((27)) == (3));
assert(candidate((63)) == (7));
assert(candidate((330)) == (11));
assert(candidate((13195)) == (29));
}
| [
"\n}"
] |
HumanEval_60_sum_to_n | cpp | #include<assert.h>
#include<bits/stdc++.h>
// sum_to_nは1からnまでの総和を求める関数である。
// >>> sum_to_n((30))
// (465)
// >>> sum_to_n((100))
// (5050)
// >>> sum_to_n((5))
// (15)
// >>> sum_to_n((10))
// (55)
// >>> sum_to_n((1))
// (1)
long sum_to_n(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py | reworded | }
int main() {
auto candidate = sum_to_n;
assert(candidate((1)) == (1));
assert(candidate((6)) == (21));
assert(candidate((11)) == (66));
assert(candidate((30)) == (465));
assert(candidate((100)) == (5050));
}
| [
"\n}"
] |
HumanEval_61_correct_bracketing | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 引数bracketsは"("と") "からなる文字列である。
// すべての開き括弧が対応する閉じ括弧を持つ場合、trueを返す。
// >>> correct_bracketing(("("))
// (false)
// >>> correct_bracketing(("()"))
// (true)
// >>> correct_bracketing(("(()())"))
// (true)
// >>> correct_bracketing((")(()"))
// (false)
bool correct_bracketing(std::string brackets) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py | reworded | }
int main() {
auto candidate = correct_bracketing;
assert(candidate(("()")) == (true));
assert(candidate(("(()())")) == (true));
assert(candidate(("()()(()())()")) == (true));
assert(candidate(("()()((()()())())(()()(()))")) == (true));
assert(candidate(("((()())))")) == (false));
assert(candidate((")(()")) == (false));
assert(candidate(("(")) == (false));
assert(candidate(("((((")) == (false));
assert(candidate((")")) == (false));
assert(candidate(("(()")) == (false));
assert(candidate(("()()(()())())(()")) == (false));
assert(candidate(("()()(()())()))()")) == (false));
}
| [
"\n}"
] |
HumanEval_62_derivative | cpp | #include<assert.h>
#include<bits/stdc++.h>
// xsは多項式の係数列を表す。
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// 関数は、この多項式の導関数を同じ形式で返す。
// >>> derivative((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (std::vector<long>({(long)1, (long)4, (long)12, (long)20}))
// >>> derivative((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)6}))
std::vector<long> derivative(std::vector<long> xs) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py | reworded | }
int main() {
auto candidate = derivative;
assert(candidate((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5}))) == (std::vector<long>({(long)1, (long)4, (long)12, (long)20})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)6})));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (std::vector<long>({(long)2, (long)2})));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)1, (long)0, (long)4}))) == (std::vector<long>({(long)2, (long)2, (long)0, (long)16})));
assert(candidate((std::vector<long>({(long)1}))) == (std::vector<long>()));
}
| [
"\n}"
] |
HumanEval_63_fibfib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// FibFib数列はフィボナッチ数列に似た数列で、以下のように定義される：
// fibfib(0) == 0
// fibfib(1) == 0
// fibfib(2) == 1
// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
// fibfib数列のn番目の要素を効率よく計算する関数を書いてください。
// >>> fibfib((1))
// (0)
// >>> fibfib((5))
// (4)
// >>> fibfib((8))
// (24)
long fibfib(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py | reworded | }
int main() {
auto candidate = fibfib;
assert(candidate((2)) == (1));
assert(candidate((1)) == (0));
assert(candidate((5)) == (4));
assert(candidate((8)) == (24));
assert(candidate((10)) == (81));
assert(candidate((12)) == (274));
assert(candidate((14)) == (927));
}
| [
"\n}"
] |
HumanEval_64_vowels_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 単語を表す文字列を引数とし、その文字列に含まれる母音の数を返す
// 関数 vowels_count を書きなさい。この場合の母音は'a', 'e', 'i', 'o', 'u'である。
// ここで、与えられた単語の末尾にある場合のみ、'y'も母音とする。
// 例::
// >>> vowels_count(("abcde"))
// (2)
// >>> vowels_count(("ACEDY"))
// (3)
long vowels_count(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py | reworded | }
int main() {
auto candidate = vowels_count;
assert(candidate(("abcde")) == (2));
assert(candidate(("Alone")) == (3));
assert(candidate(("key")) == (2));
assert(candidate(("bye")) == (1));
assert(candidate(("keY")) == (2));
assert(candidate(("bYe")) == (1));
assert(candidate(("ACEDY")) == (3));
}
| [
"\n}"
] |
HumanEval_65_circular_shift | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数 x の桁を循環シフトする。shift 分だけ桁を右にシフトし、結果を文字列として返す。
// もし、shift > 桁数なら、桁を反転して返す。
// >>> circular_shift((12), (1))
// ("21")
// >>> circular_shift((12), (2))
// ("12")
std::string circular_shift(long x, long shift) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_65_circular_shift.py | reworded | }
int main() {
auto candidate = circular_shift;
assert(candidate((100), (2)) == ("001"));
assert(candidate((12), (2)) == ("12"));
assert(candidate((97), (8)) == ("79"));
assert(candidate((12), (1)) == ("21"));
assert(candidate((11), (101)) == ("11"));
}
| [
"\n}"
] |
HumanEval_66_digitSum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// タスク
// 文字列を引数にとり、英大文字のみのASCIIコードの和を返す関数を書く。
// Examples:
// >>> digitSum((""))
// (0)
// >>> digitSum(("abAB"))
// (131)
// >>> digitSum(("abcCd"))
// (67)
// >>> digitSum(("helloE"))
// (69)
// >>> digitSum(("woArBld"))
// (131)
// >>> digitSum(("aAaaaXa"))
// (153)
long digitSum(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py | reworded | }
int main() {
auto candidate = digitSum;
assert(candidate(("")) == (0));
assert(candidate(("abAB")) == (131));
assert(candidate(("abcCd")) == (67));
assert(candidate(("helloE")) == (69));
assert(candidate(("woArBld")) == (131));
assert(candidate(("aAaaaXa")) == (153));
assert(candidate((" How are yOu?")) == (151));
assert(candidate(("You arE Very Smart")) == (327));
}
| [
"\n}"
] |
HumanEval_67_fruit_distribution | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この課題では、果物の入ったカゴに配られたリンゴとオレンジの数を表す文字列が
// 与えられ、このカゴにはリンゴ、オレンジ、マンゴーの果実が入っている。オレンジ
// とリンゴの総数を表す文字列と、かごの中の果物の総数を表す整数が与えられたら、
// かごの中のマンゴーの果物の数を返しなさい。
// たとえば:
// >>> fruit_distribution(("5 apples and 6 oranges"), (19))
// (8)
// >>> fruit_distribution(("0 apples and 1 oranges"), (3))
// (2)
// >>> fruit_distribution(("2 apples and 3 oranges"), (100))
// (95)
// >>> fruit_distribution(("100 apples and 1 oranges"), (120))
// (19)
long fruit_distribution(std::string s, long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_67_fruit_distribution.py | reworded | }
int main() {
auto candidate = fruit_distribution;
assert(candidate(("5 apples and 6 oranges"), (19)) == (8));
assert(candidate(("5 apples and 6 oranges"), (21)) == (10));
assert(candidate(("0 apples and 1 oranges"), (3)) == (2));
assert(candidate(("1 apples and 0 oranges"), (3)) == (2));
assert(candidate(("2 apples and 3 oranges"), (100)) == (95));
assert(candidate(("2 apples and 3 oranges"), (5)) == (0));
assert(candidate(("1 apples and 100 oranges"), (120)) == (19));
}
| [
"\n}"
] |
HumanEval_68_pluck | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 非負整数のノードを持つ木の枝を表す配列が与えられたとする。あなたの仕事は、
// ノードの1つを抜き取り、それを返すことである。
// 摘出されるノードは、最小偶数値を持つノードでなければならない。
// 同じ最小偶数値を持つノードが複数見つかった場合は、最小のインデックスを持つ
// ノードを返す。
// 摘出されたノードは [ smalest_value, its index ] というリストで返されなければならない。
// 偶数値がない場合や与えられた配列が空の場合は [] を返します。
// 例 1:
// >>> pluck((std::vector<long>({(long)4, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// 解説: 2は最小偶数値を持ち、最小インデックスを持つ。
// 例 2:
// >>> pluck((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// 解説: 2が最小偶数値で、2が最小インデックスを持つ。
// 例 3:
// >>> pluck((std::vector<long>()))
// (std::vector<long>())
// 例 4:
// >>> pluck((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2})))
// (std::vector<long>({(long)0, (long)1}))
// 解説: 0は最小値だが、0は2つあるので、最小インデックスを持つ最初の0を選ぶ。
// 制約:
// * 1 <= ノードの長さ <= 10000
// * 0 <= ノードの値 2:
std::vector<long> pluck(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_68_pluck.py | reworded | }
int main() {
auto candidate = pluck;
assert(candidate((std::vector<long>({(long)4, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2}))) == (std::vector<long>({(long)0, (long)1})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)0, (long)5, (long)3}))) == (std::vector<long>({(long)0, (long)3})));
assert(candidate((std::vector<long>({(long)5, (long)4, (long)8, (long)4, (long)8}))) == (std::vector<long>({(long)4, (long)1})));
assert(candidate((std::vector<long>({(long)7, (long)6, (long)7, (long)1}))) == (std::vector<long>({(long)6, (long)1})));
assert(candidate((std::vector<long>({(long)7, (long)9, (long)7, (long)1}))) == (std::vector<long>()));
}
| [
"\n}"
] |
HumanEval_69_search | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数の空でないリストが与えられる。0より大きく、その整数自身の値以上の頻度を
// 持つ最大の整数を返せ。整数の頻度とは、それがリストに現れる回数である。
// のような値が存在しない場合は -1 を返す。
// 例:
// >>> search((std::vector<long>({(long)4, (long)1, (long)2, (long)2, (long)3, (long)1})))
// (2)
// >>> search((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)3, (long)4, (long)4, (long)4})))
// (3)
// >>> search((std::vector<long>({(long)5, (long)5, (long)4, (long)4, (long)4})))
// (-1)
long search(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_69_search.py | reworded | }
int main() {
auto candidate = search;
assert(candidate((std::vector<long>({(long)5, (long)5, (long)5, (long)5, (long)1}))) == (1));
assert(candidate((std::vector<long>({(long)4, (long)1, (long)4, (long)1, (long)4, (long)4}))) == (4));
assert(candidate((std::vector<long>({(long)3, (long)3}))) == (-1));
assert(candidate((std::vector<long>({(long)8, (long)8, (long)8, (long)8, (long)8, (long)8, (long)8, (long)8}))) == (8));
assert(candidate((std::vector<long>({(long)2, (long)3, (long)3, (long)2, (long)2}))) == (2));
assert(candidate((std::vector<long>({(long)2, (long)7, (long)8, (long)8, (long)4, (long)8, (long)7, (long)3, (long)9, (long)6, (long)5, (long)10, (long)4, (long)3, (long)6, (long)7, (long)1, (long)7, (long)4, (long)10, (long)8, (long)1}))) == (1));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)8, (long)2}))) == (2));
assert(candidate((std::vector<long>({(long)6, (long)7, (long)1, (long)8, (long)8, (long)10, (long)5, (long)8, (long)5, (long)3, (long)10}))) == (1));
assert(candidate((std::vector<long>({(long)8, (long)8, (long)3, (long)6, (long)5, (long)6, (long)4}))) == (-1));
assert(candidate((std::vector<long>({(long)6, (long)9, (long)6, (long)7, (long)1, (long)4, (long)7, (long)1, (long)8, (long)8, (long)9, (long)8, (long)10, (long)10, (long)8, (long)4, (long)10, (long)4, (long)10, (long)1, (long)2, (long)9, (long)5, (long)7, (long)9}))) == (1));
assert(candidate((std::vector<long>({(long)1, (long)9, (long)10, (long)1, (long)3}))) == (1));
assert(candidate((std::vector<long>({(long)6, (long)9, (long)7, (long)5, (long)8, (long)7, (long)5, (long)3, (long)7, (long)5, (long)10, (long)10, (long)3, (long)6, (long)10, (long)2, (long)8, (long)6, (long)5, (long)4, (long)9, (long)5, (long)3, (long)10}))) == (5));
assert(candidate((std::vector<long>({(long)1}))) == (1));
assert(candidate((std::vector<long>({(long)8, (long)8, (long)10, (long)6, (long)4, (long)3, (long)5, (long)8, (long)2, (long)4, (long)2, (long)8, (long)4, (long)6, (long)10, (long)4, (long)2, (long)1, (long)10, (long)2, (long)1, (long)1, (long)5}))) == (4));
assert(candidate((std::vector<long>({(long)2, (long)10, (long)4, (long)8, (long)2, (long)10, (long)5, (long)1, (long)2, (long)9, (long)5, (long)5, (long)6, (long)3, (long)8, (long)6, (long)4, (long)10}))) == (2));
assert(candidate((std::vector<long>({(long)1, (long)6, (long)10, (long)1, (long)6, (long)9, (long)10, (long)8, (long)6, (long)8, (long)7, (long)3}))) == (1));
assert(candidate((std::vector<long>({(long)9, (long)2, (long)4, (long)1, (long)5, (long)1, (long)5, (long)2, (long)5, (long)7, (long)7, (long)7, (long)3, (long)10, (long)1, (long)5, (long)4, (long)2, (long)8, (long)4, (long)1, (long)9, (long)10, (long)7, (long)10, (long)2, (long)8, (long)10, (long)9, (long)4}))) == (4));
assert(candidate((std::vector<long>({(long)2, (long)6, (long)4, (long)2, (long)8, (long)7, (long)5, (long)6, (long)4, (long)10, (long)4, (long)6, (long)3, (long)7, (long)8, (long)8, (long)3, (long)1, (long)4, (long)2, (long)2, (long)10, (long)7}))) == (4));
assert(candidate((std::vector<long>({(long)9, (long)8, (long)6, (long)10, (long)2, (long)6, (long)10, (long)2, (long)7, (long)8, (long)10, (long)3, (long)8, (long)2, (long)6, (long)2, (long)3, (long)1}))) == (2));
assert(candidate((std::vector<long>({(long)5, (long)5, (long)3, (long)9, (long)5, (long)6, (long)3, (long)2, (long)8, (long)5, (long)6, (long)10, (long)10, (long)6, (long)8, (long)4, (long)10, (long)7, (long)7, (long)10, (long)8}))) == (-1));
assert(candidate((std::vector<long>({(long)10}))) == (-1));
assert(candidate((std::vector<long>({(long)9, (long)7, (long)7, (long)2, (long)4, (long)7, (long)2, (long)10, (long)9, (long)7, (long)5, (long)7, (long)2}))) == (2));
assert(candidate((std::vector<long>({(long)5, (long)4, (long)10, (long)2, (long)1, (long)1, (long)10, (long)3, (long)6, (long)1, (long)8}))) == (1));
assert(candidate((std::vector<long>({(long)7, (long)9, (long)9, (long)9, (long)3, (long)4, (long)1, (long)5, (long)9, (long)1, (long)2, (long)1, (long)1, (long)10, (long)7, (long)5, (long)6, (long)7, (long)6, (long)7, (long)7, (long)6}))) == (1));
assert(candidate((std::vector<long>({(long)3, (long)10, (long)10, (long)9, (long)2}))) == (-1));
}
| [
"\n}"
] |
HumanEval_70_strange_sort_list | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数のリストが与えられたとき、リストを奇妙な順序で返す。
// 奇妙なソートとは、最小値から始まり、残りの整数の最大値、最小値の順で
// ソートすることである。
// 例:
// >>> strange_sort_list((std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)1, (long)4, (long)2, (long)3}))
// >>> strange_sort_list((std::vector<long>({(long)5, (long)5, (long)5, (long)5})))
// (std::vector<long>({(long)5, (long)5, (long)5, (long)5}))
// >>> strange_sort_list((std::vector<long>()))
// (std::vector<long>())
std::vector<long> strange_sort_list(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py | reworded | }
int main() {
auto candidate = strange_sort_list;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)4, (long)2, (long)3})));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)7, (long)8, (long)9}))) == (std::vector<long>({(long)5, (long)9, (long)6, (long)8, (long)7})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == (std::vector<long>({(long)1, (long)5, (long)2, (long)4, (long)3})));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)7, (long)8, (long)9, (long)1}))) == (std::vector<long>({(long)1, (long)9, (long)5, (long)8, (long)6, (long)7})));
assert(candidate((std::vector<long>({(long)5, (long)5, (long)5, (long)5}))) == (std::vector<long>({(long)5, (long)5, (long)5, (long)5})));
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8}))) == (std::vector<long>({(long)1, (long)8, (long)2, (long)7, (long)3, (long)6, (long)4, (long)5})));
assert(candidate((std::vector<long>({(long)0, (long)2, (long)2, (long)2, (long)5, (long)5, (long)-5, (long)-5}))) == (std::vector<long>({(long)-5, (long)5, (long)-5, (long)5, (long)0, (long)2, (long)2, (long)2})));
assert(candidate((std::vector<long>({(long)111111}))) == (std::vector<long>({(long)111111})));
}
| [
"\n}"
] |
HumanEval_71_triangle_area | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 三角形の3辺の長さが与えられた。3辺が有効な三角形を形成していれば、
// 三角形の面積を小数点以下2桁で四捨五入して返す。そうでない場合は-1を
// 返す。
// 任意の2辺の和が3辺より大きいとき、3辺は有効な三角形となる。
// 例:
// >>> triangle_area((3), (4), (5))
// (6.0f)
// >>> triangle_area((1), (2), (10))
// (float(-1))
float triangle_area(long a, long b, long c) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py | reworded | }
int main() {
auto candidate = triangle_area;
assert(candidate((3), (4), (5)) == (6.0f));
assert(candidate((1), (2), (10)) == (float(-1)));
assert(candidate((4), (8), (5)) == (8.18f));
assert(candidate((2), (2), (2)) == (1.73f));
assert(candidate((1), (2), (3)) == (float(-1)));
assert(candidate((10), (5), (7)) == (16.25f));
assert(candidate((2), (6), (3)) == (float(-1)));
assert(candidate((1), (1), (1)) == (0.43f));
assert(candidate((2), (2), (10)) == (float(-1)));
}
| [
"\n}"
] |
HumanEval_72_will_it_fly | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 物体qが飛べばtrueを、そうでなければfalseを返す関数を書け。
// 物体qはバランスが取れていて（つまり、リストが回文であって）、その要素の和が
// 最大荷重w以下であれば飛ぶ。
// 例:
// >>> will_it_fly((std::vector<long>({(long)1, (long)2})), (5))
// (false)
// # 1+2 は最大荷重以下であるが、バランスが取れていない
// >>> will_it_fly((std::vector<long>({(long)3, (long)2, (long)3})), (1))
// (false)
// # バランスが取れているが、3+2+3 は最大荷重を超える
// >>> will_it_fly((std::vector<long>({(long)3, (long)2, (long)3})), (9))
// (true)
// # 3+2+3 は最大荷重以下であり、バランスも取れている
// >>> will_it_fly((std::vector<long>({(long)3})), (5))
// (true)
// # 3 は最大荷重以下であり、バランスも取れている
bool will_it_fly(std::vector<long> q, long w) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py | reworded | }
int main() {
auto candidate = will_it_fly;
assert(candidate((std::vector<long>({(long)3, (long)2, (long)3})), (9)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2})), (5)) == (false));
assert(candidate((std::vector<long>({(long)3})), (5)) == (true));
assert(candidate((std::vector<long>({(long)3, (long)2, (long)3})), (1)) == (false));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3})), (6)) == (false));
assert(candidate((std::vector<long>({(long)5})), (5)) == (true));
}
| [
"\n}"
] |
HumanEval_73_smallest_change | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数の配列arrが与えられたとき、その配列を回文配列にするために
// 必要な要素の最小数を求めよ。回文配列とは、前からも後からも同じ
// ようになる配列のことである。1回の変更で、1つの要素を他の任意の
// 要素に変更できる。
// 例えば:
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6})))
// (4)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2})))
// (1)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1})))
// (0)
long smallest_change(std::vector<long> arr) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py | reworded | }
int main() {
auto candidate = smallest_change;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6}))) == (4));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2}))) == (1));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)2}))) == (1));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)4, (long)2}))) == (1));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1}))) == (0));
assert(candidate((std::vector<long>({(long)3, (long)1, (long)1, (long)3}))) == (0));
assert(candidate((std::vector<long>({(long)1}))) == (0));
assert(candidate((std::vector<long>({(long)0, (long)1}))) == (1));
}
| [
"\n}"
] |
HumanEval_74_total_match | cpp | #include<assert.h>
#include<bits/stdc++.h>
// ２つの文字列リストを受け取り、リストの全文字数の合計がもう一方
// のリストより少ないリストを返す関数を書きなさい。
// もし2つのリストの文字数が同じなら、最初のリストを返す。
// 例
// >>> total_match((std::vector<std::string>()), (std::vector<std::string>()))
// (std::vector<std::string>())
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"})))
// (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"}))
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi", (std::string)"admin", (std::string)"project"})))
// (std::vector<std::string>({(std::string)"hi", (std::string)"admin"}))
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"})))
// (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"}))
// >>> total_match((std::vector<std::string>({(std::string)"4"})), (std::vector<std::string>({(std::string)"1", (std::string)"2", (std::string)"3", (std::string)"4", (std::string)"5"})))
// (std::vector<std::string>({(std::string)"4"}))
std::vector<std::string> total_match(std::vector<std::string> lst1, std::vector<std::string> lst2) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py | reworded | }
int main() {
auto candidate = total_match;
assert(candidate((std::vector<std::string>()), (std::vector<std::string>())) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"hi"})));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi", (std::string)"admin", (std::string)"project"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"admin"})));
assert(candidate((std::vector<std::string>({(std::string)"4"})), (std::vector<std::string>({(std::string)"1", (std::string)"2", (std::string)"3", (std::string)"4", (std::string)"5"}))) == (std::vector<std::string>({(std::string)"4"})));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"}))) == (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"})));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"}))) == (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"})));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hii"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"admin"})));
assert(candidate((std::vector<std::string>()), (std::vector<std::string>({(std::string)"this"}))) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"this"})), (std::vector<std::string>())) == (std::vector<std::string>()));
}
| [
"\n}"
] |
HumanEval_75_is_multiply_prime | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 与えられた数が3つの素数の掛け算であればtrueを、そうでなければfalseを返す
// 関数を書きなさい。
// 引数 aは100以下を既知としていよい。
// 例:
// >>> is_multiply_prime((30))
// (true)
// 30 = 2 * 3 * 5
bool is_multiply_prime(long a) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | reworded | }
int main() {
auto candidate = is_multiply_prime;
assert(candidate((5)) == (false));
assert(candidate((30)) == (true));
assert(candidate((8)) == (true));
assert(candidate((10)) == (false));
assert(candidate((125)) == (true));
assert(candidate((105)) == (true));
assert(candidate((126)) == (false));
assert(candidate((729)) == (false));
assert(candidate((891)) == (false));
assert(candidate((1001)) == (true));
}
| [
"\n}"
] |
HumanEval_76_is_simple_power | cpp | #include<assert.h>
#include<bits/stdc++.h>
// あなたのタスクは、ある数xがnの単純なべき乗である場合にtrueを、
// それ以外の場合にfalseを返す関数を書くことである。
// xは、n**int=xのとき、nの単純なべき乗である。
// 例えば:
// >>> is_simple_power((1), (4))
// (true)
// >>> is_simple_power((2), (2))
// (true)
// >>> is_simple_power((8), (2))
// (true)
// >>> is_simple_power((3), (2))
// (false)
// >>> is_simple_power((3), (1))
// (false)
// >>> is_simple_power((5), (3))
// (false)
bool is_simple_power(long x, long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py | reworded | }
int main() {
auto candidate = is_simple_power;
assert(candidate((16), (2)) == (true));
assert(candidate((143214), (16)) == (false));
assert(candidate((4), (2)) == (true));
assert(candidate((9), (3)) == (true));
assert(candidate((16), (4)) == (true));
assert(candidate((24), (2)) == (false));
assert(candidate((128), (4)) == (false));
assert(candidate((12), (6)) == (false));
assert(candidate((1), (1)) == (true));
assert(candidate((1), (12)) == (true));
}
| [
"\n}"
] |
HumanEval_77_iscube | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数aを受け取り、この整数がある整数の3乗である場合にtrue
// を返す関数を書きなさい。
// 注意：入力は常に処理可能であると仮定してよい。
// 例:
// >>> iscube((1))
// (true)
// >>> iscube((2))
// (false)
// >>> iscube((-1))
// (true)
// >>> iscube((64))
// (true)
// >>> iscube((0))
// (true)
// >>> iscube((180))
// (false)
bool iscube(long a) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | reworded | }
int main() {
auto candidate = iscube;
assert(candidate((1)) == (true));
assert(candidate((2)) == (false));
assert(candidate((-1)) == (true));
assert(candidate((64)) == (true));
assert(candidate((180)) == (false));
assert(candidate((1000)) == (true));
assert(candidate((0)) == (true));
assert(candidate((1729)) == (false));
}
| [
"\n}"
] |
HumanEval_78_hex_key | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 16進数の数字を文字列として受け取り、その中に含まれる素数である16進数の桁数を
// カウントする関数を作成するタスクが与えられました。素数とは、1より大きく、
// 2つのより小さい自然数の積でない自然数です。
// 16進数の桁には0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, Fがあります。
// 素数としては2, 3, 5, 7, 11, 13, 17,...があります。
// したがって、次の数字のいずれかがいくつあるかを判定する必要があります：
// 2, 3, 5, 7, B（=10進数で11）, D（=10進数で13）
// 注意：入力は常に正確、または空の文字列であり、記号A, B, C, D, E, Fは常に
// 大文字であると仮定してよいです。
// 例：
// >>> hex_key(("AB"))
// (1)
// >>> hex_key(("1077E"))
// (2)
// >>> hex_key(("ABED1A33"))
// (4)
// >>> hex_key(("123456789ABCDEF0"))
// (6)
// >>> hex_key(("2020"))
// (2)
long hex_key(std::string num) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py | reworded | }
int main() {
auto candidate = hex_key;
assert(candidate(("AB")) == (1));
assert(candidate(("1077E")) == (2));
assert(candidate(("ABED1A33")) == (4));
assert(candidate(("2020")) == (2));
assert(candidate(("123456789ABCDEF0")) == (6));
assert(candidate(("112233445566778899AABBCCDDEEFF00")) == (12));
}
| [
"\n}"
] |
HumanEval_79_decimal_to_binary | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 10進数形式の数値が与えられ、あなたのタスクはそれを2進数形式に変換することである。
// この関数は、文字列を返し、その各文字は2進数を表す。文字列の各文字は'0'か'1'である。
// なお、文字列の最初と最後には'db'という余分な文字をつける。
// この文字は書式を助けるためにある。
// 例:
// >>> decimal_to_binary((15))
// ("db1111db")
// >>> decimal_to_binary((32))
// ("db100000db")
std::string decimal_to_binary(long decimal) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py | reworded | }
int main() {
auto candidate = decimal_to_binary;
assert(candidate((0)) == ("db0db"));
assert(candidate((32)) == ("db100000db"));
assert(candidate((103)) == ("db1100111db"));
assert(candidate((15)) == ("db1111db"));
}
| [
"\n}"
] |
HumanEval_80_is_happy | cpp | #include<assert.h>
#include<bits/stdc++.h>
// あなたは文字列sが与えられる。
// あなたのタスクは、その文字列が幸せかどうかをチェックすることである。
// 文字列は幸せとは、文字列の長さが少なくとも3以上で、連続する3文字がすべて異なる場合である。
// 例えば:
// >>> is_happy(("a"))
// (false)
// >>> is_happy(("aa"))
// (false)
// >>> is_happy(("abcd"))
// (true)
// >>> is_happy(("aabb"))
// (false)
// >>> is_happy(("adb"))
// (true)
// >>> is_happy(("xyy"))
// (false)
bool is_happy(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py | reworded | }
int main() {
auto candidate = is_happy;
assert(candidate(("a")) == (false));
assert(candidate(("aa")) == (false));
assert(candidate(("abcd")) == (true));
assert(candidate(("aabb")) == (false));
assert(candidate(("adb")) == (true));
assert(candidate(("xyy")) == (false));
assert(candidate(("iopaxpoi")) == (true));
assert(candidate(("iopaxioi")) == (false));
}
| [
"\n}"
] |
HumanEval_81_numerical_letter_grade | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 学期最終週、教師は生徒に成績をつけなければならない。教師は独自のアルゴリズムで採点している。
// 問題は、彼女が成績評価に使ったコードを紛失してしまったことです。
// 彼女は何人かの生徒のGPAのリストをあなたに渡したので、あなたは次の表を使って評点のリストを
// 出力できる関数を書くことになりました。
// GPA | 評点
// 4.0 A+
// > 3.7 A
// > 3.3 A-
// > 3.0 B+
// > 2.7 B
// > 2.3 B-
// > 2.0 C+
// > 1.7 C
// > 1.3 C-
// > 1.0 D+
// > 0.7 D
// > 0.0 D-
// 0.0 E
// 例:
// >>> grade_equation((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f})))
// (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"}))
std::vector<std::string> numerical_letter_grade(std::vector<float> grades) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py | reworded | }
int main() {
auto candidate = numerical_letter_grade;
assert(candidate((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f}))) == (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"})));
assert(candidate((std::vector<float>({(float)1.2f}))) == (std::vector<std::string>({(std::string)"D+"})));
assert(candidate((std::vector<float>({(float)0.5f}))) == (std::vector<std::string>({(std::string)"D-"})));
assert(candidate((std::vector<float>({(float)0.0f}))) == (std::vector<std::string>({(std::string)"E"})));
assert(candidate((std::vector<float>({(float)1.0f, (float)0.3f, (float)1.5f, (float)2.8f, (float)3.3f}))) == (std::vector<std::string>({(std::string)"D", (std::string)"D-", (std::string)"C-", (std::string)"B", (std::string)"B+"})));
assert(candidate((std::vector<float>({(float)0.0f, (float)0.7f}))) == (std::vector<std::string>({(std::string)"E", (std::string)"D-"})));
}
| [
"\n}"
] |
HumanEval_82_prime_length | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列を受け取り、文字列の長さが素数であればtrueを、そうでなければfalseを返す関数を書く。
// 例
// >>> prime_length(("Hello"))
// (true)
// >>> prime_length(("abcdcba"))
// (true)
// >>> prime_length(("kittens"))
// (true)
// >>> prime_length(("orange"))
// (false)
bool prime_length(std::string string) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | reworded | }
int main() {
auto candidate = prime_length;
assert(candidate(("Hello")) == (true));
assert(candidate(("abcdcba")) == (true));
assert(candidate(("kittens")) == (true));
assert(candidate(("orange")) == (false));
assert(candidate(("wow")) == (true));
assert(candidate(("world")) == (true));
assert(candidate(("MadaM")) == (true));
assert(candidate(("Wow")) == (true));
assert(candidate(("")) == (false));
assert(candidate(("HI")) == (true));
assert(candidate(("go")) == (true));
assert(candidate(("gogo")) == (false));
assert(candidate(("aaaaaaaaaaaaaaa")) == (false));
assert(candidate(("Madam")) == (true));
assert(candidate(("M")) == (false));
assert(candidate(("0")) == (false));
}
| [
"\n}"
] |
HumanEval_83_starts_one_ends | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数 n が与えられたとき、n 桁の正の整数で 1 で始まるか
// もしくは終わる数のカウントを返す
long starts_one_ends(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py | reworded | }
int main() {
auto candidate = starts_one_ends;
assert(candidate((1)) == (1));
assert(candidate((2)) == (18));
assert(candidate((3)) == (180));
assert(candidate((4)) == (1800));
assert(candidate((5)) == (18000));
}
| [
"\n}"
] |
HumanEval_84_solve | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数 N が与えられた時、その桁の総和を2進数で返す。
// 例
// >>> solve((1000))
// ("1")
// >>> solve((150))
// ("110")
// >>> solve((147))
// ("1100")
// 数:
// @N 整数
// 制約: 0 ≤ N ≤ 10000.
// 返り値:
// 2進数表記の文字列
std::string solve(long N) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | reworded | }
int main() {
auto candidate = solve;
assert(candidate((1000)) == ("1"));
assert(candidate((150)) == ("110"));
assert(candidate((147)) == ("1100"));
assert(candidate((333)) == ("1001"));
assert(candidate((963)) == ("10010"));
}
| [
"\n}"
] |
HumanEval_85_add | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 空でない整数のリストlstが与えられたとき、奇数のインデックスにある偶数の要素を加える。
// 例:
// >>> add((std::vector<long>({(long)4, (long)2, (long)6, (long)7})))
// (2)
long add(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | reworded | }
int main() {
auto candidate = add;
assert(candidate((std::vector<long>({(long)4, (long)88}))) == (88));
assert(candidate((std::vector<long>({(long)4, (long)5, (long)6, (long)7, (long)2, (long)122}))) == (122));
assert(candidate((std::vector<long>({(long)4, (long)0, (long)6, (long)7}))) == (0));
assert(candidate((std::vector<long>({(long)4, (long)4, (long)6, (long)8}))) == (12));
}
| [
"\n}"
] |
HumanEval_86_anti_shuffle | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列を引数として受け取り、その「順序付けられたバージョン」を返す関数を作成してください。
// 順序付けられたバージョンとは、各単語（空白で区切られた）の文字がASCII値に基づいて昇順に
// 並べ替えられた新しい単語に置き換えられた文字列です。
// 注意：文章内の単語と空白の順序はそのまま保ってください。
// 例えば：
// >>> anti_shuffle(("Hi"))
// ("Hi")
// >>> anti_shuffle(("hello"))
// ("ehllo")
// >>> anti_shuffle(("Hello World!!!"))
// ("Hello !!!Wdlor")
std::string anti_shuffle(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py | reworded | }
int main() {
auto candidate = anti_shuffle;
assert(candidate(("Hi")) == ("Hi"));
assert(candidate(("hello")) == ("ehllo"));
assert(candidate(("number")) == ("bemnru"));
assert(candidate(("abcd")) == ("abcd"));
assert(candidate(("Hello World!!!")) == ("Hello !!!Wdlor"));
assert(candidate(("")) == (""));
assert(candidate(("Hi. My name is Mister Robot. How are you?")) == (".Hi My aemn is Meirst .Rboot How aer ?ouy"));
}
| [
"\n}"
] |
HumanEval_87_get_row | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2次元のデータがネストされたリストとして与えられる。これは行列に似ているが、
// 列とは異なり、各行は異なる数の列を含むことができる。
// lstと整数xが与えられたとき、リスト内の整数xを見つけ、各タプルが0から始まる
// 座標（行、列）であるようなタプルのリスト[(x1, y1), (x2, y2) ...]を返す。
// 座標を最初は行の昇順でソートする。
// また、行の座標を列の降順でソートする。
// 例:
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)}))
// >>> get_row((std::vector<std::vector<long>>()), (1))
// (std::vector<std::tuple<long, long>>())
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)}))
std::vector<std::tuple<long, long>> get_row(std::vector<std::vector<long>> lst, long x) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py | reworded | }
int main() {
auto candidate = get_row;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})})), (2)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 1), (std::tuple<long, long>)std::make_tuple(1, 1), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(3, 1), (std::tuple<long, long>)std::make_tuple(4, 1), (std::tuple<long, long>)std::make_tuple(5, 1)})));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)1, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)1, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(2, 0), (std::tuple<long, long>)std::make_tuple(3, 2), (std::tuple<long, long>)std::make_tuple(3, 0), (std::tuple<long, long>)std::make_tuple(4, 3), (std::tuple<long, long>)std::make_tuple(4, 0), (std::tuple<long, long>)std::make_tuple(5, 4), (std::tuple<long, long>)std::make_tuple(5, 0), (std::tuple<long, long>)std::make_tuple(6, 5), (std::tuple<long, long>)std::make_tuple(6, 0)})));
assert(candidate((std::vector<std::vector<long>>()), (1)) == (std::vector<std::tuple<long, long>>()));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1})})), (2)) == (std::vector<std::tuple<long, long>>()));
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)})));
}
| [
"\n}"
] |
HumanEval_88_sort_array | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 非負の整数からなる配列が与えられた場合、配列をソートしたコピーを返してください。
// 配列の最初の要素と最後の要素の和が奇数であれば、配列を昇順（小さい順）にソートします。
// その和が偶数であれば、配列を降順（大きい順）にソートします。
// 注意点：
// * 与えられた配列自体を変更しないでください。
// 例:
// >>> sort_array((std::vector<long>()))
// (std::vector<long>())
// >>> sort_array((std::vector<long>({(long)5})))
// (std::vector<long>({(long)5}))
// >>> sort_array((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5})))
// (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4, (long)5}))
// >>> sort_array((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5, (long)6})))
// (std::vector<long>({(long)6, (long)5, (long)4, (long)3, (long)2, (long)1, (long)0}))
std::vector<long> sort_array(std::vector<long> array) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py | reworded | }
int main() {
auto candidate = sort_array;
assert(candidate((std::vector<long>())) == (std::vector<long>()));
assert(candidate((std::vector<long>({(long)5}))) == (std::vector<long>({(long)5})));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5}))) == (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4, (long)5})));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5, (long)6}))) == (std::vector<long>({(long)6, (long)5, (long)4, (long)3, (long)2, (long)1, (long)0})));
assert(candidate((std::vector<long>({(long)2, (long)1}))) == (std::vector<long>({(long)1, (long)2})));
assert(candidate((std::vector<long>({(long)15, (long)42, (long)87, (long)32, (long)11, (long)0}))) == (std::vector<long>({(long)0, (long)11, (long)15, (long)32, (long)42, (long)87})));
assert(candidate((std::vector<long>({(long)21, (long)14, (long)23, (long)11}))) == (std::vector<long>({(long)23, (long)21, (long)14, (long)11})));
}
| [
"\n}"
] |
HumanEval_89_encrypt | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列を引数にとり、アルファベットを回転させて暗号化した
// 文字列を返す関数encryptを作成せよ。
// アルファベットは、文字位置が2を2倍した4文字分だけ後ろにシフトされるように
// 回転する。
// 例:
// >>> encrypt(("hi"))
// ("lm")
// >>> encrypt(("asdfghjkl"))
// ("ewhjklnop")
// >>> encrypt(("gf"))
// ("kj")
// >>> encrypt(("et"))
// ("ix")
std::string encrypt(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py | reworded | }
int main() {
auto candidate = encrypt;
assert(candidate(("hi")) == ("lm"));
assert(candidate(("asdfghjkl")) == ("ewhjklnop"));
assert(candidate(("gf")) == ("kj"));
assert(candidate(("et")) == ("ix"));
assert(candidate(("faewfawefaewg")) == ("jeiajeaijeiak"));
assert(candidate(("hellomyfriend")) == ("lippsqcjvmirh"));
assert(candidate(("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh")) == ("hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl"));
assert(candidate(("a")) == ("e"));
}
| [
"\n}"
] |
HumanEval_90_next_smallest | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数のリストが与えられる。
// リストの2番目に小さい要素を返す関数 next_smallest() を書きなさい。
// そのような要素がない場合は None を返す。
// >>> next_smallest((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5})))
// 2
// >>> next_smallest((std::vector<long>({(long)5, (long)1, (long)4, (long)3, (long)2})))
// 2
// >>> next_smallest((std::vector<long>()))
// std::nullopt
// >>> next_smallest((std::vector<long>({(long)1, (long)1})))
// std::nullopt
std::optional<long> next_smallest(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_90_next_smallest.py | reworded | }
int main() {
auto candidate = next_smallest;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == 2);
assert(candidate((std::vector<long>({(long)5, (long)1, (long)4, (long)3, (long)2}))) == 2);
assert(candidate((std::vector<long>())) == std::nullopt);
assert(candidate((std::vector<long>({(long)1, (long)1}))) == std::nullopt);
assert(candidate((std::vector<long>({(long)1, (long)1, (long)1, (long)1, (long)0}))) == 1);
assert(candidate((std::vector<long>({(long)1, (long)1}))) == std::nullopt);
assert(candidate((std::vector<long>({(long)-35, (long)34, (long)12, (long)-45}))) == -35);
}
| [
"\n}"
] |
HumanEval_91_is_bored | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 単語の文字列が与えられ、あなたのタスクは退屈指数を数える
// ことである。退屈指数とは、"I "で始まる文のことである。
// 文は'.'、’?’、'!'のいずれかで区切られる。
// 例えば::
// >>> is_bored(("Hello world"))
// (0)
// >>> is_bored(("The sky is blue. The sun is shining. I love this weather"))
// (1)
long is_bored(std::string S) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py | reworded | }
int main() {
auto candidate = is_bored;
assert(candidate(("Hello world")) == (0));
assert(candidate(("Is the sky blue?")) == (0));
assert(candidate(("I love It !")) == (1));
assert(candidate(("bIt")) == (0));
assert(candidate(("I feel good today. I will be productive. will kill It")) == (2));
assert(candidate(("You and I are going for a walk")) == (0));
}
| [
"\n}"
] |
HumanEval_92_any_int | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 3つの数値を受け取る関数を作る。
// 1つの数値が他の2つの数値の和と等しく、すべての数値が整数である場合にtrueを返す。
// それ以外の場合はfalseを返す。
// 例
// >>> any_int((float(5)), (float(2)), (float(7)))
// (true)
// >>> any_int((float(3)), (float(2)), (float(2)))
// (false)
// >>> any_int((float(3)), (float(-2)), (float(1)))
// (true)
// >>> any_int((3.6f), (-2.2f), (float(2)))
// (false)
bool any_int(float x, float y, float z) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | reworded | }
int main() {
auto candidate = any_int;
assert(candidate((float(2)), (float(3)), (float(1))) == (true));
assert(candidate((2.5f), (float(2)), (float(3))) == (false));
assert(candidate((1.5f), (float(5)), (3.5f)) == (false));
assert(candidate((float(2)), (float(6)), (float(2))) == (false));
assert(candidate((float(4)), (float(2)), (float(2))) == (true));
assert(candidate((2.2f), (2.2f), (2.2f)) == (false));
assert(candidate((float(-4)), (float(6)), (float(2))) == (true));
assert(candidate((float(2)), (float(1)), (float(1))) == (true));
assert(candidate((float(3)), (float(4)), (float(7))) == (true));
assert(candidate((3.0f), (float(4)), (float(7))) == (false));
}
| [
"\n}"
] |
HumanEval_93_encode | cpp | #include<assert.h>
#include<bits/stdc++.h>
// メッセージを受け取り、すべての文字の大文字と小文字を入れ替え、
// メッセージ中のすべての母音を英語の母音の2つ前に現れる文字に置
// き換えるようにエンコードする関数を書きなさい。
// 文字だけを想定する。
// 例
// s:
// >>> encode(("test"))
// ("TGST")
// >>> encode(("This is a message"))
// ("tHKS KS C MGSSCGG")
std::string encode(std::string message) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py | reworded | }
int main() {
auto candidate = encode;
assert(candidate(("TEST")) == ("tgst"));
assert(candidate(("Mudasir")) == ("mWDCSKR"));
assert(candidate(("YES")) == ("ygs"));
assert(candidate(("This is a message")) == ("tHKS KS C MGSSCGG"));
assert(candidate(("I DoNt KnOw WhAt tO WrItE")) == ("k dQnT kNqW wHcT Tq wRkTg"));
}
| [
"\n}"
] |
HumanEval_94_skjkasdkd | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 整数のリストが与えらる。
// 最大の素数を求め、その桁数の和を返す必要がある。
// 例:
// >>> skjkasdkd((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3})))
// (10)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1})))
// (25)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3})))
// (13)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6})))
// (11)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21})))
// (3)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7})))
// (7)
long skjkasdkd(std::vector<long> lst) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | reworded | }
int main() {
auto candidate = skjkasdkd;
assert(candidate((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3}))) == (10));
assert(candidate((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1}))) == (25));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3}))) == (13));
assert(candidate((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6}))) == (11));
assert(candidate((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21}))) == (3));
assert(candidate((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7}))) == (7));
assert(candidate((std::vector<long>({(long)8191}))) == (19));
assert(candidate((std::vector<long>({(long)8191, (long)123456, (long)127, (long)7}))) == (19));
assert(candidate((std::vector<long>({(long)127, (long)97, (long)8192}))) == (10));
}
| [
"\n}"
] |
HumanEval_95_check_dict_case | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 辞書が与えられたとき、すべてのキーが小文字であればtrueを、
// すべてのキーが大文字の文字列であればfalseを返す。
// 与えられた辞書が空の場合、この関数は false を返す。
// 例:
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {"b", "banana"}})))
// (true)
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {"A", "banana"}, {"B", "banana"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {8, "banana"}, {"a", "apple"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"STATE", "NC"}, {"ZIP", "12345"}})))
// (true)
bool check_dict_case(std::map<std::string,std::string> dict) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py | reworded | }
int main() {
auto candidate = check_dict_case;
assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"b", "banana"}}))) == (true));
assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"A", "banana"}, {"B", "banana"}}))) == (false));
assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"5", "banana"}, {"a", "apple"}}))) == (false));
assert(candidate((std::map<std::string,std::string>({{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}}))) == (false));
assert(candidate((std::map<std::string,std::string>({{"STATE", "NC"}, {"ZIP", "12345"}}))) == (true));
assert(candidate((std::map<std::string,std::string>({{"fruit", "Orange"}, {"taste", "Sweet"}}))) == (true));
assert(candidate((std::map<std::string,std::string>())) == (false));
}
| [
"\n}"
] |
HumanEval_96_count_up_to | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 非負整数を受け取り、素数でnより小さい最初のn個の
// 整数の配列を返す関数を実装せよ。
// 例えば:
// >>> count_up_to((5))
// (std::vector<long>({(long)2, (long)3}))
// >>> count_up_to((11))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7}))
// >>> count_up_to((0))
// (std::vector<long>())
// >>> count_up_to((20))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19}))
// >>> count_up_to((1))
// (std::vector<long>())
// >>> count_up_to((18))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17}))
std::vector<long> count_up_to(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py | reworded | }
int main() {
auto candidate = count_up_to;
assert(candidate((5)) == (std::vector<long>({(long)2, (long)3})));
assert(candidate((6)) == (std::vector<long>({(long)2, (long)3, (long)5})));
assert(candidate((7)) == (std::vector<long>({(long)2, (long)3, (long)5})));
assert(candidate((10)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7})));
assert(candidate((0)) == (std::vector<long>()));
assert(candidate((22)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19})));
assert(candidate((1)) == (std::vector<long>()));
assert(candidate((18)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17})));
assert(candidate((47)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19, (long)23, (long)29, (long)31, (long)37, (long)41, (long)43})));
assert(candidate((101)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19, (long)23, (long)29, (long)31, (long)37, (long)41, (long)43, (long)47, (long)53, (long)59, (long)61, (long)67, (long)71, (long)73, (long)79, (long)83, (long)89, (long)97})));
}
| [
"\n}"
] |
HumanEval_97_multiply | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 2つの整数を受け取り、その１の位の数の積を返す関数を完成させよ。
// 入力は常に有効範囲にあるとする。
// 例:
// >>> multiply((148), (412))
// (16)
// >>> multiply((19), (28))
// (72)
// >>> multiply((2020), (1851))
// (0)
// >>> multiply((14), (-15))
// (20)
long multiply(long a, long b) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | reworded | }
int main() {
auto candidate = multiply;
assert(candidate((148), (412)) == (16));
assert(candidate((19), (28)) == (72));
assert(candidate((2020), (1851)) == (0));
assert(candidate((14), (-15)) == (20));
assert(candidate((76), (67)) == (42));
assert(candidate((17), (27)) == (49));
assert(candidate((0), (1)) == (0));
assert(candidate((0), (0)) == (0));
}
| [
"\n}"
] |
HumanEval_98_count_upper | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 文字列 s が与えられたとき、偶数のインデックスに含まれる大文字の母音の数を数える。
// 例えば:
// >>> count_upper(("aBCdEf"))
// (1)
// >>> count_upper(("abcdefg"))
// (0)
// >>> count_upper(("dBBE"))
// (0)
long count_upper(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | reworded | }
int main() {
auto candidate = count_upper;
assert(candidate(("aBCdEf")) == (1));
assert(candidate(("abcdefg")) == (0));
assert(candidate(("dBBE")) == (0));
assert(candidate(("B")) == (0));
assert(candidate(("U")) == (1));
assert(candidate(("")) == (0));
assert(candidate(("EEEE")) == (2));
}
| [
"\n}"
] |
HumanEval_99_closest_integer | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 数値を表す文字列valueを受け取り、それに最も近い整数を返す関数を作る。
// その数値が2つの整数から等距離にある場合は、ゼロから四捨五入する。
// 例s
// >>> closest_integer(("10"))
// (10)
// >>> closest_integer(("15.3"))
// (15)
// Note:
// ゼロからの四捨五入とは、与えられた数値が2つの整数から
// 等距離にある場合、ゼロから遠い方を返すという意味である。
// 例えば、 close_integer("14.5")は15を返し、closest_integer("-14.5")は-15を返す。
long closest_integer(std::string value) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py | reworded | }
int main() {
auto candidate = closest_integer;
assert(candidate(("10")) == (10));
assert(candidate(("14.5")) == (15));
assert(candidate(("-15.5")) == (-16));
assert(candidate(("15.3")) == (15));
assert(candidate(("0")) == (0));
}
| [
"\n}"
] |
HumanEval_100_make_a_pile | cpp | #include<assert.h>
#include<bits/stdc++.h>
// 正の整数nが与えられたとき、n段の石の山を作らなければならない。
// 最初の段にはn個の石がある。
// 次の段の石の数は
// - nが奇数なら次の奇数。
// - nが偶数なら次の偶数。
// 各段の石の数をリストで返す。インデックス i の要素は、段 (i+1) の石の
// 数を表すものとする。
// 例:s:
// >>> make_a_pile((3))
// (std::vector<long>({(long)3, (long)5, (long)7}))
std::vector<long> make_a_pile(long n) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_100_make_a_pile.py | reworded | }
int main() {
auto candidate = make_a_pile;
assert(candidate((3)) == (std::vector<long>({(long)3, (long)5, (long)7})));
assert(candidate((4)) == (std::vector<long>({(long)4, (long)6, (long)8, (long)10})));
assert(candidate((5)) == (std::vector<long>({(long)5, (long)7, (long)9, (long)11, (long)13})));
assert(candidate((6)) == (std::vector<long>({(long)6, (long)8, (long)10, (long)12, (long)14, (long)16})));
assert(candidate((8)) == (std::vector<long>({(long)8, (long)10, (long)12, (long)14, (long)16, (long)18, (long)20, (long)22})));
}
| [
"\n}"
] |
HumanEval_101_words_string | cpp | #include<assert.h>
#include<bits/stdc++.h>
// カンマまたは空白で区切られた単語の文字列が与えられる。あなたのタスクは、
// 文字列を単語に分割し、単語の配列を返すことである。
// 例えば:
// >>> words_string(("Hi, my name is John"))
// (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"}))
// >>> words_string(("One, two, three, four, five, six"))
// (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"}))
std::vector<std::string> words_string(std::string s) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_101_words_string.py | reworded | }
int main() {
auto candidate = words_string;
assert(candidate(("Hi, my name is John")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"})));
assert(candidate(("One, two, three, four, five, six")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
assert(candidate(("Hi, my name")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name"})));
assert(candidate(("One,, two, three, four, five, six,")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
assert(candidate(("")) == (std::vector<std::string>()));
assert(candidate(("ahmed , gamal")) == (std::vector<std::string>({(std::string)"ahmed", (std::string)"gamal"})));
}
| [
"\n}"
] |
HumanEval_102_choose_num | cpp | #include<assert.h>
#include<bits/stdc++.h>
// この関数は2つの正の数xとyを受け取り、範囲[x, y]（両端を含む）に含まれる
// 最大の偶数整数を返す。そのような数がない場合、関数は-1を返す。
// 例えば:
// >>> choose_num((12), (15))
// (14)
// >>> choose_num((13), (12))
// (-1)
long choose_num(long x, long y) {
| transform | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_102_choose_num.py | reworded | }
int main() {
auto candidate = choose_num;
assert(candidate((12), (15)) == (14));
assert(candidate((13), (12)) == (-1));
assert(candidate((33), (12354)) == (12354));
assert(candidate((5234), (5233)) == (-1));
assert(candidate((6), (29)) == (28));
assert(candidate((27), (10)) == (-1));
assert(candidate((7), (7)) == (-1));
assert(candidate((546), (546)) == (546));
}
| [
"\n}"
] |
Subsets and Splits