Differences

This shows you the differences between two versions of the page.

--- pp:scalalab2 [2022/05/15 23:54]
vbadoiu created
+++ pp:scalalab2 [2022/05/19 00:16] (current)
mihai.calitescu resolved typos
@@ Line 1: / Line 1: @@
-===== 5. Functional data representation =====
+===== L10. List and Datatypes and Functional data representation  =====
-==== 5.1. Nats ===
+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)
+  * learn about data types in Scala
+  * Use the knowledge in real world scenarios such as using sockets or iterating through the filesystem
+==== I. Common list operations ====
+**1.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>
+**1.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>
+**1.1.3.** 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>
+**1.1.4.** 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>
+==== 1.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.
+**1.2.1.** Find the average grade from a gradebook. You must use ''foldRight''.
+<code scala>
+def average(g: Gradebook): Double = ???
+</code>
+**1.2.2.** 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>
+**1.2.3.** 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>
+**1.2.4.** Implement a sorting algorithm such as merge sort (in ascending order) over gradebooks:
+<code scala>
+def mergeSort(l: Gradebook): Gradebook = {
+   def merge(u: Gradebook, v: Gradebook): Gradebook = ???
+   ???
+}
+</code>
+**1.2.5** Using [[https://www.scalatest.org/user_guide/using_assertions|assertions]] check that our merge sort implementation returns the same lists as the [[https://blog.knoldus.com/sorting-in-scala-using-sortedsortby-and-sortwith-function/|stor]] from Scala.
+===== II. Functional data representation =====
+==== 2.1. Nats ===
 Consider the following toy implementation of the type ''Nat'' which encodes natural numbers.
@@ Line 13: / Line 95: @@
 For instance, ''3'' will be encoded as the value: ''Succ(Succ(Succ(Zero)))''.
-**5.1.1.** Write a function which implements addition over Nats:
+**2.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'':
+**2.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''.
+**2.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 ===
+==== 2.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:
@@ Line 41: / Line 123: @@
 </code>
-**5.2.1.** Create the tree shown below:
+**2.2.1.** Create the tree shown below:
 <code scala>
 val tree = ???
@@ Line 53: / Line 135: @@
 </code>
-**5.2.2.** Implement the method ''size'' which determines the number of non-empty nodes from the BST.
+**2.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.
+**2.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).
+**2.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)''.
+**2.2.5.** Implement a method ''depth'' which returns the maximal depth of a BST. Hint: use the method: ''_.max(_)''.
-**5.2.6.** Implement a method ''depth'' which returns the maximal depth of a BST. Hint: use the method: ''_.max(_)''.
+**(!) 2.2.6.** 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.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.7.** 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:
-**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>
              t.successor(2) = 5
@@ Line 76: / Line 154: @@
 </code>
-** (!!) 5.2.11.** Implement a method ''remove(k)'' which removes element ''k'' from the BST.
+==== III. Scala in practice ====
+**3.1** Write a function reads the contents of a directory and returns True if a given file is in the folder.
+**3.2** Look into [[http://jsuereth.com/scala-arm/sockets.html|this example]] and implement a client and echo server using sockets (we are using the Java classes).
+**3.3** In the client, send a list to the server. The server will return the maximum number from that list.