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_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:
long can_arrange(st... | remove | /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:
std::tuple<std::optional<long>, std... | remove | /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... | remove | /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
bool is_equal_to_sum_even(long n) {
| remove | /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:
// The function will receive an integer as input and should return the special
// factorial of this integer.
long special_factorial(long n) {
| remove | /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
long greatest_common_divisor(long a, long b) {
| remove | /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 -
std::string fix_spaces(std::string text) {
| remove | /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 ... | remove | /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... | remove | /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... | remove | /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... | remove | /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:
std::vector<long> o... | remove | /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:
long specialFilter(std::vector<long> nums) {
| remove | /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... | remove | /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... | remove | /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... | remove | /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
std::vector<std::string> all_prefixes(std::string string) {
| remove | /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:
long x_or_y(long n, long x, long y) {
| remove | /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.
// If the input list is empty, return 0.
long double_the_difference(std::vector<float> lst) {
| remove | /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... | remove | /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... | remove | /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
bool cycpattern_check(std::string a, std::string b) {
| remove | /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:
std::tuple<long, long> even_odd_count(long num) {
| remove | /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:
std::string int_to_mini_roman(long number) {
| remove | /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:
bool right_angle_triangle(long a, lo... | remove | /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.
st... | remove | /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... | remove | /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.
std::string string_sequence(long n) {
| remove | /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_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
std::string solve(s... | remove | /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.
std::optional<std::string> string_to_md5(std::string text) {
| remove | /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:
std::vector<long> generate_integers(long a, long b) {
| remove | /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
long count_distinct_characters(std::string string) {
| remove | /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|... | remove | /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.
long how_many_times(std::string string, std::string substring) {
| remove | /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
std::string sort_numbers(std::stri... | remove | /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... | remove | /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).
std::tuple<float, float> find_closest_elements(std::vector<float> numbers) {
| remove | /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
std::vector<float> rescale_to_unit(std::vector<float> numbers) {
| remove | /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
std::vector<long> filter_integers(std::vector<std::any> values) {
| remove | /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
long string_length(std::string string) {
| remove | /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
long largest_divisor(long n) {
| remove | /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
std::vect... | remove | /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.
std::vector<long> remove_duplicates(std::vector<long> numbers) {
| remove | /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.
std::string flip_case(std::string string) {
| remove | /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
std::string concatenate(std::vector<std::string> strings) {
| remove | /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.
std::vector<std::string> filter_by_prefix(std::vector<std::string> strings, std::string prefix) {
| remove | /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.
float truncate_number(float number) {
| remove | /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.
std::vector<long> get_positive(std::vector<long> l) {
| remove | /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.
bool is_prime(long n) {
| remove | /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.
std:... | remove | /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
std::vector<long> unique(std::vector<long> l) {
| remove | /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.
long max_element(std::vector<long> l) {
| remove | /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.
long fizz_buzz(long n) {
| remove | /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.
std::vector<long> sort_even(std::vector<long> l) {
| remove | /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.
long prime_fib(long n) {
| remove | /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.
... | remove | /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.
bool triples_sum_to_zero(std::vector<long> l) {
| remove | /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_42_incr_list | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Return list with elements incremented by 1.
std::vector<long> incr_list(std::vector<long> l) {
| remove | /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.
bool pairs_sum_to_zero(std::vector<long> l) {
| remove | /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.
std::string change_base(long x, long base) {
| remove | /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.
float triangle_area(long a, long h) {
| remove | /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... | remove | /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.
float median(std::vector<long> l) {
| remove | /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
bool is_palindrome(std::string text) {
| remove | /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).
long modp(long n, long p) {
| remove | /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 |
float mean_a... | remove | /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.
std::string remove_vowels(std::string text) {
| remove | /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.
bool below_threshold(std::vector<long> l, long t) {
| remove | /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
long add(long x, long y) {
| remove | /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.
bool same_chars(std::string s0, std::string s1) {
| remove | /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.
long fib(long n) {
| remove | /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.
bool correct_bracketing(std::string brackets) {
| remove | /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.
bool monotonic(std::vector<long> l) {
| remove | /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.
std::vector<long> common(std::vector<long> l1, std::vector<long> l2) {
| remove | /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.
long largest_prime_factor(long n) {
| remove | /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'
std::vector<long> intersperse(std::vector<long> numbers, long delimeter) {
| remove | /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.
long sum_to_n(long n) {
| remove | /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.
bool correct_bracketing(std::string brackets) {
| remove | /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.
std::vector<long> derivative(std::vector<long> xs) {
| remove | /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}"
] |
HumanEval_63_fibfib | cpp | #include<assert.h>
#include<bits/stdc++.h>
// The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fibfib(0) == 0
// fibfib(1) == 0
// fibfib(2) == 1
// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
// Please write a function to efficiently compute the n-th e... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py | verbatim | }
int main() {
auto candidate = fibfib;
assert(candidate((2)) == (1));
assert(candidate((1)) == (0));
assert(candidate((5)) == (4));
assert(candidate((8)) == (24));
assert(candidate((10)) == (81));
assert(candidate((12)) == (274));
assert(candidate((14)) == (927));
}
| [
"\n}"
] |
HumanEval_64_vowels_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function vowels_count which takes a string representing
// a word as input and returns the number of vowels in the string.
// Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
// vowel, but only when it is at the end of the given word.
// Example:... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py | verbatim | }
int main() {
auto candidate = vowels_count;
assert(candidate(("abcde")) == (2));
assert(candidate(("Alone")) == (3));
assert(candidate(("key")) == (2));
assert(candidate(("bye")) == (1));
assert(candidate(("keY")) == (2));
assert(candidate(("bYe")) == (1));
assert(candidate(("ACEDY")) ... | [
"\n}"
] |
HumanEval_65_circular_shift | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
std::string circular_shift(long x, long shift) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_65_circular_shift.py | verbatim | }
int main() {
auto candidate = circular_shift;
assert(candidate((100), (2)) == ("001"));
assert(candidate((12), (2)) == ("12"));
assert(candidate((97), (8)) == ("79"));
assert(candidate((12), (1)) == ("21"));
assert(candidate((11), (101)) == ("11"));
}
| [
"\n}"
] |
HumanEval_66_digitSum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Task
// Write a function that takes a string as input and returns the sum of the upper characters only'
// ASCII codes.
// Examples:
long digitSum(std::string s) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py | verbatim | }
int main() {
auto candidate = digitSum;
assert(candidate(("")) == (0));
assert(candidate(("abAB")) == (131));
assert(candidate(("abcCd")) == (67));
assert(candidate(("helloE")) == (69));
assert(candidate(("woArBld")) == (131));
assert(candidate(("aAaaaXa")) == (153));
assert(candidate(... | [
"\n}"
] |
HumanEval_67_fruit_distribution | cpp | #include<assert.h>
#include<bits/stdc++.h>
// In this task, you will be given a string that represents a number of apples and oranges
// that are distributed in a basket of fruit this basket contains
// apples, oranges, and mango fruits. Given the string that represents the total number of
// the oranges and apples ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_67_fruit_distribution.py | verbatim | }
int main() {
auto candidate = fruit_distribution;
assert(candidate(("5 apples and 6 oranges"), (19)) == (8));
assert(candidate(("5 apples and 6 oranges"), (21)) == (10));
assert(candidate(("0 apples and 1 oranges"), (3)) == (2));
assert(candidate(("1 apples and 0 oranges"), (3)) == (2));
asser... | [
"\n}"
] |
HumanEval_68_pluck | cpp | #include<assert.h>
#include<bits/stdc++.h>
// "Given an array representing a branch of a tree that has non-negative integer nodes
// your task is to pluck one of the nodes and return it.
// The plucked node should be the node with the smallest even value.
// If multiple nodes with the same smallest even value are found... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_68_pluck.py | verbatim | }
int main() {
auto candidate = pluck;
assert(candidate((std::vector<long>({(long)4, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
assert(candidate((std::vector<long>())) =... | [
"\n}"
] |
HumanEval_69_search | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a non-empty list of positive integers. Return the greatest integer that is greater than
// zero, and has a frequency greater than or equal to the value of the integer itself.
// The frequency of an integer is the number of times it appears in the list.
// If... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_69_search.py | verbatim | }
int main() {
auto candidate = search;
assert(candidate((std::vector<long>({(long)5, (long)5, (long)5, (long)5, (long)1}))) == (1));
assert(candidate((std::vector<long>({(long)4, (long)1, (long)4, (long)1, (long)4, (long)4}))) == (4));
assert(candidate((std::vector<long>({(long)3, (long)3}))) == (-1));... | [
"\n}"
] |
HumanEval_6_parse_nested_parens | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
std::vector<long... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_6_parse_nested_parens.py | verbatim | }
int main() {
auto candidate = parse_nested_parens;
assert(candidate(("(()()) ((())) () ((())()())")) == (std::vector<long>({(long)2, (long)3, (long)1, (long)3})));
assert(candidate(("() (()) ((())) (((())))")) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
assert(candidate(("(()(())(((... | [
"\n}"
] |
HumanEval_70_strange_sort_list | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given list of integers, return list in strange order.
// Strange sorting, is when you start with the minimum value,
// then maximum of the remaining integers, then minimum and so on.
// Examples:
std::vector<long> strange_sort_list(std::vector<long> lst) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py | verbatim | }
int main() {
auto candidate = strange_sort_list;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)4, (long)2, (long)3})));
assert(candidate((std::vector<long>({(long)5, (long)6, (long)7, (long)8, (long)9}))) == (std::vector<long>({(long)5, (... | [
"\n}"
] |
HumanEval_71_triangle_area | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given the lengths of the three sides of a triangle. Return the area of
// the triangle rounded to 2 decimal points if the three sides form a valid triangle.
// Otherwise return -1
// Three sides make a valid triangle when the sum of any two sides is greater
// than the th... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py | verbatim | }
int main() {
auto candidate = triangle_area;
assert(candidate((3), (4), (5)) == (6.0f));
assert(candidate((1), (2), (10)) == (float(-1)));
assert(candidate((4), (8), (5)) == (8.18f));
assert(candidate((2), (2), (2)) == (1.73f));
assert(candidate((1), (2), (3)) == (float(-1)));
assert(candi... | [
"\n}"
] |
HumanEval_72_will_it_fly | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that returns True if the object q will fly, and False otherwise.
// The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
// Example:
// # 1+2 is less than the maxi... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py | verbatim | }
int main() {
auto candidate = will_it_fly;
assert(candidate((std::vector<long>({(long)3, (long)2, (long)3})), (9)) == (true));
assert(candidate((std::vector<long>({(long)1, (long)2})), (5)) == (false));
assert(candidate((std::vector<long>({(long)3})), (5)) == (true));
assert(candidate((std::vector... | [
"\n}"
] |
HumanEval_73_smallest_change | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given an array arr of integers, find the minimum number of elements that
// need to be changed to make the array palindromic. A palindromic array is an array that
// is read the same backwards and forwards. In one change, you can change one element to any other element.
// ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py | verbatim | }
int main() {
auto candidate = smallest_change;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6}))) == (4));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2}))) == (1));
assert(candidate((std:... | [
"\n}"
] |
HumanEval_74_total_match | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts two lists of strings and returns the list that has
// total number of chars in the all strings of the list less than the other list.
// if the two lists have the same number of chars, return the first list.
// Examples
std::vector<std::string>... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py | verbatim | }
int main() {
auto candidate = total_match;
assert(candidate((std::vector<std::string>()), (std::vector<std::string>())) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi"}... | [
"\n}"
] |
HumanEval_75_is_multiply_prime | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that returns true if the given number is the multiplication of 3 prime numbers
// and false otherwise.
// Knowing that (a) is less then 100.
// Example:
// 30 = 2 * 3 * 5
bool is_multiply_prime(long a) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | verbatim | }
int main() {
auto candidate = is_multiply_prime;
assert(candidate((5)) == (false));
assert(candidate((30)) == (true));
assert(candidate((8)) == (true));
assert(candidate((10)) == (false));
assert(candidate((125)) == (true));
assert(candidate((105)) == (true));
assert(candidate((126)) =... | [
"\n}"
] |
HumanEval_76_is_simple_power | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Your task is to write a function that returns true if a number x is a simple
// power of n and false in other cases.
// x is a simple power of n if n**int=x
// For example:
bool is_simple_power(long x, long n) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py | verbatim | }
int main() {
auto candidate = is_simple_power;
assert(candidate((16), (2)) == (true));
assert(candidate((143214), (16)) == (false));
assert(candidate((4), (2)) == (true));
assert(candidate((9), (3)) == (true));
assert(candidate((16), (4)) == (true));
assert(candidate((24), (2)) == (false))... | [
"\n}"
] |
HumanEval_77_iscube | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes an integer a and returns True
// if this ingeger is a cube of some integer number.
// Note: you may assume the input is always valid.
// Examples:
bool iscube(long a) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | verbatim | }
int main() {
auto candidate = iscube;
assert(candidate((1)) == (true));
assert(candidate((2)) == (false));
assert(candidate((-1)) == (true));
assert(candidate((64)) == (true));
assert(candidate((180)) == (false));
assert(candidate((1000)) == (true));
assert(candidate((0)) == (true));
... | [
"\n}"
] |
HumanEval_78_hex_key | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You have been tasked to write a function that receives
// a hexadecimal number as a string and counts the number of hexadecimal
// digits that are primes (prime number, or a prime, is a natural number
// greater than 1 that is not a product of two smaller natural numbers... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py | verbatim | }
int main() {
auto candidate = hex_key;
assert(candidate(("AB")) == (1));
assert(candidate(("1077E")) == (2));
assert(candidate(("ABED1A33")) == (4));
assert(candidate(("2020")) == (2));
assert(candidate(("123456789ABCDEF0")) == (6));
assert(candidate(("112233445566778899AABBCCDDEEFF00")) =... | [
"\n}"
] |
HumanEval_79_decimal_to_binary | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You will be given a number in decimal form and your task is to convert it to
// binary format. The function should return a string, with each character representing a binary
// number. Each character in the string will be '0' or '1'.
// There will be an extra couple of char... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py | verbatim | }
int main() {
auto candidate = decimal_to_binary;
assert(candidate((0)) == ("db0db"));
assert(candidate((32)) == ("db100000db"));
assert(candidate((103)) == ("db1100111db"));
assert(candidate((15)) == ("db1111db"));
}
| [
"\n}"
] |
HumanEval_7_filter_by_substring | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Filter an input list of strings only for ones that contain given substring
std::vector<std::string> filter_by_substring(std::vector<std::string> strings, std::string substring) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | verbatim | }
int main() {
auto candidate = filter_by_substring;
assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string... | [
"\n}"
] |
HumanEval_80_is_happy | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a string s.
// Your task is to check if the string is happy or not.
// A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
bool is_happy(std::string s) {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py | verbatim | }
int main() {
auto candidate = is_happy;
assert(candidate(("a")) == (false));
assert(candidate(("aa")) == (false));
assert(candidate(("abcd")) == (true));
assert(candidate(("aabb")) == (false));
assert(candidate(("adb")) == (true));
assert(candidate(("xyy")) == (false));
assert(candidat... | [
"\n}"
] |
HumanEval_81_numerical_letter_grade | cpp | #include<assert.h>
#include<bits/stdc++.h>
// It is the last week of the semester and the teacher has to give the grades
// to students. The teacher has been making her own algorithm for grading.
// The only problem is, she has lost the code she used for grading.
// She has given you a list of GPAs for some students an... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py | verbatim | }
int main() {
auto candidate = numerical_letter_grade;
assert(candidate((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f}))) == (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"})));
assert(candidate((std::ve... | [
"\n}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.