Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Check if in given vector of numbers, are any two numbers closer to each other than
// given threshold.
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})), (0.5f))
// (false)
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.8f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.3f))
// (true)
bool has_close_elements(std::vector<float> numbers, float threshold) {

}
int main() {
    auto candidate = has_close_elements;
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.05f)) == (false));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.95f)) == (true));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.8f)) == (false));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.1f)) == (true));
    assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (1.0f)) == (true));
    assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (0.5f)) == (false));
}


Prompt:
#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 level in a vector, where element at index
// i represents the number of stones in the level (i+1).
// Examples:
// >>> make_a_pile((3))
// (std::vector<long>({(long)3, (long)5, (long)7}))
std::vector<long> make_a_pile(long n) {

}
int main() {
    auto candidate = make_a_pile;
    assert(candidate((3)) == (std::vector<long>({(long)3, (long)5, (long)7})));
    assert(candidate((4)) == (std::vector<long>({(long)4, (long)6, (long)8, (long)10})));
    assert(candidate((5)) == (std::vector<long>({(long)5, (long)7, (long)9, (long)11, (long)13})));
    assert(candidate((6)) == (std::vector<long>({(long)6, (long)8, (long)10, (long)12, (long)14, (long)16})));
    assert(candidate((8)) == (std::vector<long>({(long)8, (long)10, (long)12, (long)14, (long)16, (long)18, (long)20, (long)22})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You will be given a string of words separated by commas or spaces. Your task is
// to split the string into words and return a vector of the words.
// For example:
// >>> words_string(("Hi, my name is John"))
// (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"}))
// >>> words_string(("One, two, three, four, five, six"))
// (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"}))
std::vector<std::string> words_string(std::string s) {

}
int main() {
    auto candidate = words_string;
    assert(candidate(("Hi, my name is John")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"})));
    assert(candidate(("One, two, three, four, five, six")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
    assert(candidate(("Hi, my name")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name"})));
    assert(candidate(("One,, two, three, four, five, six,")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
    assert(candidate(("")) == (std::vector<std::string>()));
    assert(candidate(("ahmed     , gamal")) == (std::vector<std::string>({(std::string)"ahmed", (std::string)"gamal"})));
}


Prompt:
#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)
long choose_num(long x, long y) {


Prompt:
#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 operator==(long f) {
        return f1 == f ;
    }
};
// You are given two positive integers n and m, and your task is to compute the
// average of the integers from n through m (including n and m).
// Round the answer to the nearest integer and convert that to binary.
// If n is greater than m, return -1.
// Example:
// >>> rounded_avg((1), (5))
// "0b11"
// >>> rounded_avg((7), (5))
// -1
// >>> rounded_avg((10), (20))
// "0b1111"
// >>> rounded_avg((20), (33))
// "0b11010"
Union_std_string_long rounded_avg(long n, long m) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of positive integers x. return a sorted vector of all
// elements that hasn't any even digit.
// Note: Returned vector should be sorted in increasing order.
// For example:
// >>> unique_digits((std::vector<long>({(long)15, (long)33, (long)1422, (long)1})))
// (std::vector<long>({(long)1, (long)15, (long)33}))
// >>> unique_digits((std::vector<long>({(long)152, (long)323, (long)1422, (long)10})))
// (std::vector<long>())
std::vector<long> unique_digits(std::vector<long> x) {

}
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(candidate((std::vector<long>({(long)12345, (long)2033, (long)111, (long)151}))) == (std::vector<long>({(long)111, (long)151})));
    assert(candidate((std::vector<long>({(long)135, (long)103, (long)31}))) == (std::vector<long>({(long)31, (long)135})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting vector, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// >>> by_length((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", (std::string)"One", (std::string)"One"}))
// If the vector is empty, return an empty vector:
// >>> by_length((std::vector<long>()))
// (std::vector<std::string>())
// If the vector has any strange number ignore it:
// >>> by_length((std::vector<long>({(long)1, (long)-1, (long)55})))
// (std::vector<std::string>({(std::string)"One"}))
std::vector<std::string> by_length(std::vector<long> arr) {

}
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", (std::string)"One", (std::string)"One"})));
    assert(candidate((std::vector<long>())) == (std::vector<std::string>()));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)55}))) == (std::vector<std::string>({(std::string)"One"})));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)3, (long)2}))) == (std::vector<std::string>({(std::string)"Three", (std::string)"Two", (std::string)"One"})));
    assert(candidate((std::vector<long>({(long)9, (long)4, (long)8}))) == (std::vector<std::string>({(std::string)"Nine", (std::string)"Eight", (std::string)"Four"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Implement the function f that takes n as a parameter,
// and returns a vector of size n, such that the value of the element at index i is the factorial of i if i is even
// or the sum of numbers from 1 to i otherwise.
// i starts from 1.
// the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
// Example:
// >>> f((5))
// (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15}))
std::vector<long> f(long n) {

}
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})));
    assert(candidate((3)) == (std::vector<long>({(long)1, (long)2, (long)6})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a tuple that has the number of even and odd
// integer palindromes that fall within the range(1, n), inclusive.
// Example 1:
// >>> even_odd_palindrome((3))
// (std::make_tuple(1, 2))
// Explanation:
// Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
// Example 2:
// >>> even_odd_palindrome((12))
// (std::make_tuple(4, 6))
// Explanation:
// Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
// Note:
// 1. 1 <= n <= 10^3
// 2. returned tuple has the number of even and odd integer palindromes respectively.
std::tuple<long, long> even_odd_palindrome(long n) {

}
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::make_tuple(5, 6)));
    assert(candidate((19)) == (std::make_tuple(4, 6)));
    assert(candidate((9)) == (std::make_tuple(4, 5)));
    assert(candidate((1)) == (std::make_tuple(0, 1)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function count_nums which takes a vector of integers and returns
// the number of elements which has a sum of digits > 0.
// If a number is negative, then its first signed digit will be negative:
// e.g. -123 has signed digits -1, 2, and 3.
// >>> count_nums((std::vector<long>()))
// (0)
// >>> count_nums((std::vector<long>({(long)-1, (long)11, (long)-11})))
// (1)
// >>> count_nums((std::vector<long>({(long)1, (long)1, (long)2})))
// (3)
long count_nums(std::vector<long> arr) {

}
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((std::vector<long>({(long)1, (long)6, (long)9, (long)-6, (long)0, (long)1, (long)5}))) == (5));
    assert(candidate((std::vector<long>({(long)1, (long)100, (long)98, (long)-7, (long)1, (long)-1}))) == (4));
    assert(candidate((std::vector<long>({(long)12, (long)23, (long)34, (long)-45, (long)-56, (long)0}))) == (5));
    assert(candidate((std::vector<long>({(long)0, (long)1}))) == (1));
    assert(candidate((std::vector<long>({(long)1}))) == (1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// We have a vector 'arr' of N integers arr[1], arr[2], ..., arr[N].The
// numbers in the vector will be randomly ordered. Your task is to determine if
// it is possible to get a vector sorted in non-decreasing order by performing
// the following operation on the given vector:
// You are allowed to perform right shift operation any number of times.
// One right shift operation means shifting all elements of the vector by one
// position in the right direction. The last element of the vector will be moved to
// the starting position in the vector i.e. 0th index.
// If it is possible to obtain the sorted vector by performing the above operation
// then return true else return false.
// If the given vector is empty then return true.
// Note: The given vector is guaranteed to have unique elements.
// For Example:
// >>> move_one_ball((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2})))
// (true)
// Explanation: By performin 2 right shift operations, non-decreasing order can
// be achieved for the given vector.
// >>> move_one_ball((std::vector<long>({(long)3, (long)5, (long)4, (long)1, (long)2})))
// (false)
// Explanation:It is not possible to get non-decreasing order for the given
// vector by performing any number of right shift operations.
bool move_one_ball(std::vector<long> arr) {

}
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, (long)2}))) == (false));
    assert(candidate((std::vector<long>({(long)3, (long)5, (long)4, (long)1, (long)2}))) == (false));
    assert(candidate((std::vector<long>())) == (true));
}


