Prompt:
/// For a given number n, find the largest number that divides n evenly, smaller than n
/// >>> largest_divisor(15)
/// 5
fn largest_divisor(n: isize) -> isize {

fn main() {
    let candidate = largest_divisor;
    assert_eq!(candidate(3), 1);
    assert_eq!(candidate(7), 1);
    assert_eq!(candidate(10), 5);
    assert_eq!(candidate(100), 50);
    assert_eq!(candidate(49), 7);
}


Prompt:
/// Return median of elements in the vector l.
/// >>> median(vec![3, 1, 2, 4, 5])
/// 3.0
/// >>> median(vec![-10, 4, 6, 1000, 10, 20])
/// 15.0
fn median(l: Vec<isize>) -> f64 {

fn main() {
    let candidate = median;
    assert_eq!(candidate(vec![3, 1, 2, 4, 5]), 3.0);
    assert_eq!(candidate(vec![-10, 4, 6, 1000, 10, 20]), 8.0);
    assert_eq!(candidate(vec![5]), 5.0);
    assert_eq!(candidate(vec![6, 5]), 5.5);
    assert_eq!(candidate(vec![8, 1, 3, 9, 9, 2, 7]), 7.0);
}


Prompt:
/// Given two vectors operator, and operand. The first vector has basic algebra operations, and
/// the second vector is a vector of integers. Use the two given vectors to build the algebric
/// expression and return the evaluation of this expression.
/// The basic algebra operations:
/// Addition ( + )
/// Subtraction ( - )
/// Multiplication ( * )
/// Floor division ( // )
/// Exponentiation ( ** )
/// Example:
/// operator['+', '*', '-']
/// vector = [2, 3, 4, 5]
/// result = 2 + 3 * 4 - 5
/// => result = 9
/// Note:
/// The length of operator vector is equal to the length of operand vector minus one.
/// Operand is a vector of of non-negative integers.
/// Operator vector has at least one operator, and operand vector has at least two operands.
fn do_algebra(operator: Vec<String>, operand: Vec<isize>) -> isize {

fn main() {
    let candidate = do_algebra;
    assert_eq!(candidate(vec![String::from("**"), String::from("*"), String::from("+")], vec![2, 3, 4, 5]), 37);
    assert_eq!(candidate(vec![String::from("+"), String::from("*"), String::from("-")], vec![2, 3, 4, 5]), 9);
    assert_eq!(candidate(vec![String::from("//"), String::from("*")], vec![7, 3, 4]), 8);
}


Prompt:
/// Return maximum element in the vector.
/// >>> max_element(vec![1, 2, 3])
/// 3
/// >>> max_element(vec![5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
/// 123
fn max_element(l: Vec<isize>) -> isize {

fn main() {
    let candidate = max_element;
    assert_eq!(candidate(vec![1, 2, 3]), 3);
    assert_eq!(candidate(vec![5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]), 124);
}


Prompt:
/// 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(vec![1, 2, 4, 3, 5])
/// 3
/// >>> can_arrange(vec![1, 2, 3])
/// -1
fn can_arrange(arr: Vec<isize>) -> isize {

fn main() {
    let candidate = can_arrange;
    assert_eq!(candidate(vec![1, 2, 4, 3, 5]), 3);
    assert_eq!(candidate(vec![1, 2, 4, 5]), -1);
    assert_eq!(candidate(vec![1, 4, 2, 5, 6, 7, 8, 9, 10]), 2);
    assert_eq!(candidate(vec![4, 8, 5, 7, 3]), 4);
    assert_eq!(candidate(Vec::<isize>::new()), -1);
}


Prompt:
/// Imagine a road that's a perfectly straight infinitely long line.
/// n cars are driving left to right;  simultaneously, a different set of n cars
/// are driving right to left.   The two sets of cars start out being very far from
/// each other.  All cars move in the same speed.  Two cars are said to collide
/// when a car that's moving left to right hits a car that's moving right to left.
/// However, the cars are infinitely sturdy and strong; as a result, they continue moving
/// in their trajectory as if they did not collide.
/// This function outputs the number of such collisions.
fn car_race_collision(n: isize) -> isize {

fn main() {
    let candidate = car_race_collision;
    assert_eq!(candidate(2), 4);
    assert_eq!(candidate(3), 9);
    assert_eq!(candidate(4), 16);
    assert_eq!(candidate(8), 64);
    assert_eq!(candidate(10), 100);
}


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

fn main() {
    let candidate = check_if_last_char_is_a_letter;
    assert_eq!(candidate(String::from("apple")), false);
    assert_eq!(candidate(String::from("apple pi e")), true);
    assert_eq!(candidate(String::from("eeeee")), false);
    assert_eq!(candidate(String::from("A")), true);
    assert_eq!(candidate(String::from("Pumpkin pie ")), false);
    assert_eq!(candidate(String::from("Pumpkin pie 1")), false);
    assert_eq!(candidate(String::from("")), false);
    assert_eq!(candidate(String::from("eeeee e ")), false);
    assert_eq!(candidate(String::from("apple pie")), false);
    assert_eq!(candidate(String::from("apple pi e ")), false);
}


Prompt:
/// 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
fn is_prime(n: isize) -> bool {

fn main() {
    let candidate = is_prime;
    assert_eq!(candidate(6), false);
    assert_eq!(candidate(101), true);
    assert_eq!(candidate(11), true);
    assert_eq!(candidate(13441), true);
    assert_eq!(candidate(61), true);
    assert_eq!(candidate(4), false);
    assert_eq!(candidate(1), false);
    assert_eq!(candidate(5), true);
    assert_eq!(candidate(11), true);
    assert_eq!(candidate(17), true);
    assert_eq!(candidate(85), false);
    assert_eq!(candidate(77), false);
    assert_eq!(candidate(255379), false);
}


Prompt:
/// Given a vector of positive integers x. return a sorted vector of all
/// elements that hasn't any even digit.
/// Note: Returned vector should be sorted in increasing order.
/// For example:
/// >>> unique_digits(vec![15, 33, 1422, 1])
/// vec![1, 15, 33]
/// >>> unique_digits(vec![152, 323, 1422, 10])
/// Vec::<isize>::new()
fn unique_digits(x: Vec<isize>) -> Vec<isize> {


Prompt:
/// Input are two strings a and b consisting only of 1s and 0s.
/// Perform binary XOR on these inputs and return result also as a string.
/// >>> string_xor(String::from("010"), String::from("110"))
/// String::from("100")
fn string_xor(a: String, b: String) -> String {

fn main() {
    let candidate = string_xor;
    assert_eq!(candidate(String::from("111000"), String::from("101010")), String::from("010010"));
    assert_eq!(candidate(String::from("1"), String::from("1")), String::from("0"));
    assert_eq!(candidate(String::from("0101"), String::from("0000")), String::from("0101"));
}


Prompt:
/// 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
fn sum_to_n(n: isize) -> isize {

fn main() {
    let candidate = sum_to_n;
    assert_eq!(candidate(1), 1);
    assert_eq!(candidate(6), 21);
    assert_eq!(candidate(11), 66);
    assert_eq!(candidate(30), 465);
    assert_eq!(candidate(100), 5050);
}


Prompt:
/// Given a vector of numbers, return the sum of squares of the numbers
/// in the vector that are odd. Ignore numbers that are negative or not integers.
/// >>> double_the_difference(vec![1, 3, 2, 0])
/// 10
/// >>> double_the_difference(vec![-1, -2, 0])
/// 0
/// >>> double_the_difference(vec![9, -2])
/// 81
/// >>> double_the_difference(vec![0])
/// 0
/// If the input vector is empty, return 0.
fn double_the_difference(lst: Vec<f64>) -> isize {


Prompt:
/// Return length of given string
/// >>> strlen(String::from(""))
/// 0
/// >>> strlen(String::from("abc"))
/// 3
fn strlen(string: String) -> isize {

fn main() {
    let candidate = strlen;
    assert_eq!(candidate(String::from("")), 0);
    assert_eq!(candidate(String::from("x")), 1);
    assert_eq!(candidate(String::from("asdasnakj")), 9);
}


Prompt:
/// You'll be given a string of words, and your task is to count the number
/// of boredoms. A boredom is a sentence that starts with the word "I".
/// Sentences are delimited by '.', '?' or '!'.
/// For example:
/// >>> is_bored(String::from("Hello world"))
/// 0
/// >>> is_bored(String::from("The sky is blue. The sun is shining. I love this weather"))
/// 1
fn is_bored(S: String) -> isize {

fn main() {
    let candidate = is_bored;
    assert_eq!(candidate(String::from("Hello world")), 0);
    assert_eq!(candidate(String::from("Is the sky blue?")), 0);
    assert_eq!(candidate(String::from("I love It !")), 1);
    assert_eq!(candidate(String::from("bIt")), 0);
    assert_eq!(candidate(String::from("I feel good today. I will be productive. will kill It")), 2);
    assert_eq!(candidate(String::from("You and I are going for a walk")), 0);
}


Prompt:
/// 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(String::from("abcde"))
/// 2
/// >>> vowels_count(String::from("ACEDY"))
/// 3
fn vowels_count(s: String) -> isize {

fn main() {
    let candidate = vowels_count;
    assert_eq!(candidate(String::from("abcde")), 2);
    assert_eq!(candidate(String::from("Alone")), 3);
    assert_eq!(candidate(String::from("key")), 2);
    assert_eq!(candidate(String::from("bye")), 1);
    assert_eq!(candidate(String::from("keY")), 2);
    assert_eq!(candidate(String::from("bYe")), 1);
    assert_eq!(candidate(String::from("ACEDY")), 3);
}


Prompt:
/// Return n-th Fibonacci number.
/// >>> fib(10)
/// 55
/// >>> fib(1)
/// 1
/// >>> fib(8)
/// 21
fn fib(n: isize) -> isize {

fn main() {
    let candidate = fib;
    assert_eq!(candidate(10), 55);
    assert_eq!(candidate(1), 1);
    assert_eq!(candidate(8), 21);
    assert_eq!(candidate(11), 89);
    assert_eq!(candidate(12), 144);
}


Prompt:
/// 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(String::from("1/5"), String::from("5/1"))
/// true
/// >>> simplify(String::from("1/6"), String::from("2/1"))
/// false
/// >>> simplify(String::from("7/10"), String::from("10/2"))
/// false
fn simplify(x: String, n: String) -> bool {

fn main() {
    let candidate = simplify;
    assert_eq!(candidate(String::from("1/5"), String::from("5/1")), true);
    assert_eq!(candidate(String::from("1/6"), String::from("2/1")), false);
    assert_eq!(candidate(String::from("5/1"), String::from("3/1")), true);
    assert_eq!(candidate(String::from("7/10"), String::from("10/2")), false);
    assert_eq!(candidate(String::from("2/10"), String::from("50/10")), true);
    assert_eq!(candidate(String::from("7/2"), String::from("4/2")), true);
    assert_eq!(candidate(String::from("11/6"), String::from("6/1")), true);
    assert_eq!(candidate(String::from("2/3"), String::from("5/2")), false);
    assert_eq!(candidate(String::from("5/2"), String::from("3/5")), false);
    assert_eq!(candidate(String::from("2/4"), String::from("8/4")), true);
    assert_eq!(candidate(String::from("2/4"), String::from("4/2")), true);
    assert_eq!(candidate(String::from("1/5"), String::from("5/1")), true);
    assert_eq!(candidate(String::from("1/5"), String::from("1/5")), false);
}


Prompt:
/// Given a string s, count the number of uppercase vowels in even indices.
/// For example:
/// >>> count_upper(String::from("aBCdEf"))
/// 1
/// >>> count_upper(String::from("abcdefg"))
/// 0
/// >>> count_upper(String::from("dBBE"))
/// 0
fn count_upper(s: String) -> isize {

fn main() {
    let candidate = count_upper;
    assert_eq!(candidate(String::from("aBCdEf")), 1);
    assert_eq!(candidate(String::from("abcdefg")), 0);
    assert_eq!(candidate(String::from("dBBE")), 0);
    assert_eq!(candidate(String::from("B")), 0);
    assert_eq!(candidate(String::from("U")), 1);
    assert_eq!(candidate(String::from("")), 0);
    assert_eq!(candidate(String::from("EEEE")), 2);
}


Prompt:
/// You are given a rectangular grid of wells. Each row represents a single well,
/// and each 1 in a row represents a single unit of water.
/// Each well has a corresponding bucket that can be used to extract water from it,
/// and all buckets have the same capacity.
/// Your task is to use the buckets to empty the wells.
/// Output the number of times you need to lower the buckets.
/// Example 1:
/// >>> max_fill(vec![vec![0, 0, 1, 0], vec![0, 1, 0, 0], vec![1, 1, 1, 1]], 1)
/// 6
/// Example 2:
/// >>> max_fill(vec![vec![0, 0, 1, 1], vec![0, 0, 0, 0], vec![1, 1, 1, 1], vec![0, 1, 1, 1]], 2)
/// 5
/// Example 3:
/// >>> max_fill(vec![vec![0, 0, 0], vec![0, 0, 0]], 5)
/// 0
/// Constraints:
/// * all wells have the same length
/// * 1 <= grid.length <= 10^2
/// * 1 <= grid[:,1].length <= 10^2
/// * grid[i][j] -> 0 | 1
/// * 1 <= capacity <= 10
fn max_fill(grid: Vec<Vec<isize>>, capacity: isize) -> isize {


Prompt:
/// Given a vector arr of integers and a positive integer k, return a sorted vector
/// of length k with the maximum k numbers in arr.
/// Example 1:
/// >>> maximum(vec![-3, -4, 5], 3)
/// vec![-4, -3, 5]
/// Example 2:
/// >>> maximum(vec![4, -4, 4], 2)
/// vec![4, 4]
/// Example 3:
/// >>> maximum(vec![-3, 2, 1, 2, -1, -2, 1], 1)
/// vec![2]
/// Note:
/// 1. The length of the vector will be in the range of [1, 1000].
/// 2. The elements in the vector will be in the range of [-1000, 1000].
/// 3. 0 <= k <= len(arr)
fn maximum(arr: Vec<isize>, k: isize) -> Vec<isize> {


Prompt:
/// Write a function that takes a message, and encodes in such a
/// way that it swaps case of all letters, replaces all vowels in
/// the message with the letter that appears 2 places ahead of that
/// vowel in the english alphabet.
/// Assume only letters.
/// Examples:
/// >>> encode(String::from("test"))
/// String::from("TGST")
/// >>> encode(String::from("This is a message"))
/// String::from("tHKS KS C MGSSCGG")
fn encode(message: String) -> String {

fn main() {
    let candidate = encode;
    assert_eq!(candidate(String::from("TEST")), String::from("tgst"));
    assert_eq!(candidate(String::from("Mudasir")), String::from("mWDCSKR"));
    assert_eq!(candidate(String::from("YES")), String::from("ygs"));
    assert_eq!(candidate(String::from("This is a message")), String::from("tHKS KS C MGSSCGG"));
    assert_eq!(candidate(String::from("I DoNt KnOw WhAt tO WrItE")), String::from("k dQnT kNqW wHcT Tq wRkTg"));
}


Prompt:
/// remove_vowels is a function that takes string and returns string without vowels.
/// >>> remove_vowels(String::from(""))
/// String::from("")
/// >>> remove_vowels(String::from("abcdef"))
/// String::from("bcdf")
/// >>> remove_vowels(String::from("aaaaa"))
/// String::from("")
/// >>> remove_vowels(String::from("aaBAA"))
/// String::from("B")
/// >>> remove_vowels(String::from("zbcd"))
/// String::from("zbcd")
fn remove_vowels(text: String) -> String {

fn main() {
    let candidate = remove_vowels;
    assert_eq!(candidate(String::from("")), String::from(""));
    assert_eq!(candidate(String::from("abcdef
ghijklm")), String::from("bcdf
ghjklm"));
    assert_eq!(candidate(String::from("fedcba")), String::from("fdcb"));
    assert_eq!(candidate(String::from("eeeee")), String::from(""));
    assert_eq!(candidate(String::from("acBAA")), String::from("cB"));
    assert_eq!(candidate(String::from("EcBOO")), String::from("cB"));
    assert_eq!(candidate(String::from("ybcd")), String::from("ybcd"));
}


Prompt:
/// Return only positive numbers in the vector.
/// >>> get_positive(vec![-1, 2, -4, 5, 6])
/// vec![2, 5, 6]
/// >>> get_positive(vec![5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
/// vec![5, 3, 2, 3, 9, 123, 1]
fn get_positive(l: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = get_positive;
    assert_eq!(candidate(vec![-1, -2, 4, 5, 6]), vec![4, 5, 6]);
    assert_eq!(candidate(vec![5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]), vec![5, 3, 2, 3, 3, 9, 123, 1]);
    assert_eq!(candidate(vec![-1, -2]), Vec::<isize>::new());
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<isize>::new());
}


Prompt:
/// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
/// >>> string_sequence(0)
/// String::from("0")
/// >>> string_sequence(5)
/// String::from("0 1 2 3 4 5")
fn string_sequence(n: isize) -> String {

fn main() {
    let candidate = string_sequence;
    assert_eq!(candidate(0), String::from("0"));
    assert_eq!(candidate(3), String::from("0 1 2 3"));
    assert_eq!(candidate(10), String::from("0 1 2 3 4 5 6 7 8 9 10"));
}


Prompt:
/// 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)
/// vec![3, 5, 7]
fn make_a_pile(n: isize) -> Vec<isize> {


Prompt:
/// 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(String::from("abcde"), String::from("ae"))
/// (String::from("bcd"), false)
/// >>> reverse_delete(String::from("abcdef"), String::from("b"))
/// (String::from("acdef"), false)
/// >>> reverse_delete(String::from("abcdedcba"), String::from("ab"))
/// (String::from("cdedc"), true)
fn reverse_delete(s: String, c: String) -> (String, bool) {

fn main() {
    let candidate = reverse_delete;
    assert_eq!(candidate(String::from("abcde"), String::from("ae")), (String::from("bcd"), false));
    assert_eq!(candidate(String::from("abcdef"), String::from("b")), (String::from("acdef"), false));
    assert_eq!(candidate(String::from("abcdedcba"), String::from("ab")), (String::from("cdedc"), true));
    assert_eq!(candidate(String::from("dwik"), String::from("w")), (String::from("dik"), false));
    assert_eq!(candidate(String::from("a"), String::from("a")), (String::from(""), true));
    assert_eq!(candidate(String::from("abcdedcba"), String::from("")), (String::from("abcdedcba"), true));
    assert_eq!(candidate(String::from("abcdedcba"), String::from("v")), (String::from("abcdedcba"), true));
    assert_eq!(candidate(String::from("vabba"), String::from("v")), (String::from("abba"), true));
    assert_eq!(candidate(String::from("mamma"), String::from("mia")), (String::from(""), true));
}


Prompt:
/// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
/// >>> flip_case(String::from("Hello"))
/// String::from("hELLO")
fn flip_case(string: String) -> String {

fn main() {
    let candidate = flip_case;
    assert_eq!(candidate(String::from("")), String::from(""));
    assert_eq!(candidate(String::from("Hello!")), String::from("hELLO!"));
    assert_eq!(candidate(String::from("These violent delights have violent ends")), String::from("tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS"));
}


Prompt:
/// You are given a string s.
/// if s[i] is a letter, reverse its case from lower to upper or vise versa,
/// otherwise keep it as it is.
/// If the string contains no letters, reverse the string.
/// The function should return the resulted string.
/// Examples
/// >>> solve(String::from("1234"))
/// String::from("4321")
/// >>> solve(String::from("ab"))
/// String::from("AB")
/// >>> solve(String::from("#a@C"))
/// String::from("#A@c")
fn solve(s: String) -> String {

fn main() {
    let candidate = solve;
    assert_eq!(candidate(String::from("AsDf")), String::from("aSdF"));
    assert_eq!(candidate(String::from("1234")), String::from("4321"));
    assert_eq!(candidate(String::from("ab")), String::from("AB"));
    assert_eq!(candidate(String::from("#a@C")), String::from("#A@c"));
    assert_eq!(candidate(String::from("#AsdfW^45")), String::from("#aSDFw^45"));
    assert_eq!(candidate(String::from("#6@2")), String::from("2@6#"));
    assert_eq!(candidate(String::from("#$a^D")), String::from("#$A^d"));
    assert_eq!(candidate(String::from("#ccc")), String::from("#CCC"));
}


Prompt:
/// Filter an input vector of strings only for ones that start with a given prefix.
/// >>> filter_by_prefix(vec![], String::from("a"))
/// Vec::<String>::new()
/// >>> filter_by_prefix(vec![String::from("abc"), String::from("bcd"), String::from("cde"), String::from("array")], String::from("a"))
/// vec![String::from("abc"), String::from("array")]
fn filter_by_prefix(strings: Vec<String>, prefix: String) -> Vec<String> {

fn main() {
    let candidate = filter_by_prefix;
    assert_eq!(candidate(Vec::<String>::new(), String::from("john")), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("xxx"), String::from("asd"), String::from("xxy"), String::from("john doe"), String::from("xxxAAA"), String::from("xxx")], String::from("xxx")), vec![String::from("xxx"), String::from("xxxAAA"), String::from("xxx")]);
}


Prompt:
/// 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
fn choose_num(x: isize, y: isize) -> isize {

fn main() {
    let candidate = choose_num;
    assert_eq!(candidate(12, 15), 14);
    assert_eq!(candidate(13, 12), -1);
    assert_eq!(candidate(33, 12354), 12354);
    assert_eq!(candidate(5234, 5233), -1);
    assert_eq!(candidate(6, 29), 28);
    assert_eq!(candidate(27, 10), -1);
    assert_eq!(candidate(7, 7), -1);
    assert_eq!(candidate(546, 546), 546);
}


Prompt:
/// 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(String::from("This is a test"))
/// String::from("is")
/// Example 2:
/// >>> words_in_sentence(String::from("lets go for swimming"))
/// String::from("go for")
/// Constraints:
/// * 1 <= len(sentence) <= 100
/// * sentence contains only letters
fn words_in_sentence(sentence: String) -> String {

fn main() {
    let candidate = words_in_sentence;
    assert_eq!(candidate(String::from("This is a test")), String::from("is"));
    assert_eq!(candidate(String::from("lets go for swimming")), String::from("go for"));
    assert_eq!(candidate(String::from("there is no place available here")), String::from("there is no place"));
    assert_eq!(candidate(String::from("Hi I am Hussein")), String::from("Hi am Hussein"));
    assert_eq!(candidate(String::from("go for it")), String::from("go for it"));
    assert_eq!(candidate(String::from("here")), String::from(""));
    assert_eq!(candidate(String::from("here is")), String::from("is"));
}


Prompt:
/// Insert a number 'delimeter' between every two consecutive elements of input vector `numbers'
/// >>> intersperse(vec![], 4)
/// Vec::<isize>::new()
/// >>> intersperse(vec![1, 2, 3], 4)
/// vec![1, 4, 2, 4, 3]
fn intersperse(numbers: Vec<isize>, delimeter: isize) -> Vec<isize> {

fn main() {
    let candidate = intersperse;
    assert_eq!(candidate(Vec::<isize>::new(), 7), Vec::<isize>::new());
    assert_eq!(candidate(vec![5, 6, 3, 2], 8), vec![5, 8, 6, 8, 3, 8, 2]);
    assert_eq!(candidate(vec![2, 2, 2], 2), vec![2, 2, 2, 2, 2]);
}


Prompt:
/// Your task is to write a function that returns true if a number x is a simple
/// power of n and false in other cases.
/// x is a simple power of n if n**int=x
/// For example:
/// >>> is_simple_power(1, 4)
/// true
/// >>> is_simple_power(2, 2)
/// true
/// >>> is_simple_power(8, 2)
/// true
/// >>> is_simple_power(3, 2)
/// false
/// >>> is_simple_power(3, 1)
/// false
/// >>> is_simple_power(5, 3)
/// false
fn is_simple_power(x: isize, n: isize) -> bool {

fn main() {
    let candidate = is_simple_power;
    assert_eq!(candidate(16, 2), true);
    assert_eq!(candidate(143214, 16), false);
    assert_eq!(candidate(4, 2), true);
    assert_eq!(candidate(9, 3), true);
    assert_eq!(candidate(16, 4), true);
    assert_eq!(candidate(24, 2), false);
    assert_eq!(candidate(128, 4), false);
    assert_eq!(candidate(12, 6), false);
    assert_eq!(candidate(1, 1), true);
    assert_eq!(candidate(1, 12), true);
}


Prompt:
/// 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
fn is_multiply_prime(a: isize) -> bool {

fn main() {
    let candidate = is_multiply_prime;
    assert_eq!(candidate(5), false);
    assert_eq!(candidate(30), true);
    assert_eq!(candidate(8), true);
    assert_eq!(candidate(10), false);
    assert_eq!(candidate(125), true);
    assert_eq!(candidate(105), true);
    assert_eq!(candidate(126), false);
    assert_eq!(candidate(729), false);
    assert_eq!(candidate(891), false);
    assert_eq!(candidate(1001), true);
}


Prompt:
/// 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
fn right_angle_triangle(a: isize, b: isize, c: isize) -> bool {

fn main() {
    let candidate = right_angle_triangle;
    assert_eq!(candidate(3, 4, 5), true);
    assert_eq!(candidate(1, 2, 3), false);
    assert_eq!(candidate(10, 6, 8), true);
    assert_eq!(candidate(2, 2, 2), false);
    assert_eq!(candidate(7, 24, 25), true);
    assert_eq!(candidate(10, 5, 7), false);
    assert_eq!(candidate(5, 12, 13), true);
    assert_eq!(candidate(15, 8, 17), true);
    assert_eq!(candidate(48, 55, 73), true);
    assert_eq!(candidate(1, 1, 1), false);
    assert_eq!(candidate(2, 2, 10), false);
}


Prompt:
/// Create a function that takes 3 numbers.
/// Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
/// Returns false in any other cases.
/// Examples
/// >>> any_int(5, 2, 7)
/// true
/// >>> any_int(3, 2, 2)
/// false
/// >>> any_int(3, -2, 1)
/// true
/// >>> any_int(3.6, -2.2, 2)
/// false
fn any_int(x: f64, y: f64, z: f64) -> bool {

fn main() {
    let candidate = any_int;
    assert_eq!(candidate(2.0, 3.0, 1.0), true);
    assert_eq!(candidate(2.5, 2.0, 3.0), false);
    assert_eq!(candidate(1.5, 5.0, 3.5), false);
    assert_eq!(candidate(2.0, 6.0, 2.0), false);
    assert_eq!(candidate(4.0, 2.0, 2.0), true);
    assert_eq!(candidate(2.2, 2.2, 2.2), false);
    assert_eq!(candidate(-4.0, 6.0, 2.0), true);
    assert_eq!(candidate(2.0, 1.0, 1.0), true);
    assert_eq!(candidate(3.0, 4.0, 7.0), true);
    assert_eq!(candidate(3.0, 4.0, 7.0), false);
}


Prompt:
/// 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(vec![1, 2, 3])
/// vec![1, 2, 3]
/// >>> sort_third(vec![5, 6, 3, 4, 8, 9, 2])
/// vec![2, 6, 3, 4, 8, 9, 5]
fn sort_third(l: Vec<isize>) -> Vec<isize> {


Prompt:
/// Add two numbers x and y
/// >>> add(2, 3)
/// 5
/// >>> add(5, 7)
/// 12
fn add(x: isize, y: isize) -> isize {

fn main() {
    let candidate = add;
    assert_eq!(candidate(0, 1), 1);
    assert_eq!(candidate(1, 0), 1);
    assert_eq!(candidate(2, 3), 5);
    assert_eq!(candidate(5, 7), 12);
    assert_eq!(candidate(7, 5), 12);
}


Prompt:
/// You are given a non-empty vector of positive integers. Return the greatest integer that is greater than
/// zero, and has a frequency greater than or equal to the value of the integer itself.
/// The frequency of an integer is the number of times it appears in the vector.
/// If no such a value exist, return -1.
/// Examples:
/// >>> search(vec![4, 1, 2, 2, 3, 1])
/// 2
/// >>> search(vec![1, 2, 2, 3, 3, 3, 4, 4, 4])
/// 3
/// >>> search(vec![5, 5, 4, 4, 4])
/// -1
fn search(lst: Vec<isize>) -> isize {


Prompt:
/// Write a function that takes a string and returns true if the string
/// length is a prime number or false otherwise
/// Examples
/// >>> prime_length(String::from("Hello"))
/// true
/// >>> prime_length(String::from("abcdcba"))
/// true
/// >>> prime_length(String::from("kittens"))
/// true
/// >>> prime_length(String::from("orange"))
/// false
fn prime_length(string: String) -> bool {

fn main() {
    let candidate = prime_length;
    assert_eq!(candidate(String::from("Hello")), true);
    assert_eq!(candidate(String::from("abcdcba")), true);
    assert_eq!(candidate(String::from("kittens")), true);
    assert_eq!(candidate(String::from("orange")), false);
    assert_eq!(candidate(String::from("wow")), true);
    assert_eq!(candidate(String::from("world")), true);
    assert_eq!(candidate(String::from("MadaM")), true);
    assert_eq!(candidate(String::from("Wow")), true);
    assert_eq!(candidate(String::from("")), false);
    assert_eq!(candidate(String::from("HI")), true);
    assert_eq!(candidate(String::from("go")), true);
    assert_eq!(candidate(String::from("gogo")), false);
    assert_eq!(candidate(String::from("aaaaaaaaaaaaaaa")), false);
    assert_eq!(candidate(String::from("Madam")), true);
    assert_eq!(candidate(String::from("M")), false);
    assert_eq!(candidate(String::from("0")), false);
}


Prompt:
/// Return sorted unique common elements for two vectors.
/// >>> common(vec![1, 4, 3, 34, 653, 2, 5], vec![5, 7, 1, 5, 9, 653, 121])
/// vec![1, 5, 653]
/// >>> common(vec![5, 3, 2, 8], vec![3, 2])
/// vec![2, 3]
fn common(l1: Vec<isize>, l2: Vec<isize>) -> Vec<isize> {


Prompt:
/// The Brazilian factorial is defined as:
/// brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
/// where n > 0
/// For example:
/// >>> special_factorial(4)
/// 288
/// The function will receive an integer as input and should return the special
/// factorial of this integer.
fn special_factorial(n: isize) -> isize {

fn main() {
    let candidate = special_factorial;
    assert_eq!(candidate(4), 288);
    assert_eq!(candidate(5), 34560);
    assert_eq!(candidate(7), 125411328000);
    assert_eq!(candidate(1), 1);
}


Prompt:
/// 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(vec![1, 2, 3, 4], vec![1, 2, 3, 4])
/// String::from("YES")
/// >>> exchange(vec![1, 2, 3, 4], vec![1, 5, 3, 4])
/// String::from("NO")
/// It is assumed that the input vectors will be non-empty.
fn exchange(lst1: Vec<isize>, lst2: Vec<isize>) -> String {

fn main() {
    let candidate = exchange;
    assert_eq!(candidate(vec![1, 2, 3, 4], vec![1, 2, 3, 4]), String::from("YES"));
    assert_eq!(candidate(vec![1, 2, 3, 4], vec![1, 5, 3, 4]), String::from("NO"));
    assert_eq!(candidate(vec![1, 2, 3, 4], vec![2, 1, 4, 3]), String::from("YES"));
    assert_eq!(candidate(vec![5, 7, 3], vec![2, 6, 4]), String::from("YES"));
    assert_eq!(candidate(vec![5, 7, 3], vec![2, 6, 3]), String::from("NO"));
    assert_eq!(candidate(vec![3, 2, 6, 1, 8, 9], vec![3, 5, 5, 1, 1, 1]), String::from("NO"));
    assert_eq!(candidate(vec![100, 200], vec![200, 200]), String::from("YES"));
}


Prompt:
/// Given a non-empty vector of integers arr and an integer k, return
/// the sum of the elements with at most two digits from the first k elements of arr.
/// Example:
/// >>> add_elements(vec![111, 21, 3, 4000, 5, 6, 7, 8, 9], 4)
/// 24
/// Constraints:
/// 1. 1 <= len(arr) <= 100
/// 2. 1 <= k <= len(arr)
fn add_elements(arr: Vec<isize>, k: isize) -> isize {


Prompt:
/// A simple program which should return the value of x if n is
/// a prime number and should return the value of y otherwise.
/// Examples:
/// >>> x_or_y(7, 34, 12)
/// 34
/// >>> x_or_y(15, 8, 5)
/// 5
fn x_or_y(n: isize, x: isize, y: isize) -> isize {

fn main() {
    let candidate = x_or_y;
    assert_eq!(candidate(7, 34, 12), 34);
    assert_eq!(candidate(15, 8, 5), 5);
    assert_eq!(candidate(3, 33, 5212), 33);
    assert_eq!(candidate(1259, 3, 52), 3);
    assert_eq!(candidate(7919, -1, 12), -1);
    assert_eq!(candidate(3609, 1245, 583), 583);
    assert_eq!(candidate(91, 56, 129), 129);
    assert_eq!(candidate(6, 34, 1234), 1234);
    assert_eq!(candidate(1, 2, 0), 0);
    assert_eq!(candidate(2, 2, 0), 2);
}


Prompt:
/// Given length of a side and high return area for a triangle.
/// >>> triangle_area(5, 3)
/// 7.5
fn triangle_area(a: isize, h: isize) -> f64 {

fn main() {
    let candidate = triangle_area;
    assert_eq!(candidate(5, 3), 7.5);
    assert_eq!(candidate(2, 2), 2.0);
    assert_eq!(candidate(10, 8), 40.0);
}


Prompt:
/// Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
/// the last couple centuries. However, what people don't know is Tribonacci sequence.
/// Tribonacci sequence is defined by the recurrence:
/// tri(1) = 3
/// tri(n) = 1 + n / 2, if n is even.
/// tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
/// For example:
/// tri(2) = 1 + (2 / 2) = 2
/// tri(4) = 3
/// tri(3) = tri(2) + tri(1) + tri(4)
/// = 2 + 3 + 3 = 8
/// You are given a non-negative integer number n, you have to a return a vector of the
/// first n + 1 numbers of the Tribonacci sequence.
/// Examples:
/// >>> tri(3)
/// vec![1, 3, 2, 8]
fn tri(n: isize) -> Vec<isize> {


Prompt:
/// You are given a vector of two strings, both strings consist of open
/// parentheses '(' or close parentheses ')' only.
/// Your job is to check if it is possible to concatenate the two strings in
/// some order, that the resulting string will be good.
/// A string S is considered to be good if and only if all parentheses in S
/// are balanced. For example: the string '(())()' is good, while the string
/// '())' is not.
/// Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
/// Examples:
/// >>> match_parens(vec![String::from("()("), String::from(")")])
/// String::from("Yes")
/// >>> match_parens(vec![String::from(")"), String::from(")")])
/// String::from("No")
fn match_parens(lst: Vec<String>) -> String {

fn main() {
    let candidate = match_parens;
    assert_eq!(candidate(vec![String::from("()("), String::from(")")]), String::from("Yes"));
    assert_eq!(candidate(vec![String::from(")"), String::from(")")]), String::from("No"));
    assert_eq!(candidate(vec![String::from("(()(())"), String::from("())())")]), String::from("No"));
    assert_eq!(candidate(vec![String::from(")())"), String::from("(()()(")]), String::from("Yes"));
    assert_eq!(candidate(vec![String::from("(())))"), String::from("(()())((")]), String::from("Yes"));
    assert_eq!(candidate(vec![String::from("()"), String::from("())")]), String::from("No"));
    assert_eq!(candidate(vec![String::from("(()("), String::from("()))()")]), String::from("Yes"));
    assert_eq!(candidate(vec![String::from("(((("), String::from("((())")]), String::from("No"));
    assert_eq!(candidate(vec![String::from(")(()"), String::from("(()(")]), String::from("No"));
    assert_eq!(candidate(vec![String::from(")("), String::from(")(")]), String::from("No"));
    assert_eq!(candidate(vec![String::from("("), String::from(")")]), String::from("Yes"));
    assert_eq!(candidate(vec![String::from(")"), String::from("(")]), String::from("Yes"));
}


Prompt:
/// 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(vec![1, 2, 3, 2, 4])
/// vec![1, 3, 4]
fn remove_duplicates(numbers: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = remove_duplicates;
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<isize>::new());
    assert_eq!(candidate(vec![1, 2, 3, 4]), vec![1, 2, 3, 4]);
    assert_eq!(candidate(vec![1, 2, 3, 2, 4, 3, 5]), vec![1, 4, 5]);
}


Prompt:
/// Return a greatest common divisor of two integers a and b
/// >>> greatest_common_divisor(3, 5)
/// 1
/// >>> greatest_common_divisor(25, 15)
/// 5
fn greatest_common_divisor(a: isize, b: isize) -> isize {

fn main() {
    let candidate = greatest_common_divisor;
    assert_eq!(candidate(3, 7), 1);
    assert_eq!(candidate(10, 15), 5);
    assert_eq!(candidate(49, 14), 7);
    assert_eq!(candidate(144, 60), 12);
}


Prompt:
/// Checks if given string is a palindrome
/// >>> is_palindrome(String::from(""))
/// true
/// >>> is_palindrome(String::from("aba"))
/// true
/// >>> is_palindrome(String::from("aaaaa"))
/// true
/// >>> is_palindrome(String::from("zbcd"))
/// false
fn is_palindrome(text: String) -> bool {

fn main() {
    let candidate = is_palindrome;
    assert_eq!(candidate(String::from("")), true);
    assert_eq!(candidate(String::from("aba")), true);
    assert_eq!(candidate(String::from("aaaaa")), true);
    assert_eq!(candidate(String::from("zbcd")), false);
    assert_eq!(candidate(String::from("xywyx")), true);
    assert_eq!(candidate(String::from("xywyz")), false);
    assert_eq!(candidate(String::from("xywzx")), false);
}


Prompt:
/// xs represent coefficients of a polynomial.
/// xs[0] + xs[1] * x + xs[2] * x^2 + ....
/// Return derivative of this polynomial in the same form.
/// >>> derivative(vec![3, 1, 2, 4, 5])
/// vec![1, 4, 12, 20]
/// >>> derivative(vec![1, 2, 3])
/// vec![2, 6]
fn derivative(xs: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = derivative;
    assert_eq!(candidate(vec![3, 1, 2, 4, 5]), vec![1, 4, 12, 20]);
    assert_eq!(candidate(vec![1, 2, 3]), vec![2, 6]);
    assert_eq!(candidate(vec![3, 2, 1]), vec![2, 2]);
    assert_eq!(candidate(vec![3, 2, 1, 0, 4]), vec![2, 2, 0, 16]);
    assert_eq!(candidate(vec![1]), Vec::<isize>::new());
}


Prompt:
/// 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(String::from("5 apples and 6 oranges"), 19)
/// 8
/// >>> fruit_distribution(String::from("0 apples and 1 oranges"), 3)
/// 2
/// >>> fruit_distribution(String::from("2 apples and 3 oranges"), 100)
/// 95
/// >>> fruit_distribution(String::from("100 apples and 1 oranges"), 120)
/// 19
fn fruit_distribution(s: String, n: isize) -> isize {

fn main() {
    let candidate = fruit_distribution;
    assert_eq!(candidate(String::from("5 apples and 6 oranges"), 19), 8);
    assert_eq!(candidate(String::from("5 apples and 6 oranges"), 21), 10);
    assert_eq!(candidate(String::from("0 apples and 1 oranges"), 3), 2);
    assert_eq!(candidate(String::from("1 apples and 0 oranges"), 3), 2);
    assert_eq!(candidate(String::from("2 apples and 3 oranges"), 100), 95);
    assert_eq!(candidate(String::from("2 apples and 3 oranges"), 5), 0);
    assert_eq!(candidate(String::from("1 apples and 100 oranges"), 120), 19);
}


Prompt:
/// Write a function that takes an integer a and returns true
/// if this ingeger is a cube of some integer number.
/// Note: you may assume the input is always valid.
/// Examples:
/// >>> iscube(1)
/// true
/// >>> iscube(2)
/// false
/// >>> iscube(-1)
/// true
/// >>> iscube(64)
/// true
/// >>> iscube(0)
/// true
/// >>> iscube(180)
/// false
fn iscube(a: isize) -> bool {

fn main() {
    let candidate = iscube;
    assert_eq!(candidate(1), true);
    assert_eq!(candidate(2), false);
    assert_eq!(candidate(-1), true);
    assert_eq!(candidate(64), true);
    assert_eq!(candidate(180), false);
    assert_eq!(candidate(1000), true);
    assert_eq!(candidate(0), true);
    assert_eq!(candidate(1729), false);
}


Prompt:
/// 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(vec![1, 5, 2, 3, 4])
/// vec![1, 2, 3, 4, 5]
/// >>> sort_array(vec![-2, -3, -4, -5, -6])
/// vec![-6, -5, -4, -3, -2]
/// >>> sort_array(vec![1, 0, 2, 3, 4])
/// vec![0, 1, 2, 3, 4]
fn sort_array(arr: Vec<isize>) -> Vec<isize> {


Prompt:
/// Given a vector of strings, where each string consists of only digits, return a vector.
/// Each element i of the output should be "the number of odd elements in the
/// string i of the input." where all the i's should be replaced by the number
/// of odd digits in the i'th string of the input.
/// >>> odd_count(vec![String::from("1234567")])
/// vec![String::from("the number of odd elements 4n the str4ng 4 of the 4nput.")]
/// >>> odd_count(vec![String::from("3"), String::from("11111111")])
/// vec![String::from("the number of odd elements 1n the str1ng 1 of the 1nput."), String::from("the number of odd elements 8n the str8ng 8 of the 8nput.")]
fn odd_count(lst: Vec<String>) -> Vec<String> {

fn main() {
    let candidate = odd_count;
    assert_eq!(candidate(vec![String::from("1234567")]), vec![String::from("the number of odd elements 4n the str4ng 4 of the 4nput.")]);
    assert_eq!(candidate(vec![String::from("3"), String::from("11111111")]), vec![String::from("the number of odd elements 1n the str1ng 1 of the 1nput."), String::from("the number of odd elements 8n the str8ng 8 of the 8nput.")]);
    assert_eq!(candidate(vec![String::from("271"), String::from("137"), String::from("314")]), vec![String::from("the number of odd elements 2n the str2ng 2 of the 2nput."), String::from("the number of odd elements 3n the str3ng 3 of the 3nput."), String::from("the number of odd elements 2n the str2ng 2 of the 2nput.")]);
}


Prompt:
/// brackets is a string of "(" and ")".
/// return true if every opening bracket has a corresponding closing bracket.
/// >>> correct_bracketing(String::from("("))
/// false
/// >>> correct_bracketing(String::from("()"))
/// true
/// >>> correct_bracketing(String::from("(()())"))
/// true
/// >>> correct_bracketing(String::from(")(()"))
/// false
fn correct_bracketing(brackets: String) -> bool {

fn main() {
    let candidate = correct_bracketing;
    assert_eq!(candidate(String::from("()")), true);
    assert_eq!(candidate(String::from("(()())")), true);
    assert_eq!(candidate(String::from("()()(()())()")), true);
    assert_eq!(candidate(String::from("()()((()()())())(()()(()))")), true);
    assert_eq!(candidate(String::from("((()())))")), false);
    assert_eq!(candidate(String::from(")(()")), false);
    assert_eq!(candidate(String::from("(")), false);
    assert_eq!(candidate(String::from("((((")), false);
    assert_eq!(candidate(String::from(")")), false);
    assert_eq!(candidate(String::from("(()")), false);
    assert_eq!(candidate(String::from("()()(()())())(()")), false);
    assert_eq!(candidate(String::from("()()(()())()))()")), false);
}


Prompt:
/// Task
/// Write a function that takes a string as input and returns the sum of the upper characters only'
/// ASCII codes.
/// Examples:
/// >>> digitSum(String::from(""))
/// 0
/// >>> digitSum(String::from("abAB"))
/// 131
/// >>> digitSum(String::from("abcCd"))
/// 67
/// >>> digitSum(String::from("helloE"))
/// 69
/// >>> digitSum(String::from("woArBld"))
/// 131
/// >>> digitSum(String::from("aAaaaXa"))
/// 153
fn digitSum(s: String) -> isize {

fn main() {
    let candidate = digitSum;
    assert_eq!(candidate(String::from("")), 0);
    assert_eq!(candidate(String::from("abAB")), 131);
    assert_eq!(candidate(String::from("abcCd")), 67);
    assert_eq!(candidate(String::from("helloE")), 69);
    assert_eq!(candidate(String::from("woArBld")), 131);
    assert_eq!(candidate(String::from("aAaaaXa")), 153);
    assert_eq!(candidate(String::from(" How are yOu?")), 151);
    assert_eq!(candidate(String::from("You arE Very Smart")), 327);
}


Prompt:
/// 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(vec![String::from("aa"), String::from("a"), String::from("aaa")])
/// vec![String::from("aa")]
/// >>> list_sort(vec![String::from("ab"), String::from("a"), String::from("aaa"), String::from("cd")])
/// vec![String::from("ab"), String::from("cd")]
fn sorted_list_sum(lst: Vec<String>) -> Vec<String> {

fn main() {
    let candidate = sorted_list_sum;
    assert_eq!(candidate(vec![String::from("aa"), String::from("a"), String::from("aaa")]), vec![String::from("aa")]);
    assert_eq!(candidate(vec![String::from("school"), String::from("AI"), String::from("asdf"), String::from("b")]), vec![String::from("AI"), String::from("asdf"), String::from("school")]);
    assert_eq!(candidate(vec![String::from("d"), String::from("b"), String::from("c"), String::from("a")]), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("d"), String::from("dcba"), String::from("abcd"), String::from("a")]), vec![String::from("abcd"), String::from("dcba")]);
    assert_eq!(candidate(vec![String::from("AI"), String::from("ai"), String::from("au")]), vec![String::from("AI"), String::from("ai"), String::from("au")]);
    assert_eq!(candidate(vec![String::from("a"), String::from("b"), String::from("b"), String::from("c"), String::from("c"), String::from("a")]), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("aaaa"), String::from("bbbb"), String::from("dd"), String::from("cc")]), vec![String::from("cc"), String::from("dd"), String::from("aaaa"), String::from("bbbb")]);
}


Prompt:
/// 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(vec![1, 2, 2, -4])
/// Some(9)
/// >>> prod_signs(vec![0, 1])
/// Some(0)
/// >>> prod_signs(vec![])
/// None
fn prod_signs(arr: Vec<isize>) -> Option<isize> {

fn main() {
    let candidate = prod_signs;
    assert_eq!(candidate(vec![1, 2, 2, -4]), Some(-9));
    assert_eq!(candidate(vec![0, 1]), Some(0));
    assert_eq!(candidate(vec![1, 1, 1, 2, 3, -1, 1]), Some(-10));
    assert_eq!(candidate(Vec::<isize>::new()), None);
    assert_eq!(candidate(vec![2, 4, 1, 2, -1, -1, 9]), Some(20));
    assert_eq!(candidate(vec![-1, 1, -1, 1]), Some(4));
    assert_eq!(candidate(vec![-1, 1, 1, 1]), Some(-4));
    assert_eq!(candidate(vec![-1, 1, 1, 0]), Some(0));
}


Prompt:
/// Return vector with elements incremented by 1.
/// >>> incr_list(vec![1, 2, 3])
/// vec![2, 3, 4]
/// >>> incr_list(vec![5, 3, 5, 2, 3, 3, 9, 0, 123])
/// vec![6, 4, 6, 3, 4, 4, 10, 1, 124]
fn incr_list(l: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = incr_list;
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<isize>::new());
    assert_eq!(candidate(vec![3, 2, 1]), vec![4, 3, 2]);
    assert_eq!(candidate(vec![5, 2, 5, 2, 3, 3, 9, 0, 123]), vec![6, 3, 6, 3, 4, 4, 10, 1, 124]);
}


Prompt:
/// From a given vector of integers, generate a vector of rolling maximum element found until given moment
/// in the sequence.
/// >>> rolling_max(vec![1, 2, 3, 2, 3, 4, 2])
/// vec![1, 2, 3, 3, 3, 4, 4]
fn rolling_max(numbers: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = rolling_max;
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<isize>::new());
    assert_eq!(candidate(vec![1, 2, 3, 4]), vec![1, 2, 3, 4]);
    assert_eq!(candidate(vec![4, 3, 2, 1]), vec![4, 4, 4, 4]);
    assert_eq!(candidate(vec![3, 2, 3, 100, 3]), vec![3, 3, 3, 100, 100]);
}


Prompt:
/// 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(String::from("( ) (( )) (( )( ))"))
/// vec![String::from("()"), String::from("(())"), String::from("(()())")]
fn separate_paren_groups(paren_string: String) -> Vec<String> {


Prompt:
/// You will be given a string of words separated by commas or spaces. Your task is
/// to split the string into words and return a vector of the words.
/// For example:
/// >>> words_string(String::from("Hi, my name is John"))
/// vec![String::from("Hi"), String::from("my"), String::from("name"), String::from("is"), String::from("John")]
/// >>> words_string(String::from("One, two, three, four, five, six"))
/// vec![String::from("One"), String::from("two"), String::from("three"), String::from("four"), String::from("five"), String::from("six")]
fn words_string(s: String) -> Vec<String> {

fn main() {
    let candidate = words_string;
    assert_eq!(candidate(String::from("Hi, my name is John")), vec![String::from("Hi"), String::from("my"), String::from("name"), String::from("is"), String::from("John")]);
    assert_eq!(candidate(String::from("One, two, three, four, five, six")), vec![String::from("One"), String::from("two"), String::from("three"), String::from("four"), String::from("five"), String::from("six")]);
    assert_eq!(candidate(String::from("Hi, my name")), vec![String::from("Hi"), String::from("my"), String::from("name")]);
    assert_eq!(candidate(String::from("One,, two, three, four, five, six,")), vec![String::from("One"), String::from("two"), String::from("three"), String::from("four"), String::from("five"), String::from("six")]);
    assert_eq!(candidate(String::from("")), Vec::<String>::new());
    assert_eq!(candidate(String::from("ahmed     , gamal")), vec![String::from("ahmed"), String::from("gamal")]);
}


Prompt:
/// This function takes a vector l and returns a vector l' such that
/// l' is identical to l in the odd indicies, while its values at the even indicies are equal
/// to the values of the even indicies of l, but sorted.
/// >>> sort_even(vec![1, 2, 3])
/// vec![1, 2, 3]
/// >>> sort_even(vec![5, 6, 3, 4])
/// vec![3, 6, 5, 4]
fn sort_even(l: Vec<isize>) -> Vec<isize> {


Prompt:
/// 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(vec![1, 2, 3, 4, 5, 1], vec![1, 2, 3, 4, 2, -2])
/// vec![0, 0, 0, 0, 3, 3]
/// >>> compare(vec![0, 5, 0, 0, 0, 4], vec![4, 1, 1, 0, 0, -2])
/// vec![4, 4, 1, 0, 0, 6]
fn compare(game: Vec<isize>, guess: Vec<isize>) -> Vec<isize> {


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

fn main() {
    let candidate = even_odd_palindrome;
    assert_eq!(candidate(123), (8, 13));
    assert_eq!(candidate(12), (4, 6));
    assert_eq!(candidate(3), (1, 2));
    assert_eq!(candidate(63), (6, 8));
    assert_eq!(candidate(25), (5, 6));
    assert_eq!(candidate(19), (4, 6));
    assert_eq!(candidate(9), (4, 5));
    assert_eq!(candidate(1), (0, 1));
}


Prompt:
/// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
/// fib4(0) -> 0
/// fib4(1) -> 0
/// fib4(2) -> 2
/// fib4(3) -> 0
/// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
/// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
/// >>> fib4(5)
/// 4
/// >>> fib4(6)
/// 8
/// >>> fib4(7)
/// 14
fn fib4(n: isize) -> isize {

fn main() {
    let candidate = fib4;
    assert_eq!(candidate(5), 4);
    assert_eq!(candidate(8), 28);
    assert_eq!(candidate(10), 104);
    assert_eq!(candidate(12), 386);
}


Prompt:
/// Given two positive integers a and b, return the even digits between a
/// and b, in ascending order.
/// For example:
/// >>> generate_integers(2, 8)
/// vec![2, 4, 6, 8]
/// >>> generate_integers(8, 2)
/// vec![2, 4, 6, 8]
/// >>> generate_integers(10, 14)
/// Vec::<isize>::new()
fn generate_integers(a: isize, b: isize) -> Vec<isize> {

fn main() {
    let candidate = generate_integers;
    assert_eq!(candidate(2, 10), vec![2, 4, 6, 8]);
    assert_eq!(candidate(10, 2), vec![2, 4, 6, 8]);
    assert_eq!(candidate(132, 2), vec![2, 4, 6, 8]);
    assert_eq!(candidate(17, 89), Vec::<isize>::new());
}


Prompt:
/// 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(vec![1.0, 2.0, 3.0, 4.0])
/// 1.0
fn mean_absolute_deviation(numbers: Vec<f64>) -> f64 {

fn main() {
    let candidate = mean_absolute_deviation;
    assert_eq!(candidate(vec![1.0, 2.0]), 0.5);
    assert_eq!(candidate(vec![1.0, 2.0, 3.0, 4.0]), 1.0);
    assert_eq!(candidate(vec![1.0, 2.0, 3.0, 4.0, 5.0]), 1.2);
}


Prompt:
/// Create a function encrypt that takes a string as an argument and
/// returns a string encrypted with the alphabet being rotated.
/// The alphabet should be rotated in a manner such that the letters
/// shift down by two multiplied to two places.
/// For example:
/// >>> encrypt(String::from("hi"))
/// String::from("lm")
/// >>> encrypt(String::from("asdfghjkl"))
/// String::from("ewhjklnop")
/// >>> encrypt(String::from("gf"))
/// String::from("kj")
/// >>> encrypt(String::from("et"))
/// String::from("ix")
fn encrypt(s: String) -> String {

fn main() {
    let candidate = encrypt;
    assert_eq!(candidate(String::from("hi")), String::from("lm"));
    assert_eq!(candidate(String::from("asdfghjkl")), String::from("ewhjklnop"));
    assert_eq!(candidate(String::from("gf")), String::from("kj"));
    assert_eq!(candidate(String::from("et")), String::from("ix"));
    assert_eq!(candidate(String::from("faewfawefaewg")), String::from("jeiajeaijeiak"));
    assert_eq!(candidate(String::from("hellomyfriend")), String::from("lippsqcjvmirh"));
    assert_eq!(candidate(String::from("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh")), String::from("hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl"));
    assert_eq!(candidate(String::from("a")), String::from("e"));
}


Prompt:
/// 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)
/// vec![1, 5]
fn get_odd_collatz(n: isize) -> Vec<isize> {

fn main() {
    let candidate = get_odd_collatz;
    assert_eq!(candidate(14), vec![1, 5, 7, 11, 13, 17]);
    assert_eq!(candidate(5), vec![1, 5]);
    assert_eq!(candidate(12), vec![1, 3, 5]);
    assert_eq!(candidate(1), vec![1]);
}


Prompt:
/// Find how many times a given substring can be found in the original string. Count overlaping cases.
/// >>> how_many_times(String::from(""), String::from("a"))
/// 0
/// >>> how_many_times(String::from("aaa"), String::from("a"))
/// 3
/// >>> how_many_times(String::from("aaaa"), String::from("aa"))
/// 3
fn how_many_times(string: String, substring: String) -> isize {

fn main() {
    let candidate = how_many_times;
    assert_eq!(candidate(String::from(""), String::from("x")), 0);
    assert_eq!(candidate(String::from("xyxyxyx"), String::from("x")), 4);
    assert_eq!(candidate(String::from("cacacacac"), String::from("cac")), 4);
    assert_eq!(candidate(String::from("john doe"), String::from("john")), 1);
}


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

fn main() {
    let candidate = move_one_ball;
    assert_eq!(candidate(vec![3, 4, 5, 1, 2]), true);
    assert_eq!(candidate(vec![3, 5, 10, 1, 2]), true);
    assert_eq!(candidate(vec![4, 3, 1, 2]), false);
    assert_eq!(candidate(vec![3, 5, 4, 1, 2]), false);
    assert_eq!(candidate(Vec::<isize>::new()), true);
}


Prompt:
/// Write a function which sorts the given vector of integers
/// in ascending order according to the sum of their digits.
/// Note: if there are several items with similar sum of their digits,
/// order them based on their index in original vector.
/// For example:
/// >>> order_by_points(vec![1, 11, -1, -11, -12])
/// vec![-1, -11, 1, -12, 11]
/// >>> order_by_points(vec![])
/// Vec::<isize>::new()
fn order_by_points(nums: Vec<isize>) -> Vec<isize> {


Prompt:
/// Return vector of prime factors of given integer in the order from smallest to largest.
/// Each of the factors should be vectored number of times corresponding to how many times it appeares in factorization.
/// Input number should be equal to the product of all factors
/// >>> factorize(8)
/// vec![2, 2, 2]
/// >>> factorize(25)
/// vec![5, 5]
/// >>> factorize(70)
/// vec![2, 5, 7]
fn factorize(n: isize) -> Vec<isize> {

fn main() {
    let candidate = factorize;
    assert_eq!(candidate(2), vec![2]);
    assert_eq!(candidate(4), vec![2, 2]);
    assert_eq!(candidate(8), vec![2, 2, 2]);
    assert_eq!(candidate(57), vec![3, 19]);
    assert_eq!(candidate(3249), vec![3, 3, 19, 19]);
    assert_eq!(candidate(185193), vec![3, 3, 3, 19, 19, 19]);
    assert_eq!(candidate(20577), vec![3, 19, 19, 19]);
    assert_eq!(candidate(18), vec![2, 3, 3]);
}


Prompt:
/// Return true if all numbers in the vector l are below threshold t.
/// >>> below_threshold(vec![1, 2, 4, 10], 100)
/// true
/// >>> below_threshold(vec![1, 20, 4, 10], 5)
/// false
fn below_threshold(l: Vec<isize>, t: isize) -> bool {

fn main() {
    let candidate = below_threshold;
    assert_eq!(candidate(vec![1, 2, 4, 10], 100), true);
    assert_eq!(candidate(vec![1, 20, 4, 10], 5), false);
    assert_eq!(candidate(vec![1, 20, 4, 10], 21), true);
    assert_eq!(candidate(vec![1, 20, 4, 10], 22), true);
    assert_eq!(candidate(vec![1, 8, 4, 10], 11), true);
    assert_eq!(candidate(vec![1, 8, 4, 10], 10), false);
}


Prompt:
/// 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(String::from("(()()) ((())) () ((())()())"))
/// vec![2, 3, 1, 3]
fn parse_nested_parens(paren_string: String) -> Vec<isize> {


Prompt:
/// Given a non-empty vector of integers, return the sum of all of the odd elements that are in even positions.
/// Examples
/// >>> solution(vec![5, 8, 7, 1])
/// 12
/// >>> solution(vec![3, 3, 3, 3, 3])
/// 9
/// >>> solution(vec![30, 13, 24, 321])
/// 0
fn solution(lst: Vec<isize>) -> isize {

fn main() {
    let candidate = solution;
    assert_eq!(candidate(vec![5, 8, 7, 1]), 12);
    assert_eq!(candidate(vec![3, 3, 3, 3, 3]), 9);
    assert_eq!(candidate(vec![30, 13, 24, 321]), 0);
    assert_eq!(candidate(vec![5, 9]), 5);
    assert_eq!(candidate(vec![2, 4, 8]), 0);
    assert_eq!(candidate(vec![30, 13, 23, 32]), 23);
    assert_eq!(candidate(vec![3, 13, 2, 9]), 3);
}


Prompt:
/// 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).
fn get_max_triples(n: isize) -> isize {

fn main() {
    let candidate = get_max_triples;
    assert_eq!(candidate(5), 1);
    assert_eq!(candidate(6), 4);
    assert_eq!(candidate(10), 36);
    assert_eq!(candidate(100), 53361);
}


Prompt:
/// You are given a vector of integers.
/// Write a function next_smallest() that returns the 2nd smallest element of the vector.
/// Return None if there is no such element.
/// >>> next_smallest(vec![1, 2, 3, 4, 5])
/// Some(2)
/// >>> next_smallest(vec![5, 1, 4, 3, 2])
/// Some(2)
/// >>> next_smallest(vec![])
/// None
/// >>> next_smallest(vec![1, 1])
/// None
fn next_smallest(lst: Vec<isize>) -> Option<isize> {

fn main() {
    let candidate = next_smallest;
    assert_eq!(candidate(vec![1, 2, 3, 4, 5]), Some(2));
    assert_eq!(candidate(vec![5, 1, 4, 3, 2]), Some(2));
    assert_eq!(candidate(Vec::<isize>::new()), None);
    assert_eq!(candidate(vec![1, 1]), None);
    assert_eq!(candidate(vec![1, 1, 1, 1, 0]), Some(1));
    assert_eq!(candidate(vec![1, 1]), None);
    assert_eq!(candidate(vec![-35, 34, 12, -45]), Some(-35));
}


Prompt:
/// 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(String::from("three one five"))
/// String::from("one three five")
fn sort_numbers(numbers: String) -> String {

fn main() {
    let candidate = sort_numbers;
    assert_eq!(candidate(String::from("")), String::from(""));
    assert_eq!(candidate(String::from("three")), String::from("three"));
    assert_eq!(candidate(String::from("three five nine")), String::from("three five nine"));
    assert_eq!(candidate(String::from("five zero four seven nine eight")), String::from("zero four five seven eight nine"));
    assert_eq!(candidate(String::from("six five four three two one zero")), String::from("zero one two three four five six"));
}


Prompt:
/// 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(String::from("abcd"), String::from("abd"))
/// false
/// >>> cycpattern_check(String::from("hello"), String::from("ell"))
/// true
/// >>> cycpattern_check(String::from("whassup"), String::from("psus"))
/// false
/// >>> cycpattern_check(String::from("abab"), String::from("baa"))
/// true
/// >>> cycpattern_check(String::from("efef"), String::from("eeff"))
/// false
/// >>> cycpattern_check(String::from("himenss"), String::from("simen"))
/// true
fn cycpattern_check(a: String, b: String) -> bool {

fn main() {
    let candidate = cycpattern_check;
    assert_eq!(candidate(String::from("xyzw"), String::from("xyw")), false);
    assert_eq!(candidate(String::from("yello"), String::from("ell")), true);
    assert_eq!(candidate(String::from("whattup"), String::from("ptut")), false);
    assert_eq!(candidate(String::from("efef"), String::from("fee")), true);
    assert_eq!(candidate(String::from("abab"), String::from("aabb")), false);
    assert_eq!(candidate(String::from("winemtt"), String::from("tinem")), true);
}


Prompt:
/// You will be given a number in decimal form and your task is to convert it to
/// binary format. The function should return a string, with each character representing a binary
/// number. Each character in the string will be '0' or '1'.
/// There will be an extra couple of characters 'db' at the beginning and at the end of the string.
/// The extra characters are there to help with the format.
/// Examples:
/// >>> decimal_to_binary(15)
/// String::from("db1111db")
/// >>> decimal_to_binary(32)
/// String::from("db100000db")
fn decimal_to_binary(decimal: isize) -> String {

fn main() {
    let candidate = decimal_to_binary;
    assert_eq!(candidate(0), String::from("db0db"));
    assert_eq!(candidate(32), String::from("db100000db"));
    assert_eq!(candidate(103), String::from("db1100111db"));
    assert_eq!(candidate(15), String::from("db1111db"));
}


Prompt:
/// Filter an input vector of strings only for ones that contain given substring
/// >>> filter_by_substring(vec![], String::from("a"))
/// Vec::<String>::new()
/// >>> filter_by_substring(vec![String::from("abc"), String::from("bacd"), String::from("cde"), String::from("array")], String::from("a"))
/// vec![String::from("abc"), String::from("bacd"), String::from("array")]
fn filter_by_substring(strings: Vec<String>, substring: String) -> Vec<String> {

fn main() {
    let candidate = filter_by_substring;
    assert_eq!(candidate(Vec::<String>::new(), String::from("john")), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("xxx"), String::from("asd"), String::from("xxy"), String::from("john doe"), String::from("xxxAAA"), String::from("xxx")], String::from("xxx")), vec![String::from("xxx"), String::from("xxxAAA"), String::from("xxx")]);
    assert_eq!(candidate(vec![String::from("xxx"), String::from("asd"), String::from("aaaxxy"), String::from("john doe"), String::from("xxxAAA"), String::from("xxx")], String::from("xx")), vec![String::from("xxx"), String::from("aaaxxy"), String::from("xxxAAA"), String::from("xxx")]);
    assert_eq!(candidate(vec![String::from("grunt"), String::from("trumpet"), String::from("prune"), String::from("gruesome")], String::from("run")), vec![String::from("grunt"), String::from("prune")]);
}


Prompt:
/// Given an integer. return a tuple that has the number of even and odd digits respectively.
/// Example:
/// >>> even_odd_count(-12)
/// (1, 1)
/// >>> even_odd_count(123)
/// (1, 2)
fn even_odd_count(num: isize) -> (isize, isize) {

fn main() {
    let candidate = even_odd_count;
    assert_eq!(candidate(7), (0, 1));
    assert_eq!(candidate(-78), (1, 1));
    assert_eq!(candidate(3452), (2, 2));
    assert_eq!(candidate(346211), (3, 3));
    assert_eq!(candidate(-345821), (3, 3));
    assert_eq!(candidate(-2), (1, 0));
    assert_eq!(candidate(-45347), (2, 3));
    assert_eq!(candidate(0), (1, 0));
}


Prompt:
/// 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(vec![String::from("name"), String::from("of"), String::from("string")])
/// String::from("string")
/// >>> find_max(vec![String::from("name"), String::from("enam"), String::from("game")])
/// String::from("enam")
/// >>> find_max(vec![String::from("aaaaaaa"), String::from("bb"), String::from("cc")])
/// String::from("aaaaaaa")
fn find_max(words: Vec<String>) -> String {

fn main() {
    let candidate = find_max;
    assert_eq!(candidate(vec![String::from("name"), String::from("of"), String::from("string")]), String::from("string"));
    assert_eq!(candidate(vec![String::from("name"), String::from("enam"), String::from("game")]), String::from("enam"));
    assert_eq!(candidate(vec![String::from("aaaaaaa"), String::from("bb"), String::from("cc")]), String::from("aaaaaaa"));
    assert_eq!(candidate(vec![String::from("abc"), String::from("cba")]), String::from("abc"));
    assert_eq!(candidate(vec![String::from("play"), String::from("this"), String::from("game"), String::from("of"), String::from("footbott")]), String::from("footbott"));
    assert_eq!(candidate(vec![String::from("we"), String::from("are"), String::from("gonna"), String::from("rock")]), String::from("gonna"));
    assert_eq!(candidate(vec![String::from("we"), String::from("are"), String::from("a"), String::from("mad"), String::from("nation")]), String::from("nation"));
    assert_eq!(candidate(vec![String::from("this"), String::from("is"), String::from("a"), String::from("prrk")]), String::from("this"));
    assert_eq!(candidate(vec![String::from("b")]), String::from("b"));
    assert_eq!(candidate(vec![String::from("play"), String::from("play"), String::from("play")]), String::from("play"));
}


Prompt:
/// Given a positive integer n, return the count of the numbers of n-digit
/// positive integers that start or end with 1.
fn starts_one_ends(n: isize) -> isize {

fn main() {
    let candidate = starts_one_ends;
    assert_eq!(candidate(1), 1);
    assert_eq!(candidate(2), 18);
    assert_eq!(candidate(3), 180);
    assert_eq!(candidate(4), 1800);
    assert_eq!(candidate(5), 18000);
}


Prompt:
/// 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(vec![2, 4, 1, 3, 5, 7])
/// (None, Some(1))
/// >>> largest_smallest_integers(vec![])
/// (None, None)
/// >>> largest_smallest_integers(vec![0])
/// (None, None)
fn largest_smallest_integers(lst: Vec<isize>) -> (Option<isize>, Option<isize>) {

fn main() {
    let candidate = largest_smallest_integers;
    assert_eq!(candidate(vec![2, 4, 1, 3, 5, 7]), (None, Some(1)));
    assert_eq!(candidate(vec![2, 4, 1, 3, 5, 7, 0]), (None, Some(1)));
    assert_eq!(candidate(vec![1, 3, 2, 4, 5, 6, -2]), (Some(-2), Some(1)));
    assert_eq!(candidate(vec![4, 5, 3, 6, 2, 7, -7]), (Some(-7), Some(2)));
    assert_eq!(candidate(vec![7, 3, 8, 4, 9, 2, 5, -9]), (Some(-9), Some(2)));
    assert_eq!(candidate(Vec::<isize>::new()), (None, None));
    assert_eq!(candidate(vec![0]), (None, None));
    assert_eq!(candidate(vec![-1, -3, -5, -6]), (Some(-1), None));
    assert_eq!(candidate(vec![-1, -3, -5, -6, 0]), (Some(-1), None));
    assert_eq!(candidate(vec![-6, -4, -4, -3, 1]), (Some(-3), Some(1)));
    assert_eq!(candidate(vec![-6, -4, -4, -3, -100, 1]), (Some(-3), Some(1)));
}


Prompt:
/// "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(vec![4, 2, 3])
/// vec![2, 1]
/// Explanation: 2 has the smallest even value, and 2 has the smallest index.
/// Example 2:
/// >>> pluck(vec![1, 2, 3])
/// vec![2, 1]
/// Explanation: 2 has the smallest even value, and 2 has the smallest index.
/// Example 3:
/// >>> pluck(vec![])
/// Vec::<isize>::new()
/// Example 4:
/// >>> pluck(vec![5, 0, 3, 0, 4, 2])
/// vec![0, 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
fn pluck(arr: Vec<isize>) -> Vec<isize> {

fn main() {
    let candidate = pluck;
    assert_eq!(candidate(vec![4, 2, 3]), vec![2, 1]);
    assert_eq!(candidate(vec![1, 2, 3]), vec![2, 1]);
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<isize>::new());
    assert_eq!(candidate(vec![5, 0, 3, 0, 4, 2]), vec![0, 1]);
    assert_eq!(candidate(vec![1, 2, 3, 0, 5, 3]), vec![0, 3]);
    assert_eq!(candidate(vec![5, 4, 8, 4, 8]), vec![4, 1]);
    assert_eq!(candidate(vec![7, 6, 7, 1]), vec![6, 1]);
    assert_eq!(candidate(vec![7, 9, 7, 1]), Vec::<isize>::new());
}


Prompt:
/// 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(vec![])
/// 0
/// >>> count_nums(vec![-1, 11, -11])
/// 1
/// >>> count_nums(vec![1, 1, 2])
/// 3
fn count_nums(arr: Vec<isize>) -> isize {

fn main() {
    let candidate = count_nums;
    assert_eq!(candidate(Vec::<isize>::new()), 0);
    assert_eq!(candidate(vec![-1, -2, 0]), 0);
    assert_eq!(candidate(vec![1, 1, 2, -2, 3, 4, 5]), 6);
    assert_eq!(candidate(vec![1, 6, 9, -6, 0, 1, 5]), 5);
    assert_eq!(candidate(vec![1, 100, 98, -7, 1, -1]), 4);
    assert_eq!(candidate(vec![12, 23, 34, -45, -56, 0]), 5);
    assert_eq!(candidate(vec![0, 1]), 1);
    assert_eq!(candidate(vec![1]), 1);
}


Prompt:
/// Given a grid with N rows and N columns (N >= 2) and a positive integer k,
/// each cell of the grid contains a value. Every integer in the range [1, N * N]
/// inclusive appears exactly once on the cells of the grid.
/// You have to find the minimum path of length k in the grid. You can start
/// from any cell, and in each step you can move to any of the neighbor cells,
/// in other words, you can go to cells which share an edge with you current
/// cell.
/// Please note that a path of length k means visiting exactly k cells (not
/// necessarily distinct).
/// You CANNOT go off the grid.
/// A path A (of length k) is considered less than a path B (of length k) if
/// after making the ordered vectors of the values on the cells that A and B go
/// through (let's call them lst_A and lst_B), lst_A is lexicographically less
/// than lst_B, in other words, there exist an integer index i (1 <= i <= k)
/// such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
/// lst_A[j] = lst_B[j].
/// It is guaranteed that the answer is unique.
/// Return an ordered vector of the values on the cells that the minimum path go through.
/// Examples:
/// >>> minPath(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]], 3)
/// vec![1, 2, 1]
/// >>> minPath(vec![vec![5, 9, 3], vec![4, 1, 6], vec![7, 8, 2]], 1)
/// vec![1]
fn minPath(grid: Vec<Vec<isize>>, k: isize) -> Vec<isize> {


Prompt:
/// Given vector of integers, return vector in strange order.
/// Strange sorting, is when you start with the minimum value,
/// then maximum of the remaining integers, then minimum and so on.
/// Examples:
/// >>> strange_sort_list(vec![1, 2, 3, 4])
/// vec![1, 4, 2, 3]
/// >>> strange_sort_list(vec![5, 5, 5, 5])
/// vec![5, 5, 5, 5]
/// >>> strange_sort_list(vec![])
/// Vec::<isize>::new()
fn strange_sort_list(lst: Vec<isize>) -> Vec<isize> {


Prompt:
/// Given a string 'text', return its md5 hash equivalent string.
/// If 'text' is an empty string, return None.
/// >>> string_to_md5(String::from("Hello world"))
/// Some(String::from("3e25960a79dbc69b674cd4ec67a72c62"))
fn string_to_md5(text: String) -> Option<String> {

fn main() {
    let candidate = string_to_md5;
    assert_eq!(candidate(String::from("Hello world")), Some(String::from("3e25960a79dbc69b674cd4ec67a72c62")));
    assert_eq!(candidate(String::from("")), None);
    assert_eq!(candidate(String::from("A B C")), Some(String::from("0ef78513b0cb8cef12743f5aeb35f888")));
    assert_eq!(candidate(String::from("password")), Some(String::from("5f4dcc3b5aa765d61d8327deb882cf99")));
}


Prompt:
/// 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(String::from("yogurt"))
/// String::from("u")
/// >>> get_closest_vowel(String::from("FULL"))
/// String::from("U")
/// >>> get_closest_vowel(String::from("quick"))
/// String::from("")
/// >>> get_closest_vowel(String::from("ab"))
/// String::from("")
fn get_closest_vowel(word: String) -> String {

fn main() {
    let candidate = get_closest_vowel;
    assert_eq!(candidate(String::from("yogurt")), String::from("u"));
    assert_eq!(candidate(String::from("full")), String::from("u"));
    assert_eq!(candidate(String::from("easy")), String::from(""));
    assert_eq!(candidate(String::from("eAsy")), String::from(""));
    assert_eq!(candidate(String::from("ali")), String::from(""));
    assert_eq!(candidate(String::from("bad")), String::from("a"));
    assert_eq!(candidate(String::from("most")), String::from("o"));
    assert_eq!(candidate(String::from("ab")), String::from(""));
    assert_eq!(candidate(String::from("ba")), String::from(""));
    assert_eq!(candidate(String::from("quick")), String::from(""));
    assert_eq!(candidate(String::from("anime")), String::from("i"));
    assert_eq!(candidate(String::from("Asia")), String::from(""));
    assert_eq!(candidate(String::from("Above")), String::from("o"));
}


Prompt:
/// 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)
/// String::from("22")
/// >>> change_base(8, 2)
/// String::from("1000")
/// >>> change_base(7, 2)
/// String::from("111")
fn change_base(x: isize, base: isize) -> String {

fn main() {
    let candidate = change_base;
    assert_eq!(candidate(8, 3), String::from("22"));
    assert_eq!(candidate(9, 3), String::from("100"));
    assert_eq!(candidate(234, 2), String::from("11101010"));
    assert_eq!(candidate(16, 2), String::from("10000"));
    assert_eq!(candidate(8, 2), String::from("1000"));
    assert_eq!(candidate(7, 2), String::from("111"));
    assert_eq!(candidate(2, 3), String::from("2"));
    assert_eq!(candidate(3, 4), String::from("3"));
    assert_eq!(candidate(4, 5), String::from("4"));
    assert_eq!(candidate(5, 6), String::from("5"));
    assert_eq!(candidate(6, 7), String::from("6"));
    assert_eq!(candidate(7, 8), String::from("7"));
}


Prompt:
/// Check if in given vector of numbers, are any two numbers closer to each other than
/// given threshold.
/// >>> has_close_elements(vec![1.0, 2.0, 3.0], 0.5)
/// false
/// >>> has_close_elements(vec![1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
/// true
fn has_close_elements(numbers: Vec<f64>, threshold: f64) -> bool {


Prompt:
/// Create a function that takes a string as input which contains only square brackets.
/// The function should return true if and only if there is a valid subsequence of brackets
/// where at least one bracket in the subsequence is nested.
/// >>> is_nested(String::from("[[]]"))
/// true
/// >>> is_nested(String::from("[]]]]]]][[[[[]"))
/// false
/// >>> is_nested(String::from("[][]"))
/// false
/// >>> is_nested(String::from("[]"))
/// false
/// >>> is_nested(String::from("[[][]]"))
/// true
/// >>> is_nested(String::from("[[]][["))
/// true
fn is_nested(string: String) -> bool {

fn main() {
    let candidate = is_nested;
    assert_eq!(candidate(String::from("[[]]")), true);
    assert_eq!(candidate(String::from("[]]]]]]][[[[[]")), false);
    assert_eq!(candidate(String::from("[][]")), false);
    assert_eq!(candidate(String::from("[]")), false);
    assert_eq!(candidate(String::from("[[[[]]]]")), true);
    assert_eq!(candidate(String::from("[]]]]]]]]]]")), false);
    assert_eq!(candidate(String::from("[][][[]]")), true);
    assert_eq!(candidate(String::from("[[]")), false);
    assert_eq!(candidate(String::from("[]]")), false);
    assert_eq!(candidate(String::from("[[]][[")), true);
    assert_eq!(candidate(String::from("[[][]]")), true);
    assert_eq!(candidate(String::from("")), false);
    assert_eq!(candidate(String::from("[[[[[[[[")), false);
    assert_eq!(candidate(String::from("]]]]]]]]")), false);
}


Prompt:
/// Concatenate vector of strings into a single string
/// >>> concatenate(vec![])
/// String::from("")
/// >>> concatenate(vec![String::from("a"), String::from("b"), String::from("c")])
/// String::from("abc")
fn concatenate(strings: Vec<String>) -> String {

fn main() {
    let candidate = concatenate;
    assert_eq!(candidate(Vec::<String>::new()), String::from(""));
    assert_eq!(candidate(vec![String::from("x"), String::from("y"), String::from("z")]), String::from("xyz"));
    assert_eq!(candidate(vec![String::from("x"), String::from("y"), String::from("z"), String::from("w"), String::from("k")]), String::from("xyzwk"));
}


Prompt:
/// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
/// >>> prime_fib(1)
/// 2
/// >>> prime_fib(2)
/// 3
/// >>> prime_fib(3)
/// 5
/// >>> prime_fib(4)
/// 13
/// >>> prime_fib(5)
/// 89
fn prime_fib(n: isize) -> isize {

fn main() {
    let candidate = prime_fib;
    assert_eq!(candidate(1), 2);
    assert_eq!(candidate(2), 3);
    assert_eq!(candidate(3), 5);
    assert_eq!(candidate(4), 13);
    assert_eq!(candidate(5), 89);
    assert_eq!(candidate(6), 233);
    assert_eq!(candidate(7), 1597);
    assert_eq!(candidate(8), 28657);
    assert_eq!(candidate(9), 514229);
    assert_eq!(candidate(10), 433494437);
}


Prompt:
/// From a supplied vector of numbers (of length at least two) select and return two that are the closest to each
/// other and return them in order (smaller number, larger number).
/// >>> find_closest_elements(vec![1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
/// (2.0, 2.2)
/// >>> find_closest_elements(vec![1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
/// (2.0, 2.0)
fn find_closest_elements(numbers: Vec<f64>) -> (f64, f64) {


Prompt:
/// 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(String::from("AB"))
/// 1
/// >>> hex_key(String::from("1077E"))
/// 2
/// >>> hex_key(String::from("ABED1A33"))
/// 4
/// >>> hex_key(String::from("123456789ABCDEF0"))
/// 6
/// >>> hex_key(String::from("2020"))
/// 2
fn hex_key(num: String) -> isize {

fn main() {
    let candidate = hex_key;
    assert_eq!(candidate(String::from("AB")), 1);
    assert_eq!(candidate(String::from("1077E")), 2);
    assert_eq!(candidate(String::from("ABED1A33")), 4);
    assert_eq!(candidate(String::from("2020")), 2);
    assert_eq!(candidate(String::from("123456789ABCDEF0")), 6);
    assert_eq!(candidate(String::from("112233445566778899AABBCCDDEEFF00")), 12);
}


Prompt:
/// 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
fn multiply(a: isize, b: isize) -> isize {

fn main() {
    let candidate = multiply;
    assert_eq!(candidate(148, 412), 16);
    assert_eq!(candidate(19, 28), 72);
    assert_eq!(candidate(2020, 1851), 0);
    assert_eq!(candidate(14, -15), 20);
    assert_eq!(candidate(76, 67), 42);
    assert_eq!(candidate(17, 27), 49);
    assert_eq!(candidate(0, 1), 0);
    assert_eq!(candidate(0, 0), 0);
}


Prompt:
/// 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(vec![1.0, 2.0, 3.0, 4.0, 5.0])
/// vec![0.0, 0.25, 0.5, 0.75, 1.0]
fn rescale_to_unit(numbers: Vec<f64>) -> Vec<f64> {


Prompt:
/// Given a positive integer n, return the product of the odd digits.
/// Return 0 if all digits are even.
/// For example:
/// >>> digits(1)
/// 1
/// >>> digits(4)
/// 0
/// >>> digits(235)
/// 15
fn digits(n: isize) -> isize {

fn main() {
    let candidate = digits;
    assert_eq!(candidate(5), 5);
    assert_eq!(candidate(54), 5);
    assert_eq!(candidate(120), 1);
    assert_eq!(candidate(5014), 5);
    assert_eq!(candidate(98765), 315);
    assert_eq!(candidate(5576543), 2625);
    assert_eq!(candidate(2468), 0);
}


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

fn main() {
    let candidate = Strongest_Extension;
    assert_eq!(candidate(String::from("Watashi"), vec![String::from("tEN"), String::from("niNE"), String::from("eIGHt8OKe")]), String::from("Watashi.eIGHt8OKe"));
    assert_eq!(candidate(String::from("Boku123"), vec![String::from("nani"), String::from("NazeDa"), String::from("YEs.WeCaNe"), String::from("32145tggg")]), String::from("Boku123.YEs.WeCaNe"));
    assert_eq!(candidate(String::from("__YESIMHERE"), vec![String::from("t"), String::from("eMptY"), String::from("nothing"), String::from("zeR00"), String::from("NuLl__"), String::from("123NoooneB321")]), String::from("__YESIMHERE.NuLl__"));
    assert_eq!(candidate(String::from("K"), vec![String::from("Ta"), String::from("TAR"), String::from("t234An"), String::from("cosSo")]), String::from("K.TAR"));
    assert_eq!(candidate(String::from("__HAHA"), vec![String::from("Tab"), String::from("123"), String::from("781345"), String::from("-_-")]), String::from("__HAHA.123"));
    assert_eq!(candidate(String::from("YameRore"), vec![String::from("HhAas"), String::from("okIWILL123"), String::from("WorkOut"), String::from("Fails"), String::from("-_-")]), String::from("YameRore.okIWILL123"));
    assert_eq!(candidate(String::from("finNNalLLly"), vec![String::from("Die"), String::from("NowW"), String::from("Wow"), String::from("WoW")]), String::from("finNNalLLly.WoW"));
    assert_eq!(candidate(String::from("_"), vec![String::from("Bb"), String::from("91245")]), String::from("_.Bb"));
    assert_eq!(candidate(String::from("Sp"), vec![String::from("671235"), String::from("Bb")]), String::from("Sp.671235"));
}


Prompt:
use std::collections::HashMap;

/// Given a string representing a space separated lowercase letters, return a HashMap
/// 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(String::from("a b c"))
/// HashMap::from([(String::from("a"), 1), (String::from("b"), 1), (String::from("c"), 1)])
/// >>> histogram(String::from("a b b a"))
/// HashMap::from([(String::from("a"), 2), (String::from("b"), 2)])
/// >>> histogram(String::from("a b c a b"))
/// HashMap::from([(String::from("a"), 2), (String::from("b"), 2)])
/// >>> histogram(String::from("b b b b a"))
/// HashMap::from([(String::from("b"), 4)])
/// >>> histogram(String::from(""))
/// HashMap::from([])
fn histogram(test: String) -> HashMap<String, isize> {

fn main() {
    let candidate = histogram;
    assert_eq!(candidate(String::from("a b b a")), HashMap::from([(String::from("a"), 2), (String::from("b"), 2)]));
    assert_eq!(candidate(String::from("a b c a b")), HashMap::from([(String::from("a"), 2), (String::from("b"), 2)]));
    assert_eq!(candidate(String::from("a b c d g")), HashMap::from([(String::from("a"), 1), (String::from("b"), 1), (String::from("c"), 1), (String::from("d"), 1), (String::from("g"), 1)]));
    assert_eq!(candidate(String::from("r t g")), HashMap::from([(String::from("r"), 1), (String::from("t"), 1), (String::from("g"), 1)]));
    assert_eq!(candidate(String::from("b b b b a")), HashMap::from([(String::from("b"), 4)]));
    assert_eq!(candidate(String::from("r t g")), HashMap::from([(String::from("r"), 1), (String::from("t"), 1), (String::from("g"), 1)]));
    assert_eq!(candidate(String::from("")), HashMap::from([]));
    assert_eq!(candidate(String::from("a")), HashMap::from([(String::from("a"), 1)]));
}


Prompt:
/// pairs_sum_to_zero takes a vector of integers as an input.
/// it returns true if there are two distinct elements in the vector that
/// sum to zero, and false otherwise.
/// >>> pairs_sum_to_zero(vec![1, 3, 5, 0])
/// false
/// >>> pairs_sum_to_zero(vec![1, 3, -2, 1])
/// false
/// >>> pairs_sum_to_zero(vec![1, 2, 3, 7])
/// false
/// >>> pairs_sum_to_zero(vec![2, 4, -5, 3, 5, 7])
/// true
/// >>> pairs_sum_to_zero(vec![1])
/// false
fn pairs_sum_to_zero(l: Vec<isize>) -> bool {

fn main() {
    let candidate = pairs_sum_to_zero;
    assert_eq!(candidate(vec![1, 3, 5, 0]), false);
    assert_eq!(candidate(vec![1, 3, -2, 1]), false);
    assert_eq!(candidate(vec![1, 2, 3, 7]), false);
    assert_eq!(candidate(vec![2, 4, -5, 3, 5, 7]), true);
    assert_eq!(candidate(vec![1]), false);
    assert_eq!(candidate(vec![-3, 9, -1, 3, 2, 30]), true);
    assert_eq!(candidate(vec![-3, 9, -1, 3, 2, 31]), true);
    assert_eq!(candidate(vec![-3, 9, -1, 4, 2, 30]), false);
    assert_eq!(candidate(vec![-3, 9, -1, 4, 2, 31]), false);
}


Prompt:
/// Write a function that accepts two vectors of strings and returns the vector that has
/// total number of chars in the all strings of the vector less than the other vector.
/// if the two vectors have the same number of chars, return the first vector.
/// Examples
/// >>> total_match(vec![], vec![])
/// Vec::<String>::new()
/// >>> total_match(vec![String::from("hi"), String::from("admin")], vec![String::from("hI"), String::from("Hi")])
/// vec![String::from("hI"), String::from("Hi")]
/// >>> total_match(vec![String::from("hi"), String::from("admin")], vec![String::from("hi"), String::from("hi"), String::from("admin"), String::from("project")])
/// vec![String::from("hi"), String::from("admin")]
/// >>> total_match(vec![String::from("hi"), String::from("admin")], vec![String::from("hI"), String::from("hi"), String::from("hi")])
/// vec![String::from("hI"), String::from("hi"), String::from("hi")]
/// >>> total_match(vec![String::from("4")], vec![String::from("1"), String::from("2"), String::from("3"), String::from("4"), String::from("5")])
/// vec![String::from("4")]
fn total_match(lst1: Vec<String>, lst2: Vec<String>) -> Vec<String> {

fn main() {
    let candidate = total_match;
    assert_eq!(candidate(Vec::<String>::new(), Vec::<String>::new()), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("hi"), String::from("admin")], vec![String::from("hi"), String::from("hi")]), vec![String::from("hi"), String::from("hi")]);
    assert_eq!(candidate(vec![String::from("hi"), String::from("admin")], vec![String::from("hi"), String::from("hi"), String::from("admin"), String::from("project")]), vec![String::from("hi"), String::from("admin")]);
    assert_eq!(candidate(vec![String::from("4")], vec![String::from("1"), String::from("2"), String::from("3"), String::from("4"), String::from("5")]), vec![String::from("4")]);
    assert_eq!(candidate(vec![String::from("hi"), String::from("admin")], vec![String::from("hI"), String::from("Hi")]), vec![String::from("hI"), String::from("Hi")]);
    assert_eq!(candidate(vec![String::from("hi"), String::from("admin")], vec![String::from("hI"), String::from("hi"), String::from("hi")]), vec![String::from("hI"), String::from("hi"), String::from("hi")]);
    assert_eq!(candidate(vec![String::from("hi"), String::from("admin")], vec![String::from("hI"), String::from("hi"), String::from("hii")]), vec![String::from("hi"), String::from("admin")]);
    assert_eq!(candidate(Vec::<String>::new(), vec![String::from("this")]), Vec::<String>::new());
    assert_eq!(candidate(vec![String::from("this")], Vec::<String>::new()), Vec::<String>::new());
}


Prompt:
/// 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)
/// String::from("21")
/// >>> circular_shift(12, 2)
/// String::from("12")
fn circular_shift(x: isize, shift: isize) -> String {

fn main() {
    let candidate = circular_shift;
    assert_eq!(candidate(100, 2), String::from("001"));
    assert_eq!(candidate(12, 2), String::from("12"));
    assert_eq!(candidate(97, 8), String::from("79"));
    assert_eq!(candidate(12, 1), String::from("21"));
    assert_eq!(candidate(11, 101), String::from("11"));
}


Prompt:
/// Return true is vector elements are monotonically increasing or decreasing.
/// >>> monotonic(vec![1, 2, 4, 20])
/// true
/// >>> monotonic(vec![1, 20, 4, 10])
/// false
/// >>> monotonic(vec![4, 1, 0, -10])
/// true
fn monotonic(l: Vec<isize>) -> bool {

fn main() {
    let candidate = monotonic;
    assert_eq!(candidate(vec![1, 2, 4, 10]), true);
    assert_eq!(candidate(vec![1, 2, 4, 20]), true);
    assert_eq!(candidate(vec![1, 20, 4, 10]), false);
    assert_eq!(candidate(vec![4, 1, 0, -10]), true);
    assert_eq!(candidate(vec![4, 1, 1, 0]), true);
    assert_eq!(candidate(vec![1, 2, 3, 2, 5, 60]), false);
    assert_eq!(candidate(vec![1, 2, 3, 4, 5, 60]), true);
    assert_eq!(candidate(vec![9, 9, 9, 9]), true);
}


Prompt:
/// Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
/// Example
/// >>> is_equal_to_sum_even(4)
/// false
/// >>> is_equal_to_sum_even(6)
/// false
/// >>> is_equal_to_sum_even(8)
/// true
fn is_equal_to_sum_even(n: isize) -> bool {

fn main() {
    let candidate = is_equal_to_sum_even;
    assert_eq!(candidate(4), false);
    assert_eq!(candidate(6), false);
    assert_eq!(candidate(8), true);
    assert_eq!(candidate(10), true);
    assert_eq!(candidate(11), false);
    assert_eq!(candidate(12), true);
    assert_eq!(candidate(13), false);
    assert_eq!(candidate(16), true);
}