Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given vector of numbers (of at least two elements), apply a linear transform to that vector,
// such that the smallest number will become 0 and the largest will become 1
// >>> rescale_to_unit((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f})))
// (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))
std::vector<float> rescale_to_unit(std::vector<float> numbers) {

}
int main() {
    auto candidate = rescale_to_unit;
    assert(candidate((std::vector<float>({(float)2.0f, (float)49.9f}))) == (std::vector<float>({(float)0.0f, (float)1.0f})));
    assert(candidate((std::vector<float>({(float)100.0f, (float)49.9f}))) == (std::vector<float>({(float)1.0f, (float)0.0f})));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f})));
    assert(candidate((std::vector<float>({(float)2.0f, (float)1.0f, (float)5.0f, (float)3.0f, (float)4.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
    assert(candidate((std::vector<float>({(float)12.0f, (float)11.0f, (float)15.0f, (float)13.0f, (float)14.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
}


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 vector representing a branch of a tree that has non-negative integer nodes
// your task is to pluck one of the nodes and return it.
// The plucked node should be the node with the smallest even value.
// If multiple nodes with the same smallest even value are found return the node that has smallest index.
// The plucked node should be returned in a vector, [ smalest_value, its index ],
// If there are no even values or the given vector is empty, return [].
// Example 1:
// >>> pluck((std::vector<long>({(long)4, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 2:
// >>> pluck((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 3:
// >>> pluck((std::vector<long>()))
// (std::vector<long>())
// Example 4:
// >>> pluck((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2})))
// (std::vector<long>({(long)0, (long)1}))
// Explanation: 0 is the smallest value, but  there are two zeros,
// so we will choose the first zero, which has the smallest index.
// Constraints:
// * 1 <= nodes.length <= 10000
// * 0 <= node.value
std::vector<long> pluck(std::vector<long> arr) {

}
int main() {
    auto candidate = pluck;
    assert(candidate((std::vector<long>({(long)4, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2}))) == (std::vector<long>({(long)0, (long)1})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)0, (long)5, (long)3}))) == (std::vector<long>({(long)0, (long)3})));
    assert(candidate((std::vector<long>({(long)5, (long)4, (long)8, (long)4, (long)8}))) == (std::vector<long>({(long)4, (long)1})));
    assert(candidate((std::vector<long>({(long)7, (long)6, (long)7, (long)1}))) == (std::vector<long>({(long)6, (long)1})));
    assert(candidate((std::vector<long>({(long)7, (long)9, (long)7, (long)1}))) == (std::vector<long>()));
}


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>
// 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>
// Return median of elements in the vector l.
// >>> median((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (float(3))
// >>> median((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20})))
// (15.0f)
float median(std::vector<long> l) {

}
int main() {
    auto candidate = median;
    assert(candidate((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5}))) == (float(3)));
    assert(candidate((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20}))) == (8.0f));
    assert(candidate((std::vector<long>({(long)5}))) == (float(5)));
    assert(candidate((std::vector<long>({(long)6, (long)5}))) == (5.5f));
    assert(candidate((std::vector<long>({(long)8, (long)1, (long)3, (long)9, (long)9, (long)2, (long)7}))) == (float(7)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a string and returns true if the string
// length is a prime number or false otherwise
// Examples
// >>> prime_length(("Hello"))
// (true)
// >>> prime_length(("abcdcba"))
// (true)
// >>> prime_length(("kittens"))
// (true)
// >>> prime_length(("orange"))
// (false)
bool prime_length(std::string string) {

}
int main() {
    auto candidate = prime_length;
    assert(candidate(("Hello")) == (true));
    assert(candidate(("abcdcba")) == (true));
    assert(candidate(("kittens")) == (true));
    assert(candidate(("orange")) == (false));
    assert(candidate(("wow")) == (true));
    assert(candidate(("world")) == (true));
    assert(candidate(("MadaM")) == (true));
    assert(candidate(("Wow")) == (true));
    assert(candidate(("")) == (false));
    assert(candidate(("HI")) == (true));
    assert(candidate(("go")) == (true));
    assert(candidate(("gogo")) == (false));
    assert(candidate(("aaaaaaaaaaaaaaa")) == (false));
    assert(candidate(("Madam")) == (true));
    assert(candidate(("M")) == (false));
    assert(candidate(("0")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector arr of integers, find the minimum number of elements that
// need to be changed to make the vector palindromic. A palindromic vector is a vector that
// is read the same backwards and forwards. In one change, you can change one element to any other element.
// For example:
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6})))
// (4)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2})))
// (1)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1})))
// (0)
long smallest_change(std::vector<long> arr) {

}
int main() {
    auto candidate = smallest_change;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6}))) == (4));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)4, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1}))) == (0));
    assert(candidate((std::vector<long>({(long)3, (long)1, (long)1, (long)3}))) == (0));
    assert(candidate((std::vector<long>({(long)1}))) == (0));
    assert(candidate((std::vector<long>({(long)0, (long)1}))) == (1));
}


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 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>
// triples_sum_to_zero takes a vector of integers as an input.
// it returns true if there are three distinct elements in the vector that
// sum to zero, and false otherwise.
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)-2, (long)1})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)2, (long)3, (long)7})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1})))
// (false)
bool triples_sum_to_zero(std::vector<long> l) {

}
int main() {
    auto candidate = triples_sum_to_zero;
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)0}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)-2, (long)1}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)7}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)5, (long)7}))) == (false));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7}))) == (true));
    assert(candidate((std::vector<long>({(long)1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-100}))) == (false));
    assert(candidate((std::vector<long>({(long)100, (long)3, (long)5, (long)-100}))) == (false));
}


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>
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the vector of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// >>> separate_paren_groups(("( ) (( )) (( )( ))"))
// (std::vector<std::string>({(std::string)"()", (std::string)"(())", (std::string)"(()())"}))
std::vector<std::string> separate_paren_groups(std::string paren_string) {


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>
// Given a positive integer n, return the count of the numbers of n-digit
// positive integers that start or end with 1.
long starts_one_ends(long n) {

}
int main() {
    auto candidate = starts_one_ends;
    assert(candidate((1)) == (1));
    assert(candidate((2)) == (18));
    assert(candidate((3)) == (180));
    assert(candidate((4)) == (1800));
    assert(candidate((5)) == (18000));
}


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>
// 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>
// 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>
// Write a function that takes a string and returns an ordered version of it.
// Ordered version of string, is a string where all words (separated by space)
// are replaced by a new word where all the characters arranged in
// ascending order based on ascii value.
// Note: You should keep the order of words and blank spaces in the sentence.
// For example:
// >>> anti_shuffle(("Hi"))
// ("Hi")
// >>> anti_shuffle(("hello"))
// ("ehllo")
// >>> anti_shuffle(("Hello World!!!"))
// ("Hello !!!Wdlor")
std::string anti_shuffle(std::string s) {

}
int main() {
    auto candidate = anti_shuffle;
    assert(candidate(("Hi")) == ("Hi"));
    assert(candidate(("hello")) == ("ehllo"));
    assert(candidate(("number")) == ("bemnru"));
    assert(candidate(("abcd")) == ("abcd"));
    assert(candidate(("Hello World!!!")) == ("Hello !!!Wdlor"));
    assert(candidate(("")) == (""));
    assert(candidate(("Hi. My name is Mister Robot. How are you?")) == (".Hi My aemn is Meirst .Rboot How aer ?ouy"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Checks if given string is a palindrome
// >>> is_palindrome((""))
// (true)
// >>> is_palindrome(("aba"))
// (true)
// >>> is_palindrome(("aaaaa"))
// (true)
// >>> is_palindrome(("zbcd"))
// (false)
bool is_palindrome(std::string text) {

}
int main() {
    auto candidate = is_palindrome;
    assert(candidate(("")) == (true));
    assert(candidate(("aba")) == (true));
    assert(candidate(("aaaaa")) == (true));
    assert(candidate(("zbcd")) == (false));
    assert(candidate(("xywyx")) == (true));
    assert(candidate(("xywyz")) == (false));
    assert(candidate(("xywzx")) == (false));
}


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>
// Return true if a given number is prime, and false otherwise.
// >>> is_prime((6))
// (false)
// >>> is_prime((101))
// (true)
// >>> is_prime((11))
// (true)
// >>> is_prime((13441))
// (true)
// >>> is_prime((61))
// (true)
// >>> is_prime((4))
// (false)
// >>> is_prime((1))
// (false)
bool is_prime(long n) {

}
int main() {
    auto candidate = is_prime;
    assert(candidate((6)) == (false));
    assert(candidate((101)) == (true));
    assert(candidate((11)) == (true));
    assert(candidate((13441)) == (true));
    assert(candidate((61)) == (true));
    assert(candidate((4)) == (false));
    assert(candidate((1)) == (false));
    assert(candidate((5)) == (true));
    assert(candidate((11)) == (true));
    assert(candidate((17)) == (true));
    assert(candidate((85)) == (false));
    assert(candidate((77)) == (false));
    assert(candidate((255379)) == (false));
}


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>
// You have been tasked to write a function that receives
// a hexadecimal number as a string and counts the number of hexadecimal
// digits that are primes (prime number, or a prime, is a natural number
// greater than 1 that is not a product of two smaller natural numbers).
// Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
// Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
// So you have to determine a number of the following digits: 2, 3, 5, 7,
// B (=decimal 11), D (=decimal 13).
// Note: you may assume the input is always correct or empty string,
// and symbols A,B,C,D,E,F are always uppercase.
// Examples:
// >>> hex_key(("AB"))
// (1)
// >>> hex_key(("1077E"))
// (2)
// >>> hex_key(("ABED1A33"))
// (4)
// >>> hex_key(("123456789ABCDEF0"))
// (6)
// >>> hex_key(("2020"))
// (2)
long hex_key(std::string num) {

}
int main() {
    auto candidate = hex_key;
    assert(candidate(("AB")) == (1));
    assert(candidate(("1077E")) == (2));
    assert(candidate(("ABED1A33")) == (4));
    assert(candidate(("2020")) == (2));
    assert(candidate(("123456789ABCDEF0")) == (6));
    assert(candidate(("112233445566778899AABBCCDDEEFF00")) == (12));
}


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>
// 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>
// You are given a 2 dimensional data, as a nested vectors,
// which is similar to matrix, however, unlike matrices,
// each row may contain a different number of columns.
// Given lst, and integer x, find integers x in the vector,
// and return vector of tuples, [(x1, y1), (x2, y2) ...] such that
// each tuple is a coordinate - (row, columns), starting with 0.
// Sort coordinates initially by rows in ascending order.
// Also, sort coordinates of the row by columns in descending order.
// Examples:
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)}))
// >>> get_row((std::vector<std::vector<long>>()), (1))
// (std::vector<std::tuple<long, long>>())
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)}))
std::vector<std::tuple<long, long>> get_row(std::vector<std::vector<long>> lst, long x) {

}
int main() {
    auto candidate = get_row;
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})})), (2)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 1), (std::tuple<long, long>)std::make_tuple(1, 1), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(3, 1), (std::tuple<long, long>)std::make_tuple(4, 1), (std::tuple<long, long>)std::make_tuple(5, 1)})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)1, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)1, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(2, 0), (std::tuple<long, long>)std::make_tuple(3, 2), (std::tuple<long, long>)std::make_tuple(3, 0), (std::tuple<long, long>)std::make_tuple(4, 3), (std::tuple<long, long>)std::make_tuple(4, 0), (std::tuple<long, long>)std::make_tuple(5, 4), (std::tuple<long, long>)std::make_tuple(5, 0), (std::tuple<long, long>)std::make_tuple(6, 5), (std::tuple<long, long>)std::make_tuple(6, 0)})));
    assert(candidate((std::vector<std::vector<long>>()), (1)) == (std::vector<std::tuple<long, long>>()));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1})})), (2)) == (std::vector<std::tuple<long, long>>()));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)})));
}


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>
// 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>
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// >>> sort_numbers(("three one five"))
// ("one three five")
std::string sort_numbers(std::string numbers) {

}
int main() {
    auto candidate = sort_numbers;
    assert(candidate(("")) == (""));
    assert(candidate(("three")) == ("three"));
    assert(candidate(("three five nine")) == ("three five nine"));
    assert(candidate(("five zero four seven nine eight")) == ("zero four five seven eight nine"));
    assert(candidate(("six five four three two one zero")) == ("zero one two three four five six"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
// >>> circular_shift((12), (1))
// ("21")
// >>> circular_shift((12), (2))
// ("12")
std::string circular_shift(long x, long shift) {


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 vector of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
// >>> skjkasdkd((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3})))
// (10)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1})))
// (25)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3})))
// (13)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6})))
// (11)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21})))
// (3)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7})))
// (7)
long skjkasdkd(std::vector<long> lst) {

}
int main() {
    auto candidate = skjkasdkd;
    assert(candidate((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3}))) == (10));
    assert(candidate((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1}))) == (25));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3}))) == (13));
    assert(candidate((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6}))) == (11));
    assert(candidate((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21}))) == (3));
    assert(candidate((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7}))) == (7));
    assert(candidate((std::vector<long>({(long)8191}))) == (19));
    assert(candidate((std::vector<long>({(long)8191, (long)123456, (long)127, (long)7}))) == (19));
    assert(candidate((std::vector<long>({(long)127, (long)97, (long)8192}))) == (10));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given vector of integers, return a tuple consisting of a sum and a product of all the integers in a vector.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product((std::vector<long>()))
