Prompt:
#!/bin/bash
# Return length of given string
# >>> $(strlen "")
# "0"
# >>> $(strlen "abc")
# "3"
#
# $1 is a string
strlen() {

}

candidate() {
    strlen "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "0" ]]
    [[ $(candidate "x") = "1" ]]
    [[ $(candidate "asdasnakj") = "9" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
encrypt() {

}

candidate() {
    encrypt "$@"
}

set -e
run_test() {
    [[ $(candidate "hi") = "lm" ]]
    [[ $(candidate "asdfghjkl") = "ewhjklnop" ]]
    [[ $(candidate "gf") = "kj" ]]
    [[ $(candidate "et") = "ix" ]]
    [[ $(candidate "faewfawefaewg") = "jeiajeaijeiak" ]]
    [[ $(candidate "hellomyfriend") = "lippsqcjvmirh" ]]
    [[ $(candidate "dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh") = "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl" ]]
    [[ $(candidate "a") = "e" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a CSV, 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 CSV is empty.
# Examples:
# >>> $(check_dict_case "a,apple\nb,banana")
# "true"
# >>> $(check_dict_case "a,apple\nA,banana\nB,banana")
# "false"
# >>> $(check_dict_case "a,apple\n8,banana")
# "false"
# >>> $(check_dict_case "Name,John\nAge,36\nCity,Houston")
# "false"
# >>> $(check_dict_case "STATE,NC\nZIP,12345")
# "true"
#
# $1 is a two column CSV in key,value order
check_dict_case() {

}

candidate() {
    check_dict_case "$@"
}

set -e
run_test() {
    [[ $(candidate "p,pineapple\nb,banana") = "true" ]]
    [[ $(candidate "p,pineapple\nA,banana\nB,banana") = "false" ]]
    [[ $(candidate "p,pineapple\n5,banana\na,apple") = "false" ]]
    [[ $(candidate "Name,John\nAge,36\nCity,Houston") = "false" ]]
    [[ $(candidate "STATE,NC\nZIP,12345") = "true" ]]
    [[ $(candidate "fruit,Orange\ntaste,Sweet") = "true" ]]
    [[ $(candidate "") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a non-empty list of integers lst. add the even elements that are at odd indices..
# Examples:
# >>> $(add "4 2 6 7")
# "2"
#
# $1 is a space-separated list
add() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
fix_spaces() {

}

candidate() {
    fix_spaces "$@"
}

set -e
run_test() {
    [[ $(candidate "Example") = "Example" ]]
    [[ $(candidate "Mudasir Hanif ") = "Mudasir_Hanif_" ]]
    [[ $(candidate "Yellow Yellow  Dirty  Fellow") = "Yellow_Yellow__Dirty__Fellow" ]]
    [[ $(candidate "Exa   mple") = "Exa-mple" ]]
    [[ $(candidate "   Exa 1 2 2 mple") = "-Exa_1_2_2_mple" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
fibfib() {


Prompt:
#!/bin/bash
# Given a list of numbers, return the sum of squares of the numbers
# in the list 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 list is empty, return 0.
#
# $1 is a space-separated list
double_the_difference() {


Prompt:
#!/bin/bash
# Filter given list of any shthon values only for integers
# >>> $(filter_integers "a 3.14 5")
# ['"5"']
# >>> $(filter_integers "1 2 3 abc  ")
# ['"1"', '"2"', '"3"']
#
# $1 is a space-separated list
filter_integers() {

}

candidate() {
    filter_integers "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "4   23.2 9 adasd") = "4 9" ]]
    [[ $(candidate "3 c 3 3 a b") = "3 3 3" ]]
}

run_test


Prompt:
#!/bin/bash
# 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.
#
# $1 is an integer
car_race_collision() {


Prompt:
#!/bin/bash
# Input to this function is a string representing musical notes in a special ASCII format.
# Your task is to parse this string and return list 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"']
#
# $1 is a string
parse_music() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
decimal_to_binary() {

}

candidate() {
    decimal_to_binary "$@"
}

set -e
run_test() {
    [[ $(candidate "0") = "db0db" ]]
    [[ $(candidate "32") = "db100000db" ]]
    [[ $(candidate "103") = "db1100111db" ]]
    [[ $(candidate "15") = "db1111db" ]]
}

run_test


Prompt:
#!/bin/bash
# Return list of all prefixes from shortest to longest of the input string
# >>> $(all_prefixes "abc")
# ['"a"', '"ab"', '"abc"']
#
# $1 is a string
all_prefixes() {

}

candidate() {
    all_prefixes "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "asdfgh") = "a as asd asdf asdfg asdfgh" ]]
    [[ $(candidate "WWW") = "W WW WWW" ]]
}

run_test


Prompt:
#!/bin/bash
# Add two numbers x and y
# >>> $(add "2" "3")
# "5"
# >>> $(add "5" "7")
# "12"
#
# $1 is an integer
# $2 is an integer
add() {


Prompt:
#!/bin/bash
# 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 :)
#
# $1 is an integer
# $2 is an integer
# $3 is an integer
eat() {


Prompt:
#!/bin/bash
# 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\n0 1 0 0\n1 1 1 1" "1")
# "6"
# Example 2:
# >>> $(max_fill "0 0 1 1\n0 0 0 0\n1 1 1 1\n0 1 1 1" "2")
# "5"
# Example 3:
# >>> $(max_fill "0 0 0\n0 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
#
# $1 is a newline-separated, space-separated list
# $2 is an integer
max_fill() {


Prompt:
#!/bin/bash
# Given two lists operator, and operand. The first list has basic algebra operations, and
# the second list is a list of integers. Use the two given lists 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 list is equal to the length of operand list minus one.
# Operand is a list of of non-negative integers.
# Operator list has at least one operator, and operand list has at least two operands.
#
# $1 is a space-separated list
# $2 is a space-separated list
do_algebra() {


Prompt:
#!/bin/bash
# For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
# >>> $(flip_case "Hello")
# "hELLO"
#
# $1 is a string
flip_case() {

}

candidate() {
    flip_case "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "Hello\!") = "hELLO\!" ]]
    [[ $(candidate "These violent delights have violent ends") = "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"']
#
# $1 is a space-separated list
by_length() {

}

candidate() {
    by_length "$@"
}

set -e
run_test() {
    [[ $(candidate "2 1 1 4 5 8 2 3") = "Eight Five Four Three Two Two One One" ]]
    [[ $(candidate "") = "" ]]
    [[ $(candidate "1 -1 55") = "One" ]]
    [[ $(candidate "1 -1 3 2") = "Three Two One" ]]
    [[ $(candidate "9 4 8") = "Nine Eight Four" ]]
}

run_test


Prompt:
#!/bin/bash
# Return list of prime factors of given integer in the order from smallest to largest.
# Each of the factors should be listed 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"']
#
# $1 is an integer
factorize() {


Prompt:
#!/bin/bash
# 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"']
#
# $1 is an integer
count_up_to() {


Prompt:
#!/bin/bash
# Return sorted unique elements in a list
# >>> $(unique "5 3 5 2 3 3 9 0 123")
# ['"0"', '"2"', '"3"', '"5"', '"9"', '"123"']
#
# $1 is a space-separated list
unique() {


Prompt:
#!/bin/bash
# Write a function that accepts two lists of strings and returns the list that has
# total number of chars in the all strings of the list less than the other list.
# if the two lists have the same number of chars, return the first list.
# 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"']
#
# $1 is a space-separated list
# $2 is a space-separated list
total_match() {

}

candidate() {
    total_match "$@"
}

set -e
run_test() {
    [[ $(candidate "" "") = "" ]]
    [[ $(candidate "hi admin" "hi hi") = "hi hi" ]]
    [[ $(candidate "hi admin" "hi hi admin project") = "hi admin" ]]
    [[ $(candidate "4" "1 2 3 4 5") = "4" ]]
    [[ $(candidate "hi admin" "hI Hi") = "hI Hi" ]]
    [[ $(candidate "hi admin" "hI hi hi") = "hI hi hi" ]]
    [[ $(candidate "hi admin" "hI hi hii") = "hi admin" ]]
    [[ $(candidate "" "this") = "" ]]
    [[ $(candidate "this" "") = "" ]]
}

run_test


Prompt:
#!/bin/bash
# Return maximum element in the list.
# >>> $(max_element "1 2 3")
# "3"
# >>> $(max_element "5 3 -5 2 -3 3 9 0 123 1 -10")
# "123"
#
# $1 is a space-separated list
max_element() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
is_nested() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
rounded_avg() {


Prompt:
#!/bin/bash
# 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 list 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.
#
# $1 is a space-separated list
move_one_ball() {

}

candidate() {
    move_one_ball "$@"
}

set -e
run_test() {
    [[ $(candidate "3 4 5 1 2") = "true" ]]
    [[ $(candidate "3 5 10 1 2") = "true" ]]
    [[ $(candidate "4 3 1 2") = "false" ]]
    [[ $(candidate "3 5 4 1 2") = "false" ]]
    [[ $(candidate "") = "true" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a positive integer n, return a list 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 list has the number of even and odd integer palindromes respectively.
#
# $1 is an integer
even_odd_palindrome() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
is_equal_to_sum_even() {

}

candidate() {
    is_equal_to_sum_even "$@"
}

set -e
run_test() {
    [[ $(candidate "4") = "false" ]]
    [[ $(candidate "6") = "false" ]]
    [[ $(candidate "8") = "true" ]]
    [[ $(candidate "10") = "true" ]]
    [[ $(candidate "11") = "false" ]]
    [[ $(candidate "12") = "true" ]]
    [[ $(candidate "13") = "false" ]]
    [[ $(candidate "16") = "true" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"']
#
# $1 is a space-separated list
derivative() {


Prompt:
#!/bin/bash
# Given a list of numbers, return whether or not they are sorted
# in ascending order. If list 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"
#
# $1 is a space-separated list
is_sorted() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
solve() {


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


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
fizz_buzz() {


Prompt:
#!/bin/bash
# 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
#
# $1 is an integer
solve() {


Prompt:
#!/bin/bash
# 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 lists 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 list of the values on the cells that the minimum path go through.
# Examples:
# >>> $(minPath "1 2 3\n4 5 6\n7 8 9" "3")
# ['"1"', '"2"', '"1"']
# >>> $(minPath "5 9 3\n4 1 6\n7 8 2" "1")
# ['"1"']
#
# $1 is a newline-separated, space-separated list
# $2 is an integer
minPath() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
count_upper() {

}

candidate() {
    count_upper "$@"
}

set -e
run_test() {
    [[ $(candidate "aBCdEf") = "1" ]]
    [[ $(candidate "abcdefg") = "0" ]]
    [[ $(candidate "dBBE") = "0" ]]
    [[ $(candidate "B") = "0" ]]
    [[ $(candidate "U") = "1" ]]
    [[ $(candidate "") = "0" ]]
    [[ $(candidate "EEEE") = "2" ]]
}

run_test


Prompt:
#!/bin/bash
# Given an array arr of integers and a positive integer k, return a sorted list
# 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)
#
# $1 is a space-separated list
# $2 is an integer
maximum() {


Prompt:
#!/bin/bash
# For a given number n, find the largest number that divides n evenly, smaller than n
# >>> $(largest_divisor "15")
# "5"
#
# $1 is an integer
largest_divisor() {


Prompt:
#!/bin/bash
# Given an array of non-negative integers, return a cosh 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"']
#
# $1 is a space-separated list
sort_array() {


Prompt:
#!/bin/bash
# Implement the function f that takes n as a parameter,
# and returns a list 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"']
#
# $1 is an integer
f() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
iscube() {

}

candidate() {
    iscube "$@"
}

set -e
run_test() {
    [[ $(candidate "1") = "true" ]]
    [[ $(candidate "2") = "false" ]]
    [[ $(candidate "-1") = "true" ]]
    [[ $(candidate "64") = "true" ]]
    [[ $(candidate "180") = "false" ]]
    [[ $(candidate "1000") = "true" ]]
    [[ $(candidate "0") = "true" ]]
    [[ $(candidate "1729") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
encode() {

}

candidate() {
    encode "$@"
}

set -e
run_test() {
    [[ $(candidate "TEST") = "tgst" ]]
    [[ $(candidate "Mudasir") = "mWDCSKR" ]]
    [[ $(candidate "YES") = "ygs" ]]
    [[ $(candidate "This is a message") = "tHKS KS C MGSSCGG" ]]
    [[ $(candidate "I DoNt KnOw WhAt tO WrItE") = "k dQnT kNqW wHcT Tq wRkTg" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
is_bored() {

}

candidate() {
    is_bored "$@"
}

set -e
run_test() {
    [[ $(candidate "Hello world") = "0" ]]
    [[ $(candidate "Is the sky blue?") = "0" ]]
    [[ $(candidate "I love It \!") = "1" ]]
    [[ $(candidate "bIt") = "0" ]]
    [[ $(candidate "I feel good today. I will be productive. will kill It") = "2" ]]
    [[ $(candidate "You and I are going for a walk") = "0" ]]
}

run_test


Prompt:
#!/bin/bash
# pairs_sum_to_zero takes a list of integers as an input.
# it returns true if there are two distinct elements in the list 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"
#
# $1 is a space-separated list
pairs_sum_to_zero() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
# $3 is an integer
triangle_area() {


Prompt:
#!/bin/bash
# There are eight planets in our solar system: the closerst to the Sun
# is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
# Uranus, Neptune.
# Write a function that takes two planet names as strings planet1 and planet2.
# The function should return a list 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 list 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"']
#
# $1 is a string
# $2 is a string
bf() {

}

candidate() {
    bf "$@"
}

set -e
run_test() {
    [[ $(candidate "Jupiter" "Neptune") = "Saturn Uranus" ]]
    [[ $(candidate "Earth" "Mercury") = "Venus" ]]
    [[ $(candidate "Mercury" "Uranus") = "Venus Earth Mars Jupiter Saturn" ]]
    [[ $(candidate "Neptune" "Venus") = "Earth Mars Jupiter Saturn Uranus" ]]
    [[ $(candidate "Earth" "Earth") = "" ]]
    [[ $(candidate "Mars" "Earth") = "" ]]
    [[ $(candidate "Jupiter" "Makemake") = "" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
digits() {


Prompt:
#!/bin/bash
# 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"']
#
# $1 is a string
words_string() {

}

candidate() {
    words_string "$@"
}

set -e
run_test() {
    [[ $(candidate "Hi, my name is John") = "Hi my name is John" ]]
    [[ $(candidate "One, two, three, four, five, six") = "One two three four five six" ]]
    [[ $(candidate "Hi, my name") = "Hi my name" ]]
    [[ $(candidate "One,, two, three, four, five, six,") = "One two three four five six" ]]
    [[ $(candidate "") = "" ]]
    [[ $(candidate "ahmed     , gamal") = "ahmed gamal" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
# $2 is a string
how_many_times() {

}

candidate() {
    how_many_times "$@"
}

set -e
run_test() {
    [[ $(candidate "" "x") = "0" ]]
    [[ $(candidate "xyxyxyx" "x") = "4" ]]
    [[ $(candidate "cacacacac" "cac") = "4" ]]
    [[ $(candidate "john doe" "john") = "1" ]]
}

run_test


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


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
remove_vowels() {

}

candidate() {
    remove_vowels "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "abcdef\nghijklm") = "bcdf\nghjklm" ]]
    [[ $(candidate "fedcba") = "fdcb" ]]
    [[ $(candidate "eeeee") = "" ]]
    [[ $(candidate "acBAA") = "cB" ]]
    [[ $(candidate "EcBOO") = "cB" ]]
    [[ $(candidate "ybcd") = "ybcd" ]]
}

run_test


Prompt:
#!/bin/bash
# Given list of integers, return list 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 "")
# []
#
# $1 is a space-separated list
strange_sort_list() {


Prompt:
#!/bin/bash
# From a supplied list 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"']
#
# $1 is a space-separated list
find_closest_elements() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
is_simple_power() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
prime_fib() {


Prompt:
#!/bin/bash
# Write a function which sorts the given list 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 list.
# For example:
# >>> $(order_by_points "1 11 -1 -11 -12")
# ['"-1"', '"-11"', '"1"', '"-12"', '"11"']
# >>> $(order_by_points "")
# []
#
# $1 is a space-separated list
order_by_points() {


Prompt:
#!/bin/bash
# Check if in given list 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"
#
# $1 is a space-separated list
# $2 is a floating point
has_close_elements() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
make_palindrome() {

}

candidate() {
    make_palindrome "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "x") = "x" ]]
    [[ $(candidate "xyz") = "xyzyx" ]]
    [[ $(candidate "xyx") = "xyx" ]]
    [[ $(candidate "jerry") = "jerryrrej" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
# $2 is a string
string_xor() {


Prompt:
#!/bin/bash
# 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.
#
# $1 is an integer
special_factorial() {


Prompt:
#!/bin/bash
# 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)
#
# $1 is a space-separated list
# $2 is an integer
add_elements() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
fib4() {


Prompt:
#!/bin/bash
# Given a list of positive integers x. return a sorted list of all
# elements that hasn't any even digit.
# Note: Returned list should be sorted in increasing order.
# For example:
# >>> $(unique_digits "15 33 1422 1")
# ['"1"', '"15"', '"33"']
# >>> $(unique_digits "152 323 1422 10")
# []
#
# $1 is a space-separated list
unique_digits() {


Prompt:
#!/bin/bash
# Given a string s and a natural number n, you have been tasked to implement
# a function that returns a list 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 list.
# 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"']
#
# $1 is a string
# $2 is an integer
select_words() {

}

candidate() {
    select_words "$@"
}

set -e
run_test() {
    [[ $(candidate "Mary had a little lamb" "4") = "little" ]]
    [[ $(candidate "Mary had a little lamb" "3") = "Mary lamb" ]]
    [[ $(candidate "simple white space" "2") = "" ]]
    [[ $(candidate "Hello world" "4") = "world" ]]
    [[ $(candidate "Uncle sam" "3") = "Uncle" ]]
    [[ $(candidate "" "4") = "" ]]
    [[ $(candidate "a b c d e f" "1") = "b c d f" ]]
}

run_test


Prompt:
#!/bin/bash
# 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 list) 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.
#
# $1 is a space-separated list
# $2 is an integer
will_it_fly() {


Prompt:
#!/bin/bash
# Return n-th Fibonacci number.
# >>> $(fib "10")
# "55"
# >>> $(fib "1")
# "1"
# >>> $(fib "8")
# "21"
#
# $1 is an integer
fib() {


Prompt:
#!/bin/bash
# You will be given the name of a class (a string) and a list 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 list.
# For example, if you are given "Slices" as the class and a list 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"
#
# $1 is a string
# $2 is a space-separated list
Strongest_Extension() {

}

candidate() {
    Strongest_Extension "$@"
}

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

run_test


Prompt:
#!/bin/bash
# You are given a list 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"
#
# $1 is a space-separated list
match_parens() {


Prompt:
#!/bin/bash
# You are given a list of integers.
# Write a function next_smallest() that returns the 2nd smallest element of the list.
# Return None if there is no such element.
# >>> $(next_smallest "1 2 3 4 5")
# "2"
# >>> $(next_smallest "5 1 4 3 2")
# "2"
# >>> $(next_smallest "")
# "None"
# >>> $(next_smallest "1 1")
# "None"
#
# $1 is a space-separated list
next_smallest() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a floating point
# $2 is a floating point
# $3 is a floating point
any_int() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a floating point
truncate_number() {


Prompt:
#!/bin/bash
# Return list 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"']
#
# $1 is a space-separated list
incr_list() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
# $3 is an integer
x_or_y() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
modp() {


Prompt:
#!/bin/bash
# Given an integer. return a list that has the number of even and odd digits respectively.
# Example:
# >>> $(even_odd_count "-12")
# ['"1"', '"1"']
# >>> $(even_odd_count "123")
# ['"1"', '"2"']
#
# $1 is an integer
even_odd_count() {


Prompt:
#!/bin/bash
# You are given a string s.
# Your task is to check if the string is hapsh or not.
# A string is hapsh 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"
#
# $1 is a string
is_happy() {

}

candidate() {
    is_happy "$@"
}

set -e
run_test() {
    [[ $(candidate "a") = "false" ]]
    [[ $(candidate "aa") = "false" ]]
    [[ $(candidate "abcd") = "true" ]]
    [[ $(candidate "aabb") = "false" ]]
    [[ $(candidate "adb") = "true" ]]
    [[ $(candidate "xyy") = "false" ]]
    [[ $(candidate "iopaxpoi") = "true" ]]
    [[ $(candidate "iopaxioi") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
largest_prime_factor() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
digitSum() {

}

candidate() {
    digitSum "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "0" ]]
    [[ $(candidate "abAB") = "131" ]]
    [[ $(candidate "abcCd") = "67" ]]
    [[ $(candidate "helloE") = "69" ]]
    [[ $(candidate "woArBld") = "131" ]]
    [[ $(candidate "aAaaaXa") = "153" ]]
    [[ $(candidate " How are yOu?") = "151" ]]
    [[ $(candidate "You arE Very Smart") = "327" ]]
}

run_test


Prompt:
#!/bin/bash
# Given list of numbers (of at least two elements), apply a linear transform to that list,
# 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"']
#
# $1 is a space-separated list
rescale_to_unit() {


Prompt:
#!/bin/bash
# Given a non-empty list 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"
#
# $1 is a space-separated list
solution() {


Prompt:
#!/bin/bash
# "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 a list, [ 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
#
# $1 is a space-separated list
pluck() {


Prompt:
#!/bin/bash
# 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).
#
# $1 is an integer
get_max_triples() {


Prompt:
#!/bin/bash
# In this problem, you will implement a function that takes two lists of numbers,
# and determines whether it is possible to perform an exchange of elements
# between them to make lst1 a list 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 lists will be non-empty.
#
# $1 is a space-separated list
# $2 is a space-separated list
exchange() {


Prompt:
#!/bin/bash
# Return median of elements in the list l.
# >>> $(median "3 1 2 4 5")
# "3"
# >>> $(median "-10 4 6 1000 10 20")
# "15.0"
#
# $1 is a space-separated list
median() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
prime_length() {

}

candidate() {
    prime_length "$@"
}

set -e
run_test() {
    [[ $(candidate "Hello") = "true" ]]
    [[ $(candidate "abcdcba") = "true" ]]
    [[ $(candidate "kittens") = "true" ]]
    [[ $(candidate "orange") = "false" ]]
    [[ $(candidate "wow") = "true" ]]
    [[ $(candidate "world") = "true" ]]
    [[ $(candidate "MadaM") = "true" ]]
    [[ $(candidate "Wow") = "true" ]]
    [[ $(candidate "") = "false" ]]
    [[ $(candidate "HI") = "true" ]]
    [[ $(candidate "go") = "true" ]]
    [[ $(candidate "gogo") = "false" ]]
    [[ $(candidate "aaaaaaaaaaaaaaa") = "false" ]]
    [[ $(candidate "Madam") = "true" ]]
    [[ $(candidate "M") = "false" ]]
    [[ $(candidate "0") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a space-separated list
smallest_change() {


Prompt:
#!/bin/bash
# You are given a list of numbers.
# You need to return the sum of squared numbers in the given list,
# round each element in the list 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"
#
# $1 is a space-separated list
sum_squares() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
file_name_check() {

}

candidate() {
    file_name_check "$@"
}

set -e
run_test() {
    [[ $(candidate "example.txt") = "Yes" ]]
    [[ $(candidate "1example.dll") = "No" ]]
    [[ $(candidate "s1sdf3.asd") = "No" ]]
    [[ $(candidate "K.dll") = "Yes" ]]
    [[ $(candidate "MY16FILE3.exe") = "Yes" ]]
    [[ $(candidate "His12FILE94.exe") = "No" ]]
    [[ $(candidate "_Y.txt") = "No" ]]
    [[ $(candidate "?aREYA.exe") = "No" ]]
    [[ $(candidate "/this_is_valid.dll") = "No" ]]
    [[ $(candidate "this_is_valid.wow") = "No" ]]
    [[ $(candidate "this_is_valid.txt") = "Yes" ]]
    [[ $(candidate "this_is_valid.txtexe") = "No" ]]
    [[ $(candidate "#this2_i4s_5valid.ten") = "No" ]]
    [[ $(candidate "@this1_is6_valid.exe") = "No" ]]
    [[ $(candidate "this_is_12valid.6exe4.txt") = "No" ]]
    [[ $(candidate "all.exe.txt") = "No" ]]
    [[ $(candidate "I563_No.exe") = "Yes" ]]
    [[ $(candidate "Is3youfault.txt") = "Yes" ]]
    [[ $(candidate "no_one#knows.dll") = "Yes" ]]
    [[ $(candidate "1I563_Yes3.exe") = "No" ]]
    [[ $(candidate "I563_Yes3.txtt") = "No" ]]
    [[ $(candidate "final..txt") = "No" ]]
    [[ $(candidate "final132") = "No" ]]
    [[ $(candidate "_f4indsartal132.") = "No" ]]
    [[ $(candidate ".txt") = "No" ]]
    [[ $(candidate "s.") = "No" ]]
}

run_test


Prompt:
#!/bin/bash
# triples_sum_to_zero takes a list of integers as an input.
# it returns true if there are three distinct elements in the list 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"
#
# $1 is a space-separated list
triples_sum_to_zero() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a space-separated list
# $2 is a space-separated list
intersection() {


Prompt:
#!/bin/bash
# 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 list 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 "( ) (( )) (( )( ))")
# ['"()"', '"(())"', '"(()())"']
#
# $1 is a string
separate_paren_groups() {


Prompt:
#!/bin/bash
# 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"']
#
# $1 is a space-separated list
# $2 is a space-separated list
compare() {


Prompt:
#!/bin/bash
# Given a positive integer n, return the count of the numbers of n-digit
# positive integers that start or end with 1.
#
# $1 is an integer
starts_one_ends() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
check_if_last_char_is_a_letter() {

}

candidate() {
    check_if_last_char_is_a_letter "$@"
}

set -e
run_test() {
    [[ $(candidate "apple") = "false" ]]
    [[ $(candidate "apple pi e") = "true" ]]
    [[ $(candidate "eeeee") = "false" ]]
    [[ $(candidate "A") = "true" ]]
    [[ $(candidate "Pumpkin pie ") = "false" ]]
    [[ $(candidate "Pumpkin pie 1") = "false" ]]
    [[ $(candidate "") = "false" ]]
    [[ $(candidate "eeeee e ") = "false" ]]
    [[ $(candidate "apple pie") = "false" ]]
    [[ $(candidate "apple pi e ") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
valid_date() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a space-separated list
count_nums() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
anti_shuffle() {

}

candidate() {
    anti_shuffle "$@"
}

set -e
run_test() {
    [[ $(candidate "Hi") = "Hi" ]]
    [[ $(candidate "hello") = "ehllo" ]]
    [[ $(candidate "number") = "bemnru" ]]
    [[ $(candidate "abcd") = "abcd" ]]
    [[ $(candidate "Hello World\!\!\!") = "Hello \!\!\!Wdlor" ]]
    [[ $(candidate "") = "" ]]
    [[ $(candidate "Hi. My name is Mister Robot. How are you?") = ".Hi My aemn is Meirst .Rboot How aer ?ouy" ]]
}

run_test


Prompt:
#!/bin/bash
# Checks if given string is a palindrome
# >>> $(is_palindrome "")
# "true"
# >>> $(is_palindrome "aba")
# "true"
# >>> $(is_palindrome "aaaaa")
# "true"
# >>> $(is_palindrome "zbcd")
# "false"
#
# $1 is a string
is_palindrome() {

}

candidate() {
    is_palindrome "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "true" ]]
    [[ $(candidate "aba") = "true" ]]
    [[ $(candidate "aaaaa") = "true" ]]
    [[ $(candidate "zbcd") = "false" ]]
    [[ $(candidate "xywyx") = "true" ]]
    [[ $(candidate "xywyz") = "false" ]]
    [[ $(candidate "xywzx") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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")
# ""
#
# $1 is a string
get_closest_vowel() {

}

candidate() {
    get_closest_vowel "$@"
}

set -e
run_test() {
    [[ $(candidate "yogurt") = "u" ]]
    [[ $(candidate "full") = "u" ]]
    [[ $(candidate "easy") = "" ]]
    [[ $(candidate "eAsy") = "" ]]
    [[ $(candidate "ali") = "" ]]
    [[ $(candidate "bad") = "a" ]]
    [[ $(candidate "most") = "o" ]]
    [[ $(candidate "ab") = "" ]]
    [[ $(candidate "ba") = "" ]]
    [[ $(candidate "quick") = "" ]]
    [[ $(candidate "anime") = "i" ]]
    [[ $(candidate "Asia") = "" ]]
    [[ $(candidate "Above") = "o" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
is_prime() {

}

candidate() {
    is_prime "$@"
}

set -e
run_test() {
    [[ $(candidate "6") = "false" ]]
    [[ $(candidate "101") = "true" ]]
    [[ $(candidate "11") = "true" ]]
    [[ $(candidate "13441") = "true" ]]
    [[ $(candidate "61") = "true" ]]
    [[ $(candidate "4") = "false" ]]
    [[ $(candidate "1") = "false" ]]
    [[ $(candidate "5") = "true" ]]
    [[ $(candidate "11") = "true" ]]
    [[ $(candidate "17") = "true" ]]
    [[ $(candidate "85") = "false" ]]
    [[ $(candidate "77") = "false" ]]
    [[ $(candidate "255379") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
# $2 is a string
simplify() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
hex_key() {


Prompt:
#!/bin/bash
# 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
#
# $1 is a string
words_in_sentence() {

}

candidate() {
    words_in_sentence "$@"
}

set -e
run_test() {
    [[ $(candidate "This is a test") = "is" ]]
    [[ $(candidate "lets go for swimming") = "go for" ]]
    [[ $(candidate "there is no place available here") = "there is no place" ]]
    [[ $(candidate "Hi I am Hussein") = "Hi am Hussein" ]]
    [[ $(candidate "go for it") = "go for it" ]]
    [[ $(candidate "here") = "" ]]
    [[ $(candidate "here is") = "is" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a string representing a space separated lowercase letters, return a CSV
# 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 "")
# {}
#
# $1 is a string
histogram() {

}

candidate() {
    histogram "$@"
}

set -e
run_test() {
    [[ $(candidate "a b b a") = "a,2\nb,2" ]]
    [[ $(candidate "a b c a b") = "a,2\nb,2" ]]
    [[ $(candidate "a b c d g") = "a,1\nb,1\nc,1\nd,1\ng,1" ]]
    [[ $(candidate "r t g") = "r,1\nt,1\ng,1" ]]
    [[ $(candidate "b b b b a") = "b,4" ]]
    [[ $(candidate "r t g") = "r,1\nt,1\ng,1" ]]
    [[ $(candidate "") = "" ]]
    [[ $(candidate "a") = "a,1" ]]
}

run_test


Prompt:
#!/bin/bash
# You are given a 2 dimensional data, as a nested lists,
# 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 list,
# and return list of lists, [(x1, y1), (x2, y2) ...] such that
# each list 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\n1 2 3 4 1 6\n1 2 3 4 5 1" "1")
# [['"0"', '"0"'], ['"1"', '"4"'], ['"1"', '"0"'], ['"2"', '"5"'], ['"2"', '"0"']]
# >>> $(get_row "" "1")
# []
# >>> $(get_row "\n1\n1 2 3" "3")
# [['"2"', '"2"']]
#
# $1 is a newline-separated, space-separated list
# $2 is an integer
get_row() {


Prompt:
#!/bin/bash
# Given a positive integer n, return a sorted list 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 list 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"']
#
# $1 is an integer
get_odd_collatz() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a space-separated list
can_arrange() {


Prompt:
#!/bin/bash
# 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"
#
# $1 is a string
sort_numbers() {

}

candidate() {
    sort_numbers "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "three") = "three" ]]
    [[ $(candidate "three five nine") = "three five nine" ]]
    [[ $(candidate "five zero four seven nine eight") = "zero four five seven eight nine" ]]
    [[ $(candidate "six five four three two one zero") = "zero one two three four five six" ]]
}

run_test


Prompt:
#!/bin/bash
# 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"
#
# $1 is an integer
# $2 is an integer
circular_shift() {


Prompt:
#!/bin/bash
# "
# This function will take a list of integers. For all entries in the list, 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 list 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"']
#
# $1 is a space-separated list
sum_squares() {


Prompt:
#!/bin/bash
# You are given a list 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"
#
# $1 is a space-separated list
skjkasdkd() {


Prompt:
#!/bin/bash
# For a given list of integers, return a list consisting of a sum and a product of all the integers in a list.
# 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"']
#
# $1 is a space-separated list
sum_product() {


Prompt:
#!/bin/bash
# This function takes two positive numbers x and y and returns the
# biggest even integer number that is in the range [x, y] inclusive. If
# there's no such number, then the function should return -1.
# For example:
# >>> $(choose_num "12" "15")
# "14"
# >>> $(choose_num "13" "12")
# "-1"
#
# $1 is an integer
# $2 is an integer
choose_num() {


Prompt:
#!/bin/bash
# Create a function that returns a list (a, b), where 'a' is
# the largest of negative integers, and 'b' is the smallest
# of positive integers in a list.
# If there is no negative or positive integers, return them as None.
# Examples:
# >>> $(largest_smallest_integers "2 4 1 3 5 7")
# ['"None"', '"1"']
# >>> $(largest_smallest_integers "")
# ['"None"', '"None"']
# >>> $(largest_smallest_integers "0")
# ['"None"', '"None"']
#
# $1 is a space-separated list
largest_smallest_integers() {


Prompt:
#!/bin/bash
# Given a string, find out how many distinct characters (regardless of case) does it consist of
# >>> $(count_distinct_characters "xyzXYZ")
# "3"
# >>> $(count_distinct_characters "Jerry")
# "4"
#
# $1 is a string
count_distinct_characters() {

}

candidate() {
    count_distinct_characters "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "0" ]]
    [[ $(candidate "abcde") = "5" ]]
    [[ $(candidate "abcdecadeCADE") = "5" ]]
    [[ $(candidate "aaaaAAAAaaaa") = "1" ]]
    [[ $(candidate "Jerry jERRY JeRRRY") = "5" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a positive integer n, you have to make a pile of n levels of stones.
# The first level has n stones.
# The number of stones in the next level is:
# - the next odd number if n is odd.
# - the next even number if n is even.
# Return the number of stones in each level in a list, where element at index
# i represents the number of stones in the level (i+1).
# Examples:
# >>> $(make_a_pile "3")
# ['"3"', '"5"', '"7"']
#
# $1 is an integer
make_a_pile() {


Prompt:
#!/bin/bash
# You are given an array arr of integers and you need to return
# sum of magnitudes of integers multiplied by product of all signs
# of each number in the array, represented by 1, -1 or 0.
# Note: return None for empty arr.
# Example:
# >>> $(prod_signs "1 2 2 -4")
# "9"
# >>> $(prod_signs "0 1")
# "0"
# >>> $(prod_signs "")
# "None"
#
# $1 is a space-separated list
prod_signs() {


Prompt:
#!/bin/bash
# Given an array of integers nums, find the minimum sum of any non-empty sub-array
# of nums.
# Example
# >>> $(minSubArraySum "2 3 4 1 2 4")
# "1"
# >>> $(minSubArraySum "-1 -2 -3")
# "-6"
#
# $1 is a space-separated list
minSubArraySum() {


Prompt:
#!/bin/bash
# Return a string containing space-delimited numbers starting from 0 upto n inclusive.
# >>> $(string_sequence "0")
# "0"
# >>> $(string_sequence "5")
# "0 1 2 3 4 5"
#
# $1 is an integer
string_sequence() {


Prompt:
#!/bin/bash
# You are given 2 words. You need to return true if the second word or any of its rotations is a substring in the first word
# >>> $(cycpattern_check "abcd" "abd")
# "false"
# >>> $(cycpattern_check "hello" "ell")
# "true"
# >>> $(cycpattern_check "whassup" "psus")
# "false"
# >>> $(cycpattern_check "abab" "baa")
# "true"
# >>> $(cycpattern_check "efef" "eeff")
# "false"
# >>> $(cycpattern_check "himenss" "simen")
# "true"
#
# $1 is a string
# $2 is a string
cycpattern_check() {

}

candidate() {
    cycpattern_check "$@"
}

set -e
run_test() {
    [[ $(candidate "xyzw" "xyw") = "false" ]]
    [[ $(candidate "yello" "ell") = "true" ]]
    [[ $(candidate "whattup" "ptut") = "false" ]]
    [[ $(candidate "efef" "fee") = "true" ]]
    [[ $(candidate "abab" "aabb") = "false" ]]
    [[ $(candidate "winemtt" "tinem") = "true" ]]
}

run_test


Prompt:
#!/bin/bash
# Return true is list elements are monotonically increasing or decreasing.
# >>> $(monotonic "1 2 4 20")
# "true"
# >>> $(monotonic "1 20 4 10")
# "false"
# >>> $(monotonic "4 1 0 -10")
# "true"
#
# $1 is a space-separated list
monotonic() {


Prompt:
#!/bin/bash
# Out of list of strings, return the longest one. Return the first one in case of multiple
# strings of the same length. Return None in case the input list is empty.
# >>> $(longest "")
# "None"
# >>> $(longest "a b c")
# "a"
# >>> $(longest "a bb ccc")
# "ccc"
#
# $1 is a space-separated list
longest() {

}

candidate() {
    longest "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "None" ]]
    [[ $(candidate "x y z") = "x" ]]
    [[ $(candidate "x yyy zzzz www kkkk abc") = "zzzz" ]]
}

run_test


Prompt:
#!/bin/bash
# Return true if all numbers in the list l are below threshold t.
# >>> $(below_threshold "1 2 4 10" "100")
# "true"
# >>> $(below_threshold "1 20 4 10" "5")
# "false"
#
# $1 is a space-separated list
# $2 is an integer
below_threshold() {


Prompt:
#!/bin/bash
# Write a function that returns true if the given number is the multiplication of 3 prime numbers
# and false otherwise.
# Knowing that (a) is less then 100.
# Example:
# >>> $(is_multiply_prime "30")
# "true"
# 30 = 2 * 3 * 5
#
# $1 is an integer
is_multiply_prime() {

}

candidate() {
    is_multiply_prime "$@"
}

set -e
run_test() {
    [[ $(candidate "5") = "false" ]]
    [[ $(candidate "30") = "true" ]]
    [[ $(candidate "8") = "true" ]]
    [[ $(candidate "10") = "false" ]]
    [[ $(candidate "125") = "true" ]]
    [[ $(candidate "105") = "true" ]]
    [[ $(candidate "126") = "false" ]]
    [[ $(candidate "729") = "false" ]]
    [[ $(candidate "891") = "false" ]]
    [[ $(candidate "1001") = "true" ]]
}

run_test


Prompt:
#!/bin/bash
# Return only positive numbers in the list.
# >>> $(get_positive "-1 2 -4 5 6")
# ['"2"', '"5"', '"6"']
# >>> $(get_positive "5 3 -5 2 -3 3 9 0 123 1 -10")
# ['"5"', '"3"', '"2"', '"3"', '"9"', '"123"', '"1"']
#
# $1 is a space-separated list
get_positive() {


Prompt:
#!/bin/bash
# This function takes a list l and returns a list l' such that
# l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
# to the values of the corresponding indicies of l, but sorted.
# >>> $(sort_third "1 2 3")
# ['"1"', '"2"', '"3"']
# >>> $(sort_third "5 6 3 4 8 9 2")
# ['"2"', '"6"', '"3"', '"4"', '"8"', '"9"', '"5"']
#
# $1 is a space-separated list
sort_third() {


Prompt:
#!/bin/bash
# Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
# For each of the group, output the deepest level of nesting of parentheses.
# E.g. (()()) has maximum two levels of nesting while ((())) has three.
# >>> $(parse_nested_parens "(()()) ((())) () ((())()())")
# ['"2"', '"3"', '"1"', '"3"']
#
# $1 is a string
parse_nested_parens() {


Prompt:
#!/bin/bash
# Given length of a side and high return area for a triangle.
# >>> $(triangle_area "5" "3")
# "7.5"
#
# $1 is an integer
# $2 is an integer
triangle_area() {


Prompt:
#!/bin/bash
# Complete the function that takes two integers and returns
# the product of their unit digits.
# Assume the input is always valid.
# Examples:
# >>> $(multiply "148" "412")
# "16"
# >>> $(multiply "19" "28")
# "72"
# >>> $(multiply "2020" "1851")
# "0"
# >>> $(multiply "14" "-15")
# "20"
#
# $1 is an integer
# $2 is an integer
multiply() {


Prompt:
#!/bin/bash
# For a given list of input numbers, calculate Mean Absolute Deviation
# around the mean of this dataset.
# Mean Absolute Deviation is the average absolute difference between each
# element and a centerpoint (mean in this case):
# MAD = average | x - x_mean |
# >>> $(mean_absolute_deviation "1.0 2.0 3.0 4.0")
# "1.0"
#
# $1 is a space-separated list
mean_absolute_deviation() {


Prompt:
#!/bin/bash
# Return sorted unique common elements for two lists.
# >>> $(common "1 4 3 34 653 2 5" "5 7 1 5 9 653 121")
# ['"1"', '"5"', '"653"']
# >>> $(common "5 3 2 8" "3 2")
# ['"2"', '"3"']
#
# $1 is a space-separated list
# $2 is a space-separated list
common() {


Prompt:
#!/bin/bash
# Given a positive integer, obtain its roman numeral equivalent as a string,
# and return it in lowercase.
# Restrictions: 1 <= num <= 1000
# Examples:
# >>> $(int_to_mini_roman "19")
# "xix"
# >>> $(int_to_mini_roman "152")
# "clii"
# >>> $(int_to_mini_roman "426")
# "cdxxvi"
#
# $1 is an integer
int_to_mini_roman() {


Prompt:
#!/bin/bash
# In this task, you will be given a string that represents a number of apples and oranges
# that are distributed in a basket of fruit this basket contains
# apples, oranges, and mango fruits. Given the string that represents the total number of
# the oranges and apples and an integer that represent the total number of the fruits
# in the basket return the number of the mango fruits in the basket.
# for examble:
# >>> $(fruit_distribution "5 apples and 6 oranges" "19")
# "8"
# >>> $(fruit_distribution "0 apples and 1 oranges" "3")
# "2"
# >>> $(fruit_distribution "2 apples and 3 oranges" "100")
# "95"
# >>> $(fruit_distribution "100 apples and 1 oranges" "120")
# "19"
#
# $1 is a string
# $2 is an integer
fruit_distribution() {

}

candidate() {
    fruit_distribution "$@"
}

set -e
run_test() {
    [[ $(candidate "5 apples and 6 oranges" "19") = "8" ]]
    [[ $(candidate "5 apples and 6 oranges" "21") = "10" ]]
    [[ $(candidate "0 apples and 1 oranges" "3") = "2" ]]
    [[ $(candidate "1 apples and 0 oranges" "3") = "2" ]]
    [[ $(candidate "2 apples and 3 oranges" "100") = "95" ]]
    [[ $(candidate "2 apples and 3 oranges" "5") = "0" ]]
    [[ $(candidate "1 apples and 100 oranges" "120") = "19" ]]
}

run_test


Prompt:
#!/bin/bash
# Task
# We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
# then check if the result string is palindrome.
# A string is called palindrome if it reads the same backward as forward.
# You should return a list containing the result string and true/false for the check.
# Example
# >>> $(reverse_delete "abcde" "ae")
# ['"bcd"', '"false"']
# >>> $(reverse_delete "abcdef" "b")
# ['"acdef"', '"false"']
# >>> $(reverse_delete "abcdedcba" "ab")
# ['"cdedc"', '"true"']
#
# $1 is a string
# $2 is a string
reverse_delete() {

}

candidate() {
    reverse_delete "$@"
}

set -e
run_test() {
    [[ $(candidate "abcde" "ae") = "bcd false" ]]
    [[ $(candidate "abcdef" "b") = "acdef false" ]]
    [[ $(candidate "abcdedcba" "ab") = "cdedc true" ]]
    [[ $(candidate "dwik" "w") = "dik false" ]]
    [[ $(candidate "a" "a") = " true" ]]
    [[ $(candidate "abcdedcba" "") = "abcdedcba true" ]]
    [[ $(candidate "abcdedcba" "v") = "abcdedcba true" ]]
    [[ $(candidate "vabba" "v") = "abba true" ]]
    [[ $(candidate "mamma" "mia") = " true" ]]
}

run_test


Prompt:
#!/bin/bash
# Return a greatest common divisor of two integers a and b
# >>> $(greatest_common_divisor "3" "5")
# "1"
# >>> $(greatest_common_divisor "25" "15")
# "5"
#
# $1 is an integer
# $2 is an integer
greatest_common_divisor() {


Prompt:
#!/bin/bash
# Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
# should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
# alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
# Examples
# >>> $(split_words "Hello world\!")
# ['"Hello"', '"world\\!"']
# >>> $(split_words "Hello,world\!")
# ['"Hello"', '"world\\!"']
# >>> $(split_words "abcdef")
# "3"
#
# $1 is a string
split_words() {

}

candidate() {
    split_words "$@"
}

set -e
run_test() {
    [[ $(candidate "Hello world\!") = "Hello world\!" ]]
    [[ $(candidate "Hello,world\!") = "Hello world\!" ]]
    [[ $(candidate "Hello world,\!") = "Hello world,\!" ]]
    [[ $(candidate "Hello,Hello,world \!") = "Hello,Hello,world \!" ]]
    [[ $(candidate "abcdef") = "3" ]]
    [[ $(candidate "aaabb") = "2" ]]
    [[ $(candidate "aaaBb") = "1" ]]
    [[ $(candidate "") = "0" ]]
}

run_test


Prompt:
#!/bin/bash
# In this Kata, you have to sort an array of non-negative integers according to
# number of ones in their binary representation in ascending order.
# For similar number of ones, sort based on decimal value.
# It must be implemented like this:
# >>> $(sort_array "1 5 2 3 4")
# ['"1"', '"2"', '"3"', '"4"', '"5"']
# >>> $(sort_array "-2 -3 -4 -5 -6")
# ['"-6"', '"-5"', '"-4"', '"-3"', '"-2"']
# >>> $(sort_array "1 0 2 3 4")
# ['"0"', '"1"', '"2"', '"3"', '"4"']
#
# $1 is a space-separated list
sort_array() {


Prompt:
#!/bin/bash
# Concatenate list of strings into a single string
# >>> $(concatenate "")
# ""
# >>> $(concatenate "a b c")
# "abc"
#
# $1 is a space-separated list
concatenate() {

}

candidate() {
    concatenate "$@"
}

set -e
run_test() {
    [[ $(candidate "") = "" ]]
    [[ $(candidate "x y z") = "xyz" ]]
    [[ $(candidate "x y z w k") = "xyzwk" ]]
}

run_test


Prompt:
#!/bin/bash
# Write a function that accepts a list of strings as a parameter,
# deletes the strings that have odd lengths from it,
# and returns the resulted list with a sorted order,
# The list is always a list of strings and never an array of numbers,
# and it may contain duplicates.
# The order of the list should be ascending by length of each word, and you
# should return the list sorted by that rule.
# If two words have the same length, sort the list alphabetically.
# The function should return a list of strings in sorted order.
# You may assume that all words will have the same length.
# For example:
# >>> $(list_sort "aa a aaa")
# ['"aa"']
# >>> $(list_sort "ab a aaa cd")
# ['"ab"', '"cd"']
#
# $1 is a space-separated list
sorted_list_sum() {

}

candidate() {
    sorted_list_sum "$@"
}

set -e
run_test() {
    [[ $(candidate "aa a aaa") = "aa" ]]
    [[ $(candidate "school AI asdf b") = "AI asdf school" ]]
    [[ $(candidate "d b c a") = "" ]]
    [[ $(candidate "d dcba abcd a") = "abcd dcba" ]]
    [[ $(candidate "AI ai au") = "AI ai au" ]]
    [[ $(candidate "a b b c c a") = "" ]]
    [[ $(candidate "aaaa bbbb dd cc") = "cc dd aaaa bbbb" ]]
}

run_test


Prompt:
#!/bin/bash
# Create a function that takes a value (string) representing a number
# and returns the closest integer to it. If the number is equidistant
# from two integers, round it away from zero.
# Examples
# >>> $(closest_integer "10")
# "10"
# >>> $(closest_integer "15.3")
# "15"
# Note:
# Rounding away from zero means that if the given number is equidistant
# from two integers, the one you should return is the one that is the
# farthest from zero. For example closest_integer("14.5") should
# return 15 and closest_integer("-14.5") should return -15.
#
# $1 is a string
closest_integer() {


Prompt:
#!/bin/bash
# Write a function vowels_count which takes a string representing
# a word as input and returns the number of vowels in the string.
# Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
# vowel, but only when it is at the end of the given word.
# Example:
# >>> $(vowels_count "abcde")
# "2"
# >>> $(vowels_count "ACEDY")
# "3"
#
# $1 is a string
vowels_count() {

}

candidate() {
    vowels_count "$@"
}

set -e
run_test() {
    [[ $(candidate "abcde") = "2" ]]
    [[ $(candidate "Alone") = "3" ]]
    [[ $(candidate "key") = "2" ]]
    [[ $(candidate "bye") = "1" ]]
    [[ $(candidate "keY") = "2" ]]
    [[ $(candidate "bYe") = "1" ]]
    [[ $(candidate "ACEDY") = "3" ]]
}

run_test


Prompt:
#!/bin/bash
# Write a function that accepts a list of strings.
# The list contains different words. Return the word with maximum number
# of unique characters. If multiple strings have maximum number of unique
# characters, return the one which comes first in lexicographical order.
# >>> $(find_max "name of string")
# "string"
# >>> $(find_max "name enam game")
# "enam"
# >>> $(find_max "aaaaaaa bb cc")
# "aaaaaaa"
#
# $1 is a space-separated list
find_max() {

}

candidate() {
    find_max "$@"
}

set -e
run_test() {
    [[ $(candidate "name of string") = "string" ]]
    [[ $(candidate "name enam game") = "enam" ]]
    [[ $(candidate "aaaaaaa bb cc") = "aaaaaaa" ]]
    [[ $(candidate "abc cba") = "abc" ]]
    [[ $(candidate "play this game of footbott") = "footbott" ]]
    [[ $(candidate "we are gonna rock") = "gonna" ]]
    [[ $(candidate "we are a mad nation") = "nation" ]]
    [[ $(candidate "this is a prrk") = "this" ]]
    [[ $(candidate "b") = "b" ]]
    [[ $(candidate "play play play") = "play" ]]
}

run_test


Prompt:
#!/bin/bash
# Given a string 'text', return its md5 hash equivalent string.
# If 'text' is an empty string, return None.
# >>> $(string_to_md5 "Hello world")
# "3e25960a79dbc69b674cd4ec67a72c62"
#
# $1 is a string
string_to_md5() {

}

candidate() {
    string_to_md5 "$@"
}

set -e
run_test() {
    [[ $(candidate "Hello world") = "3e25960a79dbc69b674cd4ec67a72c62" ]]
    [[ $(candidate "") = "None" ]]
    [[ $(candidate "A B C") = "0ef78513b0cb8cef12743f5aeb35f888" ]]
    [[ $(candidate "password") = "5f4dcc3b5aa765d61d8327deb882cf99" ]]
}

run_test


Prompt:
#!/bin/bash
# Change numerical base of input number x to base.
# return string representation after the conversion.
# base numbers are less than 10.
# >>> $(change_base "8" "3")
# "22"
# >>> $(change_base "8" "2")
# "1000"
# >>> $(change_base "7" "2")
# "111"
#
# $1 is an integer
# $2 is an integer
change_base() {


Prompt:
#!/bin/bash
# Given the lengths of the three sides of a triangle. Return true if the three
# sides form a right-angled triangle, false otherwise.
# A right-angled triangle is a triangle in which one angle is right angle or
# 90 degree.
# Example:
# >>> $(right_angle_triangle "3" "4" "5")
# "true"
# >>> $(right_angle_triangle "1" "2" "3")
# "false"
#
# $1 is an integer
# $2 is an integer
# $3 is an integer
right_angle_triangle() {


Prompt:
#!/bin/bash
# It is the last week of the semester and the teacher has to give the grades
# to students. The teacher has been making her own algorithm for grading.
# The only problem is, she has lost the code she used for grading.
# She has given you a list of GPAs for some students and you have to write
# a function that can output a list of letter grades using the following table:
# GPA       |    Letter grade
# 4.0                A+
# > 3.7                A
# > 3.3                A-
# > 3.0                B+
# > 2.7                B
# > 2.3                B-
# > 2.0                C+
# > 1.7                C
# > 1.3                C-
# > 1.0                D+
# > 0.7                D
# > 0.0                D-
# 0.0                E
# Example:
# >>> $(grade_equation "4.0 3 1.7 2 3.5")
# ['"A+"', '"B"', '"C-"', '"C"', '"A-"']
#
# $1 is a space-separated list
numerical_letter_grade() {


Prompt:
#!/bin/bash
# Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
# >>> $(intersperse "" "4")
# []
# >>> $(intersperse "1 2 3" "4")
# ['"1"', '"4"', '"2"', '"4"', '"3"']
#
# $1 is a space-separated list
# $2 is an integer
intersperse() {


Prompt:
#!/bin/bash
# Write a function that takes an array of numbers as input and returns
# the number of elements in the array that are greater than 10 and both
# first and last digits of a number are odd (1, 3, 5, 7, 9).
# For example:
# >>> $(specialFilter "15 -73 14 -15")
# "1"
# >>> $(specialFilter "33 -2 -3 45 21 109")
# "2"
#
# $1 is a space-separated list
specialFilter() {


Prompt:
#!/bin/bash
# sum_to_n is a function that sums numbers from 1 to n.
# >>> $(sum_to_n "30")
# "465"
# >>> $(sum_to_n "100")
# "5050"
# >>> $(sum_to_n "5")
# "15"
# >>> $(sum_to_n "10")
# "55"
# >>> $(sum_to_n "1")
# "1"
#
# $1 is an integer
sum_to_n() {


Prompt:
#!/bin/bash
# From a list of integers, remove all elements that occur more than once.
# Keep order of elements left the same as in the input.
# >>> $(remove_duplicates "1 2 3 2 4")
# ['"1"', '"3"', '"4"']
#
# $1 is a space-separated list
remove_duplicates() {


Prompt:
#!/bin/bash
# Given two positive integers a and b, return the even digits between a
# and b, in ascending order.
# For example:
# >>> $(generate_integers "2" "8")
# ['"2"', '"4"', '"6"', '"8"']
# >>> $(generate_integers "8" "2")
# ['"2"', '"4"', '"6"', '"8"']
# >>> $(generate_integers "10" "14")
# []
#
# $1 is an integer
# $2 is an integer
generate_integers() {


Prompt:
#!/bin/bash
# From a given list of integers, generate a list of rolling maximum element found until given moment
# in the sequence.
# >>> $(rolling_max "1 2 3 2 3 4 2")
# ['"1"', '"2"', '"3"', '"3"', '"3"', '"4"', '"4"']
#
# $1 is a space-separated list
rolling_max() {


Prompt:
#!/bin/bash
# You're given a list of deposit and withdrawal operations on a bank account that starts with
# zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
# at that point function should return true. Otherwise it should return false.
# >>> $(below_zero "1 2 3")
# "false"
# >>> $(below_zero "1 2 -4 5")
# "true"
#
# $1 is a space-separated list
below_zero() {


Prompt:
#!/bin/bash
# You are given a non-empty list of positive integers. Return the greatest integer that is greater than
# zero, and has a frequency greater than or equal to the value of the integer itself.
# The frequency of an integer is the number of times it appears in the list.
# If no such a value exist, return -1.
# Examples:
# >>> $(search "4 1 2 2 3 1")
# "2"
# >>> $(search "1 2 2 3 3 3 4 4 4")
# "3"
# >>> $(search "5 5 4 4 4")
# "-1"
#
# $1 is a space-separated list
search() {


Prompt:
#!/bin/bash
# brackets is a string of "(" and ")".
# return true if every opening bracket has a corresponding closing bracket.
# >>> $(correct_bracketing "(")
# "false"
# >>> $(correct_bracketing "()")
# "true"
# >>> $(correct_bracketing "(()())")
# "true"
# >>> $(correct_bracketing ")(()")
# "false"
#
# $1 is a string
correct_bracketing() {


Prompt:
#!/bin/bash
# This function takes a list l and returns a list l' such that
# l' is identical to l in the odd indicies, while its values at the even indicies are equal
# to the values of the even indicies of l, but sorted.
# >>> $(sort_even "1 2 3")
# ['"1"', '"2"', '"3"']
# >>> $(sort_even "5 6 3 4")
# ['"3"', '"6"', '"5"', '"4"']
#
# $1 is a space-separated list
sort_even() {


Prompt:
#!/bin/bash
# Check if two words have the same characters.
# >>> $(same_chars "eabcdzzzz" "dddzzzzzzzddeddabc")
# "true"
# >>> $(same_chars "abcd" "dddddddabc")
# "true"
# >>> $(same_chars "dddddddabc" "abcd")
# "true"
# >>> $(same_chars "eabcd" "dddddddabc")
# "false"
# >>> $(same_chars "abcd" "dddddddabce")
# "false"
# >>> $(same_chars "eabcdzzzz" "dddzzzzzzzddddabc")
# "false"
#
# $1 is a string
# $2 is a string
same_chars() {

}

candidate() {
    same_chars "$@"
}

set -e
run_test() {
    [[ $(candidate "eabcdzzzz" "dddzzzzzzzddeddabc") = "true" ]]
    [[ $(candidate "abcd" "dddddddabc") = "true" ]]
    [[ $(candidate "dddddddabc" "abcd") = "true" ]]
    [[ $(candidate "eabcd" "dddddddabc") = "false" ]]
    [[ $(candidate "abcd" "dddddddabcf") = "false" ]]
    [[ $(candidate "eabcdzzzz" "dddzzzzzzzddddabc") = "false" ]]
    [[ $(candidate "aabb" "aaccc") = "false" ]]
}

run_test


Prompt:
#!/bin/bash
# brackets is a string of "<" and ">".
# return true if every opening bracket has a corresponding closing bracket.
# >>> $(correct_bracketing "<")
# "false"
# >>> $(correct_bracketing "<>")
# "true"
# >>> $(correct_bracketing "<<><>>")
# "true"
# >>> $(correct_bracketing "><<>")
# "false"
#
# $1 is a string
correct_bracketing() {