Prompt:
#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.
// >>> make_palindrome((""))
// ("")
// >>> make_palindrome(("cat"))
// ("catac")
// >>> make_palindrome(("cata"))
// ("catac")
std::string make_palindrome(std::string string) {

}
int main() {
    auto candidate = make_palindrome;
    assert(candidate(("")) == (""));
    assert(candidate(("x")) == ("x"));
    assert(candidate(("xyz")) == ("xyzyx"));
    assert(candidate(("xyx")) == ("xyx"));
    assert(candidate(("jerry")) == ("jerryrrej"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// In this problem, you will implement a function that takes two vectors of numbers,
// and determines whether it is possible to perform an exchange of elements
// between them to make lst1 a vector of only even numbers.
// There is no limit on the number of exchanged elements between lst1 and lst2.
// If it is possible to exchange elements between the lst1 and lst2 to make
// all the elements of lst1 to be even, return "YES".
// Otherwise, return "NO".
// For example:
// >>> exchange((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// ("YES")
// >>> exchange((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)1, (long)5, (long)3, (long)4})))
// ("NO")
// It is assumed that the input vectors will be non-empty.
std::string exchange(std::vector<long> lst1, std::vector<long> lst2) {

}
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, (long)3, (long)4}))) == ("NO"));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4})), (std::vector<long>({(long)2, (long)1, (long)4, (long)3}))) == ("YES"));
    assert(candidate((std::vector<long>({(long)5, (long)7, (long)3})), (std::vector<long>({(long)2, (long)6, (long)4}))) == ("YES"));
    assert(candidate((std::vector<long>({(long)5, (long)7, (long)3})), (std::vector<long>({(long)2, (long)6, (long)3}))) == ("NO"));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)6, (long)1, (long)8, (long)9})), (std::vector<long>({(long)3, (long)5, (long)5, (long)1, (long)1, (long)1}))) == ("NO"));
    assert(candidate((std::vector<long>({(long)100, (long)200})), (std::vector<long>({(long)200, (long)200}))) == ("YES"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string representing a space separated lowercase letters, return a map
// of the letter with the most repetition and containing the corresponding count.
// If several letters have the same occurrence, return all of them.
// Example:
// >>> histogram(("a b c"))
// (std::map<std::string,long>({{"a", 1}, {"b", 1}, {"c", 1}}))
// >>> histogram(("a b b a"))
// (std::map<std::string,long>({{"a", 2}, {"b", 2}}))
// >>> histogram(("a b c a b"))
// (std::map<std::string,long>({{"a", 2}, {"b", 2}}))
// >>> histogram(("b b b b a"))
// (std::map<std::string,long>({{"b", 4}}))
// >>> histogram((""))
// (std::map<std::string,long>())
std::map<std::string,long> histogram(std::string test) {

}
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", 1}, {"d", 1}, {"g", 1}})));
    assert(candidate(("r t g")) == (std::map<std::string,long>({{"r", 1}, {"t", 1}, {"g", 1}})));
    assert(candidate(("b b b b a")) == (std::map<std::string,long>({{"b", 4}})));
    assert(candidate(("r t g")) == (std::map<std::string,long>({{"r", 1}, {"t", 1}, {"g", 1}})));
    assert(candidate(("")) == (std::map<std::string,long>()));
    assert(candidate(("a")) == (std::map<std::string,long>({{"a", 1}})));
}


Prompt:
#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 tuple containing the result string and true/false for the check.
// Example
// >>> reverse_delete(("abcde"), ("ae"))
// (std::make_tuple("bcd", false))
// >>> reverse_delete(("abcdef"), ("b"))
// (std::make_tuple("acdef", false))
// >>> reverse_delete(("abcdedcba"), ("ab"))
// (std::make_tuple("cdedc", true))
std::tuple<std::string, bool> reverse_delete(std::string s, std::string c) {

}
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"), ("w")) == (std::make_tuple("dik", false)));
    assert(candidate(("a"), ("a")) == (std::make_tuple("", true)));
    assert(candidate(("abcdedcba"), ("")) == (std::make_tuple("abcdedcba", true)));
    assert(candidate(("abcdedcba"), ("v")) == (std::make_tuple("abcdedcba", true)));
    assert(candidate(("vabba"), ("v")) == (std::make_tuple("abba", true)));
    assert(candidate(("mamma"), ("mia")) == (std::make_tuple("", true)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of strings, where each string consists of only digits, return a vector.
// Each element i of the output should be "the number of odd elements in the
// string i of the input." where all the i's should be replaced by the number
// of odd digits in the i'th string of the input.
// >>> odd_count((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."}))
// >>> odd_count((std::vector<std::string>({(std::string)"3", (std::string)"11111111"})))
// (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."}))
std::vector<std::string> odd_count(std::vector<std::string> lst) {

}
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"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."})));
    assert(candidate((std::vector<std::string>({(std::string)"271", (std::string)"137", (std::string)"314"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 2n the str2ng 2 of the 2nput.", (std::string)"the number of odd elements 3n the str3ng 3 of the 3nput.", (std::string)"the number of odd elements 2n the str2ng 2 of the 2nput."})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of integers nums, find the minimum sum of any non-empty sub-vector
// of nums.
// Example
// >>> minSubArraySum((std::vector<long>({(long)2, (long)3, (long)4, (long)1, (long)2, (long)4})))
// (1)
// >>> minSubArraySum((std::vector<long>({(long)-1, (long)-2, (long)-3})))
// (-6)
long minSubArraySum(std::vector<long> nums) {

}
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)2, (long)-10}))) == (-14));
    assert(candidate((std::vector<long>({(long)-9999999999999999}))) == (-9999999999999999));
    assert(candidate((std::vector<long>({(long)0, (long)10, (long)20, (long)1000000}))) == (0));
    assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)-3, (long)10, (long)-5}))) == (-6));
    assert(candidate((std::vector<long>({(long)100, (long)-1, (long)-2, (long)-3, (long)10, (long)-5}))) == (-6));
    assert(candidate((std::vector<long>({(long)10, (long)11, (long)13, (long)8, (long)3, (long)4}))) == (3));
    assert(candidate((std::vector<long>({(long)100, (long)-33, (long)32, (long)-1, (long)0, (long)-2}))) == (-33));
    assert(candidate((std::vector<long>({(long)-10}))) == (-10));
    assert(candidate((std::vector<long>({(long)7}))) == (7));
    assert(candidate((std::vector<long>({(long)1, (long)-1}))) == (-1));
}


