name stringclasses 161
values | language stringclasses 22
values | prompt stringlengths 40 2.27k | doctests stringclasses 3
values | original stringclasses 956
values | prompt_terminology stringclasses 2
values | tests stringlengths 125 5.35k | stop_tokens listlengths 1 7 |
|---|---|---|---|---|---|---|---|
HumanEval_82_prime_length | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a string and returns True if the string
// length is a prime number or False otherwise
// Examples
bool prime_length(std::string string) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | verbatim | }
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));
... | [
"\n}"
] |
HumanEval_84_solve | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
std::string solve(long N) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | verbatim | }
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>
// Given a non-empty list of integers lst. add the even elements that are at odd indices..
// Examples:
long add(std::vector<long> lst) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | verbatim | }
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));
as... | [
"\n}"
] |
HumanEval_86_anti_shuffle | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a string and returns an ordered version of it.
// Ordered version of string, is a string where all words (separated by space)
// are replaced by a new word where all the characters arranged in
// ascending order based on ascii value.
// Note: You... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py | verbatim | }
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(("... | [
"\n}"
] |
HumanEval_87_get_row | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a 2 dimensional data, as a nested lists,
// which is similar to matrix, however, unlike matrices,
// each row may contain a different number of columns.
// Given lst, and integer x, find integers x in the list,
// and return list of tuples, [(x1, y1), (x2, y2)... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py | verbatim | }
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<lo... | [
"\n}"
] |
HumanEval_88_sort_array | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given an array of non-negative integers, return a copy of the given array after sorting,
// you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
// or sort it in descending order if the sum( first index value, last index ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py | verbatim | }
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::vecto... | [
"\n}"
] |
HumanEval_89_encrypt | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function encrypt that takes a string as an argument and
// returns a string encrypted with the alphabet being rotated.
// The alphabet should be rotated in a manner such that the letters
// shift down by two multiplied to two places.
// For example:
std::string e... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py | verbatim | }
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(("hellomyfrie... | [
"\n}"
] |
HumanEval_8_sum_product | cpp | #include<assert.h>
#include<bits/stdc++.h>
// For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
// Empty sum should be equal to 0 and empty product should be equal to 1.
std::tuple<long, long> sum_product(std::vector<long> numbers) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | verbatim | }
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)));
... | [
"\n}"
] |
HumanEval_90_next_smallest | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a list of integers.
// Write a function next_smallest() that returns the 2nd smallest element of the list.
// Return None if there is no such element.
std::optional<long> next_smallest(std::vector<long> lst) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_90_next_smallest.py | verbatim | }
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(cand... | [
"\n}"
] |
HumanEval_91_is_bored | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You'll be given a string of words, and your task is to count the number
// of boredoms. A boredom is a sentence that starts with the word "I".
// Sentences are delimited by '.', '?' or '!'.
// For example:
long is_bored(std::string S) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py | verbatim | }
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));
... | [
"\n}"
] |
HumanEval_92_any_int | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function that takes 3 numbers.
// Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
// Returns false in any other cases.
// Examples
bool any_int(float x, float y, float z) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | verbatim | }
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));
asse... | [
"\n}"
] |
HumanEval_93_encode | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a message, and encodes in such a
// way that it swaps case of all letters, replaces all vowels in
// the message with the letter that appears 2 places ahead of that
// vowel in the english alphabet.
// Assume only letters.
// Examples:
std::... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py | verbatim | }
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 kN... | [
"\n}"
] |
HumanEval_94_skjkasdkd | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a list of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
long skjkasdkd(std::vector<long> lst) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | verbatim | }
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(can... | [
"\n}"
] |
HumanEval_95_check_dict_case | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a dictionary, return True if all keys are strings in lower
// case or all keys are strings in upper case, else return False.
// The function should return False is the given dictionary is empty.
// Examples:
bool check_dict_case(std::map<std::string,std::string> dict... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py | verbatim | }
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<... | [
"\n}"
] |
HumanEval_96_count_up_to | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Implement a function that takes an non-negative integer and returns an array of the first n
// integers that are prime numbers and less than n.
// for example:
std::vector<long> count_up_to(long n) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py | verbatim | }
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::vect... | [
"\n}"
] |
HumanEval_97_multiply | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Complete the function that takes two integers and returns
// the product of their unit digits.
// Assume the input is always valid.
// Examples:
long multiply(long a, long b) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_98_count_upper | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string s, count the number of uppercase vowels in even indices.
// For example:
long count_upper(std::string s) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | verbatim | }
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>
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidi... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py | verbatim | }
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_9_rolling_max | cpp | #include<assert.h>
#include<bits/stdc++.h>
// From a given list of integers, generate a list of rolling maximum element found until given moment
// in the sequence.
std::vector<long> rolling_max(std::vector<long> numbers) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_0_has_close_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Check if in given vector of numbers, are any two numbers closer to each other than
// given 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, (fl... | transform | /home/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}))... | [
"\n}"
] |
HumanEval_100_make_a_pile | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, you have to make a pile of n levels of stones.
// The first level has n stones.
// The number of stones in the next level is:
// - the next odd number if n is odd.
// - the next even number if n is even.
// Return the number of stones in each lev... | transform | /home/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})));
... | [
"\n}"
] |
HumanEval_101_words_string | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You will be given a string of words separated by commas or spaces. Your task is
// to split the string into words and return a vector of the words.
// For example:
// >>> words_string(("Hi, my name is John"))
// (std::vector<std::string>({(std::string)"Hi", (std::string)"my... | transform | /home/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>({(s... | [
"\n}"
] |
HumanEval_102_choose_num | cpp | #include<assert.h>
#include<bits/stdc++.h>
// This function takes two positive numbers x and y and returns the
// biggest even integer number that is in the range [x, y] inclusive. If
// there's no such number, then the function should return -1.
// For example:
// >>> choose_num((12), (15))
// (14)
// >>> choose_num(... | transform | /home/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));
a... | [
"\n}"
] |
HumanEval_103_rounded_avg | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_std_string_long{
std::string f0;
long f1; Union_std_string_long(std::string _f0) : f0(_f0) {}
Union_std_string_long(long _f1) : f1(_f1) {}
~Union_std_string_long() {}
bool operator==(std::string f) {
return f0 == f ;
} bool ope... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_103_rounded_avg.py | reworded | }
int main() {
auto candidate = rounded_avg;
assert(candidate((1), (5)) == "0b11");
assert(candidate((7), (13)) == "0b1010");
assert(candidate((964), (977)) == "0b1111001010");
assert(candidate((996), (997)) == "0b1111100100");
assert(candidate((560), (851)) == "0b1011000010");
assert(candid... | [
"\n}"
] |
HumanEval_104_unique_digits | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of positive integers x. return a sorted vector of all
// elements that hasn't any even digit.
// Note: Returned vector should be sorted in increasing order.
// For example:
// >>> unique_digits((std::vector<long>({(long)15, (long)33, (long)1422, (long)1})))
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py | reworded | }
int main() {
auto candidate = unique_digits;
assert(candidate((std::vector<long>({(long)15, (long)33, (long)1422, (long)1}))) == (std::vector<long>({(long)1, (long)15, (long)33})));
assert(candidate((std::vector<long>({(long)152, (long)323, (long)1422, (long)10}))) == (std::vector<long>()));
assert(ca... | [
"\n}"
] |
HumanEval_105_by_length | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting vector, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// >>> by... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | reworded | }
int main() {
auto candidate = by_length;
assert(candidate((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3}))) == (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (... | [
"\n}"
] |
HumanEval_106_f | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Implement the function f that takes n as a parameter,
// and returns a vector of size n, such that the value of the element at index i is the factorial of i if i is even
// or the sum of numbers from 1 to i otherwise.
// i starts from 1.
// the factorial of i is the multipl... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | reworded | }
int main() {
auto candidate = f;
assert(candidate((5)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15})));
assert(candidate((7)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15, (long)720, (long)28})));
assert(candidate((1)) == (std::vector<long>({(long)1})))... | [
"\n}"
] |
HumanEval_107_even_odd_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a tuple that has the number of even and odd
// integer palindromes that fall within the range(1, n), inclusive.
// Example 1:
// >>> even_odd_palindrome((3))
// (std::make_tuple(1, 2))
// Explanation:
// Integer palindrome are 1, 2, 3. one... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | reworded | }
int main() {
auto candidate = even_odd_palindrome;
assert(candidate((123)) == (std::make_tuple(8, 13)));
assert(candidate((12)) == (std::make_tuple(4, 6)));
assert(candidate((3)) == (std::make_tuple(1, 2)));
assert(candidate((63)) == (std::make_tuple(6, 8)));
assert(candidate((25)) == (std::ma... | [
"\n}"
] |
HumanEval_108_count_nums | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function count_nums which takes a vector of integers and returns
// the number of elements which has a sum of digits > 0.
// If a number is negative, then its first signed digit will be negative:
// e.g. -123 has signed digits -1, 2, and 3.
// >>> count_nums((std::v... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | reworded | }
int main() {
auto candidate = count_nums;
assert(candidate((std::vector<long>())) == (0));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)0}))) == (0));
assert(candidate((std::vector<long>({(long)1, (long)1, (long)2, (long)-2, (long)3, (long)4, (long)5}))) == (6));
assert(candidate... | [
"\n}"
] |
HumanEval_109_move_one_ball | cpp | #include<assert.h>
#include<bits/stdc++.h>
// We have a vector 'arr' of N integers arr[1], arr[2], ..., arr[N].The
// numbers in the vector will be randomly ordered. Your task is to determine if
// it is possible to get a vector sorted in non-decreasing order by performing
// the following operation on the given vecto... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | reworded | }
int main() {
auto candidate = move_one_ball;
assert(candidate((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)3, (long)5, (long)10, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)1... | [
"\n}"
] |
HumanEval_10_make_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// ... | transform | /home/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_110_exchange | cpp | #include<assert.h>
#include<bits/stdc++.h>
// In this problem, you will implement a function that takes two vectors of numbers,
// and determines whether it is possible to perform an exchange of elements
// between them to make lst1 a vector of only even numbers.
// There is no limit on the number of exchanged elements... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded | }
int main() {
auto candidate = exchange;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == ("YES"));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)5, (lon... | [
"\n}"
] |
HumanEval_111_histogram | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string representing a space separated lowercase letters, return a map
// of the letter with the most repetition and containing the corresponding count.
// If several letters have the same occurrence, return all of them.
// Example:
// >>> histogram(("a b c"))
// (st... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded | }
int main() {
auto candidate = histogram;
assert(candidate(("a b b a")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c a b")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c d g")) == (std::map<std::string,long>({{"a", 1}, {"b", 1}, {"c... | [
"\n}"
] |
HumanEval_112_reverse_delete | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Task
// We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
// then check if the result string is palindrome.
// A string is called palindrome if it reads the same backward as forward.
// You should return a tup... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded | }
int main() {
auto candidate = reverse_delete;
assert(candidate(("abcde"), ("ae")) == (std::make_tuple("bcd", false)));
assert(candidate(("abcdef"), ("b")) == (std::make_tuple("acdef", false)));
assert(candidate(("abcdedcba"), ("ab")) == (std::make_tuple("cdedc", true)));
assert(candidate(("dwik"),... | [
"\n}"
] |
HumanEval_113_odd_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of strings, where each string consists of only digits, return a vector.
// Each element i of the output should be "the number of odd elements in the
// string i of the input." where all the i's should be replaced by the number
// of odd digits in the i'th str... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded | }
int main() {
auto candidate = odd_count;
assert(candidate((std::vector<std::string>({(std::string)"1234567"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."})));
assert(candidate((std::vector<std::string>({(std::string)"3", (std::string)"11111111"})... | [
"\n}"
] |
HumanEval_114_minSubArraySum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of integers nums, find the minimum sum of any non-empty sub-vector
// of nums.
// Example
// >>> minSubArraySum((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4})))
// (1)
// >>> minSubArraySum((std::vector<long>({(long)-1, (long)-2, (... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded | }
int main() {
auto candidate = minSubArraySum;
assert(candidate((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4}))) == (1));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3}))) == (-6));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3, (long)... | [
"\n}"
] |
HumanEval_115_max_fill | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it,
// and all buckets have the same capacity.
// Your tas... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded | }
int main() {
auto candidate = max_fill;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (lo... | [
"\n}"
] |
HumanEval_116_sort_array | cpp | #include<assert.h>
#include<bits/stdc++.h>
// In this Kata, you have to sort a vector of non-negative integers according to
// number of ones in their binary representation in ascending order.
// For similar number of ones, sort based on decimal value.
// It must be implemented like this:
// >>> sort_array((std::vector... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | reworded | }
int main() {
auto candidate = sort_array;
assert(candidate((std::vector<long>({(long)1, (long)5, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5})));
assert(candidate((std::vector<long>({(long)-2, (long)-3, (long)-4, (long)-5, (long)-6}))) == (std::vector<l... | [
"\n}"
] |
HumanEval_117_select_words | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string s and a natural number n, you have been tasked to implement
// a function that returns a vector of all words from string s that contain exactly
// n consonants, in order these words appear in the string s.
// If the string s is empty then the function shoul... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded | }
int main() {
auto candidate = select_words;
assert(candidate(("Mary had a little lamb"), (4)) == (std::vector<std::string>({(std::string)"little"})));
assert(candidate(("Mary had a little lamb"), (3)) == (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"})));
assert(candidate(("simple... | [
"\n}"
] |
HumanEval_118_get_closest_vowel | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a word. Your task is to find the closest vowel that stands between
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condi... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded | }
int main() {
auto candidate = get_closest_vowel;
assert(candidate(("yogurt")) == ("u"));
assert(candidate(("full")) == ("u"));
assert(candidate(("easy")) == (""));
assert(candidate(("eAsy")) == (""));
assert(candidate(("ali")) == (""));
assert(candidate(("bad")) == ("a"));
assert(candi... | [
"\n}"
] |
HumanEval_119_match_parens | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of two strings, both strings consist of open
// parentheses '(' or close parentheses ')' only.
// Your job is to check if it is possible to concatenate the two strings in
// some order, that the resulting string will be good.
// A string S is consider... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded | }
int main() {
auto candidate = match_parens;
assert(candidate((std::vector<std::string>({(std::string)"()(", (std::string)")"}))) == ("Yes"));
assert(candidate((std::vector<std::string>({(std::string)")", (std::string)")"}))) == ("No"));
assert(candidate((std::vector<std::string>({(std::string)"(()(())... | [
"\n}"
] |
HumanEval_11_string_xor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// >>> string_xor(("010"), ("110"))
// ("100")
std::string string_xor(std::string a, std::string b) {
| transform | /home/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_120_maximum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector arr of integers and a positive integer k, return a sorted vector
// of length k with the maximum k numbers in arr.
// Example 1:
// >>> maximum((std::vector<long>({(long)-3, (long)-4, (long)5})), (3))
// (std::vector<long>({(long)-4, (long)-3, (long)5}))
// ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded | }
int main() {
auto candidate = maximum;
assert(candidate((std::vector<long>({(long)-3, (long)-4, (long)5})), (3)) == (std::vector<long>({(long)-4, (long)-3, (long)5})));
assert(candidate((std::vector<long>({(long)4, (long)-4, (long)4})), (2)) == (std::vector<long>({(long)4, (long)4})));
assert(candidat... | [
"\n}"
] |
HumanEval_121_solution | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers, return the sum of all of the odd elements that are in even positions.
// Examples
// >>> solution((std::vector<long>({(long)5, (long)8, (long)7, (long)1})))
// (12)
// >>> solution((std::vector<long>({(long)3, (long)3, (long)3, (long)3,... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded | }
int main() {
auto candidate = solution;
assert(candidate((std::vector<long>({(long)5, (long)8, (long)7, (long)1}))) == (12));
assert(candidate((std::vector<long>({(long)3, (long)3, (long)3, (long)3, (long)3}))) == (9));
assert(candidate((std::vector<long>({(long)30, (long)13, (long)24, (long)321}))) =... | [
"\n}"
] |
HumanEval_122_add_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers arr and an integer k, return
// the sum of the elements with at most two digits from the first k elements of arr.
// Example:
// >>> add_elements((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (l... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded | }
int main() {
auto candidate = add_elements;
assert(candidate((std::vector<long>({(long)1, (long)-2, (long)-3, (long)41, (long)57, (long)76, (long)87, (long)88, (long)99})), (3)) == (-4));
assert(candidate((std::vector<long>({(long)111, (long)121, (long)3, (long)4000, (long)5, (long)6})), (2)) == (0));
... | [
"\n}"
] |
HumanEval_123_get_odd_collatz | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a sorted vector that has the odd numbers in collatz sequence.
// The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
// as follows: start with any positive integer n. Then each term is obtained from the
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded | }
int main() {
auto candidate = get_odd_collatz;
assert(candidate((14)) == (std::vector<long>({(long)1, (long)5, (long)7, (long)11, (long)13, (long)17})));
assert(candidate((5)) == (std::vector<long>({(long)1, (long)5})));
assert(candidate((12)) == (std::vector<long>({(long)1, (long)3, (long)5})));
... | [
"\n}"
] |
HumanEval_124_valid_date | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You have to write a function which validates a given date string and
// returns true if the date is valid otherwise false.
// The date is valid if all of the following rules are satisfied:
// 1. The date string is not empty.
// 2. The number of days is not less than 1 or hi... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded | }
int main() {
auto candidate = valid_date;
assert(candidate(("03-11-2000")) == (true));
assert(candidate(("15-01-2012")) == (false));
assert(candidate(("04-0-2040")) == (false));
assert(candidate(("06-04-2020")) == (true));
assert(candidate(("01-01-2007")) == (true));
assert(candidate(("03-... | [
"\n}"
] |
HumanEval_125_split_words | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_std_vector_std_string__long{
std::vector<std::string> f0;
long f1; Union_std_vector_std_string__long(std::vector<std::string> _f0) : f0(_f0) {}
Union_std_vector_std_string__long(long _f1) : f1(_f1) {}
~Union_std_vector_std_string__long() {}
b... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py | reworded | }
int main() {
auto candidate = split_words;
assert(candidate(("Hello world!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world!"}));
assert(candidate(("Hello,world!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world!"}));
assert(candidate(("Hello world,!"))... | [
"\n}"
] |
HumanEval_126_is_sorted | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of numbers, return whether or not they are sorted
// in ascending order. If vector has more than 1 duplicate of the same
// number, return false. Assume no negative numbers and only integers.
// Examples
// >>> is_sorted((std::vector<long>({(long)5})))
// (tr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded | }
int main() {
auto candidate = is_sorted;
assert(candidate((std::vector<long>({(long)5}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == (true));
assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5}))) == (false));
a... | [
"\n}"
] |
HumanEval_127_intersection | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given two intervals,
// where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
// The given intervals are closed which means that the interval (start, end)
// includes both start and end.
// For each given interval, it is assumed t... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded | }
int main() {
auto candidate = intersection;
assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(2, 3))) == ("NO"));
assert(candidate((std::make_tuple(-1, 1)), (std::make_tuple(0, 4))) == ("NO"));
assert(candidate((std::make_tuple(-3, -1)), (std::make_tuple(-5, 5))) == ("YES"));
assert(candi... | [
"\n}"
] |
HumanEval_128_prod_signs | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a vector arr of integers and you need to return
// sum of magnitudes of integers multiplied by product of all signs
// of each number in the vector, represented by 1, -1 or 0.
// Note: return None for empty arr.
// Example:
// >>> prod_signs((std::vector<long>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | reworded | }
int main() {
auto candidate = prod_signs;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)-4}))) == -9);
assert(candidate((std::vector<long>({(long)0, (long)1}))) == 0);
assert(candidate((std::vector<long>({(long)1, (long)1, (long)1, (long)2, (long)3, (long)-1, (long)1}))) == -10... | [
"\n}"
] |
HumanEval_129_minPath | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a grid with N rows and N columns (N >= 2) and a positive integer k,
// each cell of the grid contains a value. Every integer in the range [1, N * N]
// inclusive appears exactly once on the cells of the grid.
// You have to find the minimum path of length k in the gr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded | }
int main() {
auto candidate = minPath;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)9})})), (3)) == (std::vec... | [
"\n}"
] |
HumanEval_12_longest | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Out of vector of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return None in case the input vector is empty.
// >>> longest((std::vector<std::string>()))
// std::nullopt
// >>> longest((std::vector<std::string>({(s... | transform | /home/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::... | [
"\n}"
] |
HumanEval_130_tri | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
// the last couple centuries. However, what people don't know is Tribonacci sequence.
// Tribonacci sequence is defined by the recurrence:
// tri(1) = 3
// tri(n) = 1 + n / 2, if n is even.
// tr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded | }
int main() {
auto candidate = tri;
assert(candidate((3)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8})));
assert(candidate((4)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3})));
assert(candidate((5)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3... | [
"\n}"
] |
HumanEval_131_digits | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return the product of the odd digits.
// Return 0 if all digits are even.
// For example:
// >>> digits((1))
// (1)
// >>> digits((4))
// (0)
// >>> digits((235))
// (15)
long digits(long n) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded | }
int main() {
auto candidate = digits;
assert(candidate((5)) == (5));
assert(candidate((54)) == (5));
assert(candidate((120)) == (1));
assert(candidate((5014)) == (5));
assert(candidate((98765)) == (315));
assert(candidate((5576543)) == (2625));
assert(candidate((2468)) == (0));
}
| [
"\n}"
] |
HumanEval_132_is_nested | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function that takes a string as input which contains only square brackets.
// The function should return true if and only if there is a valid subsequence of brackets
// where at least one bracket in the subsequence is nested.
// >>> is_nested(("[[]]"))
// (true)
/... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded | }
int main() {
auto candidate = is_nested;
assert(candidate(("[[]]")) == (true));
assert(candidate(("[]]]]]]][[[[[]")) == (false));
assert(candidate(("[][]")) == (false));
assert(candidate(("[]")) == (false));
assert(candidate(("[[[[]]]]")) == (true));
assert(candidate(("[]]]]]]]]]]")) == (f... | [
"\n}"
] |
HumanEval_133_sum_squares | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of numbers.
// You need to return the sum of squared numbers in the given vector,
// round each element in the vector to the upper int(Ceiling) first.
// Examples:
// >>> lst((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})))
// (14)
// >>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded | }
int main() {
auto candidate = sum_squares;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f}))) == (14));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f}))) == (14));
assert(candidate((std::vector<float>({(float)1.0f, (float)3.0f, (float)5.0f, (f... | [
"\n}"
] |
HumanEval_134_check_if_last_char_is_a_letter | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function that returns true if the last character
// of a given string is an alphabetical character and is not
// a part of a word, and false otherwise.
// Note: "word" is a group of characters separated by space.
// Examples:
// >>> check_if_last_char_is_a_letter((... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded | }
int main() {
auto candidate = check_if_last_char_is_a_letter;
assert(candidate(("apple")) == (false));
assert(candidate(("apple pi e")) == (true));
assert(candidate(("eeeee")) == (false));
assert(candidate(("A")) == (true));
assert(candidate(("Pumpkin pie ")) == (false));
assert(candidate(... | [
"\n}"
] |
HumanEval_135_can_arrange | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function which returns the largest index of an element which
// is not greater than or equal to the element immediately preceding it. If
// no such element exists then return -1. The given vector will not contain
// duplicate values.
// Examples:
// >>> can_arrange... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded | }
int main() {
auto candidate = can_arrange;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5}))) == (3));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)5}))) == (-1));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)2, (long)5, (long)... | [
"\n}"
] |
HumanEval_136_largest_smallest_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function that returns a tuple (a, b), where 'a' is
// the largest of negative integers, and 'b' is the smallest
// of positive integers in a vector.
// If there is no negative or positive integers, return them as None.
// Examples:
// >>> largest_smallest_integers(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded | }
int main() {
auto candidate = largest_smallest_integers;
assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)3, (long)5, (long)7}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(1)));
assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)3, (l... | [
"\n}"
] |
HumanEval_137_compare_one | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_long_float_std_string{
long f0;
float f1;
std::string f2; Union_long_float_std_string(long _f0) : f0(_f0) {}
Union_long_float_std_string(float _f1) : f1(_f1) {}
Union_long_float_std_string(std::string _f2) : f2(_f2) {}
~Union_long_float_s... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_137_compare_one.py | reworded | }
int main() {
auto candidate = compare_one;
assert(candidate(1, 2) == 2);
assert(candidate(1, 2.5f) == 2.5f);
assert(candidate(2, 3) == 3);
assert(candidate(5, 6) == 6);
assert(candidate(1, "2,3") == "2,3");
assert(candidate("5,1", "6") == "6");
assert(candidate("1", "2") == "2");
a... | [
"\n}"
] |
HumanEval_138_is_equal_to_sum_even | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
// Example
// >>> is_equal_to_sum_even((4))
// (false)
// >>> is_equal_to_sum_even((6))
// (false)
// >>> is_equal_to_sum_even((8))
// (true)
bool is_equal_to_sum_even(long n) {... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded | }
int main() {
auto candidate = is_equal_to_sum_even;
assert(candidate((4)) == (false));
assert(candidate((6)) == (false));
assert(candidate((8)) == (true));
assert(candidate((10)) == (true));
assert(candidate((11)) == (false));
assert(candidate((12)) == (true));
assert(candidate((13)) =... | [
"\n}"
] |
HumanEval_139_special_factorial | cpp | #include<assert.h>
#include<bits/stdc++.h>
// The Brazilian factorial is defined as:
// brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
// where n > 0
// For example:
// >>> special_factorial((4))
// (288)
// The function will receive an integer as input and should return the special
// factorial of this integ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded | }
int main() {
auto candidate = special_factorial;
assert(candidate((4)) == (288));
assert(candidate((5)) == (34560));
assert(candidate((7)) == (125411328000));
assert(candidate((1)) == (1));
}
| [
"\n}"
] |
HumanEval_13_greatest_common_divisor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return a greatest common divisor of two integers a and b
// >>> greatest_common_divisor((3), (5))
// (1)
// >>> greatest_common_divisor((25), (15))
// (5)
long greatest_common_divisor(long a, long b) {
| transform | /home/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_140_fix_spaces | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string text, replace all spaces in it with underscores,
// and if a string has more than 2 consecutive spaces,
// then replace all consecutive spaces with -
// >>> fix_spaces((" Example"))
// ("Example")
// >>> fix_spaces((" Example 1"))
// ("Example_1")
// >>> f... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded | }
int main() {
auto candidate = fix_spaces;
assert(candidate(("Example")) == ("Example"));
assert(candidate(("Mudasir Hanif ")) == ("Mudasir_Hanif_"));
assert(candidate(("Yellow Yellow Dirty Fellow")) == ("Yellow_Yellow__Dirty__Fellow"));
assert(candidate(("Exa mple")) == ("Exa-mple"));
asse... | [
"\n}"
] |
HumanEval_141_file_name_check | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Create a function which takes a string representing a file's name, and returns
// 'Yes' if the the file's name is valid, and returns 'No' otherwise.
// A file's name is considered to be valid if and only if all the following conditions
// are met:
// - There should not be ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded | }
int main() {
auto candidate = file_name_check;
assert(candidate(("example.txt")) == ("Yes"));
assert(candidate(("1example.dll")) == ("No"));
assert(candidate(("s1sdf3.asd")) == ("No"));
assert(candidate(("K.dll")) == ("Yes"));
assert(candidate(("MY16FILE3.exe")) == ("Yes"));
assert(candida... | [
"\n}"
] |
HumanEval_142_sum_squares | cpp | #include<assert.h>
#include<bits/stdc++.h>
// "
// This function will take a vector of integers. For all entries in the vector, the function shall square the integer entry if its index is a
// multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded | }
int main() {
auto candidate = sum_squares;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (6));
assert(candidate((std::vector<long>({(long)1, (long)4, (long)9}))) == (14));
assert(candidate((std::vector<long>())) == (0));
assert(candidate((std::vector<long>({(long)1, (long)1... | [
"\n}"
] |
HumanEval_143_words_in_sentence | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a string representing a sentence,
// the sentence contains some words separated by a space,
// and you have to return a string that contains the words from the original sentence,
// whose lengths are prime numbers,
// the order of the words in the new string s... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded | }
int main() {
auto candidate = words_in_sentence;
assert(candidate(("This is a test")) == ("is"));
assert(candidate(("lets go for swimming")) == ("go for"));
assert(candidate(("there is no place available here")) == ("there is no place"));
assert(candidate(("Hi I am Hussein")) == ("Hi am Hussein"))... | [
"\n}"
] |
HumanEval_144_simplify | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Your task is to implement a function that will simplify the expression
// x * n. The function returns true if x * n evaluates to a whole number and false
// otherwise. Both x and n, are string representation of a fraction, and have the following format,
// <numerator>/<deno... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded | }
int main() {
auto candidate = simplify;
assert(candidate(("1/5"), ("5/1")) == (true));
assert(candidate(("1/6"), ("2/1")) == (false));
assert(candidate(("5/1"), ("3/1")) == (true));
assert(candidate(("7/10"), ("10/2")) == (false));
assert(candidate(("2/10"), ("50/10")) == (true));
assert(c... | [
"\n}"
] |
HumanEval_145_order_by_points | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function which sorts the given vector of integers
// in ascending order according to the sum of their digits.
// Note: if there are several items with similar sum of their digits,
// order them based on their index in original vector.
// For example:
// >>> order_by... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded | }
int main() {
auto candidate = order_by_points;
assert(candidate((std::vector<long>({(long)1, (long)11, (long)-1, (long)-11, (long)-12}))) == (std::vector<long>({(long)-1, (long)-11, (long)1, (long)-12, (long)11})));
assert(candidate((std::vector<long>({(long)1234, (long)423, (long)463, (long)145, (long)2,... | [
"\n}"
] |
HumanEval_146_specialFilter | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a vector of numbers as input and returns
// the number of elements in the vector that are greater than 10 and both
// first and last digits of a number are odd (1, 3, 5, 7, 9).
// For example:
// >>> specialFilter((std::vector<long>({(long)15, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded | }
int main() {
auto candidate = specialFilter;
assert(candidate((std::vector<long>({(long)5, (long)-2, (long)1, (long)-5}))) == (0));
assert(candidate((std::vector<long>({(long)15, (long)-73, (long)14, (long)-15}))) == (1));
assert(candidate((std::vector<long>({(long)33, (long)-2, (long)-3, (long)45, (l... | [
"\n}"
] |
HumanEval_147_get_max_triples | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a positive integer n. You have to create an integer vector a of length n.
// For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
// Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
// and a[i] + a[j] + a[k] is a multiple of 3.
// E... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded | }
int main() {
auto candidate = get_max_triples;
assert(candidate((5)) == (1));
assert(candidate((6)) == (4));
assert(candidate((10)) == (36));
assert(candidate((100)) == (53361));
}
| [
"\n}"
] |
HumanEval_148_bf | cpp | #include<assert.h>
#include<bits/stdc++.h>
// There are eight planets in our solar system: the closerst to the Sun
// is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
// Uranus, Neptune.
// Write a function that takes two planet names as strings planet1 and planet2.
// The function should return... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded | }
int main() {
auto candidate = bf;
assert(candidate(("Jupiter"), ("Neptune")) == (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"})));
assert(candidate(("Earth"), ("Mercury")) == (std::vector<std::string>({(std::string)"Venus"})));
assert(candidate(("Mercury"), ("Uranus")) == (st... | [
"\n}"
] |
HumanEval_149_sorted_list_sum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts a vector of strings as a parameter,
// deletes the strings that have odd lengths from it,
// and returns the resulted vector with a sorted order,
// The vector is always a vector of strings and never a vector of numbers,
// and it may contain d... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded | }
int main() {
auto candidate = sorted_list_sum;
assert(candidate((std::vector<std::string>({(std::string)"aa", (std::string)"a", (std::string)"aaa"}))) == (std::vector<std::string>({(std::string)"aa"})));
assert(candidate((std::vector<std::string>({(std::string)"school", (std::string)"AI", (std::string)"as... | [
"\n}"
] |
HumanEval_14_all_prefixes | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return vector of all prefixes from shortest to longest of the input string
// >>> 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 | /home/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(candidat... | [
"\n}"
] |
HumanEval_150_x_or_y | cpp | #include<assert.h>
#include<bits/stdc++.h>
// A simple program which should return the value of x if n is
// a prime number and should return the value of y otherwise.
// Examples:
// >>> x_or_y((7), (34), (12))
// (34)
// >>> x_or_y((15), (8), (5))
// (5)
long x_or_y(long n, long x, long y) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded | }
int main() {
auto candidate = x_or_y;
assert(candidate((7), (34), (12)) == (34));
assert(candidate((15), (8), (5)) == (5));
assert(candidate((3), (33), (5212)) == (33));
assert(candidate((1259), (3), (52)) == (3));
assert(candidate((7919), (-1), (12)) == (-1));
assert(candidate((3609), (12... | [
"\n}"
] |
HumanEval_151_double_the_difference | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a vector of numbers, return the sum of squares of the numbers
// in the vector that are odd. Ignore numbers that are negative or not integers.
// >>> double_the_difference((std::vector<float>({(long)1, (long)3, (long)2, (long)0})))
// (10)
// >>> double_the_difference... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded | }
int main() {
auto candidate = double_the_difference;
assert(candidate((std::vector<float>())) == (0));
assert(candidate((std::vector<float>({(float)5.0f, (float)4.0f}))) == (25));
assert(candidate((std::vector<float>({(float)0.1f, (float)0.2f, (float)0.3f}))) == (0));
assert(candidate((std::vector... | [
"\n}"
] |
HumanEval_152_compare | cpp | #include<assert.h>
#include<bits/stdc++.h>
// I think we all remember that feeling when the result of some long-awaited
// event is finally known. The feelings and thoughts you have at that moment are
// definitely worth noting down and comparing.
// Your task is to determine if a person correctly guessed the results o... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded | }
int main() {
auto candidate = compare;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)2, (long)-2}))) == (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)3, (long)3})));
assert(candida... | [
"\n}"
] |
HumanEval_153_Strongest_Extension | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You will be given the name of a class (a string) and a vector of extensions.
// The extensions are to be used to load additional classes to the class. The
// strength of the extension is as follows: Let CAP be the number of the uppercase
// letters in the extension's name, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded | }
int main() {
auto candidate = Strongest_Extension;
assert(candidate(("Watashi"), (std::vector<std::string>({(std::string)"tEN", (std::string)"niNE", (std::string)"eIGHt8OKe"}))) == ("Watashi.eIGHt8OKe"));
assert(candidate(("Boku123"), (std::vector<std::string>({(std::string)"nani", (std::string)"NazeDa", ... | [
"\n}"
] |
HumanEval_154_cycpattern_check | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given 2 words. You need to return true if the second word or any of its rotations is a substring in the first word
// >>> cycpattern_check(("abcd"), ("abd"))
// (false)
// >>> cycpattern_check(("hello"), ("ell"))
// (true)
// >>> cycpattern_check(("whassup"), ("psus... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded | }
int main() {
auto candidate = cycpattern_check;
assert(candidate(("xyzw"), ("xyw")) == (false));
assert(candidate(("yello"), ("ell")) == (true));
assert(candidate(("whattup"), ("ptut")) == (false));
assert(candidate(("efef"), ("fee")) == (true));
assert(candidate(("abab"), ("aabb")) == (false)... | [
"\n}"
] |
HumanEval_155_even_odd_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given an integer. return a tuple that has the number of even and odd digits respectively.
// Example:
// >>> even_odd_count((-12))
// (std::make_tuple(1, 1))
// >>> even_odd_count((123))
// (std::make_tuple(1, 2))
std::tuple<long, long> even_odd_count(long num) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded | }
int main() {
auto candidate = even_odd_count;
assert(candidate((7)) == (std::make_tuple(0, 1)));
assert(candidate((-78)) == (std::make_tuple(1, 1)));
assert(candidate((3452)) == (std::make_tuple(2, 2)));
assert(candidate((346211)) == (std::make_tuple(3, 3)));
assert(candidate((-345821)) == (st... | [
"\n}"
] |
HumanEval_156_int_to_mini_roman | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer, obtain its roman numeral equivalent as a string,
// and return it in lowercase.
// Restrictions: 1 <= num <= 1000
// Examples:
// >>> int_to_mini_roman((19))
// ("xix")
// >>> int_to_mini_roman((152))
// ("clii")
// >>> int_to_mini_roman((426))
// ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded | }
int main() {
auto candidate = int_to_mini_roman;
assert(candidate((19)) == ("xix"));
assert(candidate((152)) == ("clii"));
assert(candidate((251)) == ("ccli"));
assert(candidate((426)) == ("cdxxvi"));
assert(candidate((500)) == ("d"));
assert(candidate((1)) == ("i"));
assert(candidate(... | [
"\n}"
] |
HumanEval_157_right_angle_triangle | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or
// 90 degree.
// Example:
// >>> right_angle_triangle((3), (4)... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded | }
int main() {
auto candidate = right_angle_triangle;
assert(candidate((3), (4), (5)) == (true));
assert(candidate((1), (2), (3)) == (false));
assert(candidate((10), (6), (8)) == (true));
assert(candidate((2), (2), (2)) == (false));
assert(candidate((7), (24), (25)) == (true));
assert(candid... | [
"\n}"
] |
HumanEval_158_find_max | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts a vector of strings.
// The vector contains different words. Return the word with maximum number
// of unique characters. If multiple strings have maximum number of unique
// characters, return the one which comes first in lexicographical order... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded | }
int main() {
auto candidate = find_max;
assert(candidate((std::vector<std::string>({(std::string)"name", (std::string)"of", (std::string)"string"}))) == ("string"));
assert(candidate((std::vector<std::string>({(std::string)"name", (std::string)"enam", (std::string)"game"}))) == ("enam"));
assert(candi... | [
"\n}"
] |
HumanEval_159_eat | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You're a hungry rabbit, and you already have eaten a certain number of carrots,
// but now you need to eat more carrots to complete the day's meals.
// you should return a vector of [ total number of eaten carrots after your meals,
// the number of carrots left after your m... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded | }
int main() {
auto candidate = eat;
assert(candidate((5), (6), (10)) == (std::vector<long>({(long)11, (long)4})));
assert(candidate((4), (8), (9)) == (std::vector<long>({(long)12, (long)1})));
assert(candidate((1), (10), (10)) == (std::vector<long>({(long)11, (long)0})));
assert(candidate((2), (11)... | [
"\n}"
] |
HumanEval_15_string_sequence | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// >>> string_sequence((0))
// ("0")
// >>> string_sequence((5))
// ("0 1 2 3 4 5")
std::string string_sequence(long n) {
| transform | /home/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_160_do_algebra | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given two vectors operator, and operand. The first vector has basic algebra operations, and
// the second vector is a vector of integers. Use the two given vectors to build the algebric
// expression and return the evaluation of this expression.
// The basic algebra opera... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded | }
int main() {
auto candidate = do_algebra;
assert(candidate((std::vector<std::string>({(std::string)"**", (std::string)"*", (std::string)"+"})), (std::vector<long>({(long)2, (long)3, (long)4, (long)5}))) == (37));
assert(candidate((std::vector<std::string>({(std::string)"+", (std::string)"*", (std::string)... | [
"\n}"
] |
HumanEval_161_solve | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa,
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// >>> solve(("1234... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded | }
int main() {
auto candidate = solve;
assert(candidate(("AsDf")) == ("aSdF"));
assert(candidate(("1234")) == ("4321"));
assert(candidate(("ab")) == ("AB"));
assert(candidate(("#a@C")) == ("#A@c"));
assert(candidate(("#AsdfW^45")) == ("#aSDFw^45"));
assert(candidate(("#6@2")) == ("2@6#"));
... | [
"\n}"
] |
HumanEval_162_string_to_md5 | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string 'text', return its md5 hash equivalent string.
// If 'text' is an empty string, return None.
// >>> string_to_md5(("Hello world"))
// "3e25960a79dbc69b674cd4ec67a72c62"
std::optional<std::string> string_to_md5(std::string text) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | reworded | }
int main() {
auto candidate = string_to_md5;
assert(candidate(("Hello world")) == "3e25960a79dbc69b674cd4ec67a72c62");
assert(candidate(("")) == std::nullopt);
assert(candidate(("A B C")) == "0ef78513b0cb8cef12743f5aeb35f888");
assert(candidate(("password")) == "5f4dcc3b5aa765d61d8327deb882cf99");... | [
"\n}"
] |
HumanEval_163_generate_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given two positive integers a and b, return the even digits between a
// and b, in ascending order.
// For example:
// >>> generate_integers((2), (8))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((8), (2))
// (std::vector<long>({(lon... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded | }
int main() {
auto candidate = generate_integers;
assert(candidate((2), (10)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
assert(candidate((10), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
assert(candidate((132), (2)) == (std::vector<long>({(long)2, (long)4, (... | [
"\n}"
] |
HumanEval_16_count_distinct_characters | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// >>> count_distinct_characters(("xyzXYZ"))
// (3)
// >>> count_distinct_characters(("Jerry"))
// (4)
long count_distinct_characters(std::string string) {
| transform | /home/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>
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return vector of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// '... | transform | /home/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(candidat... | [
"\n}"
] |
HumanEval_18_how_many_times | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// >>> how_many_times((""), ("a"))
// (0)
// >>> how_many_times(("aaa"), ("a"))
// (3)
// >>> how_many_times(("aaaa"), ("aa"))
// (3)
long how_many_times(std::string string, s... | transform | /home/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>
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// >>> sort_numbers(("three one fi... | transform | /home/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... | [
"\n}"
] |
HumanEval_1_separate_paren_groups | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the vector of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each... | transform | /home/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>({(... | [
"\n}"
] |
HumanEval_20_find_closest_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// From a supplied vector of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// >>> find_closest_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4... | transform | /home/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.... | [
"\n}"
] |
HumanEval_21_rescale_to_unit | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given vector of numbers (of at least two elements), apply a linear transform to that vector,
// such that the smallest number will become 0 and the largest will become 1
// >>> rescale_to_unit((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5... | transform | /home/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(ca... | [
"\n}"
] |
HumanEval_22_filter_integers | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Filter given vector of any cppthon values only for integers
// >>> 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... | transform | /home/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... | [
"\n}"
] |
HumanEval_23_strlen | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return length of given string
// >>> string_length((""))
// (0)
// >>> string_length(("abc"))
// (3)
long string_length(std::string string) {
| transform | /home/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>
// For a given number n, find the largest number that divides n evenly, smaller than n
// >>> largest_divisor((15))
// (5)
long largest_divisor(long n) {
| transform | /home/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}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.