Prompt:
-- | 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
triplesSumToZero :: [Int] -> Bool
triplesSumToZero l =

main :: IO ()
main = do
  let candidate = triplesSumToZero
  if candidate [1,3,5,0] == False then pure () else error "assertion failed"
  if candidate [1,3,5,(-1)] == False then pure () else error "assertion failed"
  if candidate [1,3,(-2),1] == True then pure () else error "assertion failed"
  if candidate [1,2,3,7] == False then pure () else error "assertion failed"
  if candidate [1,2,5,7] == False then pure () else error "assertion failed"
  if candidate [2,4,(-5),3,9,7] == True then pure () else error "assertion failed"
  if candidate [1] == False then pure () else error "assertion failed"
  if candidate [1,3,5,(-100)] == False then pure () else error "assertion failed"
  if candidate [100,3,5,(-100)] == False then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = carRaceCollision
  if candidate 2 == 4 then pure () else error "assertion failed"
  if candidate 3 == 9 then pure () else error "assertion failed"
  if candidate 4 == 16 then pure () else error "assertion failed"
  if candidate 8 == 64 then pure () else error "assertion failed"
  if candidate 10 == 100 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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]
incrList :: [Int] -> [Int]
incrList l =

main :: IO ()
main = do
  let candidate = incrList
  if candidate [] == [] then pure () else error "assertion failed"
  if candidate [3,2,1] == [4,3,2] then pure () else error "assertion failed"
  if candidate [5,2,5,2,3,3,9,0,123] == [6,3,6,3,4,4,10,1,124] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
pairsSumToZero :: [Int] -> Bool
pairsSumToZero l =

main :: IO ()
main = do
  let candidate = pairsSumToZero
  if candidate [1,3,5,0] == False then pure () else error "assertion failed"
  if candidate [1,3,(-2),1] == False then pure () else error "assertion failed"
  if candidate [1,2,3,7] == False then pure () else error "assertion failed"
  if candidate [2,4,(-5),3,5,7] == True then pure () else error "assertion failed"
  if candidate [1] == False then pure () else error "assertion failed"
  if candidate [(-3),9,(-1),3,2,30] == True then pure () else error "assertion failed"
  if candidate [(-3),9,(-1),3,2,31] == True then pure () else error "assertion failed"
  if candidate [(-3),9,(-1),4,2,30] == False then pure () else error "assertion failed"
  if candidate [(-3),9,(-1),4,2,31] == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Change numerical base of input number x to base.
--  return string representation after the conversion.
--  base numbers are less than 10.
--  >>> change_base(8, 3)
--  '22'
--  >>> change_base(8, 2)
--  '1000'
--  >>> change_base(7, 2)
--  '111'
changeBase :: Int -> Int -> String
changeBase x base =

main :: IO ()
main = do
  let candidate = changeBase
  if candidate 8 3 == "22" then pure () else error "assertion failed"
  if candidate 9 3 == "100" then pure () else error "assertion failed"
  if candidate 234 2 == "11101010" then pure () else error "assertion failed"
  if candidate 16 2 == "10000" then pure () else error "assertion failed"
  if candidate 8 2 == "1000" then pure () else error "assertion failed"
  if candidate 7 2 == "111" then pure () else error "assertion failed"
  if candidate 2 3 == "2" then pure () else error "assertion failed"
  if candidate 3 4 == "3" then pure () else error "assertion failed"
  if candidate 4 5 == "4" then pure () else error "assertion failed"
  if candidate 5 6 == "5" then pure () else error "assertion failed"
  if candidate 6 7 == "6" then pure () else error "assertion failed"
  if candidate 7 8 == "7" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given length of a side and high return area for a triangle.
--  >>> triangle_area(5, 3)
--  7.5
triangleArea :: Int -> Int -> Float
triangleArea a h =

main :: IO ()
main = do
  let candidate = triangleArea
  if candidate 5 3 == 7.5 then pure () else error "assertion failed"
  if candidate 2 2 == 2.0 then pure () else error "assertion failed"
  if candidate 10 8 == 40.0 then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = fib4
  if candidate 5 == 4 then pure () else error "assertion failed"
  if candidate 8 == 28 then pure () else error "assertion failed"
  if candidate 10 == 104 then pure () else error "assertion failed"
  if candidate 12 == 386 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Return median of elements in the list l.
--  >>> median([3, 1, 2, 4, 5])
--  3
--  >>> median([-10, 4, 6, 1000, 10, 20])
--  15.0
median :: [Int] -> Float
median l =

main :: IO ()
main = do
  let candidate = median
  if candidate [3,1,2,4,5] == 3.0 then pure () else error "assertion failed"
  if candidate [(-10),4,6,1000,10,20] == 8.0 then pure () else error "assertion failed"
  if candidate [5] == 5.0 then pure () else error "assertion failed"
  if candidate [6,5] == 5.5 then pure () else error "assertion failed"
  if candidate [8,1,3,9,9,2,7] == 7.0 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Checks if given string is a palindrome
--  >>> is_palindrome('')
--  True
--  >>> is_palindrome('aba')
--  True
--  >>> is_palindrome('aaaaa')
--  True
--  >>> is_palindrome('zbcd')
--  False
isPalindrome :: String -> Bool
isPalindrome text =

main :: IO ()
main = do
  let candidate = isPalindrome
  if candidate "" == True then pure () else error "assertion failed"
  if candidate "aba" == True then pure () else error "assertion failed"
  if candidate "aaaaa" == True then pure () else error "assertion failed"
  if candidate "zbcd" == False then pure () else error "assertion failed"
  if candidate "xywyx" == True then pure () else error "assertion failed"
  if candidate "xywyz" == False then pure () else error "assertion failed"
  if candidate "xywzx" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Return 2^n modulo p (be aware of numerics).
--  >>> modp(3, 5)
--  3
--  >>> modp(1101, 101)
--  2
--  >>> modp(0, 101)
--  1
--  >>> modp(3, 11)
--  8
--  >>> modp(100, 101)
--  1
modp :: Int -> Int -> Int
modp n p =