Prompt:
#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 task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// >>> max_fill((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, (long)1})})), (1))
// (6)
// Example 2:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)1, (long)1})})), (2))
// (5)
// Example 3:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0})})), (5))
// (0)
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
long max_fill(std::vector<std::vector<long>> grid, long capacity) {

}
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, (long)1})})), (1)) == (6));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)1, (long)1})})), (2)) == (5));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0})})), (5)) == (0));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (2)) == (4));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (9)) == (2));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// In this Kata, you have to sort a vector of non-negative integers according to
// number of ones in their binary representation in ascending order.
// For similar number of ones, sort based on decimal value.
// It must be implemented like this:
// >>> sort_array((std::vector<long>({(long)1, (long)5, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))
// >>> sort_array((std::vector<long>({(long)-2, (long)-3, (long)-4, (long)-5, (long)-6})))
// (std::vector<long>({(long)-6, (long)-5, (long)-4, (long)-3, (long)-2}))
// >>> sort_array((std::vector<long>({(long)1, (long)0, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4}))
std::vector<long> sort_array(std::vector<long> arr) {

}
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<long>({(long)-4, (long)-2, (long)-6, (long)-5, (long)-3})));
    assert(candidate((std::vector<long>({(long)1, (long)0, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)0, (long)1, (long)2, (long)4, (long)3})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)2, (long)5, (long)77, (long)4, (long)5, (long)3, (long)5, (long)7, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)2, (long)2, (long)4, (long)4, (long)3, (long)3, (long)5, (long)5, (long)5, (long)7, (long)77})));
    assert(candidate((std::vector<long>({(long)3, (long)6, (long)44, (long)12, (long)32, (long)5}))) == (std::vector<long>({(long)32, (long)3, (long)5, (long)6, (long)12, (long)44})));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32}))) == (std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32})));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32}))) == (std::vector<long>({(long)2, (long)4, (long)8, (long)16, (long)32})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string s and a natural number n, you have been tasked to implement
// a function that returns a vector of all words from string s that contain exactly
// n consonants, in order these words appear in the string s.
// If the string s is empty then the function should return an empty vector.
// Note: you may assume the input string contains only letters and spaces.
// Examples:
// >>> select_words(("Mary had a little lamb"), (4))
// (std::vector<std::string>({(std::string)"little"}))
// >>> select_words(("Mary had a little lamb"), (3))
// (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"}))
// >>> select_words(("simple white space"), (2))
// (std::vector<std::string>())
// >>> select_words(("Hello world"), (4))
// (std::vector<std::string>({(std::string)"world"}))
// >>> select_words(("Uncle sam"), (3))
// (std::vector<std::string>({(std::string)"Uncle"}))
std::vector<std::string> select_words(std::string s, long n) {

}
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 white space"), (2)) == (std::vector<std::string>()));
    assert(candidate(("Hello world"), (4)) == (std::vector<std::string>({(std::string)"world"})));
    assert(candidate(("Uncle sam"), (3)) == (std::vector<std::string>({(std::string)"Uncle"})));
    assert(candidate((""), (4)) == (std::vector<std::string>()));
    assert(candidate(("a b c d e f"), (1)) == (std::vector<std::string>({(std::string)"b", (std::string)"c", (std::string)"d", (std::string)"f"})));
}


Prompt:
#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 condition.
// You may assume that the given string contains English letter only.
// Example:
// >>> get_closest_vowel(("yogurt"))
// ("u")
// >>> get_closest_vowel(("FULL"))
// ("U")
// >>> get_closest_vowel(("quick"))
// ("")
// >>> get_closest_vowel(("ab"))
// ("")
std::string get_closest_vowel(std::string word) {

}
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(candidate(("most")) == ("o"));
    assert(candidate(("ab")) == (""));
    assert(candidate(("ba")) == (""));
    assert(candidate(("quick")) == (""));
    assert(candidate(("anime")) == ("i"));
    assert(candidate(("Asia")) == (""));
    assert(candidate(("Above")) == ("o"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of two strings, both strings consist of open
// parentheses '(' or close parentheses ')' only.
// Your job is to check if it is possible to concatenate the two strings in
// some order, that the resulting string will be good.
// A string S is considered to be good if and only if all parentheses in S
// are balanced. For example: the string '(())()' is good, while the string
// '())' is not.
// Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
// Examples:
// >>> match_parens((std::vector<std::string>({(std::string)"()(", (std::string)")"})))
// ("Yes")
// >>> match_parens((std::vector<std::string>({(std::string)")", (std::string)")"})))
// ("No")
std::string match_parens(std::vector<std::string> lst) {

}
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)"(()(())", (std::string)"())())"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")())", (std::string)"(()()("}))) == ("Yes"));
    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)"(()(", (std::string)"()))()"}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)"((((", (std::string)"((())"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")(()", (std::string)"(()("}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")(", (std::string)")("}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)"(", (std::string)")"}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)")", (std::string)"("}))) == ("Yes"));
}


Prompt:
#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) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector arr of integers and a positive integer k, return a sorted vector
// of length k with the maximum k numbers in arr.
// Example 1:
// >>> maximum((std::vector<long>({(long)-3, (long)-4, (long)5})), (3))
// (std::vector<long>({(long)-4, (long)-3, (long)5}))
// Example 2:
// >>> maximum((std::vector<long>({(long)4, (long)-4, (long)4})), (2))
// (std::vector<long>({(long)4, (long)4}))
// Example 3:
// >>> maximum((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1))
// (std::vector<long>({(long)2}))
// Note:
// 1. The length of the vector will be in the range of [1, 1000].
// 2. The elements in the vector will be in the range of [-1000, 1000].
// 3. 0 <= k <= len(arr)
std::vector<long> maximum(std::vector<long> arr, long k) {

}
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(candidate((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1)) == (std::vector<long>({(long)2})));
    assert(candidate((std::vector<long>({(long)123, (long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (3)) == (std::vector<long>({(long)2, (long)20, (long)123})));
    assert(candidate((std::vector<long>({(long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (4)) == (std::vector<long>({(long)0, (long)1, (long)2, (long)20})));
    assert(candidate((std::vector<long>({(long)5, (long)15, (long)0, (long)3, (long)-13, (long)-8, (long)0})), (7)) == (std::vector<long>({(long)-13, (long)-8, (long)0, (long)0, (long)3, (long)5, (long)15})));
    assert(candidate((std::vector<long>({(long)-1, (long)0, (long)2, (long)5, (long)3, (long)-10})), (2)) == (std::vector<long>({(long)3, (long)5})));
    assert(candidate((std::vector<long>({(long)1, (long)0, (long)5, (long)-7})), (1)) == (std::vector<long>({(long)5})));
    assert(candidate((std::vector<long>({(long)4, (long)-4})), (2)) == (std::vector<long>({(long)-4, (long)4})));
    assert(candidate((std::vector<long>({(long)-10, (long)10})), (2)) == (std::vector<long>({(long)-10, (long)10})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)-23, (long)243, (long)-400, (long)0})), (0)) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers, return the sum of all of the odd elements that are in even positions.
// Examples
// >>> solution((std::vector<long>({(long)5, (long)8, (long)7, (long)1})))
// (12)
// >>> solution((std::vector<long>({(long)3, (long)3, (long)3, (long)3, (long)3})))
// (9)
// >>> solution((std::vector<long>({(long)30, (long)13, (long)24, (long)321})))
// (0)
long solution(std::vector<long> lst) {

}
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}))) == (0));
    assert(candidate((std::vector<long>({(long)5, (long)9}))) == (5));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)8}))) == (0));
    assert(candidate((std::vector<long>({(long)30, (long)13, (long)23, (long)32}))) == (23));
    assert(candidate((std::vector<long>({(long)3, (long)13, (long)2, (long)9}))) == (3));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers arr and an integer k, return
