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:
/// 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:
use std::collections::HashMap;

/// Given a HashMap, return true if all keys are strings in lower
/// case or all keys are strings in upper case, else return false.
/// The function should return false is the given HashMap is empty.
/// Examples:
/// >>> check_dict_case(HashMap::from([(String::from("a"), String::from("apple")), (String::from("b"), String::from("banana"))]))
/// true
/// >>> check_dict_case(HashMap::from([(String::from("a"), String::from("apple")), (String::from("A"), String::from("banana")), (String::from("B"), String::from("banana"))]))
/// false
/// >>> check_dict_case(HashMap::from([(String::from("a"), String::from("apple")), (8, String::from("banana")), (String::from("a"), String::from("apple"))]))
/// false
/// >>> check_dict_case(HashMap::from([(String::from("Name"), String::from("John")), (String::from("Age"), String::from("36")), (String::from("City"), String::from("Houston"))]))
/// false
/// >>> check_dict_case(HashMap::from([(String::from("STATE"), String::from("NC")), (String::from("ZIP"), String::from("12345"))]))
/// true
fn check_dict_case(dict: HashMap<String, String>) -> bool {

}

fn main() {
    let candidate = check_dict_case;
    assert_eq!(candidate(HashMap::from([(String::from("p"), String::from("pineapple")), (String::from("b"), String::from("banana"))])), true);
    assert_eq!(candidate(HashMap::from([(String::from("p"), String::from("pineapple")), (String::from("A"), String::from("banana")), (String::from("B"), String::from("banana"))])), false);
    assert_eq!(candidate(HashMap::from([(String::from("p"), String::from("pineapple")), (String::from("5"), String::from("banana")), (String::from("a"), String::from("apple"))])), false);
    assert_eq!(candidate(HashMap::from([(String::from("Name"), String::from("John")), (String::from("Age"), String::from("36")), (String::from("City"), String::from("Houston"))])), false);
    assert_eq!(candidate(HashMap::from([(String::from("STATE"), String::from("NC")), (String::from("ZIP"), String::from("12345"))])), true);
    assert_eq!(candidate(HashMap::from([(String::from("fruit"), String::from("Orange")), (String::from("taste"), String::from("Sweet"))])), true);
    assert_eq!(candidate(HashMap::from([])), false);
}


Prompt:
/// Given a non-empty vector of integers lst. add the even elements that are at odd indices..
/// Examples:
/// >>> add(vec![4, 2, 6, 7])
/// 2
fn add(lst: Vec<isize>) -> isize {

}

fn main() {
    let candidate = add;
    assert_eq!(candidate(vec![4, 88]), 88);
    assert_eq!(candidate(vec![4, 5, 6, 7, 2, 122]), 122);
    assert_eq!(candidate(vec![4, 0, 6, 7]), 0);
    assert_eq!(candidate(vec![4, 4, 6, 8]), 12);
}


Prompt:
/// Given a string text, replace all spaces in it with underscores,
/// and if a string has more than 2 consecutive spaces,
/// then replace all consecutive spaces with -
/// >>> fix_spaces(String::from(" Example"))
/// String::from("Example")
/// >>> fix_spaces(String::from(" Example 1"))
/// String::from("Example_1")
/// >>> fix_spaces(String::from(" Example 2"))
/// String::from("_Example_2")
/// >>> fix_spaces(String::from(" Example 3"))
/// String::from("_Example-3")
fn fix_spaces(text: String) -> String {

}

fn main() {
    let candidate = fix_spaces;
    assert_eq!(candidate(String::from("Example")), String::from("Example"));
    assert_eq!(candidate(String::from("Mudasir Hanif ")), String::from("Mudasir_Hanif_"));
    assert_eq!(candidate(String::from("Yellow Yellow  Dirty  Fellow")), String::from("Yellow_Yellow__Dirty__Fellow"));
    assert_eq!(candidate(String::from("Exa   mple")), String::from("Exa-mple"));
    assert_eq!(candidate(String::from("   Exa 1 2 2 mple")), String::from("-Exa_1_2_2_mple"));
}