main :: IO ()
main = do
  let candidate = modp
  if candidate 3 5 == 3 then pure () else error "assertion failed"
  if candidate 1101 101 == 2 then pure () else error "assertion failed"
  if candidate 0 101 == 1 then pure () else error "assertion failed"
  if candidate 3 11 == 8 then pure () else error "assertion failed"
  if candidate 100 101 == 1 then pure () else error "assertion failed"
  if candidate 30 5 == 4 then pure () else error "assertion failed"
  if candidate 31 5 == 3 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
meanAbsoluteDeviation :: [Float] -> Float
meanAbsoluteDeviation numbers =

main :: IO ()
main = do
  let candidate = meanAbsoluteDeviation
  if candidate [1.0,2.0] == 0.5 then pure () else error "assertion failed"
  if candidate [1.0,2.0,3.0,4.0] == 1.0 then pure () else error "assertion failed"
  if candidate [1.0,2.0,3.0,4.0,5.0] == 1.2 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | remove_vowels is a function that takes string and returns string without vowels.
--  >>> remove_vowels('')
--  ''
--  >>> remove_vowels('abcdef')
--  'bcdf'
--  >>> remove_vowels('aaaaa')
--  ''
--  >>> remove_vowels('aaBAA')
--  'B'
--  >>> remove_vowels('zbcd')
--  'zbcd'
removeVowels :: String -> String
removeVowels text =

main :: IO ()
main = do
  let candidate = removeVowels
  if candidate "" == "" then pure () else error "assertion failed"
  if candidate "abcdef
ghijklm" == "bcdf
ghjklm" then pure () else error "assertion failed"
  if candidate "fedcba" == "fdcb" then pure () else error "assertion failed"
  if candidate "eeeee" == "" then pure () else error "assertion failed"
  if candidate "acBAA" == "cB" then pure () else error "assertion failed"
  if candidate "EcBOO" == "cB" then pure () else error "assertion failed"
  if candidate "ybcd" == "ybcd" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
belowThreshold :: [Int] -> Int -> Bool
belowThreshold l t =

main :: IO ()
main = do
  let candidate = belowThreshold
  if candidate [1,2,4,10] 100 == True then pure () else error "assertion failed"
  if candidate [1,20,4,10] 5 == False then pure () else error "assertion failed"
  if candidate [1,20,4,10] 21 == True then pure () else error "assertion failed"
  if candidate [1,20,4,10] 22 == True then pure () else error "assertion failed"
  if candidate [1,8,4,10] 11 == True then pure () else error "assertion failed"
  if candidate [1,8,4,10] 10 == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Add two numbers x and y
--  >>> add(2, 3)
--  5
--  >>> add(5, 7)
--  12
add :: Int -> Int -> Int
add x y =

main :: IO ()
main = do
  let candidate = add
  if candidate 0 1 == 1 then pure () else error "assertion failed"
  if candidate 1 0 == 1 then pure () else error "assertion failed"
  if candidate 2 3 == 5 then pure () else error "assertion failed"
  if candidate 5 7 == 12 then pure () else error "assertion failed"
  if candidate 7 5 == 12 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
sameChars :: String -> String -> Bool
sameChars s0 s1 =

main :: IO ()
main = do
  let candidate = sameChars
  if candidate "eabcdzzzz" "dddzzzzzzzddeddabc" == True then pure () else error "assertion failed"
  if candidate "abcd" "dddddddabc" == True then pure () else error "assertion failed"
  if candidate "dddddddabc" "abcd" == True then pure () else error "assertion failed"
  if candidate "eabcd" "dddddddabc" == False then pure () else error "assertion failed"
  if candidate "abcd" "dddddddabcf" == False then pure () else error "assertion failed"
  if candidate "eabcdzzzz" "dddzzzzzzzddddabc" == False then pure () else error "assertion failed"
  if candidate "aabb" "aaccc" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Return n-th Fibonacci number.
--  >>> fib(10)
--  55
--  >>> fib(1)
--  1
--  >>> fib(8)
--  21
fib :: Int -> Int
fib n =

main :: IO ()
main = do
  let candidate = fib
  if candidate 10 == 55 then pure () else error "assertion failed"
  if candidate 1 == 1 then pure () else error "assertion failed"
  if candidate 8 == 21 then pure () else error "assertion failed"
  if candidate 11 == 89 then pure () else error "assertion failed"
  if candidate 12 == 144 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
correctBracketing :: String -> Bool
correctBracketing brackets =

main :: IO ()
main = do
  let candidate = correctBracketing
  if candidate "<>" == True then pure () else error "assertion failed"
  if candidate "<<><>>" == True then pure () else error "assertion failed"
  if candidate "<><><<><>><>" == True then pure () else error "assertion failed"
  if candidate "<><><<<><><>><>><<><><<>>>" == True then pure () else error "assertion failed"
  if candidate "<<<><>>>>" == False then pure () else error "assertion failed"
  if candidate "><<>" == False then pure () else error "assertion failed"
  if candidate "<" == False then pure () else error "assertion failed"
  if candidate "<<<<" == False then pure () else error "assertion failed"
  if candidate ">" == False then pure () else error "assertion failed"
  if candidate "<<>" == False then pure () else error "assertion failed"
  if candidate "<><><<><>><>><<>" == False then pure () else error "assertion failed"
  if candidate "<><><<><>><>>><>" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
monotonic :: [Int] -> Bool
monotonic l =

main :: IO ()
main = do
  let candidate = monotonic
  if candidate [1,2,4,10] == True then pure () else error "assertion failed"
  if candidate [1,2,4,20] == True then pure () else error "assertion failed"
  if candidate [1,20,4,10] == False then pure () else error "assertion failed"
  if candidate [4,1,0,(-10)] == True then pure () else error "assertion failed"
  if candidate [4,1,1,0] == True then pure () else error "assertion failed"
  if candidate [1,2,3,2,5,60] == False then pure () else error "assertion failed"
  if candidate [1,2,3,4,5,60] == True then pure () else error "assertion failed"
  if candidate [9,9,9,9] == True then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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]
common :: [Int] -> [Int] -> [Int]
common l1 l2 =

main :: IO ()
main = do
  let candidate = common
  if candidate [1,4,3,34,653,2,5] [5,7,1,5,9,653,121] == [1,5,653] then pure () else error "assertion failed"
  if candidate [5,3,2,8] [3,2] == [2,3] then pure () else error "assertion failed"
  if candidate [4,3,2,8] [3,2,4] == [2,3,4] then pure () else error "assertion failed"
  if candidate [4,3,2,8] [] == [] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Return the largest prime factor of n. Assume n > 1 and is not a prime.
