Bud Eval Datasets
Collection
OpenCompass-format evaluation datasets mirrored/curated by Bud Ecosystem for the Bud eval platform. • 66 items • Updated
Datasets:
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_0_has_close_elements | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Check if in given list of numbers, are any two numbers closer to each other than
// given threshold.
// >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
// False
// >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
// True
bool has_close_elements(std::vector<float> nu... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_0_has_close_elements.py | verbatim | }
int main() {
auto candidate = has_close_elements;
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));
assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f}))... | [
"\n}"
] |
HumanEval_100_make_a_pile | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, you have to make a pile of n levels of stones.
// The first level has n stones.
// The number of stones in the next level is:
// - the next odd number if n is odd.
// - the next even number if n is even.
// Return the number of stones in each lev... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_100_make_a_pile.py | verbatim | }
int main() {
auto candidate = make_a_pile;
assert(candidate((3)) == (std::vector<long>({(long)3, (long)5, (long)7})));
assert(candidate((4)) == (std::vector<long>({(long)4, (long)6, (long)8, (long)10})));
assert(candidate((5)) == (std::vector<long>({(long)5, (long)7, (long)9, (long)11, (long)13})));
... | [
"\n}"
] |
HumanEval_101_words_string | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You will be given a string of words separated by commas or spaces. Your task is
// to split the string into words and return an array of the words.
// For example:
// words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
// words_string("One, two, three,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_101_words_string.py | verbatim | }
int main() {
auto candidate = words_string;
assert(candidate(("Hi, my name is John")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"})));
assert(candidate(("One, two, three, four, five, six")) == (std::vector<std::string>({(s... | [
"\n}"
] |
HumanEval_102_choose_num | cpp | #include<assert.h>
#include<bits/stdc++.h>
// This function takes two positive numbers x and y and returns the
// biggest even integer number that is in the range [x, y] inclusive. If
// there's no such number, then the function should return -1.
// For example:
// choose_num(12, 15) = 14
// choose_num(13, 12) = -1
lo... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_102_choose_num.py | verbatim | }
int main() {
auto candidate = choose_num;
assert(candidate((12), (15)) == (14));
assert(candidate((13), (12)) == (-1));
assert(candidate((33), (12354)) == (12354));
assert(candidate((5234), (5233)) == (-1));
assert(candidate((6), (29)) == (28));
assert(candidate((27), (10)) == (-1));
a... | [
"\n}"
] |
HumanEval_103_rounded_avg | cpp | #include<assert.h>
#include<bits/stdc++.h>
union Union_std_string_long{
std::string f0;
long f1; Union_std_string_long(std::string _f0) : f0(_f0) {}
Union_std_string_long(long _f1) : f1(_f1) {}
~Union_std_string_long() {}
bool operator==(std::string f) {
return f0 == f ;
} bool ope... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_103_rounded_avg.py | verbatim | }
int main() {
auto candidate = rounded_avg;
assert(candidate((1), (5)) == "0b11");
assert(candidate((7), (13)) == "0b1010");
assert(candidate((964), (977)) == "0b1111001010");
assert(candidate((996), (997)) == "0b1111100100");
assert(candidate((560), (851)) == "0b1011000010");
assert(candid... | [
"\n}"
] |
HumanEval_104_unique_digits | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a list of positive integers x. return a sorted list of all
// elements that hasn't any even digit.
// Note: Returned list should be sorted in increasing order.
// For example:
// >>> unique_digits([15, 33, 1422, 1])
// [1, 15, 33]
// >>> unique_digits([152, 323, 1422... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_104_unique_digits.py | verbatim | }
int main() {
auto candidate = unique_digits;
assert(candidate((std::vector<long>({(long)15, (long)33, (long)1422, (long)1}))) == (std::vector<long>({(long)1, (long)15, (long)33})));
assert(candidate((std::vector<long>({(long)152, (long)323, (long)1422, (long)10}))) == (std::vector<long>()));
assert(ca... | [
"\n}"
] |
HumanEval_105_by_length | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given an array of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting array, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// arr = [... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_105_by_length.py | verbatim | }
int main() {
auto candidate = by_length;
assert(candidate((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3}))) == (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (... | [
"\n}"
] |
HumanEval_106_f | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Implement the function f that takes n as a parameter,
// and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even
// or the sum of numbers from 1 to i otherwise.
// i starts from 1.
// the factorial of i is the multiplic... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_106_f.py | verbatim | }
int main() {
auto candidate = f;
assert(candidate((5)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15})));
assert(candidate((7)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15, (long)720, (long)28})));
assert(candidate((1)) == (std::vector<long>({(long)1})))... | [
"\n}"
] |
HumanEval_107_even_odd_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a tuple that has the number of even and odd
// integer palindromes that fall within the range(1, n), inclusive.
// Example 1:
// Input: 3
// Output: (1, 2)
// Explanation:
// Integer palindrome are 1, 2, 3. one of them is even, and two of ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_107_even_odd_palindrome.py | verbatim | }
int main() {
auto candidate = even_odd_palindrome;
assert(candidate((123)) == (std::make_tuple(8, 13)));
assert(candidate((12)) == (std::make_tuple(4, 6)));
assert(candidate((3)) == (std::make_tuple(1, 2)));
assert(candidate((63)) == (std::make_tuple(6, 8)));
assert(candidate((25)) == (std::ma... | [
"\n}"
] |
HumanEval_108_count_nums | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Write a function count_nums which takes an array of integers and returns
// the number of elements which has a sum of digits > 0.
// If a number is negative, then its first signed digit will be negative:
// e.g. -123 has signed digits -1, 2, and 3.
// >>> count_nums([]) == ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_108_count_nums.py | verbatim | }
int main() {
auto candidate = count_nums;
assert(candidate((std::vector<long>())) == (0));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)0}))) == (0));
assert(candidate((std::vector<long>({(long)1, (long)1, (long)2, (long)-2, (long)3, (long)4, (long)5}))) == (6));
assert(candidate... | [
"\n}"
] |
HumanEval_109_move_one_ball | cpp | #include<assert.h>
#include<bits/stdc++.h>
// We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
// numbers in the array will be randomly ordered. Your task is to determine if
// it is possible to get an array sorted in non-decreasing order by performing
// the following operation on the given array:... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_109_move_one_ball.py | verbatim | }
int main() {
auto candidate = move_one_ball;
assert(candidate((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)3, (long)5, (long)10, (long)1, (long)2}))) == (true));
assert(candidate((std::vector<long>({(long)4, (long)3, (long)1... | [
"\n}"
] |
HumanEval_10_make_palindrome | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_10_make_palindrome.py | verbatim | }
int main() {
auto candidate = make_palindrome;
assert(candidate(("")) == (""));
assert(candidate(("x")) == ("x"));
assert(candidate(("xyz")) == ("xyzyx"));
assert(candidate(("xyx")) == ("xyx"));
assert(candidate(("jerry")) == ("jerryrrej"));
}
| [
"\n}"
] |
HumanEval_110_exchange | cpp | #include<assert.h>
#include<bits/stdc++.h>
// In this problem, you will implement a function that takes two lists of numbers,
// and determines whether it is possible to perform an exchange of elements
// between them to make lst1 a list of only even numbers.
// There is no limit on the number of exchanged elements bet... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_110_exchange.py | verbatim | }
int main() {
auto candidate = exchange;
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == ("YES"));
assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)5, (lon... | [
"\n}"
] |
HumanEval_111_histogram | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string representing a space separated lowercase letters, return a dictionary
// of the letter with the most repetition and containing the corresponding count.
// If several letters have the same occurrence, return all of them.
// Example:
// histogram('a b c') == {'... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_111_histogram.py | verbatim | }
int main() {
auto candidate = histogram;
assert(candidate(("a b b a")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c a b")) == (std::map<std::string,long>({{"a", 2}, {"b", 2}})));
assert(candidate(("a b c d g")) == (std::map<std::string,long>({{"a", 1}, {"b", 1}, {"c... | [
"\n}"
] |
HumanEval_112_reverse_delete | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Task
// We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
// then check if the result string is palindrome.
// A string is called palindrome if it reads the same backward as forward.
// You should return a tup... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_112_reverse_delete.py | verbatim | }
int main() {
auto candidate = reverse_delete;
assert(candidate(("abcde"), ("ae")) == (std::make_tuple("bcd", false)));
assert(candidate(("abcdef"), ("b")) == (std::make_tuple("acdef", false)));
assert(candidate(("abcdedcba"), ("ab")) == (std::make_tuple("cdedc", true)));
assert(candidate(("dwik"),... | [
"\n}"
] |
HumanEval_113_odd_count | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a list of strings, where each string consists of only digits, return a list.
// Each element i of the output should be "the number of odd elements in the
// string i of the input." where all the i's should be replaced by the number
// of odd digits in the i'th string ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_113_odd_count.py | verbatim | }
int main() {
auto candidate = odd_count;
assert(candidate((std::vector<std::string>({(std::string)"1234567"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."})));
assert(candidate((std::vector<std::string>({(std::string)"3", (std::string)"11111111"})... | [
"\n}"
] |
HumanEval_114_minSubArraySum | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given an array of integers nums, find the minimum sum of any non-empty sub-array
// of nums.
// Example
// minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
// minSubArraySum([-1, -2, -3]) == -6
long minSubArraySum(std::vector<long> nums) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_114_minSubArraySum.py | verbatim | }
int main() {
auto candidate = minSubArraySum;
assert(candidate((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4}))) == (1));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3}))) == (-6));
assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3, (long)... | [
"\n}"
] |
HumanEval_115_max_fill | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it,
// and all buckets have the same capacity.
// Your tas... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_115_max_fill.py | verbatim | }
int main() {
auto candidate = max_fill;
assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (lo... | [
"\n}"
] |
HumanEval_116_sort_array | cpp | #include<assert.h>
#include<bits/stdc++.h>
// In this Kata, you have to sort an array of non-negative integers according to
// number of ones in their binary representation in ascending order.
// For similar number of ones, sort based on decimal value.
// It must be implemented like this:
// >>> sort_array([1, 5, 2, 3,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_116_sort_array.py | verbatim | }
int main() {
auto candidate = sort_array;
assert(candidate((std::vector<long>({(long)1, (long)5, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5})));
assert(candidate((std::vector<long>({(long)-2, (long)-3, (long)-4, (long)-5, (long)-6}))) == (std::vector<l... | [
"\n}"
] |
HumanEval_117_select_words | cpp | #include<assert.h>
#include<bits/stdc++.h>
// Given a string s and a natural number n, you have been tasked to implement
// a function that returns a list of all words from string s that contain exactly
// n consonants, in order these words appear in the string s.
// If the string s is empty then the function should ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_117_select_words.py | verbatim | }
int main() {
auto candidate = select_words;
assert(candidate(("Mary had a little lamb"), (4)) == (std::vector<std::string>({(std::string)"little"})));
assert(candidate(("Mary had a little lamb"), (3)) == (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"})));
assert(candidate(("simple... | [
"\n}"
] |
HumanEval_118_get_closest_vowel | cpp | #include<assert.h>
#include<bits/stdc++.h>
// You are given a word. Your task is to find the closest vowel that stands between
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condi... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
// Input: arr = [-3, -4, 5], k = 3
// Output: [-4, -3, 5]
// Example 2:
// Input: arr = [4, -4, 4], k = 2
// Output: [4, 4]
// Exam... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([5, 8, 7, 1]) ==> 12
// solution([3, 3, 3, 3, 3]) ==> 9
// solution([30, 13, 24, 321]) ==>0
long solution(std::vector<long> lst) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
// Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
// Output: 24 # sum of 21 + 3
// Constraints:
// 1. 1 <= len(ar... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
//... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([5]) ➞ True
// is_sorted([1, 2, 3, 4, 5]) ➞ Tr... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 2, 2, -4]) == -... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([])
// >>> longest(['a', 'b', 'c'])
// 'a'
// >>> longest(['a', 'bb', 'ccc'])
// 'ccc'
std::op... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
// is_nest... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
// For lst = [1,2,3] the output should be 14
// For lst = [1,4,9] the output should be 98
// ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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("appl... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1,2... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([2, 4,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 integer.
... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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"
// fix_spaces(" Example 2"... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([15, -73, 14, -15]) => 1
// specia... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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')
// ['a', 'ab', 'abc']
std::vector<std::string> all_prefixes(std::string string) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
// for x_or_y(7, 34, 12) == 34
// for x_or_y(15, 8, 5) == 5
long x_or_y(long n, long x, long y) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
// double_the_difference([-1, -2, 0]) == 0
// double_the_difference(... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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") => False
// cycpattern_chec... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) ==> (1, 1)
// even_odd_count(123) ==> (1, 2)
std::tuple<long, long> even_odd_count(long num) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) == 'cdxxvi'
s... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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, 5) == ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
//... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
// ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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") = ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) => [2, 4, 6, 8]
// generate_integers(8, 2) => [2, 4, 6, 8]
// generate_integers(10, 14) => []
std::vector<long> generate_integers(l... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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|... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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, std::string substri... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 fiv... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
// (2.0, 2.2)
// >>> find_closest_elem... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1.0, 2.0, 3.0, 4.0, 5.0])
// [0.0, 0.25, 0.5, 0.75, 1.0]
std::vector<float> rescale_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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(['a', 3.14, 5])
// [5]
// >>> filter_integers([1, 2, 3, 'abc', {}, []])
// [1, 2, 3]
std::vector<long> filter_integers(std::vector<std::any> values) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
// >>> strlen('')
// 0
// >>> strlen('abc')
// 3
long string_length(std::string string) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 2, 3, 2, 4])
// [1, 3, 4]
std::vector<long> remove_duplicates(std::vector<long> numbers) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([])
// ''
// >>> concatenate(['a', 'b', 'c'])
// 'abc'
std::string concatenate(std::vector<std::string> strings) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([], 'a')
// []
// >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
// ['abc', 'array']
std::vector<std::string> filter_by_prefix(std::vector<std::string> strings, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.5)
// 0.5
float trunca... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([-1, 2, -4, 5, 6])
// [2, 5, 6]
// >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
// [5, 3, 2, 3, 9, 123, 1]
std::vector<long> get_positive(std::vector<long> l) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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(1)
// False
bool is_prime... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
// >... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [0, 2, 3, 5, 9, 123]
std::vector<long> unique(std::vector<long> l) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 2, 3])
// 3
// >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
// 123
long max_element(std::vector<long> l) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 2, 3])
// [1, 2, 3]
// >>> sort_even([5, 6,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 3, 5, 0])
// False
// >>> triples_sum_to_zero([1, 3, -2, 1])
// True
// >>>... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 2, 3])
// [2, 3, 4]
// >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [6, 4, 6, 3, 4, 4, 10, 1, 124]
std::vector<long> incr_list(std::vector<long> l) {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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([1, 3, 5, 0])
// False
// >>> pairs_sum_to_zero([1, 3, -2, 1])
// False
// >>> pairs_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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}"
] |
End of preview. Expand in Data Studio
- Downloads last month
- 18