Prompt:
/// The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
/// fibfib(0) == 0
/// fibfib(1) == 0
/// fibfib(2) == 1
/// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
/// Please write a function to efficiently compute the n-th element of the fibfib number sequence.
/// >>> fibfib(1)
/// 0
/// >>> fibfib(5)
/// 4
/// >>> fibfib(8)
/// 24
fn fibfib(n: isize) -> isize {

}

fn main() {
    let candidate = fibfib;
    assert_eq!(candidate(2), 1);
    assert_eq!(candidate(1), 0);
    assert_eq!(candidate(5), 4);
    assert_eq!(candidate(8), 24);
    assert_eq!(candidate(10), 81);
    assert_eq!(candidate(12), 274);
    assert_eq!(candidate(14), 927);
}


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:
/// 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:
/// Input to this function is a string representing musical notes in a special ASCII format.
/// Your task is to parse this string and return vector of integers corresponding to how many beats does each
/// not last.
/// Here is a legend:
/// 'o' - whole note, lasts four beats
/// 'o|' - half note, lasts two beats
/// '.|' - quater note, lasts one beat
/// >>> parse_music(String::from("o o| .| o| o| .| .| .| .| o o"))
/// vec![4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
fn parse_music(music_string: String) -> Vec<isize> {

}

fn main() {
    let candidate = parse_music;
    assert_eq!(candidate(String::from("")), Vec::<isize>::new());
    assert_eq!(candidate(String::from("o o o o")), vec![4, 4, 4, 4]);
    assert_eq!(candidate(String::from(".| .| .| .|")), vec![1, 1, 1, 1]);
    assert_eq!(candidate(String::from("o| o| .| .| o o o o")), vec![2, 2, 1, 1, 4, 4, 4, 4]);
    assert_eq!(candidate(String::from("o| .| o| .| o o| o o|")), vec![2, 1, 2, 1, 4, 2, 4, 2]);
}


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:
/// Return vector of all prefixes from shortest to longest of the input string
/// >>> all_prefixes(String::from("abc"))
/// vec![String::from("a"), String::from("ab"), String::from("abc")]
fn all_prefixes(string: String) -> Vec<String> {

}

fn main() {
    let candidate = all_prefixes;
    assert_eq!(candidate(String::from("")), Vec::<String>::new());
    assert_eq!(candidate(String::from("asdfgh")), vec![String::from("a"), String::from("as"), String::from("asd"), String::from("asdf"), String::from("asdfg"), String::from("asdfgh")]);
    assert_eq!(candidate(String::from("WWW")), vec![String::from("W"), String::from("WW"), String::from("WWW")]);
}


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're a hungry rabbit, and you already have eaten a certain number of carrots,
/// but now you need to eat more carrots to complete the day's meals.
/// you should return a vector of [ total number of eaten carrots after your meals,
/// the number of carrots left after your meals ]
/// if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
/// Example:
/// >>> eat(5, 6, 10)
/// vec![11, 4]
/// >>> eat(4, 8, 9)
/// vec![12, 1]
/// >>> eat(1, 10, 10)
/// vec![11, 0]
/// >>> eat(2, 11, 5)
/// vec![7, 0]
/// Variables:
/// @number : integer
/// the number of carrots that you have eaten.
/// @need : integer
/// the number of carrots that you need to eat.
/// @remaining : integer
/// the number of remaining carrots thet exist in stock
/// Constrain:
/// * 0 <= number <= 1000
/// * 0 <= need <= 1000
/// * 0 <= remaining <= 1000
/// Have fun :)
fn eat(number: isize, need: isize, remaining: isize) -> Vec<isize> {

}