--  >>> largest_prime_factor(13195)
--  29
--  >>> largest_prime_factor(2048)
--  2
largestPrimeFactor :: Int -> Int
largestPrimeFactor n =

main :: IO ()
main = do
  let candidate = largestPrimeFactor
  if candidate 15 == 5 then pure () else error "assertion failed"
  if candidate 27 == 3 then pure () else error "assertion failed"
  if candidate 63 == 7 then pure () else error "assertion failed"
  if candidate 330 == 11 then pure () else error "assertion failed"
  if candidate 13195 == 29 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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]
intersperse :: [Int] -> Int -> [Int]
intersperse numbers delimeter =

main :: IO ()
main = do
  let candidate = intersperse
  if candidate [] 7 == [] then pure () else error "assertion failed"
  if candidate [5,6,3,2] 8 == [5,8,6,8,3,8,2] then pure () else error "assertion failed"
  if candidate [2,2,2] 2 == [2,2,2,2,2] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | sum_to_n is a function that sums numbers from 1 to n.
--  >>> sum_to_n(30)
--  465
--  >>> sum_to_n(100)
--  5050
--  >>> sum_to_n(5)
--  15
--  >>> sum_to_n(10)
--  55
--  >>> sum_to_n(1)
--  1
sumToN :: Int -> Int
sumToN n =

main :: IO ()
main = do
  let candidate = sumToN
  if candidate 1 == 1 then pure () else error "assertion failed"
  if candidate 6 == 21 then pure () else error "assertion failed"
  if candidate 11 == 66 then pure () else error "assertion failed"
  if candidate 30 == 465 then pure () else error "assertion failed"
  if candidate 100 == 5050 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
correctBracketing :: String -> Bool
correctBracketing brackets =

main :: IO ()
main = do
  let candidate = correctBracketing
  if candidate "()" == True then pure () else error "assertion failed"
  if candidate "(()())" == True then pure () else error "assertion failed"
  if candidate "()()(()())()" == True then pure () else error "assertion failed"
  if candidate "()()((()()())())(()()(()))" == True then pure () else error "assertion failed"
  if candidate "((()())))" == False then pure () else error "assertion failed"
  if candidate ")(()" == False then pure () else error "assertion failed"
  if candidate "(" == False then pure () else error "assertion failed"
  if candidate "((((" == False then pure () else error "assertion failed"
  if candidate ")" == False then pure () else error "assertion failed"
  if candidate "(()" == False then pure () else error "assertion failed"
  if candidate "()()(()())())(()" == False then pure () else error "assertion failed"
  if candidate "()()(()())()))()" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | xs represent coefficients of a polynomial.
--  xs[0] + xs[1] * x + xs[2] * x^2 + ....
--  Return derivative of this polynomial in the same form.
--  >>> derivative([3, 1, 2, 4, 5])
--  [1, 4, 12, 20]
--  >>> derivative([1, 2, 3])
--  [2, 6]
derivative :: [Int] -> [Int]
derivative xs =

main :: IO ()
main = do
  let candidate = derivative
  if candidate [3,1,2,4,5] == [1,4,12,20] then pure () else error "assertion failed"
  if candidate [1,2,3] == [2,6] then pure () else error "assertion failed"
  if candidate [3,2,1] == [2,2] then pure () else error "assertion failed"
  if candidate [3,2,1,0,4] == [2,2,0,16] then pure () else error "assertion failed"
  if candidate [1] == [] then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = fibfib
  if candidate 2 == 1 then pure () else error "assertion failed"
  if candidate 1 == 0 then pure () else error "assertion failed"
  if candidate 5 == 4 then pure () else error "assertion failed"
  if candidate 8 == 24 then pure () else error "assertion failed"
  if candidate 10 == 81 then pure () else error "assertion failed"
  if candidate 12 == 274 then pure () else error "assertion failed"
  if candidate 14 == 927 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Write a function vowels_count which takes a string representing
--  a word as input and returns the number of vowels in the string.
--  Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
--  vowel, but only when it is at the end of the given word.
--  Example:
--  >>> vowels_count("abcde")
--  2
--  >>> vowels_count("ACEDY")
--  3
vowelsCount :: String -> Int
vowelsCount s =

main :: IO ()
main = do
  let candidate = vowelsCount
  if candidate "abcde" == 2 then pure () else error "assertion failed"
  if candidate "Alone" == 3 then pure () else error "assertion failed"
  if candidate "key" == 2 then pure () else error "assertion failed"
  if candidate "bye" == 1 then pure () else error "assertion failed"
  if candidate "keY" == 2 then pure () else error "assertion failed"
  if candidate "bYe" == 1 then pure () else error "assertion failed"
  if candidate "ACEDY" == 3 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Circular shift the digits of the integer x, shift the digits right by shift
--  and return the result as a string.
--  If shift > number of digits, return digits reversed.
--  >>> circular_shift(12, 1)
--  "21"
--  >>> circular_shift(12, 2)
--  "12"
circularShift :: Int -> Int -> String
circularShift x shift =

main :: IO ()
main = do
  let candidate = circularShift
  if candidate 100 2 == "001" then pure () else error "assertion failed"
  if candidate 12 2 == "12" then pure () else error "assertion failed"
  if candidate 97 8 == "79" then pure () else error "assertion failed"
  if candidate 12 1 == "21" then pure () else error "assertion failed"
  if candidate 11 101 == "11" then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = digitsum
  if candidate "" == 0 then pure () else error "assertion failed"
  if candidate "abAB" == 131 then pure () else error "assertion failed"
  if candidate "abcCd" == 67 then pure () else error "assertion failed"
  if candidate "helloE" == 69 then pure () else error "assertion failed"
  if candidate "woArBld" == 131 then pure () else error "assertion failed"
  if candidate "aAaaaXa" == 153 then pure () else error "assertion failed"
  if candidate " How are yOu?" == 151 then pure () else error "assertion failed"
  if candidate "You arE Very Smart" == 327 then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = fruitDistribution
  if candidate "5 apples and 6 oranges" 19 == 8 then pure () else error "assertion failed"
  if candidate "5 apples and 6 oranges" 21 == 10 then pure () else error "assertion failed"
  if candidate "0 apples and 1 oranges" 3 == 2 then pure () else error "assertion failed"
  if candidate "1 apples and 0 oranges" 3 == 2 then pure () else error "assertion failed"
  if candidate "2 apples and 3 oranges" 100 == 95 then pure () else error "assertion failed"
  if candidate "2 apples and 3 oranges" 5 == 0 then pure () else error "assertion failed"
  if candidate "1 apples and 100 oranges" 120 == 19 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | "Given an array representing a branch of a tree that has non-negative integer nodes
