Add final problem statements

final/instructions/README.md

@@ -17,7 +17,14 @@ You should submit your answers by pushing your code to GitLab. Don't forget to p
 ## How to obtain questions
 
 
-We have prepared each assignment similarly to labs: the problem statements are markdown files in the following directory: https://gitlab.epfl.ch/lamp/cs206/-/tree/master/final/instructions/; the code skeleton for each problem is in a separate branch of your private GitLab repository.
+We have prepared each assignment similarly to labs: the problem statements are markdown files in the directory <https://gitlab.epfl.ch/lamp/cs206/-/tree/master/final/instructions>:
+
+- [Problem 1: Combiners](concpar22final01.md)
+- [Problem 2: Wait and Notify](concpar22final02.md)
+- [Problem 3: Futures](concpar22final03.md)
+- [Problem 4: Actors](concpar22final04.md)
+
+The code skeleton for each problem is in a separate branch of your private GitLab repository.
 
 ## How to submit your solutions
 
@@ -52,7 +59,7 @@ You need to push your code to GitLab to receive a grade. If you forget to submit
 
 We expect that the exam can be completed reasonably on a laptop with around 14" screen, 1920x1080 resolution, and a reasonable CPU and RAM, such that the price (with Windows or Linux OS) remains under 1000 CHF. You are allowed to bring an external keyboard and a mouse. You are not allowed to use any other screen than your laptop's (this includes laptop screens, external monitors, tablets such as ipads and others, or phones, to give a few examples). We ask you to turn off your mobile devices during the exam. If you need multiple power sockets during the exam, please bring a socket strip with a straight plug (not a 90 degree one), as we are only guaranteeing to provide one socket per one student. 
 
-We do not provide wired ethernet and expect you to use EPFL or Eduroam WiFi network, which will be available. Please test your setup at EPFL, including the WiFi connection, before the exam. Do not change your hardware setup during the exam, unless it becomes absolutely necessary for you to continue the work. We advise you to keep your setup as robust and simple as possible and focus on solving the questions.
+We do not provide wired ethernet and expect you to use EPFL WiFi network, which will be available. Please test your setup at EPFL, including the WiFi connection, before the exam. Do not change your hardware setup during the exam, unless it becomes absolutely necessary for you to continue the work. We advise you to keep your setup as robust and simple as possible and focus on solving the questions.
 
-If you anticipate difficultues in arranging your computer setup for the exam according to the above instructions, please contact us immediately to discuss possible solutions.
+If you anticipate difficulties in arranging your computer setup for the exam according to the above instructions, please contact us immediately to discuss possible solutions.
 

final/instructions/concpar22final01.md

