## Exercise 1

Write (two versions of) a function `myReplicate` that given an integer `n` and a value `v` returns a list of length `n` initialized with `v`, namely all elements are equal to `v`.

• Goal: Warming up!
• Expected output: Two implementations of the above function: `myReplicateR` which uses recursion on natural numbers, and `myReplicateC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 2

Write (two versions of) a function `sumOdd` that given a list of integers computes the sum of the values that are odd.

Hint: consider the functions `odd` and `even` of the `Prelude`.

• Goal: Warming up (part 2)!
• Expected output: Two implementations of the above function: `sumOddR` which uses recursion on lists, and `sumOddC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 3

Write (two versions of) a function `repl` that given a list `xs` and a integer `n` returns a list containing the elements of `xs` replicated `n` times.

Hint: you can use the function `myReplicate` of Exercise 1.

• Goal: Playing with lists.
• Expected output: Two implementations of the above function: `replR` which uses recursion on lists, and `replC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 4

Write a function `totalLength` that given a list of strings `xs` computes the sum of the lengths of the strings starting with the character '`A`'.

• Goal: Test your skills with lists and strings.
• Expected output: Two implementations of the above function: `totalLengthR` which uses recursion on lists, and `totalLengthC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 5

Write a function `filterOdd` that given a list `xs` returns a new list obtained from `xs` by removing the elements at odd positions.

Hint: Here "odd positions" means the first, third, fifth, etc position.

• Goal: Playing with lists (part 2).
• Expected output: Two implementations of the above function: `filterOddR` which uses recursion on lists, and `filterOddC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 6

Write a function `titlecase` that given a string `s` converts it to titlecase by uppercasing the first letter of every word.

Hint: consider using the function `words`, `unwords` of the `Prelude` and the function `toUpper` of the module `Data.Char`. To make accessible this last function in your code use ```import Data.Char (toUpper)```.

• Goal: Experimenting with strings.
• Expected output: Two implementations of the above function: `titlecaseR` which uses recursion on lists, and `titlecaseC` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 7

Write a function `countVowelPali` that given a list of strings `xs` returns the total number of vowels in strings that are palindromes. For example,

```countVowelPali ["anna", "banana", "civic", "mouse"] = 4
```
• Goal: Fun with strings and lists (again :P).
• Expected output: Two implementations of the above function: `countVowelPali` which uses recursion on lists, and `countVowelPali` that uses combinators (i.e., functions like `map`, `filter`, `foldl/r` from the Haskell Prelude).

## Exercise 8

Recall the higher-order combinator `map` from the `Prelude`. Implement it using the combinator `foldl`.

• Goal: Experimenting with combinators.
• Expected output: The required implementation of the `map` combinator.

## Exercise 9

Consider the following definition of binary trees:

```data IntTree = Leaf Int | Node (Int, IntTree, IntTree)
```
1. Implement `tmap`, a "tree version" of the `map` combinator. More precisely, the function `tmap` should take a function `f` and a tree `t` and should apply `f` to each value in `t`.
2. Using `tmap` implement the function `succTree` taking a tree `t` and computing a tree whose elements are the successors of the values in `t`.
3. Write a function `sumSucc` taking a tree `t` and computing the sum of the elements of `succTree t`.
• Goal: Experimenting with trees.
• Expected output: An implementation of the three required functions.

Created: 2022-10-25 Tue 18:40

Validate