Prompt:
//Return length of given string
// >>> strlen("")
// 0
// >>> strlen("abc")
// 3
function strlen(string){

const assert = require('node:assert');

function test() {
  let candidate = strlen;
  assert.deepEqual(candidate(""),0);
  assert.deepEqual(candidate("x"),1);
  assert.deepEqual(candidate("asdasnakj"),9);
}

test();


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("hi")
// "lm"
// >>> encrypt("asdfghjkl")
// "ewhjklnop"
// >>> encrypt("gf")
// "kj"
// >>> encrypt("et")
// "ix"
function encrypt(s){

const assert = require('node:assert');

function test() {
  let candidate = encrypt;
  assert.deepEqual(candidate("hi"),"lm");
  assert.deepEqual(candidate("asdfghjkl"),"ewhjklnop");
  assert.deepEqual(candidate("gf"),"kj");
  assert.deepEqual(candidate("et"),"ix");
  assert.deepEqual(candidate("faewfawefaewg"),"jeiajeaijeiak");
  assert.deepEqual(candidate("hellomyfriend"),"lippsqcjvmirh");
  assert.deepEqual(candidate("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh"),"hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl");
  assert.deepEqual(candidate("a"),"e");
}

test();


Prompt:
//Given an object, 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 object is empty.
// Examples:
// >>> check_dict_case({"a": "apple", "b": "banana"})
// true
// >>> check_dict_case({"a": "apple", "A": "banana", "B": "banana"})
// false
// >>> check_dict_case({"a": "apple", 8: "banana", "a": "apple"})
// false
// >>> check_dict_case({"Name": "John", "Age": "36", "City": "Houston"})
// false
// >>> check_dict_case({"STATE": "NC", "ZIP": "12345"})
// true
function check_dict_case(dict){

const assert = require('node:assert');

function test() {
  let candidate = check_dict_case;
  assert.deepEqual(candidate({"p": "pineapple", "b": "banana"}),true);
  assert.deepEqual(candidate({"p": "pineapple", "A": "banana", "B": "banana"}),false);
  assert.deepEqual(candidate({"p": "pineapple", "5": "banana", "a": "apple"}),false);
  assert.deepEqual(candidate({"Name": "John", "Age": "36", "City": "Houston"}),false);
  assert.deepEqual(candidate({"STATE": "NC", "ZIP": "12345"}),true);
  assert.deepEqual(candidate({"fruit": "Orange", "taste": "Sweet"}),true);
  assert.deepEqual(candidate({}),false);
}

test();


Prompt:
//Given a non-empty array of integers lst. add the even elements that are at odd indices..
// Examples:
// >>> add([4, 2, 6, 7])
// 2
function add(lst){

const assert = require('node:assert');

function test() {
  let candidate = add;
  assert.deepEqual(candidate([4, 88]),88);
  assert.deepEqual(candidate([4, 5, 6, 7, 2, 122]),122);
  assert.deepEqual(candidate([4, 0, 6, 7]),0);
  assert.deepEqual(candidate([4, 4, 6, 8]),12);
}

test();


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(" Example")
// "Example"
// >>> fix_spaces(" Example 1")
// "Example_1"
// >>> fix_spaces(" Example 2")
// "_Example_2"
// >>> fix_spaces(" Example 3")
// "_Example-3"
function fix_spaces(text){

const assert = require('node:assert');

function test() {
  let candidate = fix_spaces;
  assert.deepEqual(candidate("Example"),"Example");
  assert.deepEqual(candidate("Mudasir Hanif "),"Mudasir_Hanif_");
  assert.deepEqual(candidate("Yellow Yellow  Dirty  Fellow"),"Yellow_Yellow__Dirty__Fellow");
  assert.deepEqual(candidate("Exa   mple"),"Exa-mple");
  assert.deepEqual(candidate("   Exa 1 2 2 mple"),"-Exa_1_2_2_mple");
}

test();


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
function fibfib(n){

const assert = require('node:assert');

function test() {
  let candidate = fibfib;
  assert.deepEqual(candidate(2),1);
  assert.deepEqual(candidate(1),0);
  assert.deepEqual(candidate(5),4);
  assert.deepEqual(candidate(8),24);
  assert.deepEqual(candidate(10),81);
  assert.deepEqual(candidate(12),274);
  assert.deepEqual(candidate(14),927);
}

test();


Prompt:
//Given an array of numbers, return the sum of squares of the numbers
// in the array that are odd. Ignore numbers that are negative or not integers.
// >>> double_the_difference([1, 3, 2, 0])
// 10
// >>> double_the_difference([-1, -2, 0])
// 0
// >>> double_the_difference([9, -2])
// 81
// >>> double_the_difference([0])
// 0
// If the input array is empty, return 0.
function double_the_difference(lst){

const assert = require('node:assert');

function test() {
  let candidate = double_the_difference;
  assert.deepEqual(candidate([]),0);
  assert.deepEqual(candidate([5.0, 4.0]),25);
  assert.deepEqual(candidate([0.1, 0.2, 0.3]),0);
  assert.deepEqual(candidate([-10.0, -20.0, -30.0]),0);
  assert.deepEqual(candidate([-1.0, -2.0, 8.0]),0);
  assert.deepEqual(candidate([0.2, 3.0, 5.0]),34);
  assert.deepEqual(candidate([-9.0, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0]),165);
}

test();


Prompt:
//Filter given array of any jsthon values only for integers
// >>> filter_integers(["a", 3.14, 5])
// [5]
// >>> filter_integers([1, 2, 3, "abc", {}, []])
// [1, 2, 3]
function filter_integers(values){

const assert = require('node:assert');

function test() {
  let candidate = filter_integers;
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([4, {}, [], 23.2, 9, "adasd"]),[4, 9]);
  assert.deepEqual(candidate([3, "c", 3, 3, "a", "b"]),[3, 3, 3]);
}

test();


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.
function car_race_collision(n){

const assert = require('node:assert');

function test() {
  let candidate = car_race_collision;
  assert.deepEqual(candidate(2),4);
  assert.deepEqual(candidate(3),9);
  assert.deepEqual(candidate(4),16);
  assert.deepEqual(candidate(8),64);
  assert.deepEqual(candidate(10),100);
}

test();


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 array 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("o o| .| o| o| .| .| .| .| o o")
// [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
function parse_music(music_string){

const assert = require('node:assert');

function test() {
  let candidate = parse_music;
  assert.deepEqual(candidate(""),[]);
  assert.deepEqual(candidate("o o o o"),[4, 4, 4, 4]);
  assert.deepEqual(candidate(".| .| .| .|"),[1, 1, 1, 1]);
  assert.deepEqual(candidate("o| o| .| .| o o o o"),[2, 2, 1, 1, 4, 4, 4, 4]);
  assert.deepEqual(candidate("o| .| o| .| o o| o o|"),[2, 1, 2, 1, 4, 2, 4, 2]);
}

test();


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)
// "db1111db"
// >>> decimal_to_binary(32)
// "db100000db"
function decimal_to_binary(decimal){

const assert = require('node:assert');

function test() {
  let candidate = decimal_to_binary;
  assert.deepEqual(candidate(0),"db0db");
  assert.deepEqual(candidate(32),"db100000db");
  assert.deepEqual(candidate(103),"db1100111db");
  assert.deepEqual(candidate(15),"db1111db");
}

test();


Prompt:
//Return array of all prefixes from shortest to longest of the input string
// >>> all_prefixes("abc")
// ["a", "ab", "abc"]
function all_prefixes(string){

const assert = require('node:assert');

function test() {
  let candidate = all_prefixes;
  assert.deepEqual(candidate(""),[]);
  assert.deepEqual(candidate("asdfgh"),["a", "as", "asd", "asdf", "asdfg", "asdfgh"]);
  assert.deepEqual(candidate("WWW"),["W", "WW", "WWW"]);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = add;
  assert.deepEqual(candidate(0, 1),1);
  assert.deepEqual(candidate(1, 0),1);
  assert.deepEqual(candidate(2, 3),5);
  assert.deepEqual(candidate(5, 7),12);
  assert.deepEqual(candidate(7, 5),12);
}

test();


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 an array 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)
// [11, 4]
// >>> eat(4, 8, 9)
// [12, 1]
// >>> eat(1, 10, 10)
// [11, 0]
// >>> eat(2, 11, 5)
// [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 :)
function eat(number, need, remaining){

const assert = require('node:assert');

function test() {
  let candidate = eat;
  assert.deepEqual(candidate(5, 6, 10),[11, 4]);
  assert.deepEqual(candidate(4, 8, 9),[12, 1]);
  assert.deepEqual(candidate(1, 10, 10),[11, 0]);
  assert.deepEqual(candidate(2, 11, 5),[7, 0]);
  assert.deepEqual(candidate(4, 5, 7),[9, 2]);
  assert.deepEqual(candidate(4, 5, 1),[5, 0]);
}

test();


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([[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], 1)
// 6
// Example 2:
// >>> max_fill([[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], 2)
// 5
// Example 3:
// >>> max_fill([[0, 0, 0], [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
function max_fill(grid, capacity){


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

const assert = require('node:assert');

function test() {
  let candidate = do_algebra;
  assert.deepEqual(candidate(["**", "*", "+"], [2, 3, 4, 5]),37);
  assert.deepEqual(candidate(["+", "*", "-"], [2, 3, 4, 5]),9);
  assert.deepEqual(candidate(["//", "*"], [7, 3, 4]),8);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = flip_case;
  assert.deepEqual(candidate(""),"");
  assert.deepEqual(candidate("Hello!"),"hELLO!");
  assert.deepEqual(candidate("These violent delights have violent ends"),"tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS");
}

test();


Prompt:
//Given an array of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting array, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// >>> by_length([2, 1, 1, 4, 5, 8, 2, 3])
// ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
// If the array is empty, return an empty array:
// >>> by_length([])
// []
// If the array has any strange number ignore it:
// >>> by_length([1, -1, 55])
// ["One"]
function by_length(arr){

const assert = require('node:assert');

function test() {
  let candidate = by_length;
  assert.deepEqual(candidate([2, 1, 1, 4, 5, 8, 2, 3]),["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]);
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([1, -1, 55]),["One"]);
  assert.deepEqual(candidate([1, -1, 3, 2]),["Three", "Two", "One"]);
  assert.deepEqual(candidate([9, 4, 8]),["Nine", "Eight", "Four"]);
}

test();


Prompt:
//Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed 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)
// [2, 2, 2]
// >>> factorize(25)
// [5, 5]
// >>> factorize(70)
// [2, 5, 7]
function factorize(n){

const assert = require('node:assert');

function test() {
  let candidate = factorize;
  assert.deepEqual(candidate(2),[2]);
  assert.deepEqual(candidate(4),[2, 2]);
  assert.deepEqual(candidate(8),[2, 2, 2]);
  assert.deepEqual(candidate(57),[3, 19]);
  assert.deepEqual(candidate(3249),[3, 3, 19, 19]);
  assert.deepEqual(candidate(185193),[3, 3, 3, 19, 19, 19]);
  assert.deepEqual(candidate(20577),[3, 19, 19, 19]);
  assert.deepEqual(candidate(18),[2, 3, 3]);
}

test();


Prompt:
//Implement a function that takes an non-negative integer and returns an array of the first n
// integers that are prime numbers and less than n.
// for example:
// >>> count_up_to(5)
// [2, 3]
// >>> count_up_to(11)
// [2, 3, 5, 7]
// >>> count_up_to(0)
// []
// >>> count_up_to(20)
// [2, 3, 5, 7, 11, 13, 17, 19]
// >>> count_up_to(1)
// []
// >>> count_up_to(18)
// [2, 3, 5, 7, 11, 13, 17]
function count_up_to(n){

const assert = require('node:assert');

function test() {
  let candidate = count_up_to;
  assert.deepEqual(candidate(5),[2, 3]);
  assert.deepEqual(candidate(6),[2, 3, 5]);
  assert.deepEqual(candidate(7),[2, 3, 5]);
  assert.deepEqual(candidate(10),[2, 3, 5, 7]);
  assert.deepEqual(candidate(0),[]);
  assert.deepEqual(candidate(22),[2, 3, 5, 7, 11, 13, 17, 19]);
  assert.deepEqual(candidate(1),[]);
  assert.deepEqual(candidate(18),[2, 3, 5, 7, 11, 13, 17]);
  assert.deepEqual(candidate(47),[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]);
  assert.deepEqual(candidate(101),[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]);
}

test();


Prompt:
//Return sorted unique elements in an array
// >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [0, 2, 3, 5, 9, 123]
function unique(l){

const assert = require('node:assert');

function test() {
  let candidate = unique;
  assert.deepEqual(candidate([5, 3, 5, 2, 3, 3, 9, 0, 123]),[0, 2, 3, 5, 9, 123]);
}

test();


Prompt:
//Write a function that accepts two arrays of strings and returns the array that has
// total number of chars in the all strings of the array less than the other array.
// if the two arrays have the same number of chars, return the first array.
// Examples
// >>> total_match([], [])
// []
// >>> total_match(["hi", "admin"], ["hI", "Hi"])
// ["hI", "Hi"]
// >>> total_match(["hi", "admin"], ["hi", "hi", "admin", "project"])
// ["hi", "admin"]
// >>> total_match(["hi", "admin"], ["hI", "hi", "hi"])
// ["hI", "hi", "hi"]
// >>> total_match(["4"], ["1", "2", "3", "4", "5"])
// ["4"]
function total_match(lst1, lst2){

const assert = require('node:assert');

function test() {
  let candidate = total_match;
  assert.deepEqual(candidate([], []),[]);
  assert.deepEqual(candidate(["hi", "admin"], ["hi", "hi"]),["hi", "hi"]);
  assert.deepEqual(candidate(["hi", "admin"], ["hi", "hi", "admin", "project"]),["hi", "admin"]);
  assert.deepEqual(candidate(["4"], ["1", "2", "3", "4", "5"]),["4"]);
  assert.deepEqual(candidate(["hi", "admin"], ["hI", "Hi"]),["hI", "Hi"]);
  assert.deepEqual(candidate(["hi", "admin"], ["hI", "hi", "hi"]),["hI", "hi", "hi"]);
  assert.deepEqual(candidate(["hi", "admin"], ["hI", "hi", "hii"]),["hi", "admin"]);
  assert.deepEqual(candidate([], ["this"]),[]);
  assert.deepEqual(candidate(["this"], []),[]);
}

test();


Prompt:
//Return maximum element in the array.
// >>> max_element([1, 2, 3])
// 3
// >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
// 123
function max_element(l){

const assert = require('node:assert');

function test() {
  let candidate = max_element;
  assert.deepEqual(candidate([1, 2, 3]),3);
  assert.deepEqual(candidate([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]),124);
}

test();


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("[[]]")
// true
// >>> is_nested("[]]]]]]][[[[[]")
// false
// >>> is_nested("[][]")
// false
// >>> is_nested("[]")
// false
// >>> is_nested("[[][]]")
// true
// >>> is_nested("[[]][[")
// true
function is_nested(string){

const assert = require('node:assert');

function test() {
  let candidate = is_nested;
  assert.deepEqual(candidate("[[]]"),true);
  assert.deepEqual(candidate("[]]]]]]][[[[[]"),false);
  assert.deepEqual(candidate("[][]"),false);
  assert.deepEqual(candidate("[]"),false);
  assert.deepEqual(candidate("[[[[]]]]"),true);
  assert.deepEqual(candidate("[]]]]]]]]]]"),false);
  assert.deepEqual(candidate("[][][[]]"),true);
  assert.deepEqual(candidate("[[]"),false);
  assert.deepEqual(candidate("[]]"),false);
  assert.deepEqual(candidate("[[]][["),true);
  assert.deepEqual(candidate("[[][]]"),true);
  assert.deepEqual(candidate(""),false);
  assert.deepEqual(candidate("[[[[[[[["),false);
  assert.deepEqual(candidate("]]]]]]]]"),false);
}

test();


Prompt:
//You are given two positive integers n and m, and your task is to compute the
// average of the integers from n through m (including n and m).
// Round the answer to the nearest integer and convert that to binary.
// If n is greater than m, return -1.
// Example:
// >>> rounded_avg(1, 5)
// "0b11"
// >>> rounded_avg(7, 5)
// -1
// >>> rounded_avg(10, 20)
// "0b1111"
// >>> rounded_avg(20, 33)
// "0b11010"
function rounded_avg(n, m){

const assert = require('node:assert');

function test() {
  let candidate = rounded_avg;
  assert.deepEqual(candidate(1, 5),"0b11");
  assert.deepEqual(candidate(7, 13),"0b1010");
  assert.deepEqual(candidate(964, 977),"0b1111001010");
  assert.deepEqual(candidate(996, 997),"0b1111100100");
  assert.deepEqual(candidate(560, 851),"0b1011000010");
  assert.deepEqual(candidate(185, 546),"0b101101110");
  assert.deepEqual(candidate(362, 496),"0b110101101");
  assert.deepEqual(candidate(350, 902),"0b1001110010");
  assert.deepEqual(candidate(197, 233),"0b11010111");
  assert.deepEqual(candidate(7, 5),-1);
  assert.deepEqual(candidate(5, 1),-1);
  assert.deepEqual(candidate(5, 5),"0b101");
}

test();


Prompt:
//Given an array of strings, where each string consists of only digits, return an array.
// 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(["1234567"])
// ["the number of odd elements 4n the str4ng 4 of the 4nput."]
// >>> odd_count(["3", "11111111"])
// ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."]
function odd_count(lst){

const assert = require('node:assert');

function test() {
  let candidate = odd_count;
  assert.deepEqual(candidate(["1234567"]),["the number of odd elements 4n the str4ng 4 of the 4nput."]);
  assert.deepEqual(candidate(["3", "11111111"]),["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."]);
  assert.deepEqual(candidate(["271", "137", "314"]),["the number of odd elements 2n the str2ng 2 of the 2nput.", "the number of odd elements 3n the str3ng 3 of the 3nput.", "the number of odd elements 2n the str2ng 2 of the 2nput."]);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = move_one_ball;
  assert.deepEqual(candidate([3, 4, 5, 1, 2]),true);
  assert.deepEqual(candidate([3, 5, 10, 1, 2]),true);
  assert.deepEqual(candidate([4, 3, 1, 2]),false);
  assert.deepEqual(candidate([3, 5, 4, 1, 2]),false);
  assert.deepEqual(candidate([]),true);
}

test();


Prompt:
//Given a positive integer n, return an array 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 array has the number of even and odd integer palindromes respectively.
function even_odd_palindrome(n){

const assert = require('node:assert');

function test() {
  let candidate = even_odd_palindrome;
  assert.deepEqual(candidate(123),[8, 13]);
  assert.deepEqual(candidate(12),[4, 6]);
  assert.deepEqual(candidate(3),[1, 2]);
  assert.deepEqual(candidate(63),[6, 8]);
  assert.deepEqual(candidate(25),[5, 6]);
  assert.deepEqual(candidate(19),[4, 6]);
  assert.deepEqual(candidate(9),[4, 5]);
  assert.deepEqual(candidate(1),[0, 1]);
}

test();


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
function is_equal_to_sum_even(n){

const assert = require('node:assert');

function test() {
  let candidate = is_equal_to_sum_even;
  assert.deepEqual(candidate(4),false);
  assert.deepEqual(candidate(6),false);
  assert.deepEqual(candidate(8),true);
  assert.deepEqual(candidate(10),true);
  assert.deepEqual(candidate(11),false);
  assert.deepEqual(candidate(12),true);
  assert.deepEqual(candidate(13),false);
  assert.deepEqual(candidate(16),true);
}

test();


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([3, 1, 2, 4, 5])
// [1, 4, 12, 20]
// >>> derivative([1, 2, 3])
// [2, 6]
function derivative(xs){

const assert = require('node:assert');

function test() {
  let candidate = derivative;
  assert.deepEqual(candidate([3, 1, 2, 4, 5]),[1, 4, 12, 20]);
  assert.deepEqual(candidate([1, 2, 3]),[2, 6]);
  assert.deepEqual(candidate([3, 2, 1]),[2, 2]);
  assert.deepEqual(candidate([3, 2, 1, 0, 4]),[2, 2, 0, 16]);
  assert.deepEqual(candidate([1]),[]);
}

test();


Prompt:
//Given an array of numbers, return whether or not they are sorted
// in ascending order. If array has more than 1 duplicate of the same
// number, return false. Assume no negative numbers and only integers.
// Examples
// >>> is_sorted([5])
// true
// >>> is_sorted([1, 2, 3, 4, 5])
// true
// >>> is_sorted([1, 3, 2, 4, 5])
// false
// >>> is_sorted([1, 2, 3, 4, 5, 6])
// true
// >>> is_sorted([1, 2, 3, 4, 5, 6, 7])
// true
// >>> is_sorted([1, 3, 2, 4, 5, 6, 7])
// false
// >>> is_sorted([1, 2, 2, 3, 3, 4])
// true
// >>> is_sorted([1, 2, 2, 2, 3, 4])
// false
function is_sorted(lst){

const assert = require('node:assert');

function test() {
  let candidate = is_sorted;
  assert.deepEqual(candidate([5]),true);
  assert.deepEqual(candidate([1, 2, 3, 4, 5]),true);
  assert.deepEqual(candidate([1, 3, 2, 4, 5]),false);
  assert.deepEqual(candidate([1, 2, 3, 4, 5, 6]),true);
  assert.deepEqual(candidate([1, 2, 3, 4, 5, 6, 7]),true);
  assert.deepEqual(candidate([1, 3, 2, 4, 5, 6, 7]),false);
  assert.deepEqual(candidate([]),true);
  assert.deepEqual(candidate([1]),true);
  assert.deepEqual(candidate([3, 2, 1]),false);
  assert.deepEqual(candidate([1, 2, 2, 2, 3, 4]),false);
  assert.deepEqual(candidate([1, 2, 3, 3, 3, 4]),false);
  assert.deepEqual(candidate([1, 2, 2, 3, 3, 4]),true);
  assert.deepEqual(candidate([1, 2, 3, 4]),true);
}

test();


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("1234")
// "4321"
// >>> solve("ab")
// "AB"
// >>> solve("#a@C")
// "#A@c"
function solve(s){

const assert = require('node:assert');

function test() {
  let candidate = solve;
  assert.deepEqual(candidate("AsDf"),"aSdF");
  assert.deepEqual(candidate("1234"),"4321");
  assert.deepEqual(candidate("ab"),"AB");
  assert.deepEqual(candidate("#a@C"),"#A@c");
  assert.deepEqual(candidate("#AsdfW^45"),"#aSDFw^45");
  assert.deepEqual(candidate("#6@2"),"2@6#");
  assert.deepEqual(candidate("#$a^D"),"#$A^d");
  assert.deepEqual(candidate("#ccc"),"#CCC");
}

test();


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 an array of the
// first n + 1 numbers of the Tribonacci sequence.
// Examples:
// >>> tri(3)
// [1, 3, 2, 8]
function tri(n){

const assert = require('node:assert');

function test() {
  let candidate = tri;
  assert.deepEqual(candidate(3),[1, 3, 2, 8]);
  assert.deepEqual(candidate(4),[1, 3, 2, 8, 3]);
  assert.deepEqual(candidate(5),[1, 3, 2, 8, 3, 15]);
  assert.deepEqual(candidate(6),[1, 3, 2, 8, 3, 15, 4]);
  assert.deepEqual(candidate(7),[1, 3, 2, 8, 3, 15, 4, 24]);
  assert.deepEqual(candidate(8),[1, 3, 2, 8, 3, 15, 4, 24, 5]);
  assert.deepEqual(candidate(9),[1, 3, 2, 8, 3, 15, 4, 24, 5, 35]);
  assert.deepEqual(candidate(20),[1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11]);
  assert.deepEqual(candidate(0),[1]);
  assert.deepEqual(candidate(1),[1, 3]);
}

test();


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
function fizz_buzz(n){

const assert = require('node:assert');

function test() {
  let candidate = fizz_buzz;
  assert.deepEqual(candidate(50),0);
  assert.deepEqual(candidate(78),2);
  assert.deepEqual(candidate(79),3);
  assert.deepEqual(candidate(100),3);
  assert.deepEqual(candidate(200),6);
  assert.deepEqual(candidate(4000),192);
  assert.deepEqual(candidate(10000),639);
  assert.deepEqual(candidate(100000),8026);
}

test();


Prompt:
//Filter an input array of strings only for ones that start with a given prefix.
// >>> filter_by_prefix([], "a")
// []
// >>> filter_by_prefix(["abc", "bcd", "cde", "array"], "a")
// ["abc", "array"]
function filter_by_prefix(strings, prefix){

const assert = require('node:assert');

function test() {
  let candidate = filter_by_prefix;
  assert.deepEqual(candidate([], "john"),[]);
  assert.deepEqual(candidate(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx"),["xxx", "xxxAAA", "xxx"]);
}

test();


Prompt:
//Given a positive integer N, return the total sum of its digits in binary.
// Example
// >>> solve(1000)
// "1"
// >>> solve(150)
// "110"
// >>> solve(147)
// "1100"
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
function solve(N){

const assert = require('node:assert');

function test() {
  let candidate = solve;
  assert.deepEqual(candidate(1000),"1");
  assert.deepEqual(candidate(150),"110");
  assert.deepEqual(candidate(147),"1100");
  assert.deepEqual(candidate(333),"1001");
  assert.deepEqual(candidate(963),"10010");
}

test();


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 arrays 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 array of the values on the cells that the minimum path go through.
// Examples:
// >>> minPath([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3)
// [1, 2, 1]
// >>> minPath([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1)
// [1]
function minPath(grid, k){


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

const assert = require('node:assert');

function test() {
  let candidate = count_upper;
  assert.deepEqual(candidate("aBCdEf"),1);
  assert.deepEqual(candidate("abcdefg"),0);
  assert.deepEqual(candidate("dBBE"),0);
  assert.deepEqual(candidate("B"),0);
  assert.deepEqual(candidate("U"),1);
  assert.deepEqual(candidate(""),0);
  assert.deepEqual(candidate("EEEE"),2);
}

test();


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


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

const assert = require('node:assert');

function test() {
  let candidate = largest_divisor;
  assert.deepEqual(candidate(3),1);
  assert.deepEqual(candidate(7),1);
  assert.deepEqual(candidate(10),5);
  assert.deepEqual(candidate(100),50);
  assert.deepEqual(candidate(49),7);
}

test();


Prompt:
//Given an array of non-negative integers, return a cojs of the given array after sorting,
// you will sort the given array 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 array.
// Examples:
// >>> sort_array([])
// []
// >>> sort_array([5])
// [5]
// >>> sort_array([2, 4, 3, 0, 1, 5])
// [0, 1, 2, 3, 4, 5]
// >>> sort_array([2, 4, 3, 0, 1, 5, 6])
// [6, 5, 4, 3, 2, 1, 0]
function sort_array(array){

const assert = require('node:assert');

function test() {
  let candidate = sort_array;
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([5]),[5]);
  assert.deepEqual(candidate([2, 4, 3, 0, 1, 5]),[0, 1, 2, 3, 4, 5]);
  assert.deepEqual(candidate([2, 4, 3, 0, 1, 5, 6]),[6, 5, 4, 3, 2, 1, 0]);
  assert.deepEqual(candidate([2, 1]),[1, 2]);
  assert.deepEqual(candidate([15, 42, 87, 32, 11, 0]),[0, 11, 15, 32, 42, 87]);
  assert.deepEqual(candidate([21, 14, 23, 11]),[23, 21, 14, 11]);
}

test();


Prompt:
//Implement the function f that takes n as a parameter,
// and returns an array 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)
// [1, 2, 6, 24, 15]
function f(n){

const assert = require('node:assert');

function test() {
  let candidate = f;
  assert.deepEqual(candidate(5),[1, 2, 6, 24, 15]);
  assert.deepEqual(candidate(7),[1, 2, 6, 24, 15, 720, 28]);
  assert.deepEqual(candidate(1),[1]);
  assert.deepEqual(candidate(3),[1, 2, 6]);
}

test();


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
function iscube(a){

const assert = require('node:assert');

function test() {
  let candidate = iscube;
  assert.deepEqual(candidate(1),true);
  assert.deepEqual(candidate(2),false);
  assert.deepEqual(candidate(-1),true);
  assert.deepEqual(candidate(64),true);
  assert.deepEqual(candidate(180),false);
  assert.deepEqual(candidate(1000),true);
  assert.deepEqual(candidate(0),true);
  assert.deepEqual(candidate(1729),false);
}

test();


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("test")
// "TGST"
// >>> encode("This is a message")
// "tHKS KS C MGSSCGG"
function encode(message){

const assert = require('node:assert');

function test() {
  let candidate = encode;
  assert.deepEqual(candidate("TEST"),"tgst");
  assert.deepEqual(candidate("Mudasir"),"mWDCSKR");
  assert.deepEqual(candidate("YES"),"ygs");
  assert.deepEqual(candidate("This is a message"),"tHKS KS C MGSSCGG");
  assert.deepEqual(candidate("I DoNt KnOw WhAt tO WrItE"),"k dQnT kNqW wHcT Tq wRkTg");
}

test();


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("Hello world")
// 0
// >>> is_bored("The sky is blue. The sun is shining. I love this weather")
// 1
function is_bored(S){

const assert = require('node:assert');

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

test();


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

const assert = require('node:assert');

function test() {
  let candidate = pairs_sum_to_zero;
  assert.deepEqual(candidate([1, 3, 5, 0]),false);
  assert.deepEqual(candidate([1, 3, -2, 1]),false);
  assert.deepEqual(candidate([1, 2, 3, 7]),false);
  assert.deepEqual(candidate([2, 4, -5, 3, 5, 7]),true);
  assert.deepEqual(candidate([1]),false);
  assert.deepEqual(candidate([-3, 9, -1, 3, 2, 30]),true);
  assert.deepEqual(candidate([-3, 9, -1, 3, 2, 31]),true);
  assert.deepEqual(candidate([-3, 9, -1, 4, 2, 30]),false);
  assert.deepEqual(candidate([-3, 9, -1, 4, 2, 31]),false);
}

test();


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
function triangle_area(a, b, c){

const assert = require('node:assert');

function test() {
  let candidate = triangle_area;
  assert.deepEqual(candidate(3, 4, 5),6.0);
  assert.deepEqual(candidate(1, 2, 10),-1);
  assert.deepEqual(candidate(4, 8, 5),8.18);
  assert.deepEqual(candidate(2, 2, 2),1.73);
  assert.deepEqual(candidate(1, 2, 3),-1);
  assert.deepEqual(candidate(10, 5, 7),16.25);
  assert.deepEqual(candidate(2, 6, 3),-1);
  assert.deepEqual(candidate(1, 1, 1),0.43);
  assert.deepEqual(candidate(2, 2, 10),-1);
}

test();


Prompt:
//There are eight planets in our solar system: the closerst to the Sun
// is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
// Uranus, Neptune.
// Write a function that takes two planet names as strings planet1 and planet2.
// The function should return an array containing all planets whose orbits are
// located between the orbit of planet1 and the orbit of planet2, sorted by
// the proximity to the sun.
// The function should return an empty array if planet1 or planet2
// are not correct planet names.
// Examples
// >>> bf("Jupiter", "Neptune")
// ["Saturn", "Uranus"]
// >>> bf("Earth", "Mercury")
// "Venus"
// >>> bf("Mercury", "Uranus")
// ["Venus", "Earth", "Mars", "Jupiter", "Saturn"]
function bf(planet1, planet2){

const assert = require('node:assert');

function test() {
  let candidate = bf;
  assert.deepEqual(candidate("Jupiter", "Neptune"),["Saturn", "Uranus"]);
  assert.deepEqual(candidate("Earth", "Mercury"),["Venus"]);
  assert.deepEqual(candidate("Mercury", "Uranus"),["Venus", "Earth", "Mars", "Jupiter", "Saturn"]);
  assert.deepEqual(candidate("Neptune", "Venus"),["Earth", "Mars", "Jupiter", "Saturn", "Uranus"]);
  assert.deepEqual(candidate("Earth", "Earth"),[]);
  assert.deepEqual(candidate("Mars", "Earth"),[]);
  assert.deepEqual(candidate("Jupiter", "Makemake"),[]);
}

test();


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
function digits(n){

const assert = require('node:assert');

function test() {
  let candidate = digits;
  assert.deepEqual(candidate(5),5);
  assert.deepEqual(candidate(54),5);
  assert.deepEqual(candidate(120),1);
  assert.deepEqual(candidate(5014),5);
  assert.deepEqual(candidate(98765),315);
  assert.deepEqual(candidate(5576543),2625);
  assert.deepEqual(candidate(2468),0);
}

test();


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 an array of the words.
// For example:
// >>> words_string("Hi, my name is John")
// ["Hi", "my", "name", "is", "John"]
// >>> words_string("One, two, three, four, five, six")
// ["One", "two", "three", "four", "five", "six"]
function words_string(s){

const assert = require('node:assert');

function test() {
  let candidate = words_string;
  assert.deepEqual(candidate("Hi, my name is John"),["Hi", "my", "name", "is", "John"]);
  assert.deepEqual(candidate("One, two, three, four, five, six"),["One", "two", "three", "four", "five", "six"]);
  assert.deepEqual(candidate("Hi, my name"),["Hi", "my", "name"]);
  assert.deepEqual(candidate("One,, two, three, four, five, six,"),["One", "two", "three", "four", "five", "six"]);
  assert.deepEqual(candidate(""),[]);
  assert.deepEqual(candidate("ahmed     , gamal"),["ahmed", "gamal"]);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = how_many_times;
  assert.deepEqual(candidate("", "x"),0);
  assert.deepEqual(candidate("xyxyxyx", "x"),4);
  assert.deepEqual(candidate("cacacacac", "cac"),4);
  assert.deepEqual(candidate("john doe", "john"),1);
}

test();


Prompt:
//Create a function that takes integers, floats, or strings representing
// real numbers, and returns the larger variable in its given variable type.
// Return undefined if the values are equal.
// Note: If a real number is represented as a string, the floating point might be . or ,
// >>> compare_one(1, 2.5)
// 2.5
// >>> compare_one(1, "2,3")
// "2,3"
// >>> compare_one("5,1", "6")
// "6"
// >>> compare_one("1", 1)
// undefined
function compare_one(a, b){

const assert = require('node:assert');

function test() {
  let candidate = compare_one;
  assert.deepEqual(candidate(1, 2),2);
  assert.deepEqual(candidate(1, 2.5),2.5);
  assert.deepEqual(candidate(2, 3),3);
  assert.deepEqual(candidate(5, 6),6);
  assert.deepEqual(candidate(1, "2,3"),"2,3");
  assert.deepEqual(candidate("5,1", "6"),"6");
  assert.deepEqual(candidate("1", "2"),"2");
  assert.deepEqual(candidate("1", 1),undefined);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = remove_vowels;
  assert.deepEqual(candidate(""),"");
  assert.deepEqual(candidate("abcdef
ghijklm"),"bcdf
ghjklm");
  assert.deepEqual(candidate("fedcba"),"fdcb");
  assert.deepEqual(candidate("eeeee"),"");
  assert.deepEqual(candidate("acBAA"),"cB");
  assert.deepEqual(candidate("EcBOO"),"cB");
  assert.deepEqual(candidate("ybcd"),"ybcd");
}

test();


Prompt:
//Given array of integers, return array 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([1, 2, 3, 4])
// [1, 4, 2, 3]
// >>> strange_sort_list([5, 5, 5, 5])
// [5, 5, 5, 5]
// >>> strange_sort_list([])
// []
function strange_sort_list(lst){

const assert = require('node:assert');

function test() {
  let candidate = strange_sort_list;
  assert.deepEqual(candidate([1, 2, 3, 4]),[1, 4, 2, 3]);
  assert.deepEqual(candidate([5, 6, 7, 8, 9]),[5, 9, 6, 8, 7]);
  assert.deepEqual(candidate([1, 2, 3, 4, 5]),[1, 5, 2, 4, 3]);
  assert.deepEqual(candidate([5, 6, 7, 8, 9, 1]),[1, 9, 5, 8, 6, 7]);
  assert.deepEqual(candidate([5, 5, 5, 5]),[5, 5, 5, 5]);
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([1, 2, 3, 4, 5, 6, 7, 8]),[1, 8, 2, 7, 3, 6, 4, 5]);
  assert.deepEqual(candidate([0, 2, 2, 2, 5, 5, -5, -5]),[-5, 5, -5, 5, 0, 2, 2, 2]);
  assert.deepEqual(candidate([111111]),[111111]);
}

test();


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


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
function is_simple_power(x, n){

const assert = require('node:assert');

function test() {
  let candidate = is_simple_power;
  assert.deepEqual(candidate(16, 2),true);
  assert.deepEqual(candidate(143214, 16),false);
  assert.deepEqual(candidate(4, 2),true);
  assert.deepEqual(candidate(9, 3),true);
  assert.deepEqual(candidate(16, 4),true);
  assert.deepEqual(candidate(24, 2),false);
  assert.deepEqual(candidate(128, 4),false);
  assert.deepEqual(candidate(12, 6),false);
  assert.deepEqual(candidate(1, 1),true);
  assert.deepEqual(candidate(1, 12),true);
}

test();


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
function prime_fib(n){

const assert = require('node:assert');

function test() {
  let candidate = prime_fib;
  assert.deepEqual(candidate(1),2);
  assert.deepEqual(candidate(2),3);
  assert.deepEqual(candidate(3),5);
  assert.deepEqual(candidate(4),13);
  assert.deepEqual(candidate(5),89);
  assert.deepEqual(candidate(6),233);
  assert.deepEqual(candidate(7),1597);
  assert.deepEqual(candidate(8),28657);
  assert.deepEqual(candidate(9),514229);
  assert.deepEqual(candidate(10),433494437);
}

test();


Prompt:
//Write a function which sorts the given array 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 array.
// For example:
// >>> order_by_points([1, 11, -1, -11, -12])
// [-1, -11, 1, -12, 11]
// >>> order_by_points([])
// []
function order_by_points(nums){


Prompt:
//Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
// false
// >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
// true
function has_close_elements(numbers, threshold){

const assert = require('node:assert');

function test() {
  let candidate = has_close_elements;
  assert.deepEqual(candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3),true);
  assert.deepEqual(candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05),false);
  assert.deepEqual(candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95),true);
  assert.deepEqual(candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.8),false);
  assert.deepEqual(candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1),true);
  assert.deepEqual(candidate([1.1, 2.2, 3.1, 4.1, 5.1], 1.0),true);
  assert.deepEqual(candidate([1.1, 2.2, 3.1, 4.1, 5.1], 0.5),false);
}

test();


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("")
// ""
// >>> make_palindrome("cat")
// "catac"
// >>> make_palindrome("cata")
// "catac"
function make_palindrome(string){

const assert = require('node:assert');

function test() {
  let candidate = make_palindrome;
  assert.deepEqual(candidate(""),"");
  assert.deepEqual(candidate("x"),"x");
  assert.deepEqual(candidate("xyz"),"xyzyx");
  assert.deepEqual(candidate("xyx"),"xyx");
  assert.deepEqual(candidate("jerry"),"jerryrrej");
}

test();


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("010", "110")
// "100"
function string_xor(a, b){

const assert = require('node:assert');

function test() {
  let candidate = string_xor;
  assert.deepEqual(candidate("111000", "101010"),"010010");
  assert.deepEqual(candidate("1", "1"),"0");
  assert.deepEqual(candidate("0101", "0000"),"0101");
}

test();


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.
function special_factorial(n){

const assert = require('node:assert');

function test() {
  let candidate = special_factorial;
  assert.deepEqual(candidate(4),288);
  assert.deepEqual(candidate(5),34560);
  assert.deepEqual(candidate(7),125411328000);
  assert.deepEqual(candidate(1),1);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = add_elements;
  assert.deepEqual(candidate([1, -2, -3, 41, 57, 76, 87, 88, 99], 3),-4);
  assert.deepEqual(candidate([111, 121, 3, 4000, 5, 6], 2),0);
  assert.deepEqual(candidate([11, 21, 3, 90, 5, 6, 7, 8, 9], 4),125);
  assert.deepEqual(candidate([111, 21, 3, 4000, 5, 6, 7, 8, 9], 4),24);
  assert.deepEqual(candidate([1], 1),1);
}

test();


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
function fib4(n){

const assert = require('node:assert');

function test() {
  let candidate = fib4;
  assert.deepEqual(candidate(5),4);
  assert.deepEqual(candidate(8),28);
  assert.deepEqual(candidate(10),104);
  assert.deepEqual(candidate(12),386);
}

test();


Prompt:
//Given an array of positive integers x. return a sorted array of all
// elements that hasn't any even digit.
// Note: Returned array should be sorted in increasing order.
// For example:
// >>> unique_digits([15, 33, 1422, 1])
// [1, 15, 33]
// >>> unique_digits([152, 323, 1422, 10])
// []
function unique_digits(x){

const assert = require('node:assert');

function test() {
  let candidate = unique_digits;
  assert.deepEqual(candidate([15, 33, 1422, 1]),[1, 15, 33]);
  assert.deepEqual(candidate([152, 323, 1422, 10]),[]);
  assert.deepEqual(candidate([12345, 2033, 111, 151]),[111, 151]);
  assert.deepEqual(candidate([135, 103, 31]),[31, 135]);
}

test();


Prompt:
//Given a string s and a natural number n, you have been tasked to implement
// a function that returns an array 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 array.
// Note: you may assume the input string contains only letters and spaces.
// Examples:
// >>> select_words("Mary had a little lamb", 4)
// ["little"]
// >>> select_words("Mary had a little lamb", 3)
// ["Mary", "lamb"]
// >>> select_words("simple white space", 2)
// []
// >>> select_words("Hello world", 4)
// ["world"]
// >>> select_words("Uncle sam", 3)
// ["Uncle"]
function select_words(s, n){

const assert = require('node:assert');

function test() {
  let candidate = select_words;
  assert.deepEqual(candidate("Mary had a little lamb", 4),["little"]);
  assert.deepEqual(candidate("Mary had a little lamb", 3),["Mary", "lamb"]);
  assert.deepEqual(candidate("simple white space", 2),[]);
  assert.deepEqual(candidate("Hello world", 4),["world"]);
  assert.deepEqual(candidate("Uncle sam", 3),["Uncle"]);
  assert.deepEqual(candidate("", 4),[]);
  assert.deepEqual(candidate("a b c d e f", 1),["b", "c", "d", "f"]);
}

test();


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 array) and the sum of its elements is less than or equal the maximum possible weight w.
// Example:
// >>> will_it_fly([1, 2], 5)
// false
// # 1+2 is less than the maximum possible weight, but it's unbalanced.
// >>> will_it_fly([3, 2, 3], 1)
// false
// # it's balanced, but 3+2+3 is more than the maximum possible weight.
// >>> will_it_fly([3, 2, 3], 9)
// true
// # 3+2+3 is less than the maximum possible weight, and it's balanced.
// >>> will_it_fly([3], 5)
// true
// # 3 is less than the maximum possible weight, and it's balanced.
function will_it_fly(q, w){

const assert = require('node:assert');

function test() {
  let candidate = will_it_fly;
  assert.deepEqual(candidate([3, 2, 3], 9),true);
  assert.deepEqual(candidate([1, 2], 5),false);
  assert.deepEqual(candidate([3], 5),true);
  assert.deepEqual(candidate([3, 2, 3], 1),false);
  assert.deepEqual(candidate([1, 2, 3], 6),false);
  assert.deepEqual(candidate([5], 5),true);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = fib;
  assert.deepEqual(candidate(10),55);
  assert.deepEqual(candidate(1),1);
  assert.deepEqual(candidate(8),21);
  assert.deepEqual(candidate(11),89);
  assert.deepEqual(candidate(12),144);
}

test();


Prompt:
//You will be given the name of a class (a string) and an array 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 array.
// For example, if you are given "Slices" as the class and an array of the
// extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
// return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension
// (its strength is -1).
// Example:
// >>> Strongest_Extension("my_class", ["AA", "Be", "CC"])
// "my_class.AA"
function Strongest_Extension(class_name, extensions){

const assert = require('node:assert');

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

test();


Prompt:
//You are given an array 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(["()(", ")"])
// "Yes"
// >>> match_parens([")", ")"])
// "No"
function match_parens(lst){

const assert = require('node:assert');

function test() {
  let candidate = match_parens;
  assert.deepEqual(candidate(["()(", ")"]),"Yes");
  assert.deepEqual(candidate([")", ")"]),"No");
  assert.deepEqual(candidate(["(()(())", "())())"]),"No");
  assert.deepEqual(candidate([")())", "(()()("]),"Yes");
  assert.deepEqual(candidate(["(())))", "(()())(("]),"Yes");
  assert.deepEqual(candidate(["()", "())"]),"No");
  assert.deepEqual(candidate(["(()(", "()))()"]),"Yes");
  assert.deepEqual(candidate(["((((", "((())"]),"No");
  assert.deepEqual(candidate([")(()", "(()("]),"No");
  assert.deepEqual(candidate([")(", ")("]),"No");
  assert.deepEqual(candidate(["(", ")"]),"Yes");
  assert.deepEqual(candidate([")", "("]),"Yes");
}

test();


Prompt:
//You are given an array of integers.
// Write a function next_smallest() that returns the 2nd smallest element of the array.
// Return undefined if there is no such element.
// >>> next_smallest([1, 2, 3, 4, 5])
// 2
// >>> next_smallest([5, 1, 4, 3, 2])
// 2
// >>> next_smallest([])
// undefined
// >>> next_smallest([1, 1])
// undefined
function next_smallest(lst){

const assert = require('node:assert');

function test() {
  let candidate = next_smallest;
  assert.deepEqual(candidate([1, 2, 3, 4, 5]),2);
  assert.deepEqual(candidate([5, 1, 4, 3, 2]),2);
  assert.deepEqual(candidate([]),undefined);
  assert.deepEqual(candidate([1, 1]),undefined);
  assert.deepEqual(candidate([1, 1, 1, 1, 0]),1);
  assert.deepEqual(candidate([1, 1]),undefined);
  assert.deepEqual(candidate([-35, 34, 12, -45]),-35);
}

test();


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
function any_int(x, y, z){

const assert = require('node:assert');

function test() {
  let candidate = any_int;
  assert.deepEqual(candidate(2, 3, 1),true);
  assert.deepEqual(candidate(2.5, 2, 3),false);
  assert.deepEqual(candidate(1.5, 5, 3.5),false);
  assert.deepEqual(candidate(2, 6, 2),false);
  assert.deepEqual(candidate(4, 2, 2),true);
  assert.deepEqual(candidate(2.2, 2.2, 2.2),false);
  assert.deepEqual(candidate(-4, 6, 2),true);
  assert.deepEqual(candidate(2, 1, 1),true);
  assert.deepEqual(candidate(3, 4, 7),true);
  assert.deepEqual(candidate(3.0, 4, 7),false);
}

test();


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
function truncate_number(number){

const assert = require('node:assert');

function test() {
  let candidate = truncate_number;
  assert.deepEqual(candidate(3.5),0.5);
  assert.deepEqual(candidate(1.25),0.25);
  assert.deepEqual(candidate(123.0),0.0);
}

test();


Prompt:
//Return array with elements incremented by 1.
// >>> incr_list([1, 2, 3])
// [2, 3, 4]
// >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [6, 4, 6, 3, 4, 4, 10, 1, 124]
function incr_list(l){

const assert = require('node:assert');

function test() {
  let candidate = incr_list;
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([3, 2, 1]),[4, 3, 2]);
  assert.deepEqual(candidate([5, 2, 5, 2, 3, 3, 9, 0, 123]),[6, 3, 6, 3, 4, 4, 10, 1, 124]);
}

test();


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
function x_or_y(n, x, y){

const assert = require('node:assert');

function test() {
  let candidate = x_or_y;
  assert.deepEqual(candidate(7, 34, 12),34);
  assert.deepEqual(candidate(15, 8, 5),5);
  assert.deepEqual(candidate(3, 33, 5212),33);
  assert.deepEqual(candidate(1259, 3, 52),3);
  assert.deepEqual(candidate(7919, -1, 12),-1);
  assert.deepEqual(candidate(3609, 1245, 583),583);
  assert.deepEqual(candidate(91, 56, 129),129);
  assert.deepEqual(candidate(6, 34, 1234),1234);
  assert.deepEqual(candidate(1, 2, 0),0);
  assert.deepEqual(candidate(2, 2, 0),2);
}

test();


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
function modp(n, p){

const assert = require('node:assert');

function test() {
  let candidate = modp;
  assert.deepEqual(candidate(3, 5),3);
  assert.deepEqual(candidate(1101, 101),2);
  assert.deepEqual(candidate(0, 101),1);
  assert.deepEqual(candidate(3, 11),8);
  assert.deepEqual(candidate(100, 101),1);
  assert.deepEqual(candidate(30, 5),4);
  assert.deepEqual(candidate(31, 5),3);
}

test();


Prompt:
//Given an integer. return an array that has the number of even and odd digits respectively.
// Example:
// >>> even_odd_count(-12)
// [1, 1]
// >>> even_odd_count(123)
// [1, 2]
function even_odd_count(num){

const assert = require('node:assert');

function test() {
  let candidate = even_odd_count;
  assert.deepEqual(candidate(7),[0, 1]);
  assert.deepEqual(candidate(-78),[1, 1]);
  assert.deepEqual(candidate(3452),[2, 2]);
  assert.deepEqual(candidate(346211),[3, 3]);
  assert.deepEqual(candidate(-345821),[3, 3]);
  assert.deepEqual(candidate(-2),[1, 0]);
  assert.deepEqual(candidate(-45347),[2, 3]);
  assert.deepEqual(candidate(0),[1, 0]);
}

test();


Prompt:
//You are given a string s.
// Your task is to check if the string is hapjs or not.
// A string is hapjs if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// >>> is_happy("a")
// false
// >>> is_happy("aa")
// false
// >>> is_happy("abcd")
// true
// >>> is_happy("aabb")
// false
// >>> is_happy("adb")
// true
// >>> is_happy("xyy")
// false
function is_happy(s){

const assert = require('node:assert');

function test() {
  let candidate = is_happy;
  assert.deepEqual(candidate("a"),false);
  assert.deepEqual(candidate("aa"),false);
  assert.deepEqual(candidate("abcd"),true);
  assert.deepEqual(candidate("aabb"),false);
  assert.deepEqual(candidate("adb"),true);
  assert.deepEqual(candidate("xyy"),false);
  assert.deepEqual(candidate("iopaxpoi"),true);
  assert.deepEqual(candidate("iopaxioi"),false);
}

test();


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
function largest_prime_factor(n){

const assert = require('node:assert');

function test() {
  let candidate = largest_prime_factor;
  assert.deepEqual(candidate(15),5);
  assert.deepEqual(candidate(27),3);
  assert.deepEqual(candidate(63),7);
  assert.deepEqual(candidate(330),11);
  assert.deepEqual(candidate(13195),29);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = digitSum;
  assert.deepEqual(candidate(""),0);
  assert.deepEqual(candidate("abAB"),131);
  assert.deepEqual(candidate("abcCd"),67);
  assert.deepEqual(candidate("helloE"),69);
  assert.deepEqual(candidate("woArBld"),131);
  assert.deepEqual(candidate("aAaaaXa"),153);
  assert.deepEqual(candidate(" How are yOu?"),151);
  assert.deepEqual(candidate("You arE Very Smart"),327);
}

test();


Prompt:
//Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
// [0.0, 0.25, 0.5, 0.75, 1.0]
function rescale_to_unit(numbers){


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

const assert = require('node:assert');

function test() {
  let candidate = solution;
  assert.deepEqual(candidate([5, 8, 7, 1]),12);
  assert.deepEqual(candidate([3, 3, 3, 3, 3]),9);
  assert.deepEqual(candidate([30, 13, 24, 321]),0);
  assert.deepEqual(candidate([5, 9]),5);
  assert.deepEqual(candidate([2, 4, 8]),0);
  assert.deepEqual(candidate([30, 13, 23, 32]),23);
  assert.deepEqual(candidate([3, 13, 2, 9]),3);
}

test();


Prompt:
//"Given an array 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 an array, [ smalest_value, its index ],
// If there are no even values or the given array is empty, return [].
// Example 1:
// >>> pluck([4, 2, 3])
// [2, 1]
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 2:
// >>> pluck([1, 2, 3])
// [2, 1]
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 3:
// >>> pluck([])
// []
// Example 4:
// >>> pluck([5, 0, 3, 0, 4, 2])
// [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
function pluck(arr){

const assert = require('node:assert');

function test() {
  let candidate = pluck;
  assert.deepEqual(candidate([4, 2, 3]),[2, 1]);
  assert.deepEqual(candidate([1, 2, 3]),[2, 1]);
  assert.deepEqual(candidate([]),[]);
  assert.deepEqual(candidate([5, 0, 3, 0, 4, 2]),[0, 1]);
  assert.deepEqual(candidate([1, 2, 3, 0, 5, 3]),[0, 3]);
  assert.deepEqual(candidate([5, 4, 8, 4, 8]),[4, 1]);
  assert.deepEqual(candidate([7, 6, 7, 1]),[6, 1]);
  assert.deepEqual(candidate([7, 9, 7, 1]),[]);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = get_max_triples;
  assert.deepEqual(candidate(5),1);
  assert.deepEqual(candidate(6),4);
  assert.deepEqual(candidate(10),36);
  assert.deepEqual(candidate(100),53361);
}

test();


Prompt:
//In this problem, you will implement a function that takes two arrays of numbers,
// and determines whether it is possible to perform an exchange of elements
// between them to make lst1 an array 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([1, 2, 3, 4], [1, 2, 3, 4])
// "YES"
// >>> exchange([1, 2, 3, 4], [1, 5, 3, 4])
// "NO"
// It is assumed that the input arrays will be non-empty.
function exchange(lst1, lst2){

const assert = require('node:assert');

function test() {
  let candidate = exchange;
  assert.deepEqual(candidate([1, 2, 3, 4], [1, 2, 3, 4]),"YES");
  assert.deepEqual(candidate([1, 2, 3, 4], [1, 5, 3, 4]),"NO");
  assert.deepEqual(candidate([1, 2, 3, 4], [2, 1, 4, 3]),"YES");
  assert.deepEqual(candidate([5, 7, 3], [2, 6, 4]),"YES");
  assert.deepEqual(candidate([5, 7, 3], [2, 6, 3]),"NO");
  assert.deepEqual(candidate([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]),"NO");
  assert.deepEqual(candidate([100, 200], [200, 200]),"YES");
}

test();


Prompt:
//Return median of elements in the array l.
// >>> median([3, 1, 2, 4, 5])
// 3
// >>> median([-10, 4, 6, 1000, 10, 20])
// 15.0
function median(l){

const assert = require('node:assert');

function test() {
  let candidate = median;
  assert.deepEqual(candidate([3, 1, 2, 4, 5]),3);
  assert.deepEqual(candidate([-10, 4, 6, 1000, 10, 20]),8.0);
  assert.deepEqual(candidate([5]),5);
  assert.deepEqual(candidate([6, 5]),5.5);
  assert.deepEqual(candidate([8, 1, 3, 9, 9, 2, 7]),7);
}

test();


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("Hello")
// true
// >>> prime_length("abcdcba")
// true
// >>> prime_length("kittens")
// true
// >>> prime_length("orange")
// false
function prime_length(string){

const assert = require('node:assert');

function test() {
  let candidate = prime_length;
  assert.deepEqual(candidate("Hello"),true);
  assert.deepEqual(candidate("abcdcba"),true);
  assert.deepEqual(candidate("kittens"),true);
  assert.deepEqual(candidate("orange"),false);
  assert.deepEqual(candidate("wow"),true);
  assert.deepEqual(candidate("world"),true);
  assert.deepEqual(candidate("MadaM"),true);
  assert.deepEqual(candidate("Wow"),true);
  assert.deepEqual(candidate(""),false);
  assert.deepEqual(candidate("HI"),true);
  assert.deepEqual(candidate("go"),true);
  assert.deepEqual(candidate("gogo"),false);
  assert.deepEqual(candidate("aaaaaaaaaaaaaaa"),false);
  assert.deepEqual(candidate("Madam"),true);
  assert.deepEqual(candidate("M"),false);
  assert.deepEqual(candidate("0"),false);
}

test();


Prompt:
//Given an array arr of integers, find the minimum number of elements that
// need to be changed to make the array palindromic. A palindromic array is an array that
// is read the same backwards and forwards. In one change, you can change one element to any other element.
// For example:
// >>> smallest_change([1, 2, 3, 5, 4, 7, 9, 6])
// 4
// >>> smallest_change([1, 2, 3, 4, 3, 2, 2])
// 1
// >>> smallest_change([1, 2, 3, 2, 1])
// 0
function smallest_change(arr){

const assert = require('node:assert');

function test() {
  let candidate = smallest_change;
  assert.deepEqual(candidate([1, 2, 3, 5, 4, 7, 9, 6]),4);
  assert.deepEqual(candidate([1, 2, 3, 4, 3, 2, 2]),1);
  assert.deepEqual(candidate([1, 4, 2]),1);
  assert.deepEqual(candidate([1, 4, 4, 2]),1);
  assert.deepEqual(candidate([1, 2, 3, 2, 1]),0);
  assert.deepEqual(candidate([3, 1, 1, 3]),0);
  assert.deepEqual(candidate([1]),0);
  assert.deepEqual(candidate([0, 1]),1);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = sum_squares;
  assert.deepEqual(candidate([1.0, 2.0, 3.0]),14);
  assert.deepEqual(candidate([1.0, 2.0, 3.0]),14);
  assert.deepEqual(candidate([1.0, 3.0, 5.0, 7.0]),84);
  assert.deepEqual(candidate([1.4, 4.2, 0.0]),29);
  assert.deepEqual(candidate([-2.4, 1.0, 1.0]),6);
  assert.deepEqual(candidate([100.0, 1.0, 15.0, 2.0]),10230);
  assert.deepEqual(candidate([10000.0, 10000.0]),200000000);
  assert.deepEqual(candidate([-1.4, 4.6, 6.3]),75);
  assert.deepEqual(candidate([-1.4, 17.9, 18.9, 19.9]),1086);
  assert.deepEqual(candidate([0.0]),0);
  assert.deepEqual(candidate([-1.0]),1);
  assert.deepEqual(candidate([-1.0, 1.0, 0.0]),2);
}

test();


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("example.txt")
// "Yes"
// >>> file_name_check("1example.dll")
// "No"
function file_name_check(file_name){

const assert = require('node:assert');

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

test();


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

const assert = require('node:assert');

function test() {
  let candidate = triples_sum_to_zero;
  assert.deepEqual(candidate([1, 3, 5, 0]),false);
  assert.deepEqual(candidate([1, 3, 5, -1]),false);
  assert.deepEqual(candidate([1, 3, -2, 1]),true);
  assert.deepEqual(candidate([1, 2, 3, 7]),false);
  assert.deepEqual(candidate([1, 2, 5, 7]),false);
  assert.deepEqual(candidate([2, 4, -5, 3, 9, 7]),true);
  assert.deepEqual(candidate([1]),false);
  assert.deepEqual(candidate([1, 3, 5, -100]),false);
  assert.deepEqual(candidate([100, 3, 5, -100]),false);
}

test();


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])
// "NO"
// >>> intersection([-1, 1], [0, 4])
// "NO"
// >>> intersection([-3, -1], [-5, 5])
// "YES"
function intersection(interval1, interval2){

const assert = require('node:assert');

function test() {
  let candidate = intersection;
  assert.deepEqual(candidate([1, 2], [2, 3]),"NO");
  assert.deepEqual(candidate([-1, 1], [0, 4]),"NO");
  assert.deepEqual(candidate([-3, -1], [-5, 5]),"YES");
  assert.deepEqual(candidate([-2, 2], [-4, 0]),"YES");
  assert.deepEqual(candidate([-11, 2], [-1, -1]),"NO");
  assert.deepEqual(candidate([1, 2], [3, 5]),"NO");
  assert.deepEqual(candidate([1, 2], [1, 2]),"NO");
  assert.deepEqual(candidate([-2, -2], [-3, -2]),"NO");
}

test();


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 array 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("( ) (( )) (( )( ))")
// ["()", "(())", "(()())"]
function separate_paren_groups(paren_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 arrays of scores and guesses of equal length, where each index shows a match.
// Return an array 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([1, 2, 3, 4, 5, 1], [1, 2, 3, 4, 2, -2])
// [0, 0, 0, 0, 3, 3]
// >>> compare([0, 5, 0, 0, 0, 4], [4, 1, 1, 0, 0, -2])
// [4, 4, 1, 0, 0, 6]
function compare(game, guess){


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

const assert = require('node:assert');

function test() {
  let candidate = starts_one_ends;
  assert.deepEqual(candidate(1),1);
  assert.deepEqual(candidate(2),18);
  assert.deepEqual(candidate(3),180);
  assert.deepEqual(candidate(4),1800);
  assert.deepEqual(candidate(5),18000);
}

test();


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("apple pie")
// false
// >>> check_if_last_char_is_a_letter("apple pi e")
// true
// >>> check_if_last_char_is_a_letter("apple pi e ")
// false
// >>> check_if_last_char_is_a_letter("")
// false
function check_if_last_char_is_a_letter(txt){

const assert = require('node:assert');

function test() {
  let candidate = check_if_last_char_is_a_letter;
  assert.deepEqual(candidate("apple"),false);
  assert.deepEqual(candidate("apple pi e"),true);
  assert.deepEqual(candidate("eeeee"),false);
  assert.deepEqual(candidate("A"),true);
  assert.deepEqual(candidate("Pumpkin pie "),false);
  assert.deepEqual(candidate("Pumpkin pie 1"),false);
  assert.deepEqual(candidate(""),false);
  assert.deepEqual(candidate("eeeee e "),false);
  assert.deepEqual(candidate("apple pie"),false);
  assert.deepEqual(candidate("apple pi e "),false);
}

test();


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("03-11-2000")
// true
// >>> valid_date("15-01-2012")
// false
// >>> valid_date("04-0-2040")
// false
// >>> valid_date("06-04-2020")
// true
// >>> valid_date("06/04/2020")
// false
function valid_date(date){

const assert = require('node:assert');

function test() {
  let candidate = valid_date;
  assert.deepEqual(candidate("03-11-2000"),true);
  assert.deepEqual(candidate("15-01-2012"),false);
  assert.deepEqual(candidate("04-0-2040"),false);
  assert.deepEqual(candidate("06-04-2020"),true);
  assert.deepEqual(candidate("01-01-2007"),true);
  assert.deepEqual(candidate("03-32-2011"),false);
  assert.deepEqual(candidate(""),false);
  assert.deepEqual(candidate("04-31-3000"),false);
  assert.deepEqual(candidate("06-06-2005"),true);
  assert.deepEqual(candidate("21-31-2000"),false);
  assert.deepEqual(candidate("04-12-2003"),true);
  assert.deepEqual(candidate("04122003"),false);
  assert.deepEqual(candidate("20030412"),false);
  assert.deepEqual(candidate("2003-04"),false);
  assert.deepEqual(candidate("2003-04-12"),false);
  assert.deepEqual(candidate("04-2003"),false);
}

test();


Prompt:
//Write a function count_nums which takes an array of integers and returns
// the number of elements which has a sum of digits > 0.
// If a number is negative, then its first signed digit will be negative:
// e.g. -123 has signed digits -1, 2, and 3.
// >>> count_nums([])
// 0
// >>> count_nums([-1, 11, -11])
// 1
// >>> count_nums([1, 1, 2])
// 3
function count_nums(arr){

const assert = require('node:assert');

function test() {
  let candidate = count_nums;
  assert.deepEqual(candidate([]),0);
  assert.deepEqual(candidate([-1, -2, 0]),0);
  assert.deepEqual(candidate([1, 1, 2, -2, 3, 4, 5]),6);
  assert.deepEqual(candidate([1, 6, 9, -6, 0, 1, 5]),5);
  assert.deepEqual(candidate([1, 100, 98, -7, 1, -1]),4);
  assert.deepEqual(candidate([12, 23, 34, -45, -56, 0]),5);
  assert.deepEqual(candidate([0, 1]),1);
  assert.deepEqual(candidate([1]),1);
}

test();


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("Hi")
// "Hi"
// >>> anti_shuffle("hello")
// "ehllo"
// >>> anti_shuffle("Hello World!!!")
// "Hello !!!Wdlor"
function anti_shuffle(s){

const assert = require('node:assert');

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

test();


Prompt:
//Checks if given string is a palindrome
// >>> is_palindrome("")
// true
// >>> is_palindrome("aba")
// true
// >>> is_palindrome("aaaaa")
// true
// >>> is_palindrome("zbcd")
// false
function is_palindrome(text){

const assert = require('node:assert');

function test() {
  let candidate = is_palindrome;
  assert.deepEqual(candidate(""),true);
  assert.deepEqual(candidate("aba"),true);
  assert.deepEqual(candidate("aaaaa"),true);
  assert.deepEqual(candidate("zbcd"),false);
  assert.deepEqual(candidate("xywyx"),true);
  assert.deepEqual(candidate("xywyz"),false);
  assert.deepEqual(candidate("xywzx"),false);
}

test();


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("yogurt")
// "u"
// >>> get_closest_vowel("FULL")
// "U"
// >>> get_closest_vowel("quick")
// ""
// >>> get_closest_vowel("ab")
// ""
function get_closest_vowel(word){

const assert = require('node:assert');

function test() {
  let candidate = get_closest_vowel;
  assert.deepEqual(candidate("yogurt"),"u");
  assert.deepEqual(candidate("full"),"u");
  assert.deepEqual(candidate("easy"),"");
  assert.deepEqual(candidate("eAsy"),"");
  assert.deepEqual(candidate("ali"),"");
  assert.deepEqual(candidate("bad"),"a");
  assert.deepEqual(candidate("most"),"o");
  assert.deepEqual(candidate("ab"),"");
  assert.deepEqual(candidate("ba"),"");
  assert.deepEqual(candidate("quick"),"");
  assert.deepEqual(candidate("anime"),"i");
  assert.deepEqual(candidate("Asia"),"");
  assert.deepEqual(candidate("Above"),"o");
}

test();


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
function is_prime(n){

const assert = require('node:assert');

function test() {
  let candidate = is_prime;
  assert.deepEqual(candidate(6),false);
  assert.deepEqual(candidate(101),true);
  assert.deepEqual(candidate(11),true);
  assert.deepEqual(candidate(13441),true);
  assert.deepEqual(candidate(61),true);
  assert.deepEqual(candidate(4),false);
  assert.deepEqual(candidate(1),false);
  assert.deepEqual(candidate(5),true);
  assert.deepEqual(candidate(11),true);
  assert.deepEqual(candidate(17),true);
  assert.deepEqual(candidate(85),false);
  assert.deepEqual(candidate(77),false);
  assert.deepEqual(candidate(255379),false);
}

test();


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("1/5", "5/1")
// true
// >>> simplify("1/6", "2/1")
// false
// >>> simplify("7/10", "10/2")
// false
function simplify(x, n){

const assert = require('node:assert');

function test() {
  let candidate = simplify;
  assert.deepEqual(candidate("1/5", "5/1"),true);
  assert.deepEqual(candidate("1/6", "2/1"),false);
  assert.deepEqual(candidate("5/1", "3/1"),true);
  assert.deepEqual(candidate("7/10", "10/2"),false);
  assert.deepEqual(candidate("2/10", "50/10"),true);
  assert.deepEqual(candidate("7/2", "4/2"),true);
  assert.deepEqual(candidate("11/6", "6/1"),true);
  assert.deepEqual(candidate("2/3", "5/2"),false);
  assert.deepEqual(candidate("5/2", "3/5"),false);
  assert.deepEqual(candidate("2/4", "8/4"),true);
  assert.deepEqual(candidate("2/4", "4/2"),true);
  assert.deepEqual(candidate("1/5", "5/1"),true);
  assert.deepEqual(candidate("1/5", "1/5"),false);
}

test();


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("AB")
// 1
// >>> hex_key("1077E")
// 2
// >>> hex_key("ABED1A33")
// 4
// >>> hex_key("123456789ABCDEF0")
// 6
// >>> hex_key("2020")
// 2
function hex_key(num){

const assert = require('node:assert');

function test() {
  let candidate = hex_key;
  assert.deepEqual(candidate("AB"),1);
  assert.deepEqual(candidate("1077E"),2);
  assert.deepEqual(candidate("ABED1A33"),4);
  assert.deepEqual(candidate("2020"),2);
  assert.deepEqual(candidate("123456789ABCDEF0"),6);
  assert.deepEqual(candidate("112233445566778899AABBCCDDEEFF00"),12);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = words_in_sentence;
  assert.deepEqual(candidate("This is a test"),"is");
  assert.deepEqual(candidate("lets go for swimming"),"go for");
  assert.deepEqual(candidate("there is no place available here"),"there is no place");
  assert.deepEqual(candidate("Hi I am Hussein"),"Hi am Hussein");
  assert.deepEqual(candidate("go for it"),"go for it");
  assert.deepEqual(candidate("here"),"");
  assert.deepEqual(candidate("here is"),"is");
}

test();


Prompt:
//Given a string representing a space separated lowercase letters, return an object
// of the letter with the most repetition and containing the corresponding count.
// If several letters have the same occurrence, return all of them.
// Example:
// >>> histogram("a b c")
// {"a": 1, "b": 1, "c": 1}
// >>> histogram("a b b a")
// {"a": 2, "b": 2}
// >>> histogram("a b c a b")
// {"a": 2, "b": 2}
// >>> histogram("b b b b a")
// {"b": 4}
// >>> histogram("")
// {}
function histogram(test){

const assert = require('node:assert');

function test() {
  let candidate = histogram;
  assert.deepEqual(candidate("a b b a"),{"a": 2, "b": 2});
  assert.deepEqual(candidate("a b c a b"),{"a": 2, "b": 2});
  assert.deepEqual(candidate("a b c d g"),{"a": 1, "b": 1, "c": 1, "d": 1, "g": 1});
  assert.deepEqual(candidate("r t g"),{"r": 1, "t": 1, "g": 1});
  assert.deepEqual(candidate("b b b b a"),{"b": 4});
  assert.deepEqual(candidate("r t g"),{"r": 1, "t": 1, "g": 1});
  assert.deepEqual(candidate(""),{});
  assert.deepEqual(candidate("a"),{"a": 1});
}

test();


Prompt:
//You are given a 2 dimensional data, as a nested arrays,
// 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 array,
// and return array of arrays, [(x1, y1), (x2, y2) ...] such that
// each array 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([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 1, 6], [1, 2, 3, 4, 5, 1]], 1)
// [[0, 0], [1, 4], [1, 0], [2, 5], [2, 0]]
// >>> get_row([], 1)
// []
// >>> get_row([[], [1], [1, 2, 3]], 3)
// [[2, 2]]
function get_row(lst, x){


Prompt:
//Given a positive integer n, return a sorted array 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 array 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)
// [1, 5]
function get_odd_collatz(n){

const assert = require('node:assert');

function test() {
  let candidate = get_odd_collatz;
  assert.deepEqual(candidate(14),[1, 5, 7, 11, 13, 17]);
  assert.deepEqual(candidate(5),[1, 5]);
  assert.deepEqual(candidate(12),[1, 3, 5]);
  assert.deepEqual(candidate(1),[1]);
}

test();


Prompt:
//Create a function which returns the largest index of an element which
// is not greater than or equal to the element immediately preceding it. If
// no such element exists then return -1. The given array will not contain
// duplicate values.
// Examples:
// >>> can_arrange([1, 2, 4, 3, 5])
// 3
// >>> can_arrange([1, 2, 3])
// -1
function can_arrange(arr){

const assert = require('node:assert');

function test() {
  let candidate = can_arrange;
  assert.deepEqual(candidate([1, 2, 4, 3, 5]),3);
  assert.deepEqual(candidate([1, 2, 4, 5]),-1);
  assert.deepEqual(candidate([1, 4, 2, 5, 6, 7, 8, 9, 10]),2);
  assert.deepEqual(candidate([4, 8, 5, 7, 3]),4);
  assert.deepEqual(candidate([]),-1);
}

test();


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

const assert = require('node:assert');

function test() {
  let candidate = sort_numbers;
  assert.deepEqual(candidate(""),"");
  assert.deepEqual(candidate("three"),"three");
  assert.deepEqual(candidate("three five nine"),"three five nine");
  assert.deepEqual(candidate("five zero four seven nine eight"),"zero four five seven eight nine");
  assert.deepEqual(candidate("six five four three two one zero"),"zero one two three four five six");
}

test();


Prompt:
//Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
// >>> circular_shift(12, 1)
// "21"
// >>> circular_shift(12, 2)
// "12"
function circular_shift(x, shift){

const assert = require('node:assert');

function test() {
  let candidate = circular_shift;
  assert.deepEqual(candidate(100, 2),"001");
  assert.deepEqual(candidate(12, 2),"12");
  assert.deepEqual(candidate(97, 8),"79");
  assert.deepEqual(candidate(12, 1),"21");
  assert.deepEqual(candidate(11, 101),"11");
}

test();


Prompt:
//"
// This function will take an array of integers. For all entries in the array, the function shall square the integer entry if its index is a
// multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
// change the entries in the array whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries.
// Examples:
// >>> lst
// [1, 2, 3]
// >>> lst
// []
// >>> lst
// [-1, -5, 2, -1, -5]
function sum_squares(lst){


Prompt:
//You are given an array of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
// >>> skjkasdkd([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3])
// 10
// >>> skjkasdkd([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1])
// 25
// >>> skjkasdkd([1, 3, 1, 32, 5107, 34, 83278, 109, 163, 23, 2323, 32, 30, 1, 9, 3])
// 13
// >>> skjkasdkd([0, 724, 32, 71, 99, 32, 6, 0, 5, 91, 83, 0, 5, 6])
// 11
// >>> skjkasdkd([0, 81, 12, 3, 1, 21])
// 3
// >>> skjkasdkd([0, 8, 1, 2, 1, 7])
// 7
function skjkasdkd(lst){


Prompt:
//For a given array of integers, return an array consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product([])
// [0, 1]
// >>> sum_product([1, 2, 3, 4])
// [10, 24]
function sum_product(numbers){

const assert = require('node:assert');

function test() {
  let candidate = sum_product;
  assert.deepEqual(candidate([]),[0, 1]);
  assert.deepEqual(candidate([1, 1, 1]),[3, 1]);
  assert.deepEqual(candidate([100, 0]),[100, 0]);
  assert.deepEqual(candidate([3, 5, 7]),[15, 105]);
  assert.deepEqual(candidate([10]),[10, 10]);
}

test();