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_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 | verbatim | }
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 list 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 considered... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | verbatim | }
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 | verbatim | }
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 an array arr of integers and a positive integer k, return a sorted list
// 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}))
// Ex... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | verbatim | }
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 list 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 | verbatim | }
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 array 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, (lo... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | verbatim | }
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 list 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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of numbers, return whether or not they are sorted
// in ascending order. If list 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})))
// (true)
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | verbatim | }
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 | verbatim | }
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 an array arr of integers and you need to return
// sum of magnitudes of integers multiplied by product of all signs
// of each number in the array, 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 | verbatim | }
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 | verbatim | }
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 list 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 list is empty.
// >>> longest((std::vector<std::string>()))
// std::nullopt
// >>> longest((std::vector<std::string>({(std::... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of numbers.
// You need to return the sum of squared numbers in the given list,
// round each element in the list to the upper int(Ceiling) first.
// Examples:
// >>> lst((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})))
// (14)
// >>> lst(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | verbatim | }
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 | verbatim | }
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 array 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 | verbatim | }
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 list.
// If there is no negative or positive integers, return them as None.
// Examples:
// >>> largest_smallest_integers((s... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of integers. For all entries in the list, 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
// c... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list 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 list.
// For example:
// >>> order_by_poi... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | verbatim | }
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 an array of numbers as input and returns
// the number of elements in the array 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 | verbatim | }
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 array 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.
// Ex... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | verbatim | }
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 | verbatim | }
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 list of strings as a parameter,
// deletes the strings that have odd lengths from it,
// and returns the resulted list with a sorted order,
// The list is always a list of strings and never an array of numbers,
// and it may contain duplicate... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | verbatim | }
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 list 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 | verbatim | }
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 | verbatim | }
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 list of numbers, return the sum of squares of the numbers
// in the list 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((st... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | verbatim | }
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 | verbatim | }
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 list 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, an... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of strings.
// The list 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 | verbatim | }
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 an array 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 | verbatim | }
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 | verbatim | }
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 lists operator, and operand. The first list has basic algebra operations, and
// the second list is a list of integers. Use the two given lists to build the algebric
// expression and return the evaluation of this expression.
// The basic algebra operations:
// ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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 list of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each o... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py | verbatim | }
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 list 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.0... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py | verbatim | }
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 list of numbers (of at least two elements), apply a linear transform to that list,
// 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.0f}... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py | verbatim | }
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 list of any python 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,lo... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py | verbatim | }
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 | verbatim | }
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 | verbatim | }
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>
// Return list of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// >>> fa... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py | verbatim | }
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, (... | [
"\n}"
] |
HumanEval_26_remove_duplicates | cpp | #include<assert.h>
#include<bits/stdc++.h>
// From a list of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// >>> remove_duplicates((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4})))
// (std::vector<long>({(long)1, (long)3, (long)4}))
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py | verbatim | }
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, (... | [
"\n}"
] |
HumanEval_27_flip_case | cpp | #include<assert.h>
#include<bits/stdc++.h>
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// >>> flip_case(("Hello"))
// ("hELLO")
std::string flip_case(std::string string) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py | verbatim | }
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>
// Concatenate list of strings into a single string
// >>> 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> strin... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py | verbatim | }
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::st... | [
"\n}"
] |
HumanEval_29_filter_by_prefix | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Filter an input list of strings only for ones that start with a given 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py | verbatim | }
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)"x... | [
"\n}"
] |
HumanEval_2_truncate_number | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// >>> truncate_number((3.5f))
// (0.5f)
float ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py | verbatim | }
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_30_get_positive | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return only positive numbers in the list.
// >>> 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, (lo... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py | verbatim | }
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, ... | [
"\n}"
] |
HumanEval_31_is_prime | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return true if a given number is prime, and false otherwise.
// >>> 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((... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py | verbatim | }
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)... | [
"\n}"
] |
HumanEval_33_sort_third | cpp | #include<assert.h>
#include<bits/stdc++.h>
// This function takes a list l and returns a list l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_34_unique | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return sorted unique elements in a list
// >>> 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::vec... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_34_unique.py | verbatim | }
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>
// Return maximum element in the list.
// >>> 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 m... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_35_max_element.py | verbatim | }
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>
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// >>> fizz_buzz((50))
// (0)
// >>> fizz_buzz((78))
// (2)
// >>> fizz_buzz((79))
// (3)
long fizz_buzz(long n) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_37_sort_even | cpp | #include<assert.h>
#include<bits/stdc++.h>
// This function takes a list l and returns a list l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// >>> sort_even((std::vector<long>({(long)1, (long)2, (long)3})... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py | verbatim | }
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})))... | [
"\n}"
] |
HumanEval_39_prime_fib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// >>> 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 | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py | verbatim | }
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(... | [
"\n}"
] |
HumanEval_3_below_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You're given a list of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return True. Otherwise it should return False.
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py | verbatim | }
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));
... | [
"\n}"
] |
HumanEval_40_triples_sum_to_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// triples_sum_to_zero takes a list of integers as an input.
// it returns True if there are three distinct elements in the list that
// sum to zero, and False otherwise.
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> tr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_41_car_race_collision | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right; simultaneously, a different set of n cars
// are driving right to left. The two sets of cars start out being very far from
// each other. All cars move in the same spee... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py | verbatim | }
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>
// Return list with elements incremented by 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, (l... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py | verbatim | }
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, ... | [
"\n}"
] |
HumanEval_43_pairs_sum_to_zero | cpp | #include<assert.h>
#include<bits/stdc++.h>
// pairs_sum_to_zero takes a list of integers as an input.
// it returns True if there are two distinct elements in the list that
// sum to zero, and False otherwise.
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> pairs_su... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py | verbatim | }
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}))... | [
"\n}"
] |
HumanEval_44_change_base | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// >>> change_base((8), (3))
// ("22")
// >>> change_base((8), (2))
// ("1000")
// >>> change_base((7), (2))
// ("111")
std::string chang... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py | verbatim | }
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")... | [
"\n}"
] |
HumanEval_45_triangle_area | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given length of a side and high return area for a triangle.
// >>> triangle_area((5), (3))
// (7.5f)
float triangle_area(long a, long h) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py | verbatim | }
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>
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// 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).
// Please write a function to efficiently comput... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py | verbatim | }
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>
// Return median of elements in the list 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<lon... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py | verbatim | }
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}))) =... | [
"\n}"
] |
HumanEval_48_is_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Checks if given string is a palindrome
// >>> is_palindrome((""))
// (true)
// >>> is_palindrome(("aba"))
// (true)
// >>> is_palindrome(("aaaaa"))
// (true)
// >>> is_palindrome(("zbcd"))
// (false)
bool is_palindrome(std::string text) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py | verbatim | }
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(... | [
"\n}"
] |
HumanEval_49_modp | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return 2^n modulo p (be aware of numerics).
// >>> 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 | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py | verbatim | }
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)... | [
"\n}"
] |
HumanEval_4_mean_absolute_deviation | cpp | #include<assert.h>
#include<bits/stdc++.h>
// For a given list of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// >>> mean_... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py | verbatim | }
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,... | [
"\n}"
] |
HumanEval_51_remove_vowels | cpp | #include<assert.h>
#include<bits/stdc++.h>
// remove_vowels is a function that takes string and returns string without vowels.
// >>> remove_vowels((""))
// ("")
// >>> remove_vowels(("abcdef"))
// ("bcdf")
// >>> remove_vowels(("aaaaa"))
// ("")
// >>> remove_vowels(("aaBAA"))
// ("B")
// >>> remove_vowels(("zbcd"))
/... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py | verbatim | }
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")) == ... | [
"\n}"
] |
HumanEval_52_below_threshold | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return True if all numbers in the list l are below threshold t.
// >>> 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_53_add | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Add two numbers x and y
// >>> add((2), (3))
// (5)
// >>> add((5), (7))
// (12)
long add(long x, long y) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py | verbatim | }
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>
// Check if two words have the same characters.
// >>> same_chars(("eabcdzzzz"), ("dddzzzzzzzddeddabc"))
// (true)
// >>> same_chars(("abcd"), ("dddddddabc"))
// (true)
// >>> same_chars(("dddddddabc"), ("abcd"))
// (true)
// >>> same_chars(("eabcd"), ("dddddddabc"))
// (false... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py | verbatim | }
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(... | [
"\n}"
] |
HumanEval_55_fib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return n-th Fibonacci number.
// >>> fib((10))
// (55)
// >>> fib((1))
// (1)
// >>> fib((8))
// (21)
long fib(long n) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py | verbatim | }
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 is a string of "<" and ">".
// return True if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing(("<"))
// (false)
// >>> correct_bracketing(("<>"))
// (true)
// >>> correct_bracketing(("<<><>>"))
// (true)
// >>> correct_bracketin... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_56_correct_bracketing.py | verbatim | }
int main() {
auto candidate = correct_bracketing;
assert(candidate(("<>")) == (true));
assert(candidate(("<<><>>")) == (true));
assert(candidate(("<><><<><>><>")) == (true));
assert(candidate(("<><><<<><><>><>><<><><<>>>")) == (true));
assert(candidate(("<<<><>>>>")) == (false));
assert(ca... | [
"\n}"
] |
HumanEval_57_monotonic | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return True is list elements are monotonically increasing or decreasing.
// >>> 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::ve... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_57_monotonic.py | verbatim | }
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}))) == (f... | [
"\n}"
] |
HumanEval_58_common | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return sorted unique common elements for two lists.
// >>> 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)... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_58_common.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_59_largest_prime_factor | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return the largest prime factor of n. Assume n > 1 and is not a prime.
// >>> largest_prime_factor((13195))
// (29)
// >>> largest_prime_factor((2048))
// (2)
long largest_prime_factor(long n) {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py | verbatim | }
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_5_intersperse | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
// >>> 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py | verbatim | }
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... | [
"\n}"
] |
HumanEval_60_sum_to_n | cpp | #include<assert.h>
#include<bits/stdc++.h>
// sum_to_n is a function that sums numbers from 1 to 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 | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py | verbatim | }
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 is a string of "(" and ")".
// return True if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing(("("))
// (false)
// >>> correct_bracketing(("()"))
// (true)
// >>> correct_bracketing(("(()())"))
// (true)
// >>> correct_bracketin... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py | verbatim | }
int main() {
auto candidate = correct_bracketing;
assert(candidate(("()")) == (true));
assert(candidate(("(()())")) == (true));
assert(candidate(("()()(()())()")) == (true));
assert(candidate(("()()((()()())())(()()(()))")) == (true));
assert(candidate(("((()())))")) == (false));
assert(ca... | [
"\n}"
] |
HumanEval_62_derivative | cpp | #include<assert.h>
#include<bits/stdc++.h>
// xs represent coefficients of a polynomial.
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// Return derivative of this polynomial in the same form.
// >>> derivative((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (std::vector<long>({(long)1, (long)4, (lon... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py | verbatim | }
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})));
... | [
"\n}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.