// the sum of the elements with at most two digits from the first k elements of arr.
// Example:
// >>> add_elements((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4))
// (24)
// Constraints:
// 1. 1 <= len(arr) <= 100
// 2. 1 <= k <= len(arr)
long add_elements(std::vector<long> arr, long k) {

}
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));
    assert(candidate((std::vector<long>({(long)11, (long)21, (long)3, (long)90, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (125));
    assert(candidate((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (24));
    assert(candidate((std::vector<long>({(long)1})), (1)) == (1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a sorted vector that has the odd numbers in collatz sequence.
// The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
// as follows: start with any positive integer n. Then each term is obtained from the
// previous term as follows: if the previous term is even, the next term is one half of
// the previous term. If the previous term is odd, the next term is 3 times the previous
// term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
// Note:
// 1. Collatz(1) is [1].
// 2. returned vector sorted in increasing order.
// For example:
// get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
// >>> get_odd_collatz((5))
// (std::vector<long>({(long)1, (long)5}))
std::vector<long> get_odd_collatz(long n) {

}
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})));
    assert(candidate((1)) == (std::vector<long>({(long)1})));
}


Prompt:
#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 higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.
// 3. The months should not be less than 1 or higher than 12.
// 4. The date should be in the format: mm-dd-yyyy
// >>> valid_date(("03-11-2000"))
// (true)
// >>> valid_date(("15-01-2012"))
// (false)
// >>> valid_date(("04-0-2040"))
// (false)
// >>> valid_date(("06-04-2020"))
// (true)
// >>> valid_date(("06/04/2020"))
// (false)
bool valid_date(std::string date) {


Prompt:
#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() {}
    bool operator==(std::vector<std::string> f) {
        return f0 == f ;
    }    bool operator==(long f) {
        return f1 == f ;
    }
};
// Given a string of words, return a vector of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// >>> split_words(("Hello world!"))
// std::vector<std::string>({(std::string)"Hello", (std::string)"world!"})
// >>> split_words(("Hello,world!"))
// std::vector<std::string>({(std::string)"Hello", (std::string)"world!"})
// >>> split_words(("abcdef"))
// 3
Union_std_vector_std_string__long split_words(std::string txt) {

}
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,!")) == std::vector<std::string>({(std::string)"Hello", (std::string)"world,!"}));
    assert(candidate(("Hello,Hello,world !")) == std::vector<std::string>({(std::string)"Hello,Hello,world", (std::string)"!"}));
    assert(candidate(("abcdef")) == 3);
    assert(candidate(("aaabb")) == 2);
    assert(candidate(("aaaBb")) == 1);
    assert(candidate(("")) == 0);
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of numbers, return whether or not they are sorted
// in ascending order. If vector has more than 1 duplicate of the same
// number, return false. Assume no negative numbers and only integers.
// Examples
// >>> is_sorted((std::vector<long>({(long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)7})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)4})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)2, (long)3, (long)4})))
// (false)
bool is_sorted(std::vector<long> lst) {

}
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));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)7}))) == (false));
    assert(candidate((std::vector<long>())) == (true));
    assert(candidate((std::vector<long>({(long)1}))) == (true));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)2, (long)3, (long)4}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)3, (long)3, (long)4}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)4}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (true));
}


Prompt:
#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 that its start is less or equal its end.
// Your task is to determine whether the length of intersection of these two
// intervals is a prime number.
// Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
// which its length is 1, which not a prime number.
// If the length of the intersection is a prime number, return "YES",
// otherwise, return "NO".
// If the two intervals don't intersect, return "NO".
// [input/output] samples:
// >>> intersection((std::make_tuple(1, 2)), (std::make_tuple(2, 3)))
// ("NO")
// >>> intersection((std::make_tuple(-1, 1)), (std::make_tuple(0, 4)))
// ("NO")
// >>> intersection((std::make_tuple(-3, -1)), (std::make_tuple(-5, 5)))
// ("YES")
std::string intersection(std::tuple<long, long> interval1, std::tuple<long, long> interval2) {

}
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(candidate((std::make_tuple(-2, 2)), (std::make_tuple(-4, 0))) == ("YES"));
    assert(candidate((std::make_tuple(-11, 2)), (std::make_tuple(-1, -1))) == ("NO"));
    assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(3, 5))) == ("NO"));
    assert(candidate((std::make_tuple(1, 2)), (std::make_tuple(1, 2))) == ("NO"));
    assert(candidate((std::make_tuple(-2, -2)), (std::make_tuple(-3, -2))) == ("NO"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector arr of integers and you need to return
// sum of magnitudes of integers multiplied by product of all signs
// of each number in the vector, represented by 1, -1 or 0.
// Note: return None for empty arr.
// Example:
// >>> prod_signs((std::vector<long>({(long)1, (long)2, (long)2, (long)-4})))
// 9
// >>> prod_signs((std::vector<long>({(long)0, (long)1})))
// 0
// >>> prod_signs((std::vector<long>()))
// std::nullopt
std::optional<long> prod_signs(std::vector<long> arr) {

}
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);
    assert(candidate((std::vector<long>())) == std::nullopt);
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)1, (long)2, (long)-1, (long)-1, (long)9}))) == 20);
    assert(candidate((std::vector<long>({(long)-1, (long)1, (long)-1, (long)1}))) == 4);
    assert(candidate((std::vector<long>({(long)-1, (long)1, (long)1, (long)1}))) == -4);
    assert(candidate((std::vector<long>({(long)-1, (long)1, (long)1, (long)0}))) == 0);
}


Prompt:
#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 grid. You can start
// from any cell, and in each step you can move to any of the neighbor cells,
// in other words, you can go to cells which share an edge with you current
// cell.
// Please note that a path of length k means visiting exactly k cells (not
// necessarily distinct).
// You CANNOT go off the grid.
// A path A (of length k) is considered less than a path B (of length k) if
// after making the ordered vectors of the values on the cells that A and B go
// through (let's call them lst_A and lst_B), lst_A is lexicographically less
// than lst_B, in other words, there exist an integer index i (1 <= i <= k)
// such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
// lst_A[j] = lst_B[j].
// It is guaranteed that the answer is unique.
// Return an ordered vector of the values on the cells that the minimum path go through.
// Examples:
// >>> minPath((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::vector<long>({(long)1, (long)2, (long)1}))
// >>> minPath((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1))
// (std::vector<long>({(long)1}))
std::vector<long> minPath(std::vector<std::vector<long>> grid, long k) {

}
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::vector<long>({(long)1, (long)2, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1)) == (std::vector<long>({(long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4}), (std::vector<long>)std::vector<long>({(long)5, (long)6, (long)7, (long)8}), (std::vector<long>)std::vector<long>({(long)9, (long)10, (long)11, (long)12}), (std::vector<long>)std::vector<long>({(long)13, (long)14, (long)15, (long)16})})), (4)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)10}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)12, (long)1}), (std::vector<long>)std::vector<long>({(long)3, (long)16, (long)11, (long)15}), (std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2})})), (7)) == (std::vector<long>({(long)1, (long)10, (long)1, (long)10, (long)1, (long)10, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2}), (std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)15}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)1, (long)12}), (std::vector<long>)std::vector<long>({(long)3, (long)10, (long)11, (long)16})})), (5)) == (std::vector<long>({(long)1, (long)7, (long)1, (long)7, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1})})), (9)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2})})), (12)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4}), (std::vector<long>)std::vector<long>({(long)3, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)6, (long)8, (long)9})})), (8)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)3, (long)8, (long)9}), (std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4})})), (8)) == (std::vector<long>({(long)1, (long)5, (long)1, (long)5, (long)1, (long)5, (long)1, (long)5})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2}), (std::vector<long>)std::vector<long>({(long)3, (long)4})})), (10)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)3}), (std::vector<long>)std::vector<long>({(long)3, (long)2})})), (10)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Out of vector of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return None in case the input vector is empty.
// >>> longest((std::vector<std::string>()))
// std::nullopt
// >>> longest((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"c"})))
// "a"
// >>> longest((std::vector<std::string>({(std::string)"a", (std::string)"bb", (std::string)"ccc"})))
// "ccc"
std::optional<std::string> longest(std::vector<std::string> strings) {

}
int main() {
    auto candidate = longest;
    assert(candidate((std::vector<std::string>())) == std::nullopt);
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z"}))) == "x");
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"yyy", (std::string)"zzzz", (std::string)"www", (std::string)"kkkk", (std::string)"abc"}))) == "zzzz");
}