// (std::make_tuple(0, 1))
// >>> sum_product((std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// (std::make_tuple(10, 24))
std::tuple<long, long> sum_product(std::vector<long> numbers) {

}
int main() {
    auto candidate = sum_product;
    assert(candidate((std::vector<long>())) == (std::make_tuple(0, 1)));
    assert(candidate((std::vector<long>({(long)1, (long)1, (long)1}))) == (std::make_tuple(3, 1)));
    assert(candidate((std::vector<long>({(long)100, (long)0}))) == (std::make_tuple(100, 0)));
    assert(candidate((std::vector<long>({(long)3, (long)5, (long)7}))) == (std::make_tuple(15, 105)));
    assert(candidate((std::vector<long>({(long)10}))) == (std::make_tuple(10, 10)));
}


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>
// 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>
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// >>> count_distinct_characters(("xyzXYZ"))
// (3)
// >>> count_distinct_characters(("Jerry"))
// (4)
long count_distinct_characters(std::string string) {

}
int main() {
    auto candidate = count_distinct_characters;
    assert(candidate(("")) == (0));
    assert(candidate(("abcde")) == (5));
    assert(candidate(("abcdecadeCADE")) == (5));
    assert(candidate(("aaaaAAAAaaaa")) == (1));
    assert(candidate(("Jerry jERRY JeRRRY")) == (5));
}


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 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 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>
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// >>> string_sequence((0))
// ("0")
// >>> string_sequence((5))
// ("0 1 2 3 4 5")
std::string string_sequence(long n) {

}
int main() {
    auto candidate = string_sequence;
    assert(candidate((0)) == ("0"));
    assert(candidate((3)) == ("0 1 2 3"));
    assert(candidate((10)) == ("0 1 2 3 4 5 6 7 8 9 10"));
}


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>
// Return true is vector elements are monotonically increasing or decreasing.
// >>> monotonic((std::vector<long>({(long)1, (long)2, (long)4, (long)20})))
// (true)
// >>> monotonic((std::vector<long>({(long)1, (long)20, (long)4, (long)10})))
// (false)
// >>> monotonic((std::vector<long>({(long)4, (long)1, (long)0, (long)-10})))
// (true)
bool monotonic(std::vector<long> l) {

}
int main() {
    auto candidate = monotonic;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)20}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10}))) == (false));
    assert(candidate((std::vector<long>({(long)4, (long)1, (long)0, (long)-10}))) == (true));
    assert(candidate((std::vector<long>({(long)4, (long)1, (long)1, (long)0}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)5, (long)60}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)60}))) == (true));
    assert(candidate((std::vector<long>({(long)9, (long)9, (long)9, (long)9}))) == (true));
}


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>
// Return true if all numbers in the vector l are below threshold t.
// >>> below_threshold((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100))
// (true)
// >>> below_threshold((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5))
// (false)
bool below_threshold(std::vector<long> l, long t) {

}
int main() {
    auto candidate = below_threshold;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5)) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (21)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (22)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (11)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (10)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that returns true if the given number is the multiplication of 3 prime numbers