fn main() {
    let candidate = eat;
    assert_eq!(candidate(5, 6, 10), vec![11, 4]);
    assert_eq!(candidate(4, 8, 9), vec![12, 1]);
    assert_eq!(candidate(1, 10, 10), vec![11, 0]);
    assert_eq!(candidate(2, 11, 5), vec![7, 0]);
    assert_eq!(candidate(4, 5, 7), vec![9, 2]);
    assert_eq!(candidate(4, 5, 1), vec![5, 0]);
}


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 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:
/// 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:
/// Given a vector of integers, sort the integers that are between 1 and 9 inclusive,
/// reverse the resulting vector, and then replace each digit by its corresponding name from
/// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
/// For example:
/// >>> by_length(vec![2, 1, 1, 4, 5, 8, 2, 3])
/// vec![String::from("Eight"), String::from("Five"), String::from("Four"), String::from("Three"), String::from("Two"), String::from("Two"), String::from("One"), String::from("One")]
/// If the vector is empty, return an empty vector:
/// >>> by_length(vec![])
/// Vec::<String>::new()
/// If the vector has any strange number ignore it:
/// >>> by_length(vec![1, -1, 55])
/// vec![String::from("One")]
fn by_length(arr: Vec<isize>) -> Vec<String> {

}

fn main() {
    let candidate = by_length;
    assert_eq!(candidate(vec![2, 1, 1, 4, 5, 8, 2, 3]), vec![String::from("Eight"), String::from("Five"), String::from("Four"), String::from("Three"), String::from("Two"), String::from("Two"), String::from("One"), String::from("One")]);
    assert_eq!(candidate(Vec::<isize>::new()), Vec::<String>::new());
    assert_eq!(candidate(vec![1, -1, 55]), vec![String::from("One")]);
    assert_eq!(candidate(vec![1, -1, 3, 2]), vec![String::from("Three"), String::from("Two"), String::from("One")]);
    assert_eq!(candidate(vec![9, 4, 8]), vec![String::from("Nine"), String::from("Eight"), String::from("Four")]);
}


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:
/// Implement a function that takes an non-negative integer and returns a vector of the first n
/// integers that are prime numbers and less than n.
/// for example:
/// >>> count_up_to(5)
/// vec![2, 3]
/// >>> count_up_to(11)
/// vec![2, 3, 5, 7]
/// >>> count_up_to(0)
/// Vec::<isize>::new()
/// >>> count_up_to(20)
/// vec![2, 3, 5, 7, 11, 13, 17, 19]
/// >>> count_up_to(1)
/// Vec::<isize>::new()
/// >>> count_up_to(18)
/// vec![2, 3, 5, 7, 11, 13, 17]
fn count_up_to(n: isize) -> Vec<isize> {


Prompt:
/// Return sorted unique elements in a vector
/// >>> unique(vec![5, 3, 5, 2, 3, 3, 9, 0, 123])
/// vec![0, 2, 3, 5, 9, 123]
fn unique(l: Vec<isize>) -> Vec<isize> {


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


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:
/// Given a vector of numbers, return whether or not they are sorted
/// in ascending order. If vector has more than 1 duplicate of the same
/// number, return false. Assume no negative numbers and only integers.
/// Examples
/// >>> is_sorted(vec![5])
/// true
/// >>> is_sorted(vec![1, 2, 3, 4, 5])
/// true
/// >>> is_sorted(vec![1, 3, 2, 4, 5])
/// false
/// >>> is_sorted(vec![1, 2, 3, 4, 5, 6])
/// true
/// >>> is_sorted(vec![1, 2, 3, 4, 5, 6, 7])
/// true
/// >>> is_sorted(vec![1, 3, 2, 4, 5, 6, 7])
/// false
/// >>> is_sorted(vec![1, 2, 2, 3, 3, 4])
/// true
/// >>> is_sorted(vec![1, 2, 2, 2, 3, 4])
/// false
fn is_sorted(lst: Vec<isize>) -> bool {

}

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


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:
/// 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:
/// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
/// >>> fizz_buzz(50)
/// 0
/// >>> fizz_buzz(78)
/// 2
/// >>> fizz_buzz(79)
/// 3
fn fizz_buzz(n: isize) -> isize {

}

fn main() {
    let candidate = fizz_buzz;
    assert_eq!(candidate(50), 0);
    assert_eq!(candidate(78), 2);
    assert_eq!(candidate(79), 3);
    assert_eq!(candidate(100), 3);
    assert_eq!(candidate(200), 6);
    assert_eq!(candidate(4000), 192);
    assert_eq!(candidate(10000), 639);
    assert_eq!(candidate(100000), 8026);
}


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:
/// Given a positive integer N, return the total sum of its digits in binary.
/// Example
/// >>> solve(1000)
/// String::from("1")
/// >>> solve(150)
/// String::from("110")
/// >>> solve(147)
/// String::from("1100")
/// Variables:
/// @N integer
/// Constraints: 0 ≤ N ≤ 10000.
/// Output:
/// a string of binary number
fn solve(N: isize) -> String {

}

fn main() {
    let candidate = solve;
    assert_eq!(candidate(1000), String::from("1"));
    assert_eq!(candidate(150), String::from("110"));
    assert_eq!(candidate(147), String::from("1100"));
    assert_eq!(candidate(333), String::from("1001"));
    assert_eq!(candidate(963), String::from("10010"));
}


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 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:
/// 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:
/// 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:
/// Given a vector of non-negative integers, return a cors of the given vector after sorting,
/// you will sort the given vector in ascending order if the sum( first index value, last index value) is odd,
/// or sort it in descending order if the sum( first index value, last index value) is even.
/// Note:
/// * don't change the given vector.
/// Examples:
/// >>> sort_array(vec![])
/// Vec::<isize>::new()
/// >>> sort_array(vec![5])
/// vec![5]
/// >>> sort_array(vec![2, 4, 3, 0, 1, 5])
/// vec![0, 1, 2, 3, 4, 5]
/// >>> sort_array(vec![2, 4, 3, 0, 1, 5, 6])
/// vec![6, 5, 4, 3, 2, 1, 0]
fn sort_array(array: Vec<isize>) -> Vec<isize> {


Prompt:
/// Implement the function f that takes n as a parameter,
/// and returns a vector of size n, such that the value of the element at index i is the factorial of i if i is even
/// or the sum of numbers from 1 to i otherwise.
/// i starts from 1.
/// the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
/// Example:
/// >>> f(5)
/// vec![1, 2, 6, 24, 15]
fn f(n: isize) -> Vec<isize> {

}

fn main() {
    let candidate = f;
    assert_eq!(candidate(5), vec![1, 2, 6, 24, 15]);
    assert_eq!(candidate(7), vec![1, 2, 6, 24, 15, 720, 28]);
    assert_eq!(candidate(1), vec![1]);
    assert_eq!(candidate(3), vec![1, 2, 6]);
}


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:
/// 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:
/// 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:
/// 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:
/// Given the lengths of the three sides of a triangle. Return the area of
/// the triangle rounded to 2 decimal points if the three sides form a valid triangle.
/// Otherwise return -1
/// Three sides make a valid triangle when the sum of any two sides is greater
/// than the third side.
/// Example:
/// >>> triangle_area(3, 4, 5)
/// 6.0
/// >>> triangle_area(1, 2, 10)
/// -1.0
fn triangle_area(a: isize, b: isize, c: isize) -> f64 {

}

fn main() {
    let candidate = triangle_area;
    assert_eq!(candidate(3, 4, 5), 6.0);
    assert_eq!(candidate(1, 2, 10), -1.0);
    assert_eq!(candidate(4, 8, 5), 8.18);
    assert_eq!(candidate(2, 2, 2), 1.73);
    assert_eq!(candidate(1, 2, 3), -1.0);
    assert_eq!(candidate(10, 5, 7), 16.25);
    assert_eq!(candidate(2, 6, 3), -1.0);
    assert_eq!(candidate(1, 1, 1), 0.43);
    assert_eq!(candidate(2, 2, 10), -1.0);
}


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 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:
/// 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:
/// 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:
/// 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:
/// 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:
/// 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:
/// 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:
/// 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:
/// 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:
/// Find the shortest palindrome that begins with a supplied string.
/// Algorithm idea is simple:
/// - Find the longest postfix of supplied string that is a palindrome.
/// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
/// >>> make_palindrome(String::from(""))
/// String::from("")
/// >>> make_palindrome(String::from("cat"))
/// String::from("catac")
/// >>> make_palindrome(String::from("cata"))
/// String::from("catac")
fn make_palindrome(string: String) -> String {

}

fn main() {
    let candidate = make_palindrome;
    assert_eq!(candidate(String::from("")), String::from(""));
    assert_eq!(candidate(String::from("x")), String::from("x"));
    assert_eq!(candidate(String::from("xyz")), String::from("xyzyx"));
    assert_eq!(candidate(String::from("xyx")), String::from("xyx"));
    assert_eq!(candidate(String::from("jerry")), String::from("jerryrrej"));
}


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:
/// 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:
/// 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:
/// 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 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:
/// Given a string s and a natural number n, you have been tasked to implement
/// a function that returns a vector of all words from string s that contain exactly
/// n consonants, in order these words appear in the string s.
/// If the string s is empty then the function should return an empty vector.
/// Note: you may assume the input string contains only letters and spaces.
/// Examples:
/// >>> select_words(String::from("Mary had a little lamb"), 4)
/// vec![String::from("little")]
/// >>> select_words(String::from("Mary had a little lamb"), 3)
/// vec![String::from("Mary"), String::from("lamb")]
/// >>> select_words(String::from("simple white space"), 2)
/// Vec::<String>::new()
/// >>> select_words(String::from("Hello world"), 4)
/// vec![String::from("world")]
/// >>> select_words(String::from("Uncle sam"), 3)
/// vec![String::from("Uncle")]
fn select_words(s: String, n: isize) -> Vec<String> {

}

fn main() {
    let candidate = select_words;
    assert_eq!(candidate(String::from("Mary had a little lamb"), 4), vec![String::from("little")]);
    assert_eq!(candidate(String::from("Mary had a little lamb"), 3), vec![String::from("Mary"), String::from("lamb")]);
    assert_eq!(candidate(String::from("simple white space"), 2), Vec::<String>::new());
    assert_eq!(candidate(String::from("Hello world"), 4), vec![String::from("world")]);
    assert_eq!(candidate(String::from("Uncle sam"), 3), vec![String::from("Uncle")]);
    assert_eq!(candidate(String::from(""), 4), Vec::<String>::new());
    assert_eq!(candidate(String::from("a b c d e f"), 1), vec![String::from("b"), String::from("c"), String::from("d"), String::from("f")]);
}


Prompt:
/// Write a function that returns true if the object q will fly, and false otherwise.
/// The object q will fly if it's balanced (it is a palindromic vector) and the sum of its elements is less than or equal the maximum possible weight w.
/// Example:
/// >>> will_it_fly(vec![1, 2], 5)
/// false
/// # 1+2 is less than the maximum possible weight, but it's unbalanced.
/// >>> will_it_fly(vec![3, 2, 3], 1)
/// false
/// # it's balanced, but 3+2+3 is more than the maximum possible weight.
/// >>> will_it_fly(vec![3, 2, 3], 9)
/// true
/// # 3+2+3 is less than the maximum possible weight, and it's balanced.
/// >>> will_it_fly(vec![3], 5)
/// true
/// # 3 is less than the maximum possible weight, and it's balanced.
fn will_it_fly(q: Vec<isize>, w: isize) -> bool {

}

fn main() {
    let candidate = will_it_fly;
    assert_eq!(candidate(vec![3, 2, 3], 9), true);
    assert_eq!(candidate(vec![1, 2], 5), false);
    assert_eq!(candidate(vec![3], 5), true);
    assert_eq!(candidate(vec![3, 2, 3], 1), false);
    assert_eq!(candidate(vec![1, 2, 3], 6), false);
    assert_eq!(candidate(vec![5], 5), true);
}


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:
/// 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:
/// 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:
/// 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:
/// 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:
/// Given a positive floating point number, it can be decomposed into
/// and integer part (largest integer smaller than given number) and decimals
/// (leftover part always smaller than 1).
/// Return the decimal part of the number.
/// >>> truncate_number(3.5)
/// 0.5
fn truncate_number(number: f64) -> f64 {

}

fn main() {
    let candidate = truncate_number;
    assert_eq!(candidate(3.5), 0.5);
    assert_eq!(candidate(1.25), 0.25);
    assert_eq!(candidate(123.0), 0.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:
/// 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:
/// Return 2^n modulo p (be aware of numerics).
/// >>> modp(3, 5)
/// 3
/// >>> modp(1101, 101)
/// 2
/// >>> modp(0, 101)
/// 1
/// >>> modp(3, 11)
/// 8
/// >>> modp(100, 101)
/// 1
fn modp(n: isize, p: isize) -> isize {

}

fn main() {
    let candidate = modp;
    assert_eq!(candidate(3, 5), 3);
    assert_eq!(candidate(1101, 101), 2);
    assert_eq!(candidate(0, 101), 1);
    assert_eq!(candidate(3, 11), 8);
    assert_eq!(candidate(100, 101), 1);
    assert_eq!(candidate(30, 5), 4);
    assert_eq!(candidate(31, 5), 3);
}


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:
/// You are given a string s.
/// Your task is to check if the string is haprs or not.
/// A string is haprs if its length is at least 3 and every 3 consecutive letters are distinct
/// For example:
/// >>> is_happy(String::from("a"))
/// false
/// >>> is_happy(String::from("aa"))
/// false
/// >>> is_happy(String::from("abcd"))
/// true
/// >>> is_happy(String::from("aabb"))
/// false
/// >>> is_happy(String::from("adb"))
/// true
/// >>> is_happy(String::from("xyy"))
/// false
fn is_happy(s: String) -> bool {

}

fn main() {
    let candidate = is_happy;
    assert_eq!(candidate(String::from("a")), false);
    assert_eq!(candidate(String::from("aa")), false);
    assert_eq!(candidate(String::from("abcd")), true);
    assert_eq!(candidate(String::from("aabb")), false);
    assert_eq!(candidate(String::from("adb")), true);
    assert_eq!(candidate(String::from("xyy")), false);
    assert_eq!(candidate(String::from("iopaxpoi")), true);
    assert_eq!(candidate(String::from("iopaxioi")), false);
}


Prompt:
/// Return the largest prime factor of n. Assume n > 1 and is not a prime.
/// >>> largest_prime_factor(13195)
/// 29
/// >>> largest_prime_factor(2048)
/// 2
fn largest_prime_factor(n: isize) -> isize {

}

fn main() {
    let candidate = largest_prime_factor;
    assert_eq!(candidate(15), 5);
    assert_eq!(candidate(27), 3);
    assert_eq!(candidate(63), 7);
    assert_eq!(candidate(330), 11);
    assert_eq!(candidate(13195), 29);
}


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:
/// 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 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:
/// "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:
/// 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:
/// 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:
/// 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:
/// 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:
/// Given a vector arr of integers, find the minimum number of elements that
/// need to be changed to make the vector palindromic. A palindromic vector is a vector that
/// is read the same backwards and forwards. In one change, you can change one element to any other element.
/// For example:
/// >>> smallest_change(vec![1, 2, 3, 5, 4, 7, 9, 6])
/// 4
/// >>> smallest_change(vec![1, 2, 3, 4, 3, 2, 2])
/// 1
/// >>> smallest_change(vec![1, 2, 3, 2, 1])
/// 0
fn smallest_change(arr: Vec<isize>) -> isize {

}

fn main() {
    let candidate = smallest_change;
    assert_eq!(candidate(vec![1, 2, 3, 5, 4, 7, 9, 6]), 4);
    assert_eq!(candidate(vec![1, 2, 3, 4, 3, 2, 2]), 1);
    assert_eq!(candidate(vec![1, 4, 2]), 1);
    assert_eq!(candidate(vec![1, 4, 4, 2]), 1);
    assert_eq!(candidate(vec![1, 2, 3, 2, 1]), 0);
    assert_eq!(candidate(vec![3, 1, 1, 3]), 0);
    assert_eq!(candidate(vec![1]), 0);
    assert_eq!(candidate(vec![0, 1]), 1);
}


Prompt:
/// You are given a vector of numbers.
/// You need to return the sum of squared numbers in the given vector,
/// round each element in the vector to the upper int(Ceiling) first.
/// Examples:
/// >>> lst(vec![1.0, 2.0, 3.0])
/// 14
/// >>> lst(vec![1.0, 4.0, 9.0])
/// 98
/// >>> lst(vec![1.0, 3.0, 5.0, 7.0])
/// 84
/// >>> lst(vec![1.4, 4.2, 0.0])
/// 29
/// >>> lst(vec![-2.4, 1.0, 1.0])
/// 6
fn sum_squares(lst: Vec<f64>) -> isize {


Prompt:
/// Create a function which takes a string representing a file's name, and returns
/// 'Yes' if the the file's name is valid, and returns 'No' otherwise.
/// A file's name is considered to be valid if and only if all the following conditions
/// are met:
/// - There should not be more than three digits ('0'-'9') in the file's name.
/// - The file's name contains exactly one dot '.'
/// - The substring before the dot should not be empty, and it starts with a letter from
/// the latin alphapet ('a'-'z' and 'A'-'Z').
/// - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
/// Examples:
/// >>> file_name_check(String::from("example.txt"))
/// String::from("Yes")
/// >>> file_name_check(String::from("1example.dll"))
/// String::from("No")
fn file_name_check(file_name: String) -> String {

}

fn main() {
    let candidate = file_name_check;
    assert_eq!(candidate(String::from("example.txt")), String::from("Yes"));
    assert_eq!(candidate(String::from("1example.dll")), String::from("No"));
    assert_eq!(candidate(String::from("s1sdf3.asd")), String::from("No"));
    assert_eq!(candidate(String::from("K.dll")), String::from("Yes"));
    assert_eq!(candidate(String::from("MY16FILE3.exe")), String::from("Yes"));
    assert_eq!(candidate(String::from("His12FILE94.exe")), String::from("No"));
    assert_eq!(candidate(String::from("_Y.txt")), String::from("No"));
    assert_eq!(candidate(String::from("?aREYA.exe")), String::from("No"));
    assert_eq!(candidate(String::from("/this_is_valid.dll")), String::from("No"));
    assert_eq!(candidate(String::from("this_is_valid.wow")), String::from("No"));
    assert_eq!(candidate(String::from("this_is_valid.txt")), String::from("Yes"));
    assert_eq!(candidate(String::from("this_is_valid.txtexe")), String::from("No"));
    assert_eq!(candidate(String::from("#this2_i4s_5valid.ten")), String::from("No"));
    assert_eq!(candidate(String::from("@this1_is6_valid.exe")), String::from("No"));
    assert_eq!(candidate(String::from("this_is_12valid.6exe4.txt")), String::from("No"));
    assert_eq!(candidate(String::from("all.exe.txt")), String::from("No"));
    assert_eq!(candidate(String::from("I563_No.exe")), String::from("Yes"));
    assert_eq!(candidate(String::from("Is3youfault.txt")), String::from("Yes"));
    assert_eq!(candidate(String::from("no_one#knows.dll")), String::from("Yes"));
    assert_eq!(candidate(String::from("1I563_Yes3.exe")), String::from("No"));
    assert_eq!(candidate(String::from("I563_Yes3.txtt")), String::from("No"));
    assert_eq!(candidate(String::from("final..txt")), String::from("No"));
    assert_eq!(candidate(String::from("final132")), String::from("No"));
    assert_eq!(candidate(String::from("_f4indsartal132.")), String::from("No"));
    assert_eq!(candidate(String::from(".txt")), String::from("No"));
    assert_eq!(candidate(String::from("s.")), String::from("No"));
}


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

}

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


Prompt:
/// You are given two intervals,
/// where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
/// The given intervals are closed which means that the interval (start, end)
/// includes both start and end.
/// For each given interval, it is assumed that its start is less or equal its end.
/// Your task is to determine whether the length of intersection of these two
/// intervals is a prime number.
/// Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
/// which its length is 1, which not a prime number.
/// If the length of the intersection is a prime number, return "YES",
/// otherwise, return "NO".
/// If the two intervals don't intersect, return "NO".
/// [input/output] samples:
/// >>> intersection((1, 2), (2, 3))
/// String::from("NO")
/// >>> intersection((-1, 1), (0, 4))
/// String::from("NO")
/// >>> intersection((-3, -1), (-5, 5))
/// String::from("YES")
fn intersection(interval1: (isize, isize), interval2: (isize, isize)) -> String {

}

fn main() {
    let candidate = intersection;
    assert_eq!(candidate((1, 2), (2, 3)), String::from("NO"));
    assert_eq!(candidate((-1, 1), (0, 4)), String::from("NO"));
    assert_eq!(candidate((-3, -1), (-5, 5)), String::from("YES"));
    assert_eq!(candidate((-2, 2), (-4, 0)), String::from("YES"));
    assert_eq!(candidate((-11, 2), (-1, -1)), String::from("NO"));
    assert_eq!(candidate((1, 2), (3, 5)), String::from("NO"));
    assert_eq!(candidate((1, 2), (1, 2)), String::from("NO"));
    assert_eq!(candidate((-2, -2), (-3, -2)), String::from("NO"));
}


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:
/// 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 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 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:
/// You have to write a function which validates a given date string and
/// returns true if the date is valid otherwise false.
/// The date is valid if all of the following rules are satisfied:
/// 1. The date string is not empty.
/// 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.
/// 3. The months should not be less than 1 or higher than 12.
/// 4. The date should be in the format: mm-dd-yyyy
/// >>> valid_date(String::from("03-11-2000"))
/// true
/// >>> valid_date(String::from("15-01-2012"))
/// false
/// >>> valid_date(String::from("04-0-2040"))
/// false
/// >>> valid_date(String::from("06-04-2020"))
/// true
/// >>> valid_date(String::from("06/04/2020"))
/// false
fn valid_date(date: String) -> bool {

}

fn main() {
    let candidate = valid_date;
    assert_eq!(candidate(String::from("03-11-2000")), true);
    assert_eq!(candidate(String::from("15-01-2012")), false);
    assert_eq!(candidate(String::from("04-0-2040")), false);
    assert_eq!(candidate(String::from("06-04-2020")), true);
    assert_eq!(candidate(String::from("01-01-2007")), true);
    assert_eq!(candidate(String::from("03-32-2011")), false);
    assert_eq!(candidate(String::from("")), false);
    assert_eq!(candidate(String::from("04-31-3000")), false);
    assert_eq!(candidate(String::from("06-06-2005")), true);
    assert_eq!(candidate(String::from("21-31-2000")), false);
    assert_eq!(candidate(String::from("04-12-2003")), true);
    assert_eq!(candidate(String::from("04122003")), false);
    assert_eq!(candidate(String::from("20030412")), false);
    assert_eq!(candidate(String::from("2003-04")), false);
    assert_eq!(candidate(String::from("2003-04-12")), false);
    assert_eq!(candidate(String::from("04-2003")), false);
}


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

}

fn main() {
    let candidate = anti_shuffle;
    assert_eq!(candidate(String::from("Hi")), String::from("Hi"));
    assert_eq!(candidate(String::from("hello")), String::from("ehllo"));
    assert_eq!(candidate(String::from("number")), String::from("bemnru"));
    assert_eq!(candidate(String::from("abcd")), String::from("abcd"));
    assert_eq!(candidate(String::from("Hello World!!!")), String::from("Hello !!!Wdlor"));
    assert_eq!(candidate(String::from("")), String::from(""));
    assert_eq!(candidate(String::from("Hi. My name is Mister Robot. How are you?")), String::from(".Hi My aemn is Meirst .Rboot How aer ?ouy"));
}


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


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