Prompt:
#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.
// tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
// For example:
// tri(2) = 1 + (2 / 2) = 2
// tri(4) = 3
// tri(3) = tri(2) + tri(1) + tri(4)
// = 2 + 3 + 3 = 8
// You are given a non-negative integer number n, you have to a return a vector of the
// first n + 1 numbers of the Tribonacci sequence.
// Examples:
// >>> tri((3))
// (std::vector<long>({(long)1, (long)3, (long)2, (long)8}))
std::vector<long> tri(long n) {

}
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, (long)15})));
    assert(candidate((6)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4})));
    assert(candidate((7)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24})));
    assert(candidate((8)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5})));
    assert(candidate((9)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35})));
    assert(candidate((20)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35, (long)6, (long)48, (long)7, (long)63, (long)8, (long)80, (long)9, (long)99, (long)10, (long)120, (long)11})));
    assert(candidate((0)) == (std::vector<long>({(long)1})));
    assert(candidate((1)) == (std::vector<long>({(long)1, (long)3})));
}


Prompt:
#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) {

}
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));
}


Prompt:
#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_nested(("[]]]]]]][[[[[]"))
// (false)
// >>> is_nested(("[][]"))
// (false)
// >>> is_nested(("[]"))
// (false)
// >>> is_nested(("[[][]]"))
// (true)
// >>> is_nested(("[[]][["))
// (true)
bool is_nested(std::string string) {

}
int main() {
    auto candidate = is_nested;
    assert(candidate(("[[]]")) == (true));
    assert(candidate(("[]]]]]]][[[[[]")) == (false));
    assert(candidate(("[][]")) == (false));
    assert(candidate(("[]")) == (false));
    assert(candidate(("[[[[]]]]")) == (true));
    assert(candidate(("[]]]]]]]]]]")) == (false));
    assert(candidate(("[][][[]]")) == (true));
    assert(candidate(("[[]")) == (false));
    assert(candidate(("[]]")) == (false));
    assert(candidate(("[[]][[")) == (true));
    assert(candidate(("[[][]]")) == (true));
    assert(candidate(("")) == (false));
    assert(candidate(("[[[[[[[[")) == (false));
    assert(candidate(("]]]]]]]]")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of numbers.
// You need to return the sum of squared numbers in the given vector,
// round each element in the vector to the upper int(Ceiling) first.
// Examples:
// >>> lst((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})))
// (14)
// >>> lst((std::vector<float>({(float)1.0f, (float)4.0f, (float)9.0f})))
// (98)
// >>> lst((std::vector<float>({(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f})))
// (84)
// >>> lst((std::vector<float>({(float)1.4f, (float)4.2f, (float)0.0f})))
// (29)
// >>> lst((std::vector<float>({(float)-2.4f, (float)1.0f, (float)1.0f})))
// (6)
long sum_squares(std::vector<float> lst) {

}
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, (float)7.0f}))) == (84));
    assert(candidate((std::vector<float>({(float)1.4f, (float)4.2f, (float)0.0f}))) == (29));
    assert(candidate((std::vector<float>({(float)-2.4f, (float)1.0f, (float)1.0f}))) == (6));
    assert(candidate((std::vector<float>({(float)100.0f, (float)1.0f, (float)15.0f, (float)2.0f}))) == (10230));
    assert(candidate((std::vector<float>({(float)10000.0f, (float)10000.0f}))) == (200000000));
    assert(candidate((std::vector<float>({(float)-1.4f, (float)4.6f, (float)6.3f}))) == (75));
    assert(candidate((std::vector<float>({(float)-1.4f, (float)17.9f, (float)18.9f, (float)19.9f}))) == (1086));
    assert(candidate((std::vector<float>({(float)0.0f}))) == (0));
    assert(candidate((std::vector<float>({(float)-1.0f}))) == (1));
    assert(candidate((std::vector<float>({(float)-1.0f, (float)1.0f, (float)0.0f}))) == (2));
}


Prompt:
#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(("apple pie"))
// (false)
// >>> check_if_last_char_is_a_letter(("apple pi e"))
// (true)
// >>> check_if_last_char_is_a_letter(("apple pi e "))
// (false)
// >>> check_if_last_char_is_a_letter((""))
// (false)
bool check_if_last_char_is_a_letter(std::string txt) {

}
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(("Pumpkin pie 1")) == (false));
    assert(candidate(("")) == (false));
    assert(candidate(("eeeee e ")) == (false));
    assert(candidate(("apple pie")) == (false));
    assert(candidate(("apple pi e ")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Create a function which returns the largest index of an element which
// is not greater than or equal to the element immediately preceding it. If
// no such element exists then return -1. The given vector will not contain
// duplicate values.
// Examples:
// >>> can_arrange((std::vector<long>({(long)1, (long)2, (long)4, (long)3, (long)5})))
// (3)
// >>> can_arrange((std::vector<long>({(long)1, (long)2, (long)3})))
// (-1)
long can_arrange(std::vector<long> arr) {

}
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)6, (long)7, (long)8, (long)9, (long)10}))) == (2));
    assert(candidate((std::vector<long>({(long)4, (long)8, (long)5, (long)7, (long)3}))) == (4));
    assert(candidate((std::vector<long>())) == (-1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Create a function that returns a tuple (a, b), where 'a' is
// the largest of negative integers, and 'b' is the smallest
// of positive integers in a vector.
// If there is no negative or positive integers, return them as None.
// Examples:
// >>> largest_smallest_integers((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))
// >>> largest_smallest_integers((std::vector<long>()))
// std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt))
// >>> largest_smallest_integers((std::vector<long>({(long)0})))
// std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt))
std::tuple<std::optional<long>, std::optional<long>> largest_smallest_integers(std::vector<long> lst) {

}
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, (long)5, (long)7, (long)0}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(1)));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)-2}))) == std::make_tuple(-2, 1));
    assert(candidate((std::vector<long>({(long)4, (long)5, (long)3, (long)6, (long)2, (long)7, (long)-7}))) == std::make_tuple(-7, 2));
    assert(candidate((std::vector<long>({(long)7, (long)3, (long)8, (long)4, (long)9, (long)2, (long)5, (long)-9}))) == std::make_tuple(-9, 2));
    assert(candidate((std::vector<long>())) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt)));
    assert(candidate((std::vector<long>({(long)0}))) == std::make_tuple(std::optional<long>(std::nullopt), std::optional<long>(std::nullopt)));
    assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)-5, (long)-6}))) == std::make_tuple(std::optional<long>(-1), std::optional<long>(std::nullopt)));
    assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)-5, (long)-6, (long)0}))) == std::make_tuple(std::optional<long>(-1), std::optional<long>(std::nullopt)));
    assert(candidate((std::vector<long>({(long)-6, (long)-4, (long)-4, (long)-3, (long)1}))) == std::make_tuple(-3, 1));
    assert(candidate((std::vector<long>({(long)-6, (long)-4, (long)-4, (long)-3, (long)-100, (long)1}))) == std::make_tuple(-3, 1));
}