--  your task is to pluck one of the nodes and return it.
--  The plucked node should be the node with the smallest even value.
--  If multiple nodes with the same smallest even value are found return the node that has smallest index.
--  The plucked node should be returned in a list, [ smalest_value, its index ],
--  If there are no even values or the given array is empty, return [].
--  Example 1:
--  Input: [4,2,3]
--  Output: [2, 1]
--  Explanation: 2 has the smallest even value, and 2 has the smallest index.
--  Example 2:
--  Input: [1,2,3]
--  Output: [2, 1]
--  Explanation: 2 has the smallest even value, and 2 has the smallest index.
--  Example 3:
--  Input: []
--  Output: []
--  Example 4:
--  Input: [5, 0, 3, 0, 4, 2]
--  Output: [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
pluck :: [Int] -> [Int]
pluck arr =

main :: IO ()
main = do
  let candidate = pluck
  if candidate [4,2,3] == [2,1] then pure () else error "assertion failed"
  if candidate [1,2,3] == [2,1] then pure () else error "assertion failed"
  if candidate [] == [] then pure () else error "assertion failed"
  if candidate [5,0,3,0,4,2] == [0,1] then pure () else error "assertion failed"
  if candidate [1,2,3,0,5,3] == [0,3] then pure () else error "assertion failed"
  if candidate [5,4,8,4,8] == [4,1] then pure () else error "assertion failed"
  if candidate [7,6,7,1] == [6,1] then pure () else error "assertion failed"
  if candidate [7,9,7,1] == [] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
search :: [Int] -> Int
search lst =

main :: IO ()
main = do
  let candidate = search
  if candidate [5,5,5,5,1] == 1 then pure () else error "assertion failed"
  if candidate [4,1,4,1,4,4] == 4 then pure () else error "assertion failed"
  if candidate [3,3] == (-1) then pure () else error "assertion failed"
  if candidate [8,8,8,8,8,8,8,8] == 8 then pure () else error "assertion failed"
  if candidate [2,3,3,2,2] == 2 then pure () else error "assertion failed"
  if candidate [2,7,8,8,4,8,7,3,9,6,5,10,4,3,6,7,1,7,4,10,8,1] == 1 then pure () else error "assertion failed"
  if candidate [3,2,8,2] == 2 then pure () else error "assertion failed"
  if candidate [6,7,1,8,8,10,5,8,5,3,10] == 1 then pure () else error "assertion failed"
  if candidate [8,8,3,6,5,6,4] == (-1) then pure () else error "assertion failed"
  if candidate [6,9,6,7,1,4,7,1,8,8,9,8,10,10,8,4,10,4,10,1,2,9,5,7,9] == 1 then pure () else error "assertion failed"
  if candidate [1,9,10,1,3] == 1 then pure () else error "assertion failed"
  if candidate [6,9,7,5,8,7,5,3,7,5,10,10,3,6,10,2,8,6,5,4,9,5,3,10] == 5 then pure () else error "assertion failed"
  if candidate [1] == 1 then pure () else error "assertion failed"
  if candidate [8,8,10,6,4,3,5,8,2,4,2,8,4,6,10,4,2,1,10,2,1,1,5] == 4 then pure () else error "assertion failed"
  if candidate [2,10,4,8,2,10,5,1,2,9,5,5,6,3,8,6,4,10] == 2 then pure () else error "assertion failed"
  if candidate [1,6,10,1,6,9,10,8,6,8,7,3] == 1 then pure () else error "assertion failed"
  if candidate [9,2,4,1,5,1,5,2,5,7,7,7,3,10,1,5,4,2,8,4,1,9,10,7,10,2,8,10,9,4] == 4 then pure () else error "assertion failed"
  if candidate [2,6,4,2,8,7,5,6,4,10,4,6,3,7,8,8,3,1,4,2,2,10,7] == 4 then pure () else error "assertion failed"
  if candidate [9,8,6,10,2,6,10,2,7,8,10,3,8,2,6,2,3,1] == 2 then pure () else error "assertion failed"
  if candidate [5,5,3,9,5,6,3,2,8,5,6,10,10,6,8,4,10,7,7,10,8] == (-1) then pure () else error "assertion failed"
  if candidate [10] == (-1) then pure () else error "assertion failed"
  if candidate [9,7,7,2,4,7,2,10,9,7,5,7,2] == 2 then pure () else error "assertion failed"
  if candidate [5,4,10,2,1,1,10,3,6,1,8] == 1 then pure () else error "assertion failed"
  if candidate [7,9,9,9,3,4,1,5,9,1,2,1,1,10,7,5,6,7,6,7,7,6] == 1 then pure () else error "assertion failed"
  if candidate [3,10,10,9,2] == (-1) then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
--  For each of the group, output the deepest level of nesting of parentheses.
--  E.g. (()()) has maximum two levels of nesting while ((())) has three.
--  >>> parse_nested_parens('(()()) ((())) () ((())()())')
--  [2, 3, 1, 3]
parseNestedParens :: String -> [Int]
parseNestedParens paren_string =

main :: IO ()
main = do
  let candidate = parseNestedParens
  if candidate "(()()) ((())) () ((())()())" == [2,3,1,3] then pure () else error "assertion failed"
  if candidate "() (()) ((())) (((())))" == [1,2,3,4] then pure () else error "assertion failed"
  if candidate "(()(())((())))" == [4] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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([]) == []
strangeSortList :: [Int] -> [Int]
strangeSortList lst =

main :: IO ()
main = do
  let candidate = strangeSortList
  if candidate [1,2,3,4] == [1,4,2,3] then pure () else error "assertion failed"
  if candidate [5,6,7,8,9] == [5,9,6,8,7] then pure () else error "assertion failed"
  if candidate [1,2,3,4,5] == [1,5,2,4,3] then pure () else error "assertion failed"
  if candidate [5,6,7,8,9,1] == [1,9,5,8,6,7] then pure () else error "assertion failed"
  if candidate [5,5,5,5] == [5,5,5,5] then pure () else error "assertion failed"
  if candidate [] == [] then pure () else error "assertion failed"
  if candidate [1,2,3,4,5,6,7,8] == [1,8,2,7,3,6,4,5] then pure () else error "assertion failed"
  if candidate [0,2,2,2,5,5,(-5),(-5)] == [(-5),5,(-5),5,0,2,2,2] then pure () else error "assertion failed"
  if candidate [111111] == [111111] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given the lengths of the three sides of a triangle. Return the area of
--  the triangle rounded to 2 decimal points if the three sides form a valid triangle.
--  Otherwise return -1
--  Three sides make a valid triangle when the sum of any two sides is greater
--  than the third side.
--  Example:
--  triangle_area(3, 4, 5) == 6.00
--  triangle_area(1, 2, 10) == -1
triangleArea :: Int -> Int -> Int -> Float
triangleArea a b c =

main :: IO ()
main = do
  let candidate = triangleArea
  if candidate 3 4 5 == 6.0 then pure () else error "assertion failed"
  if candidate 1 2 10 == (-1).0 then pure () else error "assertion failed"
  if candidate 4 8 5 == 8.18 then pure () else error "assertion failed"
  if candidate 2 2 2 == 1.73 then pure () else error "assertion failed"
  if candidate 1 2 3 == (-1).0 then pure () else error "assertion failed"
  if candidate 10 5 7 == 16.25 then pure () else error "assertion failed"
  if candidate 2 6 3 == (-1).0 then pure () else error "assertion failed"
  if candidate 1 1 1 == 0.43 then pure () else error "assertion failed"
  if candidate 2 2 10 == (-1).0 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Write a function that returns True if the object q will fly, and False otherwise.
--  The object q will fly if it's balanced (it is a palindromic 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.
willItFly :: [Int] -> Int -> Bool
willItFly q w =

main :: IO ()
main = do
  let candidate = willItFly
  if candidate [3,2,3] 9 == True then pure () else error "assertion failed"
  if candidate [1,2] 5 == False then pure () else error "assertion failed"
  if candidate [3] 5 == True then pure () else error "assertion failed"
  if candidate [3,2,3] 1 == False then pure () else error "assertion failed"
  if candidate [1,2,3] 6 == False then pure () else error "assertion failed"
  if candidate [5] 5 == True then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = smallestChange
  if candidate [1,2,3,5,4,7,9,6] == 4 then pure () else error "assertion failed"
  if candidate [1,2,3,4,3,2,2] == 1 then pure () else error "assertion failed"
  if candidate [1,4,2] == 1 then pure () else error "assertion failed"
  if candidate [1,4,4,2] == 1 then pure () else error "assertion failed"
  if candidate [1,2,3,2,1] == 0 then pure () else error "assertion failed"
  if candidate [3,1,1,3] == 0 then pure () else error "assertion failed"
  if candidate [1] == 0 then pure () else error "assertion failed"
  if candidate [0,1] == 1 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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']
totalMatch :: [String] -> [String] -> [String]
totalMatch lst1 lst2 =

main :: IO ()
main = do
  let candidate = totalMatch
  if candidate [] [] == [] then pure () else error "assertion failed"
  if candidate ["hi","admin"] ["hi","hi"] == ["hi","hi"] then pure () else error "assertion failed"
  if candidate ["hi","admin"] ["hi","hi","admin","project"] == ["hi","admin"] then pure () else error "assertion failed"
  if candidate ["4"] ["1","2","3","4","5"] == ["4"] then pure () else error "assertion failed"
  if candidate ["hi","admin"] ["hI","Hi"] == ["hI","Hi"] then pure () else error "assertion failed"
  if candidate ["hi","admin"] ["hI","hi","hi"] == ["hI","hi","hi"] then pure () else error "assertion failed"
  if candidate ["hi","admin"] ["hI","hi","hii"] == ["hi","admin"] then pure () else error "assertion failed"
  if candidate [] ["this"] == [] then pure () else error "assertion failed"
  if candidate ["this"] [] == [] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Write a function that returns true if the given number is the multiplication of 3 prime numbers
--  and false otherwise.
--  Knowing that (a) is less then 100.
--  Example:
--  is_multiply_prime(30) == True
--  30 = 2 * 3 * 5
isMultiplyPrime :: Int -> Bool
isMultiplyPrime a =

main :: IO ()
main = do
  let candidate = isMultiplyPrime
  if candidate 5 == False then pure () else error "assertion failed"
  if candidate 30 == True then pure () else error "assertion failed"
  if candidate 8 == True then pure () else error "assertion failed"
  if candidate 10 == False then pure () else error "assertion failed"
  if candidate 125 == True then pure () else error "assertion failed"
  if candidate 105 == True then pure () else error "assertion failed"
  if candidate 126 == False then pure () else error "assertion failed"
  if candidate 729 == False then pure () else error "assertion failed"
  if candidate 891 == False then pure () else error "assertion failed"
  if candidate 1001 == True then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = isSimplePower
  if candidate 16 2 == True then pure () else error "assertion failed"
  if candidate 143214 16 == False then pure () else error "assertion failed"
  if candidate 4 2 == True then pure () else error "assertion failed"
  if candidate 9 3 == True then pure () else error "assertion failed"
  if candidate 16 4 == True then pure () else error "assertion failed"
  if candidate 24 2 == False then pure () else error "assertion failed"
  if candidate 128 4 == False then pure () else error "assertion failed"
  if candidate 12 6 == False then pure () else error "assertion failed"
  if candidate 1 1 == True then pure () else error "assertion failed"
  if candidate 1 12 == True then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Write a function that takes an integer a and returns True
--  if this ingeger is a cube of some integer number.
--  Note: you may assume the input is always valid.
--  Examples:
--  iscube(1) ==> True
--  iscube(2) ==> False
--  iscube(-1) ==> True
--  iscube(64) ==> True
--  iscube(0) ==> True
--  iscube(180) ==> False
iscube :: Int -> Bool
iscube a =

main :: IO ()
main = do
  let candidate = iscube
  if candidate 1 == True then pure () else error "assertion failed"
  if candidate 2 == False then pure () else error "assertion failed"
  if candidate (-1) == True then pure () else error "assertion failed"
  if candidate 64 == True then pure () else error "assertion failed"
  if candidate 180 == False then pure () else error "assertion failed"
  if candidate 1000 == True then pure () else error "assertion failed"
  if candidate 0 == True then pure () else error "assertion failed"
  if candidate 1729 == False then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = hexKey
  if candidate "AB" == 1 then pure () else error "assertion failed"
  if candidate "1077E" == 2 then pure () else error "assertion failed"
  if candidate "ABED1A33" == 4 then pure () else error "assertion failed"
  if candidate "2020" == 2 then pure () else error "assertion failed"
  if candidate "123456789ABCDEF0" == 6 then pure () else error "assertion failed"
  if candidate "112233445566778899AABBCCDDEEFF00" == 12 then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = decimalToBinary
  if candidate 0 == "db0db" then pure () else error "assertion failed"
  if candidate 32 == "db100000db" then pure () else error "assertion failed"
  if candidate 103 == "db1100111db" then pure () else error "assertion failed"
  if candidate 15 == "db1111db" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Filter an input list of strings only for ones that contain given substring
--  >>> filter_by_substring([], 'a')
--  []
--  >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
--  ['abc', 'bacd', 'array']
filterBySubstring :: [String] -> String -> [String]
filterBySubstring strings substring =

main :: IO ()
main = do
  let candidate = filterBySubstring
  if candidate [] "john" == [] then pure () else error "assertion failed"
  if candidate ["xxx","asd","xxy","john doe","xxxAAA","xxx"] "xxx" == ["xxx","xxxAAA","xxx"] then pure () else error "assertion failed"
  if candidate ["xxx","asd","aaaxxy","john doe","xxxAAA","xxx"] "xx" == ["xxx","aaaxxy","xxxAAA","xxx"] then pure () else error "assertion failed"
  if candidate ["grunt","trumpet","prune","gruesome"] "run" == ["grunt","prune"] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | You are given a string s.
--  Your task is to check if the string is happy or not.
--  A string is happy 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
isHappy :: String -> Bool
isHappy s =

main :: IO ()
main = do
  let candidate = isHappy
  if candidate "a" == False then pure () else error "assertion failed"
  if candidate "aa" == False then pure () else error "assertion failed"
  if candidate "abcd" == True then pure () else error "assertion failed"
  if candidate "aabb" == False then pure () else error "assertion failed"
  if candidate "adb" == True then pure () else error "assertion failed"
  if candidate "xyy" == False then pure () else error "assertion failed"
  if candidate "iopaxpoi" == True then pure () else error "assertion failed"
  if candidate "iopaxioi" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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-']
numericalLetterGrade :: [Float] -> [String]
numericalLetterGrade grades =

main :: IO ()
main = do
  let candidate = numericalLetterGrade
  if candidate [4.0,3,1.7,2,3.5] == ["A+","B","C-","C","A-"] then pure () else error "assertion failed"
  if candidate [1.2] == ["D+"] then pure () else error "assertion failed"
  if candidate [0.5] == ["D-"] then pure () else error "assertion failed"
  if candidate [0.0] == ["E"] then pure () else error "assertion failed"
  if candidate [1.0,0.3,1.5,2.8,3.3] == ["D","D-","C-","B","B+"] then pure () else error "assertion failed"
  if candidate [0.0,0.7] == ["E","D-"] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Write a function that takes a string and returns True if the string
--  length is a prime number or False otherwise
--  Examples
--  prime_length('Hello') == True
--  prime_length('abcdcba') == True
--  prime_length('kittens') == True
--  prime_length('orange') == False
primeLength :: String -> Bool
primeLength string =

main :: IO ()
main = do
  let candidate = primeLength
  if candidate "Hello" == True then pure () else error "assertion failed"
  if candidate "abcdcba" == True then pure () else error "assertion failed"
  if candidate "kittens" == True then pure () else error "assertion failed"
  if candidate "orange" == False then pure () else error "assertion failed"
  if candidate "wow" == True then pure () else error "assertion failed"
  if candidate "world" == True then pure () else error "assertion failed"
  if candidate "MadaM" == True then pure () else error "assertion failed"
  if candidate "Wow" == True then pure () else error "assertion failed"
  if candidate "" == False then pure () else error "assertion failed"
  if candidate "HI" == True then pure () else error "assertion failed"
  if candidate "go" == True then pure () else error "assertion failed"
  if candidate "gogo" == False then pure () else error "assertion failed"
  if candidate "aaaaaaaaaaaaaaa" == False then pure () else error "assertion failed"
  if candidate "Madam" == True then pure () else error "assertion failed"
  if candidate "M" == False then pure () else error "assertion failed"
  if candidate "0" == False then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given a positive integer n, return the count of the numbers of n-digit
--  positive integers that start or end with 1.
startsOneEnds :: Int -> Int
startsOneEnds n =

main :: IO ()
main = do
  let candidate = startsOneEnds
  if candidate 1 == 1 then pure () else error "assertion failed"
  if candidate 2 == 18 then pure () else error "assertion failed"
  if candidate 3 == 180 then pure () else error "assertion failed"
  if candidate 4 == 1800 then pure () else error "assertion failed"
  if candidate 5 == 18000 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given a positive integer N, return the total sum of its digits in binary.
--  Example
--  For N = 1000, the sum of digits will be 1 the output should be "1".
--  For N = 150, the sum of digits will be 6 the output should be "110".
--  For N = 147, the sum of digits will be 12 the output should be "1100".
--  Variables:
--  @N integer
--  Constraints: 0 â‰¤ N â‰¤ 10000.
--  Output:
--  a string of binary number
solve :: Int -> String
solve N =

main :: IO ()
main = do
  let candidate = solve
  if candidate 1000 == "1" then pure () else error "assertion failed"
  if candidate 150 == "110" then pure () else error "assertion failed"
  if candidate 147 == "1100" then pure () else error "assertion failed"
  if candidate 333 == "1001" then pure () else error "assertion failed"
  if candidate 963 == "10010" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given a non-empty list of integers lst. add the even elements that are at odd indices..
--  Examples:
--  add([4, 2, 6, 7]) ==> 2
add :: [Int] -> Int
add lst =

main :: IO ()
main = do
  let candidate = add
  if candidate [4,88] == 88 then pure () else error "assertion failed"
  if candidate [4,5,6,7,2,122] == 122 then pure () else error "assertion failed"
  if candidate [4,0,6,7] == 0 then pure () else error "assertion failed"
  if candidate [4,4,6,8] == 12 then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = antiShuffle
  if candidate "Hi" == "Hi" then pure () else error "assertion failed"
  if candidate "hello" == "ehllo" then pure () else error "assertion failed"
  if candidate "number" == "bemnru" then pure () else error "assertion failed"
  if candidate "abcd" == "abcd" then pure () else error "assertion failed"
  if candidate "Hello World!!!" == "Hello !!!Wdlor" then pure () else error "assertion failed"
  if candidate "" == "" then pure () else error "assertion failed"
  if candidate "Hi. My name is Mister Robot. How are you?" == ".Hi My aemn is Meirst .Rboot How aer ?ouy" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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 tuples, [(x1, y1), (x2, y2) ...] such that
--  each tuple is a coordinate - (row, columns), starting with 0.
--  Sort coordinates initially by rows in ascending order.
--  Also, sort coordinates of the row by columns in descending order.
--  Examples:
--  get_row([
--  [1,2,3,4,5,6],
--  [1,2,3,4,1,6],
--  [1,2,3,4,5,1]
--  ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
--  get_row([], 1) == []
--  get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
getRow :: [[Int]] -> Int -> [(Int, Int)]
getRow lst x =


Prompt:
-- | Given an array of non-negative integers, return a copy 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]
sortArray :: [Int] -> [Int]
sortArray array =

main :: IO ()
main = do
  let candidate = sortArray
  if candidate [] == [] then pure () else error "assertion failed"
  if candidate [5] == [5] then pure () else error "assertion failed"
  if candidate [2,4,3,0,1,5] == [0,1,2,3,4,5] then pure () else error "assertion failed"
  if candidate [2,4,3,0,1,5,6] == [6,5,4,3,2,1,0] then pure () else error "assertion failed"
  if candidate [2,1] == [1,2] then pure () else error "assertion failed"
  if candidate [15,42,87,32,11,0] == [0,11,15,32,42,87] then pure () else error "assertion failed"
  if candidate [21,14,23,11] == [23,21,14,11] then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = encrypt
  if candidate "hi" == "lm" then pure () else error "assertion failed"
  if candidate "asdfghjkl" == "ewhjklnop" then pure () else error "assertion failed"
  if candidate "gf" == "kj" then pure () else error "assertion failed"
  if candidate "et" == "ix" then pure () else error "assertion failed"
  if candidate "faewfawefaewg" == "jeiajeaijeiak" then pure () else error "assertion failed"
  if candidate "hellomyfriend" == "lippsqcjvmirh" then pure () else error "assertion failed"
  if candidate "dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh" == "hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl" then pure () else error "assertion failed"
  if candidate "a" == "e" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | For a given list of integers, return a tuple 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)
sumProduct :: [Int] -> (Int, Int)
sumProduct numbers =

main :: IO ()
main = do
  let candidate = sumProduct
  if candidate [] == (0, 1) then pure () else error "assertion failed"
  if candidate [1,1,1] == (3, 1) then pure () else error "assertion failed"
  if candidate [100,0] == (100, 0) then pure () else error "assertion failed"
  if candidate [3,5,7] == (15, 105) then pure () else error "assertion failed"
  if candidate [10] == (10, 10) then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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
nextSmallest :: [Int] -> Maybe Int
nextSmallest lst =

main :: IO ()
main = do
  let candidate = nextSmallest
  if candidate [1,2,3,4,5] == Just (2) then pure () else error "assertion failed"
  if candidate [5,1,4,3,2] == Just (2) then pure () else error "assertion failed"
  if candidate [] == Just (Nothing) then pure () else error "assertion failed"
  if candidate [1,1] == Just (Nothing) then pure () else error "assertion failed"
  if candidate [1,1,1,1,0] == Just (1) then pure () else error "assertion failed"
  if candidate [1,1] == Just (Nothing) then pure () else error "assertion failed"
  if candidate [(-35),34,12,(-45)] == Just ((-35)) then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = isBored
  if candidate "Hello world" == 0 then pure () else error "assertion failed"
  if candidate "Is the sky blue?" == 0 then pure () else error "assertion failed"
  if candidate "I love It !" == 1 then pure () else error "assertion failed"
  if candidate "bIt" == 0 then pure () else error "assertion failed"
  if candidate "I feel good today. I will be productive. will kill It" == 2 then pure () else error "assertion failed"
  if candidate "You and I are going for a walk" == 0 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Create a function that takes 3 numbers.
--  Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
--  Returns false in any other cases.
--  Examples
--  any_int(5, 2, 7) âžž True
--  any_int(3, 2, 2) âžž False
--  any_int(3, -2, 1) âžž True
--  any_int(3.6, -2.2, 2) âžž False
anyInt :: Float -> Float -> Float -> Bool
anyInt x y z =

main :: IO ()
main = do
  let candidate = anyInt
  if candidate 2.0 3.0 1.0 == True then pure () else error "assertion failed"
  if candidate 2.5 2.0 3.0 == False then pure () else error "assertion failed"
  if candidate 1.5 5.0 3.5 == False then pure () else error "assertion failed"
  if candidate 2.0 6.0 2.0 == False then pure () else error "assertion failed"
  if candidate 4.0 2.0 2.0 == True then pure () else error "assertion failed"
  if candidate 2.2 2.2 2.2 == False then pure () else error "assertion failed"
  if candidate (-4).0 6.0 2.0 == True then pure () else error "assertion failed"
  if candidate 2.0 1.0 1.0 == True then pure () else error "assertion failed"
  if candidate 3.0 4.0 7.0 == True then pure () else error "assertion failed"
  if candidate 3.0 4.0 7.0 == False then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = encode
  if candidate "TEST" == "tgst" then pure () else error "assertion failed"
  if candidate "Mudasir" == "mWDCSKR" then pure () else error "assertion failed"
  if candidate "YES" == "ygs" then pure () else error "assertion failed"
  if candidate "This is a message" == "tHKS KS C MGSSCGG" then pure () else error "assertion failed"
  if candidate "I DoNt KnOw WhAt tO WrItE" == "k dQnT kNqW wHcT Tq wRkTg" then pure () else error "assertion failed"
  pure ()


Prompt:
-- | You are given a list of integers.
--  You need to find the largest prime value and return the sum of its digits.
--  Examples:
--  For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
--  For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
--  For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
--  For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
--  For lst = [0,81,12,3,1,21] the output should be 3
--  For lst = [0,8,1,2,1,7] the output should be 7
skjkasdkd :: [Int] -> Int
skjkasdkd lst =

main :: IO ()
main = do
  let candidate = skjkasdkd
  if candidate [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] == 10 then pure () else error "assertion failed"
  if candidate [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] == 25 then pure () else error "assertion failed"
  if candidate [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] == 13 then pure () else error "assertion failed"
  if candidate [0,724,32,71,99,32,6,0,5,91,83,0,5,6] == 11 then pure () else error "assertion failed"
  if candidate [0,81,12,3,1,21] == 3 then pure () else error "assertion failed"
  if candidate [0,8,1,2,1,7] == 7 then pure () else error "assertion failed"
  if candidate [8191] == 19 then pure () else error "assertion failed"
  if candidate [8191,123456,127,7] == 19 then pure () else error "assertion failed"
  if candidate [127,97,8192] == 10 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given a dictionary, 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 dictionary is empty.
--  Examples:
--  check_dict_case({"a":"apple", "b":"banana"}) should return True.
--  check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
--  check_dict_case({"a":"apple", "8":"banana", "a":"apple"}) should return False.
--  check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
--  check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
checkDictCase :: [(String, String)] -> Bool
checkDictCase dict =

main :: IO ()
main = do
  let candidate = checkDictCase
  if candidate [("p", "pineapple"), ("b", "banana")] == True then pure () else error "assertion failed"
  if candidate [("p", "pineapple"), ("A", "banana"), ("B", "banana")] == False then pure () else error "assertion failed"
  if candidate [("p", "pineapple"), ("5", "banana"), ("a", "apple")] == False then pure () else error "assertion failed"
  if candidate [("Name", "John"), ("Age", "36"), ("City", "Houston")] == False then pure () else error "assertion failed"
  if candidate [("STATE", "NC"), ("ZIP", "12345")] == True then pure () else error "assertion failed"
  if candidate [("fruit", "Orange"), ("taste", "Sweet")] == True then pure () else error "assertion failed"
  if candidate [] == False then pure () else error "assertion failed"
  pure ()


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

main :: IO ()
main = do
  let candidate = countUpTo
  if candidate 5 == [2,3] then pure () else error "assertion failed"
  if candidate 6 == [2,3,5] then pure () else error "assertion failed"
  if candidate 7 == [2,3,5] then pure () else error "assertion failed"
  if candidate 10 == [2,3,5,7] then pure () else error "assertion failed"
  if candidate 0 == [] then pure () else error "assertion failed"
  if candidate 22 == [2,3,5,7,11,13,17,19] then pure () else error "assertion failed"
  if candidate 1 == [] then pure () else error "assertion failed"
  if candidate 18 == [2,3,5,7,11,13,17] then pure () else error "assertion failed"
  if candidate 47 == [2,3,5,7,11,13,17,19,23,29,31,37,41,43] then pure () else error "assertion failed"
  if candidate 101 == [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97] then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Complete the function that takes two integers and returns
--  the product of their unit digits.
--  Assume the input is always valid.
--  Examples:
--  multiply(148, 412) should return 16.
--  multiply(19, 28) should return 72.
--  multiply(2020, 1851) should return 0.
--  multiply(14,-15) should return 20.
multiply :: Int -> Int -> Int
multiply a b =

main :: IO ()
main = do
  let candidate = multiply
  if candidate 148 412 == 16 then pure () else error "assertion failed"
  if candidate 19 28 == 72 then pure () else error "assertion failed"
  if candidate 2020 1851 == 0 then pure () else error "assertion failed"
  if candidate 14 (-15) == 20 then pure () else error "assertion failed"
  if candidate 76 67 == 42 then pure () else error "assertion failed"
  if candidate 17 27 == 49 then pure () else error "assertion failed"
  if candidate 0 1 == 0 then pure () else error "assertion failed"
  if candidate 0 0 == 0 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | Given a string s, count the number of uppercase vowels in even indices.
--  For example:
--  count_upper('aBCdEf') returns 1
--  count_upper('abcdefg') returns 0
--  count_upper('dBBE') returns 0
countUpper :: String -> Int
countUpper s =

main :: IO ()
main = do
  let candidate = countUpper
  if candidate "aBCdEf" == 1 then pure () else error "assertion failed"
  if candidate "abcdefg" == 0 then pure () else error "assertion failed"
  if candidate "dBBE" == 0 then pure () else error "assertion failed"
  if candidate "B" == 0 then pure () else error "assertion failed"
  if candidate "U" == 1 then pure () else error "assertion failed"
  if candidate "" == 0 then pure () else error "assertion failed"
  if candidate "EEEE" == 2 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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.
closestInteger :: String -> Int
closestInteger value =

main :: IO ()
main = do
  let candidate = closestInteger
  if candidate "10" == 10 then pure () else error "assertion failed"
  if candidate "14.5" == 15 then pure () else error "assertion failed"
  if candidate "-15.5" == (-16) then pure () else error "assertion failed"
  if candidate "15.3" == 15 then pure () else error "assertion failed"
  if candidate "0" == 0 then pure () else error "assertion failed"
  pure ()


Prompt:
-- | 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]
rollingMax :: [Int] -> [Int]
rollingMax numbers =

main :: IO ()
main = do
  let candidate = rollingMax
  if candidate [] == [] then pure () else error "assertion failed"
  if candidate [1,2,3,4] == [1,2,3,4] then pure () else error "assertion failed"
  if candidate [4,3,2,1] == [4,4,4,4] then pure () else error "assertion failed"
  if candidate [3,2,3,100,3] == [3,3,3,100,100] then pure () else error "assertion failed"
  pure ()