+# Problem 1: Combiners
+
+## Setup
+
+Use the following commands to make a fresh clone of your repository:
+
+```
+git clone -b concpar22final01 git@gitlab.epfl.ch:lamp/student-repositories-s22/cs206-GASPAR.git concpar22final01
+```
+
+If you have issues with the IDE, try [reimporting the
+build](https://gitlab.epfl.ch/lamp/cs206/-/blob/master/labs/example-lab.md#troubleshooting),
+if you still have problems, use `compile` in sbt instead.
+
+## Exercise
+
+In this exercise, you will implement an array Combiner. The Combiner internally uses a double linked list whose nodes also point to their successor's successor and their predecessor's predecessor. Your goal is to complete the implementation of the (simplified) Combiner interface, by implementing the `result` method to compute the result array from this array combiner.
+
+Here you can see the declaration of the `DLLCombiner` class and the related `Node` class definition. Look at the `Lib` trait in the `lib.scala` file to find all definitions of relevant functions and classes.
+
+```scala
+  class Node(val value: Int):
+    protected var next: Node = null      // null for last node.
+    protected var next2: Node = null     // null for last node.
+    protected var previous: Node = null  // null for first node.
+    protected var previous2: Node = null // null for first node.
+
+    def getNext: Node = next // do NOT use in the result method
+    def getNext2: Node = next2
+    def getPrevious: Node = previous // do NOT use in the result method
+    def getPrevious2: Node = previous2
+
+    def setNext(n: Node): Unit = next = n
+    def setNext2(n: Node): Unit = next2 = n
+    def setPrevious(n: Node): Unit = previous = n
+    def setPrevious2(n: Node): Unit = previous2 = n
+
+
+  // Simplified Combiner interface
+  // Implements methods `+=` and `combine`
+  // Abstract methods should be implemented in subclasses
+  abstract class DLLCombiner
+```
+
+`DLLCombiner` class contains the implementation of methods `+=` and `combine`. You should look at them to better understand the structure of this array Combiner, before moving on to solving this exercise. 
+
+Your task in the exercise will be to implement the `result` method of the `DLLCombinerImplementation` class. This method should compute the result array from this array combiner. In your solution, you should **not** use methods `getNext` and `getPrevious`, but only `getNext2` and `getPrevious2`, to reduce the number of moving operations.
+
+According to the Combiner contract, `result` should work in parallel. Implement this method efficiently using 4 parallel tasks, by copying the double linked list to the array from both ends at the same time. Two threads should start from the start of the list and two from the end. In each case, one thread would be responsible for odd indexes and the other for even ones.
+
+Following the description above, your task in the exercise is to:
+
+ 1. Implement the four tasks to copy parts of the resulting array. Each task is responsible for copying one quarter of the array:
+   - `task1` copies every other Integer element of data array, starting from the first (index 0), up to the middle
+   - `task2` copies every other Integer element of data array, starting from the second, up to the middle
+   - `task3` copies every other Integer element of data array, starting from the second to last, up to the middle
+   - `task4` copies every other Integer element of data array, starting from the last, up to the middle
+ 2. Implement the method `result` to compute the result array in parallel using those four tasks.
+
+ Here is one example of the `result` method:
+
+```scala
+    val combiner1 = new DLLCombinerImplementation
+    combiner1 += 7 
+    combiner1 += 2 
+    combiner1 += 4 
+    combiner1 += 3 
+    combiner1 += 9 
+    combiner1 += 5 
+    combiner1 += 1 
+
+    val res1 = combiner1.result() // (7, 2, 4, 3, 9, 5, 1)
+```
+In this example, `task1` was responsible for copying elements at indexes 0 and 2, `task2` for copying the element at index 1, `task3` for copying elements at indexes 5 and 3, and `task4` for copying element at indexes 6 and 4.
+
+Here is another example with combining:
+
+```scala
+    val c1 = new DLLCombinerImplementation
+    c1 += 7 
+    c1 += 2 
+    c1 += 4 
+    c1 += 3 
+    c1 += 9 
+    c1 += 5 
+    c1 += 1 
+
+    val c2 = new DLLCombinerImplementation
+    c2 += 6 
+    c2 += 8 
+    c2 += 5 
+    c2 += 1 
+
+    val c3 = new DLLCombinerImplementation
+    c3 += 1
+
+    c1.combine(c2).combine(c3) 
+    val res = c1.result() // (7, 2, 4, 3, 9, 5, 1, 6, 8, 5, 1, 1)
+```
+
+You can get partial points for solving parts of this exercise.
+In your solution you should only make changes to the `DLLCombinerImplementation` class. You are not allowed to change the file `lib.scala`.

final/instructions/concpar22final02.md

+# Problem 2: Wait and Notify
+
+## Setup
+
+Use the following commands to make a fresh clone of your repository:
+
+```
+git clone -b concpar22final02 git@gitlab.epfl.ch:lamp/student-repositories-s22/cs206-GASPAR.git concpar22final02
+```
+
+If you have issues with the IDE, try [reimporting the
+build](https://gitlab.epfl.ch/lamp/cs206/-/blob/master/labs/example-lab.md#troubleshooting),
+if you still have problems, use `compile` in sbt instead.
+
+## Problem 2.1: Implement Barrier methods
+
+Your first task is to implement a _barrier_. A barrier acts as a synchronization point between multiple threads. It is used when you want all threads to finish a task before starting the next one. 
+
+You have to complete the following two methods in the `Barrier` class:
+1. `awaitZero` function waits for the count value to be zero.
+2. `countDown` function decrements the count by one. It notifies other threads if count is less than or equal to zero. 
+
+The barrier will be implemented using these functions. When the thread finish a task, it will decrement the count by using the `countDown` function. Then, it will call the `awaitZero` function to wait for other threads.
+
+## Problem 2.2: Use the Barrier to apply filters to an image
+
+In this part, each thread will apply an array of filters to each row of the image. Your task is to use the `Barrier` to act as a synchronization point while applying the filters. Each thread should wait for the other threads to complete the current filter before applying the next filter.
+
+`ImageLib.scala` provides an implementation of an image processing library with different filters. Each filter has a kernel which is applied on the image. `ImageLib.scala` implements four different filters. It provides an `applyFilter` method which applies a particular filter's kernel on a particular row on the input `Array` and generates the output in the output `Array`.
+
+The `ImageLib` class takes the size of an image as input. The image is a square matrix. The class has two buffers `buffer1` and `buffer2`. The initial image will be in `buffer1`. For the filtering task, you will switch between these buffers as input and output. For example, for the first filter `buffer1` will the input buffer and `buffer2` will be the output buffer. For the second filter `buffer2` will the input and `buffer1` will be the output and so on for subsequent filters.
+
+In `Problem2.scala` file where you will complete the `imagePipeline` function:
+
+- The `imagePipeline` function gets a array of filters and an array of row numbers. This filter needs to be applied to all the rows present in `row` array. After applying each filter, the thread has to wait for other threads to complete before applying the next filter. You will use barrier in this case. 
+- The `imagePipeline` function will return the output buffer. Note the output buffer can change between `buffer1` and `buffer2` depending on the number of filters applied.
+
+You can get partial points for solving parts of this exercise.

final/instructions/concpar22final03.md

+# Problem 3: Futures
+
+## Setup
+
+Use the following commands to make a fresh clone of your repository:
+
+```
+git clone -b concpar22final03 git@gitlab.epfl.ch:lamp/student-repositories-s22/cs206-GASPAR.git concpar22final03
+```
+
+If you have issues with the IDE, try [reimporting the
+build](https://gitlab.epfl.ch/lamp/cs206/-/blob/master/labs/example-lab.md#troubleshooting),
+if you still have problems, use `compile` in sbt instead.
+
+## Exercise
+
+The famous trading cards game Scala: The Programming has recently been gaining traction.  
+In this little exercise, you will propose to clients your services as a trader: Buying and selling cards in groups on demand.
+
+You are provided in the file `Economics.scala` with an interface to handle asynchronous buying and selling of cards and management of your money. Do not modify this file. More precisely, this interface defines:
+
+- A `Card`, which has a `name` and which you can own (`isMine == true`) or not (`isMine == false`). This is only to prevent a card from being sold or used multiple times, and you may not need it. You can find the value of a card using `valueOf`.
+- A `MoneyBag`, which is a container to transport money. Similarly, the money inside a bag can only be used once. The function `moneyIn` informs you of the bag's value, should you need it.
+- The function `sellCard`, which will sell a card through a `Future` and gives you back a `Future[MoneyBag]`. If you do not own the card, the `Future` will fail.
+- The function `buyCard`, which will consume a given `MoneyBag` and handle you, through a `Future`, the requested card. The provided bag must contain the exact amount of money corresponding to the card's value.
+- Finally, you have a bank account with the following functions: 
+	- `balance`: indicates your current monetary possession
+	- `withdraw`: substracts a given amount from your balance, and handles you a corresponding `Future[MoneyBag]`
+	- `deposit`: consumes a moneyBag and returns a `Future[Unit]` when the balance is updated. Note that you should not deposit empty moneyBags! If you do, you will get a failure, possibly indicating that you try to deposit the same bag twice.
+
+Your task in the exercise is to implement the function `orderDeck` in the file `Problem3.scala`. In a `Future`, start by checking that the sum of the money and the value of the cards the client gives you is large enough to buy the requested list of cards. If it is not, then the future should fail with a `NotEnoughMoneyException`.
+
+Then, sell all provided cards and put the received moneyBags in your bank accounts by chaining asynchronously the `Futures` of `sellCard` and `deposit`. You will obtain a `List[Future[Unit]]`, which should be converted into a `Future[Unit]` (so that when this `Future` returns, all deposits have finished). Those steps are provided for you in the helper function `sellListOfCards`.
+
+Then, do the opposite: withdraw `MoneyBags` of adequate value and use them to buy cards. Finally agregate the `List[Future[Card]]` into a `Future[List[Card]]`. You can implement those steps into the `buyListOfCards` function. Take inspiration from the given example `sellListOfCards`, and combine them in the `orderDeck` function.
+
+Final tip: Make good use of `map`, `flatMap` and `zip` on futures.

final/instructions/concpar22final04.md

+# Problem 4: Implementing Spotify using actors
+
+## Setup
+
+Use the following commands to make a fresh clone of your repository:
+
+```
+git clone -b concpar22final04 git@gitlab.epfl.ch:lamp/student-repositories-s22/cs206-GASPAR.git concpar22final04
+```
+
+If you have issues with the IDE, try [reimporting the
+build](https://gitlab.epfl.ch/lamp/cs206/-/blob/master/labs/example-lab.md#troubleshooting),
+if you still have problems, use `compile` in sbt instead.
+
+## Useful Links
+
+- [Akka Classic documentation](https://doc.akka.io/docs/akka/current/index-classic.html), in particular:
+    - [Classic Actors](https://doc.akka.io/docs/akka/current/actors.html)
+    - [Testing Classic Actors](https://doc.akka.io/docs/akka/current/testing.html)
+    - [Classic Logging](https://doc.akka.io/docs/akka/current/logging.html)
+- [Akka Classic API reference](https://doc.akka.io/api/akka/current/akka/actor/index.html)
+- [CS206 slides](https://gitlab.epfl.ch/lamp/cs206/-/tree/master/slides)
+
+## Overview
+
+In this exercise, you will implement the core functionalities of an online music streaming service. Users will be modelled as individual Akka actors.
+
+- Each user has a unique identifier and a name.
+- Each user can like and unlike songs (stored in the user's _liked songs_ list). Liked songs are sorted by reverse date of liking time (the last liked song must be the first element of the list). Elements of this list must be unique: a song can only be liked once. Liking a song twice should not impact the order.
+- Each user can subscribe and unsubscribe to other users to see what they are listening to. This is stored in the user's _activity feed_. The items in the activity feed are sorted by reverse date of activity time (the last added activity must be the first element of the list). Items in this list should be unique by user id. If a new activity with a user id that is already in the list is added, the former should be removed, so that we always see the latest activity for each user we have subscribed to.
+
+This corresponds to the core features of Spotify:
+
+![](./spotify.jpg)
+
+Your task is to implement the receive method of the `User` actor. See the enums in the `User` what messages and responses a `User` should handle.
+
+You are allowed to add private methods and attributes to the `User` class. You can also import any Scala collection you might find useful.
+
+To implement the last part (problem 4.4), you will need to interact with the `SongStore` actor passed as the `songStore` parameter. You do not need it for the other parts.
+
+## Problem 4.1: Getting user info (50 points)
+
+Your first task is to implement the `User.receive` method so that it handles the `GetInfo` and `GetHomepageData` messages. This will allow you to pass the first 2 tests.
+
+## Problem 4.2: Updating user info (70 points)
+
+Your second task is to expand `User.receive` so that it handles the `Like` and `Unlike` messages.
+
+## Problem 4.3: Updating user info (70 points)
+
+Your third task is to expand `User.receive` so that it handles the `Subscribe`, `Unsubscribe`, `AddActivity` and `Play` messages.
+
+## Problem 4.4: Displaying the homepage (60 points)
+
+Your last (but not least!) task is to expand `User.receive` so that it handles the `GetHomepageText` message.
+
+A `GetHomepageText` should be answered with `HomepageText` message. Here is an example of a `HomepageText.result`:
+
+```
+Howdy Ada!
+
+Liked Songs:
+* Sunny by Boney M.
+* J'irai où tu iras by Céline Dion & Jean-Jacques Goldman
+* Hold the line by TOTO
+
+Activity Feed:
+* Bob is listening to Straight Edge by Minor Threat
+* Donald is listening to Désenchantée by Mylène Farmer
+* Carol is listening to Breakfast in America by Supertramp
+```
+
+More precisely, it should contains the following lines in order:
+
+1. `Howdy $name!`, where `$name` is the name of the recipient user.
+2. A blank line
+3. `Liked Songs:`
+4. Zero or more lines listing the user's liked songs. Each of these lines should be of the form `"* ${song.title} by ${song.artist}`, where `${song.title}` is the title of the song and `${song.artist}` its artist.
+5. A blank line
+6. Zero or more lines listing the user activity feed items. Each of these lines should be of the form `* ${user.name} is listening to ${song.title} by ${song.artist}`, where `${user.name}` is the name of the user listening, `${song.title}` is the title of the song and `${song.artist}` its artist.
+
+In order to fetch the songs information (titles and artists), you should use the `songStore` actor passed as an argument to `User`. See the enums in the `SongsStore` companion object to learn how to interact with the song store.
+
+__Hint 1:__ to construct the result, you might find useful to use [`f-strings`](https://docs.scala-lang.org/overviews/core/string-interpolation.html#the-f-interpolator) and the [`List.mkString`](https://www.scala-lang.org/api/2.13.3/scala/collection/immutable/List.html#mkString(sep:String):String) method. Here is an example of how to use them:
+
+```scala
+val fruits = List("Banana", "Apple", "Kiwi")
+val result = f"""Fruits:
+${fruits.map(fruit => f"* ${fruit}").mkString("\n")}"""
+
+assert(result == """Fruits:
+* Banana
+* Apple
+* Kiwi""")
+```
+
+__Hint 2:__ if you need to send the result of a future to an actor, you should use the `pipeTo` method as described in the lectures and [here](https://doc.akka.io/docs/akka/2.5/futures.html#use-the-pipe-pattern).