Prompt:
#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_std_string() {}
    bool operator==(long f) {
        return f0 == f ;
    }    bool operator==(float f) {
        return f1 == f ;
    }    bool operator==(std::string f) {
        return f2 == f ;
    }
};
union Union_long_float_std_string_std_nullopt{
    long f0;
    float f1;
    std::string f2;
    std::nullopt f3;    Union_long_float_std_string_std_nullopt(long _f0) : f0(_f0) {}
    Union_long_float_std_string_std_nullopt(float _f1) : f1(_f1) {}
    Union_long_float_std_string_std_nullopt(std::string _f2) : f2(_f2) {}
    Union_long_float_std_string_std_nullopt(std::nullopt _f3) : f3(_f3) {}
    ~Union_long_float_std_string_std_nullopt() {}
    bool operator==(long f) {
        return f0 == f ;
    }    bool operator==(float f) {
        return f1 == f ;
    }    bool operator==(std::string f) {
        return f2 == f ;
    }    bool operator==(std::nullopt f) {
        return f3 == f ;
    }
};
// Create a function that takes integers, floats, or strings representing
// real numbers, and returns the larger variable in its given variable type.
// Return None if the values are equal.
// Note: If a real number is represented as a string, the floating point might be . or ,
// >>> compare_one(1, 2.5f)
// 2.5f
// >>> compare_one(1, "2,3")
// "2,3"
// >>> compare_one("5,1", "6")
// "6"
// >>> compare_one("1", 1)
// std::nullopt
Union_long_float_std_string_std_nullopt compare_one(Union_long_float_std_string a, Union_long_float_std_string b) {

}
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");
    assert(candidate("1", 1) == std::nullopt);
}


Prompt:
#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) {

}
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)) == (false));
    assert(candidate((16)) == (true));
}


Prompt:
#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.
long special_factorial(long n) {

}
int main() {
    auto candidate = special_factorial;
    assert(candidate((4)) == (288));
    assert(candidate((5)) == (34560));
    assert(candidate((7)) == (125411328000));
    assert(candidate((1)) == (1));
}


Prompt:
#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) {

}
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));
}


Prompt:
#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"))
// ("_Example_2")
// >>> fix_spaces((" Example 3"))
// ("_Example-3")
std::string fix_spaces(std::string text) {

}
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"));
    assert(candidate(("   Exa 1 2 2 mple")) == ("-Exa_1_2_2_mple"));
}


Prompt:
#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 more than three digits ('0'-'9') in the file's name.
// - The file's name contains exactly one dot '.'
// - The substring before the dot should not be empty, and it starts with a letter from
// the latin alphapet ('a'-'z' and 'A'-'Z').
// - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
// Examples:
// >>> file_name_check(("example.txt"))
// ("Yes")
// >>> file_name_check(("1example.dll"))
// ("No")
std::string file_name_check(std::string file_name) {

}
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(candidate(("His12FILE94.exe")) == ("No"));
    assert(candidate(("_Y.txt")) == ("No"));
    assert(candidate(("?aREYA.exe")) == ("No"));
    assert(candidate(("/this_is_valid.dll")) == ("No"));
    assert(candidate(("this_is_valid.wow")) == ("No"));
    assert(candidate(("this_is_valid.txt")) == ("Yes"));
    assert(candidate(("this_is_valid.txtexe")) == ("No"));
    assert(candidate(("#this2_i4s_5valid.ten")) == ("No"));
    assert(candidate(("@this1_is6_valid.exe")) == ("No"));
    assert(candidate(("this_is_12valid.6exe4.txt")) == ("No"));
    assert(candidate(("all.exe.txt")) == ("No"));
    assert(candidate(("I563_No.exe")) == ("Yes"));
    assert(candidate(("Is3youfault.txt")) == ("Yes"));
    assert(candidate(("no_one#knows.dll")) == ("Yes"));
    assert(candidate(("1I563_Yes3.exe")) == ("No"));
    assert(candidate(("I563_Yes3.txtt")) == ("No"));
    assert(candidate(("final..txt")) == ("No"));
    assert(candidate(("final132")) == ("No"));
    assert(candidate(("_f4indsartal132.")) == ("No"));
    assert(candidate((".txt")) == ("No"));
    assert(candidate(("s.")) == ("No"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// "
// This function will take a vector of integers. For all entries in the vector, the function shall square the integer entry if its index is a
// multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
// change the entries in the vector whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries.
// Examples:
// >>> lst
// (long({(long)1, (long)2, (long)3}))
// >>> lst
// (long())
// >>> lst
// (long({(long)-1, (long)-5, (long)2, (long)-1, (long)-5}))
long sum_squares(std::vector<long> lst) {

}
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, (long)1, (long)1, (long)1, (long)1, (long)1, (long)1, (long)1}))) == (9));
    assert(candidate((std::vector<long>({(long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1, (long)-1}))) == (-3));
    assert(candidate((std::vector<long>({(long)0}))) == (0));
    assert(candidate((std::vector<long>({(long)-1, (long)-5, (long)2, (long)-1, (long)-5}))) == (-126));
    assert(candidate((std::vector<long>({(long)-56, (long)-99, (long)1, (long)0, (long)-2}))) == (3030));
    assert(candidate((std::vector<long>({(long)-1, (long)0, (long)0, (long)0, (long)0, (long)0, (long)0, (long)0, (long)-1}))) == (0));
    assert(candidate((std::vector<long>({(long)-16, (long)-9, (long)-2, (long)36, (long)36, (long)26, (long)-20, (long)25, (long)-40, (long)20, (long)-4, (long)12, (long)-26, (long)35, (long)37}))) == (-14196));
    assert(candidate((std::vector<long>({(long)-1, (long)-3, (long)17, (long)-1, (long)-15, (long)13, (long)-1, (long)14, (long)-14, (long)-12, (long)-5, (long)14, (long)-14, (long)6, (long)13, (long)11, (long)16, (long)16, (long)4, (long)10}))) == (-1448));
}


Prompt:
#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 should be the same as the original one.
// Example 1:
// >>> words_in_sentence(("This is a test"))
// ("is")
// Example 2:
// >>> words_in_sentence(("lets go for swimming"))
// ("go for")
// Constraints:
// * 1 <= len(sentence) <= 100
// * sentence contains only letters
std::string words_in_sentence(std::string sentence) {

}
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"));
    assert(candidate(("go for it")) == ("go for it"));
    assert(candidate(("here")) == (""));
    assert(candidate(("here is")) == ("is"));
}