// and false otherwise.
// Knowing that (a) is less then 100.
// Example:
// >>> is_multiply_prime((30))
// (true)
// 30 = 2 * 3 * 5
bool is_multiply_prime(long a) {

}
int main() {
    auto candidate = is_multiply_prime;
    assert(candidate((5)) == (false));
    assert(candidate((30)) == (true));
    assert(candidate((8)) == (true));
    assert(candidate((10)) == (false));
    assert(candidate((125)) == (true));
    assert(candidate((105)) == (true));
    assert(candidate((126)) == (false));
    assert(candidate((729)) == (false));
    assert(candidate((891)) == (false));
    assert(candidate((1001)) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return only positive numbers in the vector.
// >>> get_positive((std::vector<long>({(long)-1, (long)2, (long)-4, (long)5, (long)6})))
// (std::vector<long>({(long)2, (long)5, (long)6}))
// >>> get_positive((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10})))
// (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)9, (long)123, (long)1}))
std::vector<long> get_positive(std::vector<long> l) {

}
int main() {
    auto candidate = get_positive;
    assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)4, (long)5, (long)6}))) == (std::vector<long>({(long)4, (long)5, (long)6})));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10}))) == (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)3, (long)9, (long)123, (long)1})));
    assert(candidate((std::vector<long>({(long)-1, (long)-2}))) == (std::vector<long>()));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// This function takes a vector l and returns a vector l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// >>> sort_third((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
