Edit this page Backlinks This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong. ===== 4. Lists in Scala ===== Objectives: * get familiar with **pattern matching** lists, as well as common list operations from Scala and how they work * get familiar with common **higher-order functions** over lists (partition, map, foldRight, foldLeft, filter) ==== 4.1. Common list operations ==== **4.1.1.** Write a function which returns true if a list of integers has at least k elements. Use patterns. <code scala> def atLeastk(k: Int, l: List[Int]): Boolean = if (k == 0) ??? else ??? } </code> **4.1.2.** Write a function which returns the first ''n'' elements from a given list. The function should not be implemented as tail-recursive. <code scala> def take(n: Int, l: List[Int]): List[Int] = ??? //take(3,List(1,2,3,4,5)) = List(1,2,3) </code> **4.1.3.** Write a function which //drops// the first ''n'' elements from a given list. The function should not be implemented as tail-recursive. <code scala> def drop(n: Int, l: List[Int]): List[Int] = ??? //drop(3,List(1,2,3,4,5)) = List(4,5) </code> **4.1.4.** Write a function which takes a predicate ''p: Int => Boolean'', a list ''l'' and returns a sublist of ''l'' containing those elements for which ''p'' is true. The function should be **curried**. <code scala> def takeP(p: Int => Boolean)(l: List[Int]): List[Int] = ??? //takeP(_%2 == 0)(List(1,2,3,4,5,6)) = List(2,4,6) </code> **4.1.5.** Write a function which uses a predicate to partition (split) a list. <code scala> def part(p: Int => Boolean)(l: List[Int]): (List[Int], List[Int]) = ??? // part(_%2 == 0)(List(1,2,3,4,5,6)) = (List(2,4,6),List(1,3,5)) </code> ==== 4.2. Gradebooks ==== More general implementation of ''taken'', ''dropn'' and ''part'' are already implemented in Scala and can be used as member functions of lists. Examples are shown below: <code scala> val l = List(1,2,3,4,5,6,7,8,9) l.take(3) l.drop(3) l.partition(_%2 == 0) </code> In what follows, we shall encode a gradebook as a list of pairs ''(<name>,<grade>)'', where ''<name>'' is a String and ''<grade>'' is an Int. Example: <code scala> val gradebook = List(("G",3), ("F", 10), ("M",6), ("P",4)) </code> To make the type signatures more legible, we can introduce type aliases in Scala: <code scala> type Gradebook = List[(String,Int)] //the type Gradebook now refers to a list of pairs of String and Int </code> Add this type alias to your code before solving the following exercises. **4.2.1.** Write a function which adds one point to all students which have a passing grade (>= 5), and leaves all other grades unchanged. <code scala> def increment(g: Gradebook): Gradebook = g.map(???) </code> **4.2.2.** Find the average grade from a gradebook. You must use ''foldRight''. <code scala> def average(g: Gradebook): Double = ??? </code> **4.2.3.** Write a function which takes a gradebook and returns the percentage of failed vs. passed students, as a pair (x,y). <code scala> def percentage(g: Gradebook): (Double,Double) = ??? </code> **4.2.4.** Write a function which takes a gradebook and returns the list of names which have passed. Use filter and map from Scala. <code scala> def pass(g: Gradebook): List[String] = ??? </code> **4.2.5.** Implement merge-sort (in ascending order) over gradebooks: <code scala> def mergeSort(l: Gradebook): Gradebook = { def merge(u: Gradebook, v: Gradebook): Gradebook = ??? ??? } </code> **4.2.6** Write a function which takes a gradebook and reports all passing students in **descending** order of their grade. <code scala> def honorsList(g: Gradebook): List[String] = ??? </code> ===== 5. Functional data representation ===== ==== 5.1. Nats === Consider the following toy implementation of the type ''Nat'' which encodes natural numbers. <code scala> trait Nat {} case object Zero extends Nat {} case class Succ(n: Nat) extends Nat {} </code> For instance, ''3'' will be encoded as the value: ''Succ(Succ(Succ(Zero)))''. **5.1.1.** Write a function which implements addition over Nats: <code scala> def add(n: Nat, m: Nat): Nat = ??? </code> **5.1.2.** Write a function which converts a ''Nat'' to an ''Int'': <code scala> def toInt(n: Nat): Int = ??? </code> **5.1.3.** Write a function which converts an ''Int'' to a ''Nat''. <code scala> def fromInt(i: Int): Nat </code> ==== 5.2. Binary Search Trees === In a [[https://en.wikipedia.org/wiki/Binary_search_tree| binary search tree (BST)]], the key of the current node, is always: * **smaller** or equal than **all** keys in the **right** sub-tree. * **larger** or equal than **all** keys in the **left** sub-tree. Consider a binary search tree with keys as integers, encoded as follows: <code scala> trait ITree {} case object Empty extends ITree case class INode(key: Int, left: ITree, right: ITree) extends ITree </code> **5.2.1.** Create the tree shown below: <code scala> val tree = ??? /* 5 / \ 2 7 / \ \ 1 3 9 */ </code> **5.2.2.** Implement the method ''size'' which determines the number of non-empty nodes from the BST. **5.2.3.** Define the method ''contains'', which checks if a given integer is a member of the BST. **5.2.4.** Implement the method ''ins'' which inserts a new integer in the BST. **Note:** the insertion must return a new BST (the //binary search tree// property mentioned above must hold after insertion). **5.2.5.** Implement a method ''flatten'' which converts a BST into a list of integers. You must carefully choose the flattening method in such a way as to obtain **a sorted list** from the BST. Hint: you may use the list concatenation operator '':::'' (triple colons; example usage: ''List(1,2,3):::List(4,5)''. **5.2.6.** Implement a method ''depth'' which returns the maximal depth of a BST. Hint: use the method: ''_.max(_)''. **(!) 5.2.8.** Implement a method ''minimum'' which returns the smallest integer from a BST. (If the tree is empty, we return -1). Hint: use the example above, to guide your implementation. **5.2.9.** Implement a similar method ''maximum''. **(!) 5.2.10.** Implement a method ''successor(k)'' which returns **the smallest** integer from the BST, which is **larger** than ''k''. Use the following examples for your implementation: <code> 5 t.successor(2) = 5 / \ t.successor(5) = 6 2 7 t.successor(7) = 8 / \ 6 8 </code> ** (!!) 5.2.11.** Implement a method ''remove(k)'' which removes element ''k'' from the BST.