Prompt:
#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>/<denominator> where both numerator and denominator are positive whole numbers.
// You can assume that x, and n are valid fractions, and do not have zero as denominator.
// >>> simplify(("1/5"), ("5/1"))
// (true)
// >>> simplify(("1/6"), ("2/1"))
// (false)
// >>> simplify(("7/10"), ("10/2"))
// (false)
bool simplify(std::string x, std::string n) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function which sorts the given vector of integers
// in ascending order according to the sum of their digits.
// Note: if there are several items with similar sum of their digits,
// order them based on their index in original vector.
// For example:
// >>> order_by_points((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}))
// >>> order_by_points((std::vector<long>()))
// (std::vector<long>())
std::vector<long> order_by_points(std::vector<long> nums) {

}
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, (long)423, (long)423, (long)53, (long)6, (long)37, (long)3457, (long)3, (long)56, (long)0, (long)46}))) == (std::vector<long>({(long)0, (long)2, (long)3, (long)6, (long)53, (long)423, (long)423, (long)423, (long)1234, (long)145, (long)37, (long)46, (long)56, (long)463, (long)3457})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)-11, (long)-32, (long)43, (long)54, (long)-98, (long)2, (long)-3}))) == (std::vector<long>({(long)-3, (long)-32, (long)-98, (long)-11, (long)1, (long)2, (long)43, (long)54})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9, (long)10, (long)11}))) == (std::vector<long>({(long)1, (long)10, (long)2, (long)11, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9})));
    assert(candidate((std::vector<long>({(long)0, (long)6, (long)6, (long)-76, (long)-21, (long)23, (long)4}))) == (std::vector<long>({(long)-76, (long)-21, (long)0, (long)4, (long)23, (long)6, (long)6})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a vector of numbers as input and returns
// the number of elements in the vector that are greater than 10 and both
// first and last digits of a number are odd (1, 3, 5, 7, 9).
// For example:
// >>> specialFilter((std::vector<long>({(long)15, (long)-73, (long)14, (long)-15})))
// (1)
// >>> specialFilter((std::vector<long>({(long)33, (long)-2, (long)-3, (long)45, (long)21, (long)109})))
// (2)
long specialFilter(std::vector<long> nums) {

}
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, (long)21, (long)109}))) == (2));
    assert(candidate((std::vector<long>({(long)43, (long)-12, (long)93, (long)125, (long)121, (long)109}))) == (4));
    assert(candidate((std::vector<long>({(long)71, (long)-2, (long)-33, (long)75, (long)21, (long)19}))) == (3));
    assert(candidate((std::vector<long>({(long)1}))) == (0));
    assert(candidate((std::vector<long>())) == (0));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a positive integer n. You have to create an integer vector a of length n.
// For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
// Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
// and a[i] + a[j] + a[k] is a multiple of 3.
// Example :
// >>> get_max_triples((5))
// (1)
// Explanation:
// a = [1, 3, 7, 13, 21]
// The only valid triple is (1, 7, 13).
long get_max_triples(long n) {

}
int main() {
    auto candidate = get_max_triples;
    assert(candidate((5)) == (1));
    assert(candidate((6)) == (4));
    assert(candidate((10)) == (36));
    assert(candidate((100)) == (53361));
}


Prompt:
#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 a tuple containing all planets whose orbits are
// located between the orbit of planet1 and the orbit of planet2, sorted by
// the proximity to the sun.
// The function should return an empty tuple if planet1 or planet2
// are not correct planet names.
// Examples
// >>> bf(("Jupiter"), ("Neptune"))
// (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"}))
// >>> bf(("Earth"), ("Mercury"))
// (std::vector<std::string>("Venus"))
// >>> bf(("Mercury"), ("Uranus"))
// (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"}))
std::vector<std::string> bf(std::string planet1, std::string planet2) {

}
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")) == (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"})));
    assert(candidate(("Neptune"), ("Venus")) == (std::vector<std::string>({(std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn", (std::string)"Uranus"})));
    assert(candidate(("Earth"), ("Earth")) == (std::vector<std::string>()));
    assert(candidate(("Mars"), ("Earth")) == (std::vector<std::string>()));
    assert(candidate(("Jupiter"), ("Makemake")) == (std::vector<std::string>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts a vector of strings as a parameter,
// deletes the strings that have odd lengths from it,
// and returns the resulted vector with a sorted order,
// The vector is always a vector of strings and never a vector of numbers,
// and it may contain duplicates.
// The order of the vector should be ascending by length of each word, and you
// should return the vector sorted by that rule.
// If two words have the same length, sort the vector alphabetically.
// The function should return a vector of strings in sorted order.
// You may assume that all words will have the same length.
// For example:
// >>> list_sort((std::vector<std::string>({(std::string)"aa", (std::string)"a", (std::string)"aaa"})))
// (std::vector<std::string>({(std::string)"aa"}))
// >>> list_sort((std::vector<std::string>({(std::string)"ab", (std::string)"a", (std::string)"aaa", (std::string)"cd"})))
// (std::vector<std::string>({(std::string)"ab", (std::string)"cd"}))
std::vector<std::string> sorted_list_sum(std::vector<std::string> lst) {

}
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)"asdf", (std::string)"b"}))) == (std::vector<std::string>({(std::string)"AI", (std::string)"asdf", (std::string)"school"})));
    assert(candidate((std::vector<std::string>({(std::string)"d", (std::string)"b", (std::string)"c", (std::string)"a"}))) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"d", (std::string)"dcba", (std::string)"abcd", (std::string)"a"}))) == (std::vector<std::string>({(std::string)"abcd", (std::string)"dcba"})));
    assert(candidate((std::vector<std::string>({(std::string)"AI", (std::string)"ai", (std::string)"au"}))) == (std::vector<std::string>({(std::string)"AI", (std::string)"ai", (std::string)"au"})));
    assert(candidate((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"b", (std::string)"c", (std::string)"c", (std::string)"a"}))) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"aaaa", (std::string)"bbbb", (std::string)"dd", (std::string)"cc"}))) == (std::vector<std::string>({(std::string)"cc", (std::string)"dd", (std::string)"aaaa", (std::string)"bbbb"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return vector of all prefixes from shortest to longest of the input string
// >>> all_prefixes(("abc"))
// (std::vector<std::string>({(std::string)"a", (std::string)"ab", (std::string)"abc"}))
std::vector<std::string> all_prefixes(std::string string) {

}
int main() {
    auto candidate = all_prefixes;
    assert(candidate(("")) == (std::vector<std::string>()));
    assert(candidate(("asdfgh")) == (std::vector<std::string>({(std::string)"a", (std::string)"as", (std::string)"asd", (std::string)"asdf", (std::string)"asdfg", (std::string)"asdfgh"})));
    assert(candidate(("WWW")) == (std::vector<std::string>({(std::string)"W", (std::string)"WW", (std::string)"WWW"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// A simple program which should return the value of x if n is
// a prime number and should return the value of y otherwise.
// Examples:
// >>> x_or_y((7), (34), (12))
// (34)
// >>> x_or_y((15), (8), (5))
// (5)
long x_or_y(long n, long x, long y) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of numbers, return the sum of squares of the numbers
// in the vector that are odd. Ignore numbers that are negative or not integers.
// >>> double_the_difference((std::vector<float>({(long)1, (long)3, (long)2, (long)0})))
// (10)
// >>> double_the_difference((std::vector<float>({(long)-1, (long)-2, (long)0})))
// (0)
// >>> double_the_difference((std::vector<float>({(long)9, (long)-2})))
// (81)
// >>> double_the_difference((std::vector<float>({(long)0})))
// (0)
// If the input vector is empty, return 0.
long double_the_difference(std::vector<float> lst) {

}
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<float>({(float)-10.0f, (float)-20.0f, (float)-30.0f}))) == (0));
    assert(candidate((std::vector<float>({(float)-1.0f, (float)-2.0f, (float)8.0f}))) == (0));
    assert(candidate((std::vector<float>({(float)0.2f, (float)3.0f, (float)5.0f}))) == (34));
    assert(candidate((std::vector<float>({(float)-9.0f, (float)-7.0f, (float)-5.0f, (float)-3.0f, (float)-1.0f, (float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f, (float)9.0f}))) == (165));
}


Prompt:
#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 of a number of matches.
// You are given two vectors of scores and guesses of equal length, where each index shows a match.
// Return a vector of the same length denoting how far off each guess was. If they have guessed correctly,
// the value is 0, and if not, the value is the absolute difference between the guess and the score.
// example:
// >>> compare((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}))
// >>> compare((std::vector<long>({(long)0, (long)5, (long)0, (long)0, (long)0, (long)4})), (std::vector<long>({(long)4, (long)1, (long)1, (long)0, (long)0, (long)-2})))
// (std::vector<long>({(long)4, (long)4, (long)1, (long)0, (long)0, (long)6}))
std::vector<long> compare(std::vector<long> game, std::vector<long> guess) {

}
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(candidate((std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0})), (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0}))) == (std::vector<long>({(long)0, (long)0, (long)0, (long)0, (long)0, (long)0})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3})), (std::vector<long>({(long)-1, (long)-2, (long)-3}))) == (std::vector<long>({(long)2, (long)4, (long)6})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5})), (std::vector<long>({(long)-1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)2, (long)0, (long)0, (long)1})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You will be given the name of a class (a string) and a vector of extensions.
// The extensions are to be used to load additional classes to the class. The
// strength of the extension is as follows: Let CAP be the number of the uppercase
// letters in the extension's name, and let SM be the number of lowercase letters
// in the extension's name, the strength is given by the fraction CAP - SM.
// You should find the strongest extension and return a string in this
// format: ClassName.StrongestExtensionName.
// If there are two or more extensions with the same strength, you should
// choose the one that comes first in the vector.
// For example, if you are given "Slices" as the class and a vector of the
// extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
// return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension
// (its strength is -1).
// Example:
// >>> Strongest_Extension(("my_class"), (std::vector<std::string>({(std::string)"AA", (std::string)"Be", (std::string)"CC"})))
// ("my_class.AA")
std::string Strongest_Extension(std::string class_name, std::vector<std::string> extensions) {

}
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", (std::string)"YEs.WeCaNe", (std::string)"32145tggg"}))) == ("Boku123.YEs.WeCaNe"));
    assert(candidate(("__YESIMHERE"), (std::vector<std::string>({(std::string)"t", (std::string)"eMptY", (std::string)"nothing", (std::string)"zeR00", (std::string)"NuLl__", (std::string)"123NoooneB321"}))) == ("__YESIMHERE.NuLl__"));
    assert(candidate(("K"), (std::vector<std::string>({(std::string)"Ta", (std::string)"TAR", (std::string)"t234An", (std::string)"cosSo"}))) == ("K.TAR"));
    assert(candidate(("__HAHA"), (std::vector<std::string>({(std::string)"Tab", (std::string)"123", (std::string)"781345", (std::string)"-_-"}))) == ("__HAHA.123"));
    assert(candidate(("YameRore"), (std::vector<std::string>({(std::string)"HhAas", (std::string)"okIWILL123", (std::string)"WorkOut", (std::string)"Fails", (std::string)"-_-"}))) == ("YameRore.okIWILL123"));
    assert(candidate(("finNNalLLly"), (std::vector<std::string>({(std::string)"Die", (std::string)"NowW", (std::string)"Wow", (std::string)"WoW"}))) == ("finNNalLLly.WoW"));
    assert(candidate(("_"), (std::vector<std::string>({(std::string)"Bb", (std::string)"91245"}))) == ("_.Bb"));
    assert(candidate(("Sp"), (std::vector<std::string>({(std::string)"671235", (std::string)"Bb"}))) == ("Sp.671235"));
}


