module Hasklet1 where


-- | A generic binary tree with values at internal nodes.
data Tree a = Node a (Tree a) (Tree a)
            | Leaf
  deriving (Eq,Show)


-- | Build a balanced binary tree from a list of values.
tree :: [a] -> Tree a
tree []     = Leaf
tree (x:xs) = Node x (tree l) (tree r)
  where (l,r) = splitAt (length xs `div` 2) xs


-- Some example trees containing integers.
t1, t2, t3, t4 :: Tree Int
t1 = Node 1 Leaf (Node 2 Leaf Leaf)
t2 = Node 3 (Node 4 Leaf Leaf) Leaf
t3 = Node 5 t1 t2
t4 = tree (filter odd [1..100])

-- An example tree containing a secret message!
t5 :: Tree Char
t5 = tree " bstyoouu rd oerrvialentikne"


-- | Define a recursive function that sums the numbers in a tree.
--
--   >>> sumTree Leaf
--   0
--
--   >>> sumTree t3
--   15
--
--   >>> sumTree t4
--   2500
--
sumTree :: Num a => Tree a -> a
sumTree = undefined


-- | Define a recursive function that checks whether a given element is
--   contained in a tree.
--
--   >>> contains 57 t4
--   True
--
--   >>> contains 58 t4
--   False
--
--   >>> contains 'k' t5
--   True
--
--   >>> contains 'z' t5
--   False
--
contains :: Eq a => a -> Tree a -> Bool
contains = undefined


-- | Define a function for converting a binary tree of type 'Tree a' into
--   a value of type 'b' by folding an accumulator function over the tree.
--   You should start by writing a type definition for the function.
--
--   Note there is more than one correct type for this function! Part of your
--   task is to figure out the type. For inspiration, think about the types of
--   the functions `foldl` and `foldr` for lists.
-- 
foldTree = undefined


-- | Use 'foldTree' to define a new version of 'sumTree'.
--
--   >>> sumTreeFold Leaf
--   0
--
--   >>> sumTreeFold t3
--   15
--
--   >>> sumTreeFold t4
--   2500
--
sumTreeFold :: Num a => Tree a -> a
sumTreeFold = undefined


-- | Use 'foldTree' to define a new version of 'contains'.
--
--   >>> containsFold 57 t4
--   True
--
--   >>> containsFold 58 t4
--   False
--
--   >>> containsFold 'v' t5
--   True
--
--   >>> containsFold 'q' t5
--   False
--
containsFold :: Eq a => a -> Tree a -> Bool
containsFold = undefined


-- | Implement a function that returns a list of values contained at each
--   level of the tree. That is, it should return a nested list where the
--   first list contains the value at the root, the second list contains the
--   values at its children, the third list contains the values at the next
--   level down the tree, and so on.
--
--   Apply this function to 't5' to reveal the secret message!
--
--   >>> levels Leaf
--   []
--   
--   >>> levels t1
--   [[1],[2]]
--   
--   >>> levels t2
--   [[3],[4]]
--   
--   >>> levels t3
--   [[5],[1,3],[2,4]]
--
--   >>> levels (tree [1..10])
--   [[1],[2,6],[3,4,7,9],[5,8,10]]
--
levels :: Tree a -> [[a]]
levels = undefined