updated README

README.md

@@ -15,11 +15,14 @@
     * [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)
+    * [Midterm preparation](#midterm-preparation)
+    * [Midterm](#midterm)
   * [Assignments](#assignments)
     * [Assignment 1 - Square root](#assignment-1---square-root)
     * [Assignment 2 - Map-reduce](#assignment-2---map-reduce)
     * [Assignment 3 - Binary tree](#assignment-3---binary-tree)
     * [Assignment 4 - Lists and pattern matching](#assignment-4---lists-and-pattern-matching)
+    * [Assignment 5 - High-order functions on lists](#assignment-5---high-order-functions-on-lists)
 <!-- TOC -->
 
 
@@ -58,6 +61,10 @@
 ### Midterm preparation
 [Files](src/MidTermPrep1)
 
+### Midterm
+[Files](src/MidTerm1)
+
+
 ## Assignments
 
 ### Assignment 1 - Square root

src/MidTerm1/Ex1.sc

@@ -0,0 +1,7 @@
+val pi: List[Long] = List(3, 1, 4, 1, 5, 9, 2)
+val slice: List[Int] = List(4, 1, 5)
+
+pi.indexOfSlice(slice)
+
+//List("Hello", "world", "Scala").foldRight(0)((a, b) => a + b.length)
+List("Hello", "world", "Scala").foldLeft(0)((a, b) => a + b.length)

src/MidTerm1/Ex2.sc

@@ -0,0 +1,34 @@
+import scala.annotation.tailrec
+
+@tailrec
+def foldLeft[A, B](list: List[A])(init: B)(f: (B, A) => B): B = {
+  list match {
+    case Nil => init
+    case head::tail => foldLeft(tail)(f(init, head))(f)
+  }
+}
+
+@tailrec
+def dropWhile[T](list: List[T])(predicate: T => Boolean): List[T] = {
+  list match {
+    case head::tail if predicate(head) => dropWhile(tail)(predicate)
+    case _ => list
+  }
+}
+
+def predicates[T](list: List[T])(preds: List[T => Boolean]): List[T] = {
+  list.foldRight(List.empty[T])((e: T, l: List[T]) => {
+    //if (preds.foldLeft(true)((a, b) => a && b(e))) e::l
+    if (preds.forall(b => b(e))) e::l
+    else l
+  })
+}
+
+def fixedPoint(f: Int => Int): Int => Int = {
+  def func(x: Int): Int = {
+    val y: Int = f(x)
+    if (x == y) y
+    else f(y)
+  }
+  func
+}

src/MidTerm1/Ex3.sc

@@ -0,0 +1,37 @@
+import scala.annotation.tailrec
+
+abstract class Text {
+  def isEmpty: Boolean = {
+    this match {
+      case Chars(cs) => cs.isEmpty
+      case Concat(t1, t2) => t1.isEmpty && t2.isEmpty
+    }
+  }
+  def head: Char = {
+    this match {
+      case Chars(cs) => cs.head
+      case Concat(t1, t2) => if (t1.isEmpty) t2.head else t1.head
+    }
+  }
+  def tail: Text = {
+    this match {
+      case Chars(cs) => Chars(cs.tail)
+      case Concat(t1, t2) => if (t2.isEmpty) t1.tail else Concat(t1, t2.tail)
+    }
+  }
+  def map(f: Char => Char): Text = {
+    this match {
+      case Chars(cs) => Chars(cs.map(f))
+      case Concat(t1, t2) => Concat(t1.map(f), t2.map(f))
+    }
+  }
+}
+case class Chars(cs: List[Char]) extends Text
+case class Concat(t1: Text, t2: Text) extends Text
+
+@tailrec
+def equals(t1: Text, t2: Text): Boolean = {
+  if (t1.isEmpty) t2.isEmpty
+  else if (t2.isEmpty) false
+  else (t1.head == t2.head) && equals(t1.tail, t2.tail)
+}

src/MidTermPrep1/Ex2.sc

@@ -14,7 +14,23 @@ def balanceMatch(chars: List[Char]): Boolean = {
   checkStep(chars, 0)
 }
 
-balanceMatch("(if (x == 0) then max (1, x))".toList)
-balanceMatch("I told him (that it's not (yet) done). (But he wasn't listening)".toList)
-balanceMatch(")".toList)
-balanceMatch("())()".toList)
+def balanceMatch2(chars: List[Char]): Boolean = {
+  @tailrec
+  def checkStep(chars: List[Char], n: Int): Boolean = {
+    chars match {
+      case Nil => n == 0
+      case _ if n < 0 => false
+      case '('::rest => checkStep(rest, n + 1)
+      case ')'::rest => checkStep(rest, n - 1)
+      case _::rest => checkStep(rest, n)
+    }
+  }
+  checkStep(chars, 0)
+}
+
+balanceMatch2("(if (x == 0) then max (1, x))".toList)
+balanceMatch2("I told him (that it's not (yet) done). (But he wasn't listening)".toList)
+balanceMatch2(")".toList)
+balanceMatch2("())()".toList)
+balanceMatch2("())(()".toList)
+balanceMatch2("(".toList)