Prompt:
#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_check(("abab"), ("baa"))
// (true)
// >>> cycpattern_check(("efef"), ("eeff"))
// (false)
// >>> cycpattern_check(("himenss"), ("simen"))
// (true)
bool cycpattern_check(std::string a, std::string b) {

}
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));
    assert(candidate(("winemtt"), ("tinem")) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given an integer. return a tuple that has the number of even and odd digits respectively.
// Example:
// >>> even_odd_count((-12))
// (std::make_tuple(1, 1))
// >>> even_odd_count((123))
// (std::make_tuple(1, 2))
std::tuple<long, long> even_odd_count(long num) {

}
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)) == (std::make_tuple(3, 3)));
    assert(candidate((-2)) == (std::make_tuple(1, 0)));
    assert(candidate((-45347)) == (std::make_tuple(2, 3)));
    assert(candidate((0)) == (std::make_tuple(1, 0)));
}


Prompt:
#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")
std::string int_to_mini_roman(long number) {

}
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((4)) == ("iv"));
    assert(candidate((43)) == ("xliii"));
    assert(candidate((90)) == ("xc"));
    assert(candidate((94)) == ("xciv"));
    assert(candidate((532)) == ("dxxxii"));
    assert(candidate((900)) == ("cm"));
    assert(candidate((994)) == ("cmxciv"));
    assert(candidate((1000)) == ("m"));
}


Prompt:
#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))
// (true)
// >>> right_angle_triangle((1), (2), (3))
// (false)
bool right_angle_triangle(long a, long b, long c) {

}
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(candidate((10), (5), (7)) == (false));
    assert(candidate((5), (12), (13)) == (true));
    assert(candidate((15), (8), (17)) == (true));
    assert(candidate((48), (55), (73)) == (true));
    assert(candidate((1), (1), (1)) == (false));
    assert(candidate((2), (2), (10)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts a vector of strings.
// The vector contains different words. Return the word with maximum number
// of unique characters. If multiple strings have maximum number of unique
// characters, return the one which comes first in lexicographical order.
// >>> find_max((std::vector<std::string>({(std::string)"name", (std::string)"of", (std::string)"string"})))
// ("string")
// >>> find_max((std::vector<std::string>({(std::string)"name", (std::string)"enam", (std::string)"game"})))
// ("enam")
// >>> find_max((std::vector<std::string>({(std::string)"aaaaaaa", (std::string)"bb", (std::string)"cc"})))
// ("aaaaaaa")
std::string find_max(std::vector<std::string> words) {

}
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(candidate((std::vector<std::string>({(std::string)"aaaaaaa", (std::string)"bb", (std::string)"cc"}))) == ("aaaaaaa"));
    assert(candidate((std::vector<std::string>({(std::string)"abc", (std::string)"cba"}))) == ("abc"));
    assert(candidate((std::vector<std::string>({(std::string)"play", (std::string)"this", (std::string)"game", (std::string)"of", (std::string)"footbott"}))) == ("footbott"));
    assert(candidate((std::vector<std::string>({(std::string)"we", (std::string)"are", (std::string)"gonna", (std::string)"rock"}))) == ("gonna"));
    assert(candidate((std::vector<std::string>({(std::string)"we", (std::string)"are", (std::string)"a", (std::string)"mad", (std::string)"nation"}))) == ("nation"));
    assert(candidate((std::vector<std::string>({(std::string)"this", (std::string)"is", (std::string)"a", (std::string)"prrk"}))) == ("this"));
    assert(candidate((std::vector<std::string>({(std::string)"b"}))) == ("b"));
    assert(candidate((std::vector<std::string>({(std::string)"play", (std::string)"play", (std::string)"play"}))) == ("play"));
}