added assignment 5 ex 2

README.md

@@ -14,6 +14,7 @@
     * [Lesson 2 - Higher order functions](#lesson-2---higher-order-functions)
     * [Lesson 3 - Data structures](#lesson-3---data-structures)
     * [Lesson 4 - Lists and pattern matching](#lesson-4---lists-and-pattern-matching)
+    * [Lesson 5 - Advanced lists and High order functions](#lesson-5---advanced-lists-and-high-order-functions)
   * [Assignments](#assignments)
     * [Assignment 1 - Square root](#assignment-1---square-root)
     * [Assignment 2 - Map-reduce](#assignment-2---map-reduce)
@@ -49,6 +50,11 @@
 - Pattern matching
 - Genericity
 
+### Lesson 5 - Advanced lists and High order functions
+[Files](src/Lesson5)
+- Lists
+- High order functions
+
 ## Assignments
 
 ### Assignment 1 - Square root
@@ -74,4 +80,12 @@
 - Expression interpreter
 - Binary tree
 - List functions
-- Predicates (any / every)
+- Predicates (any / every)
+
+### Assignment 5 - High-order functions on lists
+[Files](src/Assignment5)
+- High-order functions
+- Lists
+- Map
+- Fold
+- Zip

src/Assignment5/Folds.sc

@@ -0,0 +1,36 @@
+def areTrue(booleans: List[Boolean]): Boolean = {
+  booleans.foldLeft(true)((acc, value) => acc && value)
+}
+
+def lString(strings: List[String]): Int = {
+  strings.foldLeft(0)((len, str) => len + str.length)
+}
+
+def longest(strings: List[String]): Int = {
+  strings.foldLeft(0)((maxLen, str) => if (str.length > maxLen) str.length else maxLen)
+}
+
+def isPresent[T](list: List[T], target: T): Boolean = {
+  list.foldLeft(false)((res, value) => res || value == target)
+}
+
+def flattenList(list: List[Any]): List[Any] = {
+  list.foldRight(List.empty[Any])((elem, acc) => {
+    elem match {
+      case l: List[Any] => flattenList(l).foldRight(acc)((e, l) => e::l)
+      case _ => elem::acc
+    }
+  })
+}
+
+assert(!areTrue(List(true, true, false)))
+assert(areTrue(List(true, true, true)))
+
+assert(lString(List("Folding", "is", "fun")) == 12)
+
+assert(longest(List("What", "is", "the", "longest?")) == 8)
+
+assert(!isPresent(List(1, 2, 3, 4), 5))
+assert(isPresent(List(1, 2, 3, 4), 3))
+
+assert(flattenList(List(List(1, 1), 2, List(3, List(5, 8)))) == List(1, 1, 2, 3, 5, 8))

src/Assignment5/HOFOnLists.sc

@@ -0,0 +1,18 @@
+def lengthStrings(strings: List[String]): List[Int] = {
+  strings map (s => s.length)
+}
+
+def dup[T](elem: T, n: Int): List[T] = {
+  (1 to n).toList map (_ => elem)
+}
+
+def dot(list1: List[Int], list2: List[Int]): List[Int] = {
+  list1 zip list2 map (p => p._1 * p._2)
+}
+
+assert(lengthStrings(List("How","long","are","we?")) == List(3, 4, 3, 3))
+
+assert(dup("foo", 5) == List("foo", "foo", "foo", "foo", "foo"))
+assert(dup(List(1,2,3), 2) == List(List(1,2,3), List(1,2,3)))
+
+assert(dot(List(1,2,3), List(2,4,3)) == List(2,8,9))

src/Lesson5/Ex5_2.sc

@@ -0,0 +1,19 @@
+def length[A](x: List[A]): Int = {
+  x.foldRight(0)((elem: A, len: Int) => len + 1)
+}
+
+def map[A, B](x: List[A], f: A => B): List[B] = {
+  x.foldRight(List.empty[B])((elem: A, list: List[B]) => f(elem)::list)
+}
+
+def dup[A](l: List[A]): List[A] = {
+  l.flatMap(e => List(e, e))
+}
+
+def dup2[A](l: List[A]): List[A] = {
+  l.foldRight(List.empty[A])((e, l) => e::e::l)
+}
+
+length(1::2::3::4::Nil)
+map(1::2::3::4::Nil, (x: Int) => x * 2)
+dup(1::2::3::Nil)