// >>> sort_third((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2})))
// (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5}))
std::vector<long> sort_third(std::vector<long> l) {

}
int main() {
    auto candidate = sort_third;
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)8, (long)3, (long)4, (long)6, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)8, (long)3, (long)4, (long)6, (long)9, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)9, (long)4, (long)8, (long)3, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)9, (long)4, (long)8, (long)3, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2, (long)1}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5, (long)1})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// >>> parse_nested_parens(("(()()) ((())) () ((())()())"))
// (std::vector<long>({(long)2, (long)3, (long)1, (long)3}))
std::vector<long> parse_nested_parens(std::string paren_string) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given length of a side and high return area for a triangle.
// >>> triangle_area((5), (3))
// (7.5f)
float triangle_area(long a, long h) {

}
int main() {
    auto candidate = triangle_area;
    assert(candidate((5), (3)) == (7.5f));
    assert(candidate((2), (2)) == (2.0f));
    assert(candidate((10), (8)) == (40.0f));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Complete the function that takes two integers and returns
// the product of their unit digits.
// Assume the input is always valid.
// Examples:
// >>> multiply((148), (412))
// (16)
// >>> multiply((19), (28))
// (72)
// >>> multiply((2020), (1851))
// (0)
// >>> multiply((14), (-15))
// (20)
long multiply(long a, long b) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given vector of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// >>> mean_absolute_deviation((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f})))
// (1.0f)
float mean_absolute_deviation(std::vector<float> numbers) {

}
int main() {
    auto candidate = mean_absolute_deviation;
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f}))) == (0.5f));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f}))) == (1.0f));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (1.2f));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return sorted unique common elements for two vectors.
// >>> common((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121})))
// (std::vector<long>({(long)1, (long)5, (long)653}))
// >>> common((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2})))
// (std::vector<long>({(long)2, (long)3}))
std::vector<long> common(std::vector<long> l1, std::vector<long> l2) {

}
int main() {
    auto candidate = common;
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121}))) == (std::vector<long>({(long)1, (long)5, (long)653})));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2}))) == (std::vector<long>({(long)2, (long)3})));
    assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2, (long)4}))) == (std::vector<long>({(long)2, (long)3, (long)4})));
    assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>())) == (std::vector<long>()));
}


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>
// In this task, you will be given a string that represents a number of apples and oranges
// that are distributed in a basket of fruit this basket contains
// apples, oranges, and mango fruits. Given the string that represents the total number of
// the oranges and apples and an integer that represent the total number of the fruits
// in the basket return the number of the mango fruits in the basket.
// for examble:
// >>> fruit_distribution(("5 apples and 6 oranges"), (19))
// (8)
// >>> fruit_distribution(("0 apples and 1 oranges"), (3))
// (2)
// >>> fruit_distribution(("2 apples and 3 oranges"), (100))
// (95)
// >>> fruit_distribution(("100 apples and 1 oranges"), (120))
// (19)
long fruit_distribution(std::string s, long n) {

}
int main() {
    auto candidate = fruit_distribution;
    assert(candidate(("5 apples and 6 oranges"), (19)) == (8));
    assert(candidate(("5 apples and 6 oranges"), (21)) == (10));
    assert(candidate(("0 apples and 1 oranges"), (3)) == (2));
    assert(candidate(("1 apples and 0 oranges"), (3)) == (2));
    assert(candidate(("2 apples and 3 oranges"), (100)) == (95));
    assert(candidate(("2 apples and 3 oranges"), (5)) == (0));
    assert(candidate(("1 apples and 100 oranges"), (120)) == (19));
}


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>
// 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>
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>
// 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>
// Concatenate vector of strings into a single string
// >>> concatenate((std::vector<std::string>()))
// ("")
// >>> concatenate((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"c"})))
// ("abc")
std::string concatenate(std::vector<std::string> strings) {

}
int main() {
    auto candidate = concatenate;
    assert(candidate((std::vector<std::string>())) == (""));
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z"}))) == ("xyz"));
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z", (std::string)"w", (std::string)"k"}))) == ("xyzwk"));
}


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>
// Filter an input vector of strings only for ones that contain given substring
// >>> filter_by_substring((std::vector<std::string>()), ("a"))
// (std::vector<std::string>())
// >>> filter_by_substring((std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"cde", (std::string)"array"})), ("a"))
// (std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"array"}))
std::vector<std::string> filter_by_substring(std::vector<std::string> strings, std::string substring) {

}
int main() {
    auto candidate = filter_by_substring;
    assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xxx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"xxxAAA", (std::string)"xxx"})));
    assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"aaaxxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"aaaxxy", (std::string)"xxxAAA", (std::string)"xxx"})));
    assert(candidate((std::vector<std::string>({(std::string)"grunt", (std::string)"trumpet", (std::string)"prune", (std::string)"gruesome"})), ("run")) == (std::vector<std::string>({(std::string)"grunt", (std::string)"prune"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// >>> closest_integer(("10"))
// (10)
// >>> closest_integer(("15.3"))
// (15)
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
long closest_integer(std::string value) {

}
int main() {
    auto candidate = closest_integer;
    assert(candidate(("10")) == (10));
    assert(candidate(("14.5")) == (15));
    assert(candidate(("-15.5")) == (-16));
    assert(candidate(("15.3")) == (15));
    assert(candidate(("0")) == (0));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function vowels_count which takes a string representing
// a word as input and returns the number of vowels in the string.
// Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
// vowel, but only when it is at the end of the given word.
// Example:
// >>> vowels_count(("abcde"))
// (2)
// >>> vowels_count(("ACEDY"))
// (3)
long vowels_count(std::string s) {

}
int main() {
    auto candidate = vowels_count;
    assert(candidate(("abcde")) == (2));
    assert(candidate(("Alone")) == (3));
    assert(candidate(("key")) == (2));
    assert(candidate(("bye")) == (1));
    assert(candidate(("keY")) == (2));
    assert(candidate(("bYe")) == (1));
    assert(candidate(("ACEDY")) == (3));
}


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


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string 'text', return its md5 hash equivalent string.
// If 'text' is an empty string, return None.
// >>> string_to_md5(("Hello world"))
// "3e25960a79dbc69b674cd4ec67a72c62"
std::optional<std::string> string_to_md5(std::string text) {

}
int main() {
    auto candidate = string_to_md5;
    assert(candidate(("Hello world")) == "3e25960a79dbc69b674cd4ec67a72c62");
    assert(candidate(("")) == std::nullopt);
    assert(candidate(("A B C")) == "0ef78513b0cb8cef12743f5aeb35f888");
    assert(candidate(("password")) == "5f4dcc3b5aa765d61d8327deb882cf99");
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// >>> change_base((8), (3))
// ("22")
// >>> change_base((8), (2))
// ("1000")
// >>> change_base((7), (2))
// ("111")
std::string change_base(long x, long base) {


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>
// It is the last week of the semester and the teacher has to give the grades
// to students. The teacher has been making her own algorithm for grading.
// The only problem is, she has lost the code she used for grading.
// She has given you a vector of GPAs for some students and you have to write
// a function that can output a vector of letter grades using the following table:
// GPA       |    Letter grade
// 4.0                A+
// > 3.7                A
// > 3.3                A-
// > 3.0                B+
// > 2.7                B
// > 2.3                B-
// > 2.0                C+
// > 1.7                C
// > 1.3                C-
// > 1.0                D+
// > 0.7                D
// > 0.0                D-
// 0.0                E
// Example:
// >>> grade_equation((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f})))
// (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"}))
std::vector<std::string> numerical_letter_grade(std::vector<float> grades) {

}
int main() {
    auto candidate = numerical_letter_grade;
    assert(candidate((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f}))) == (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"})));
    assert(candidate((std::vector<float>({(float)1.2f}))) == (std::vector<std::string>({(std::string)"D+"})));
    assert(candidate((std::vector<float>({(float)0.5f}))) == (std::vector<std::string>({(std::string)"D-"})));
    assert(candidate((std::vector<float>({(float)0.0f}))) == (std::vector<std::string>({(std::string)"E"})));
    assert(candidate((std::vector<float>({(float)1.0f, (float)0.3f, (float)1.5f, (float)2.8f, (float)3.3f}))) == (std::vector<std::string>({(std::string)"D", (std::string)"D-", (std::string)"C-", (std::string)"B", (std::string)"B+"})));
    assert(candidate((std::vector<float>({(float)0.0f, (float)0.7f}))) == (std::vector<std::string>({(std::string)"E", (std::string)"D-"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Insert a number 'delimeter' between every two consecutive elements of input vector `numbers'
// >>> intersperse((std::vector<long>()), (4))
// (std::vector<long>())
// >>> intersperse((std::vector<long>({(long)1, (long)2, (long)3})), (4))
// (std::vector<long>({(long)1, (long)4, (long)2, (long)4, (long)3}))
std::vector<long> intersperse(std::vector<long> numbers, long delimeter) {

}
int main() {
    auto candidate = intersperse;
    assert(candidate((std::vector<long>()), (7)) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)2})), (8)) == (std::vector<long>({(long)5, (long)8, (long)6, (long)8, (long)3, (long)8, (long)2})));
    assert(candidate((std::vector<long>({(long)2, (long)2, (long)2})), (2)) == (std::vector<long>({(long)2, (long)2, (long)2, (long)2, (long)2})));
}


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>
// sum_to_n is a function that sums numbers from 1 to n.
// >>> sum_to_n((30))
// (465)
// >>> sum_to_n((100))
// (5050)
// >>> sum_to_n((5))
// (15)
// >>> sum_to_n((10))
// (55)
// >>> sum_to_n((1))
// (1)
long sum_to_n(long n) {

}
int main() {
    auto candidate = sum_to_n;
    assert(candidate((1)) == (1));
    assert(candidate((6)) == (21));
    assert(candidate((11)) == (66));
    assert(candidate((30)) == (465));
    assert(candidate((100)) == (5050));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// From a vector of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// >>> remove_duplicates((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4})))
// (std::vector<long>({(long)1, (long)3, (long)4}))
std::vector<long> remove_duplicates(std::vector<long> numbers) {

}
int main() {
    auto candidate = remove_duplicates;
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4, (long)3, (long)5}))) == (std::vector<long>({(long)1, (long)4, (long)5})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given two positive integers a and b, return the even digits between a
// and b, in ascending order.
// For example:
// >>> generate_integers((2), (8))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((8), (2))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((10), (14))
// (std::vector<long>())
std::vector<long> generate_integers(long a, long b) {

}
int main() {
    auto candidate = generate_integers;
    assert(candidate((2), (10)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((10), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((132), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((17), (89)) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// From a given vector of integers, generate a vector of rolling maximum element found until given moment
// in the sequence.
// >>> rolling_max((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)3, (long)4, (long)2})))
// (std::vector<long>({(long)1, (long)2, (long)3, (long)3, (long)3, (long)4, (long)4}))
std::vector<long> rolling_max(std::vector<long> numbers) {

}
int main() {
    auto candidate = rolling_max;
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
    assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)1}))) == (std::vector<long>({(long)4, (long)4, (long)4, (long)4})));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)3, (long)100, (long)3}))) == (std::vector<long>({(long)3, (long)3, (long)3, (long)100, (long)100})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You're given a vector of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)3})))
// (false)
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)-4, (long)5})))
// (true)
bool below_zero(std::vector<long> operations) {

}
int main() {
    auto candidate = below_zero;
    assert(candidate((std::vector<long>())) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)-3, (long)1, (long)2, (long)-3}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)-4, (long)5, (long)6}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-5}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)-2, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (true));
}