Exercise: Prelude.sum [*]

Redefine the sum function which sums elements of a list of numbers.

sum :: Num a => [a] -> a

Exercise: Prelude.last [*]

Redefine the last function which returns the last element of a list.

last :: [a]{-non-empty-} -> a

Exercise: Prelude.init [*]

Redefine the init function which returns all the elements of a list but the last.

init :: [a]{-non-empty-} -> [a]

Exercise: Prelude.minimum [*]

Redefine the minimum function which returns the element with the smallest value in the list.

Hint: Use the min function which returns the smaller one from its two parameters.

minimum :: Ord a => [a]{-finite, non-empty-} -> a

Exercise: Prelude.concat [*]

Redefine the concat function which concatenates arbitrary number of lists of the same type of elements.

concat :: [[a]] -> [a]

--    concat [[1,2], [3,4], [5,6]]
-- == concat ([1,2]: [3,4]: [5,6]: [])
-- == [1,2] ++ concat ([3,4]: [5,6]: [])
-- == [1,2] ++ [3,4] ++ concat ([5,6]: [])
-- == [1,2] ++ [3,4] ++ [5,6] ++ concat []
-- == [1,2] ++ [3,4] ++ [5,6] ++ []
-- == [1, 2, 3, 4, 5, 6]

Exercise: (Prelude.++) [*]

Redefine the (++) operator which concatenates two lists.

(++) :: [a] -> [a] -> [a]

Exercise: Merge Lists

Define a function to merge lists. The resulting should contain elements of both input lists ordered.

merge :: [a] -> [a] -> [a]

Exercise: Prelude.zip [*]

Redefine the function for combining lists into a list of pairs (which is called “zipping”).

zip :: [a] -> [b] -> [(a,b)]

Exercise: Data.List.isPrefixOf [*]

Redefine the isPrefixOf function from the Data.List module which determines if the second parameter starts with the first parameter (and contains it entirely). If this is true, then we say that the first parameter is the prefix of the second.

isPrefixOf :: Eq a => [a] -> [a] -> Bool

Exercise: Prelude.elem [*]

Redefine the elem function which decides a value is element of a list.

elem :: Eq a => a -> [a]{-finite-} -> Bool

Exercise: Data.List.nub [*]

Redefine the nub function from the Data.List module. The nub function is to remove duplicate elements from a list.

nub :: Eq a => [a] -> [a]

Exercise: Evaluate Polynomial

Evaluate a polynomial given by its coefficients at a given point.

polinom :: Num a => [a] -> a -> a

Exercise: Split List

Split a list into segments of a given length.

runs :: Int -> [a] -> [[a]]

Exercise: Split List Differently [*]

Split a list into segments of lengths given in another list.

slice :: [Int] -> [a] -> [[a]]

Exercise: Every nth Element

Define the every function which takes every nth of a list.

every :: Int -> [a] -> [a]

Exercise: Quicksort [*]

Define the quicksort (where a list is partitioned into elements smaller and larger than its head).

qsort :: Ord a => [a] -> [a]

Exercise: Data.List.tails [*]

Generate all possible suffices for a list. (This function is already defined in the Data.List module.)

tails :: [a] -> [[a]] 

Exercise: Data.List.inits

Generate all possible prefices for a list. (This function is already defined in the Data.List module.)

inits :: [a] -> [[a]]

Exercise: Deletions of an Element from a List

Delete an element from a list in all possible ways.

deletions :: [a] -> [[a]]

Exercise: Insertions of an Element to a List

Insert an element into a list in all possible ways.

insertions :: a -> [a] -> [[a]]

Exercise: Permutations

Give all the possible permutations for a list.

permutations :: [a] -> [[a]]

[“123”,“213”,“231”,“132”,“312”,“321”]

Exercise: Decompose Integer into Sums

part :: Int -> [[Int]]

Decompose an integer into sums in all possible ways.

Each sum is represented as a list (e.g. 1 + 2 + 4 is representead as [1,2,4]).

Let the ordering matter in the sum (i.e. 1 + 2 and 2 + 1 are different decompositions).

Hint: The algorithm is as follows.

If we want to decompose the integer 4 in all possible way, then it can be done in the following way:

• 4 is a decomposition of 4.
• 3 + x is a decomposition of 4 if x is a decomposition of 1. Since 1 can be only decomposed in one way, this will give us 3 + 1.
• 2 + x is a decomposition of 4 if x is a decomposition of 2. Since decompositions of 2 are 2 and 1 + 1, this will give us 3 + 2 and 3 + 1 + 1.
• 1 + x is a decomposition of 4 if x is a decomposition of 3. Since decompositions of 3 are 3, 2 + 1, 1 + 2, and 1 + 1 + 1, this will give us 1 + 3, 1 + 2 + 1, 1 + 1 + 2, and 1 + 1 + 1 + 1.

We called the part function in each case. Then we concatenate the results of all the four cases.