// Scala Lecture 3//=================// naive quicksort with "On" functiondef sortOn(f: Int => Int, xs: List[Int]) : List[Int] = { if (xs.size < 2) xs else { val pivot = xs.head val (left, right) = xs.partition(f(_) < f(pivot)) sortOn(f, left) ::: pivot :: sortOn(f, right.tail) }} sortOn(identity, List(99,99,99,98,10,-3,2)) sortOn(n => - n, List(99,99,99,98,10,-3,2))// Recursion Again ;o)//====================// another well-known example: Towers of Hanoi//=============================================def move(from: Char, to: Char) = println(s"Move disc from $from to $to!")def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = { if (n == 0) () else { hanoi(n - 1, from, to, via) move(from, to) hanoi(n - 1, via, from, to) }} hanoi(4, 'A', 'B', 'C')// User-defined Datatypes//========================abstract class Treecase class Leaf(x: Int) extends Treecase class Node(s: String, left: Tree, right: Tree) extends Tree val lf = Leaf(20)val tr = Node("foo", Leaf(10), Leaf(23))val lst : List[Tree] = List(lf, tr)abstract class Colourcase object Red extends Colour case object Green extends Colour case object Blue extends Colourcase object Yellow extends Colourdef fav_colour(c: Colour) : Boolean = c match { case Green => true case _ => false }fav_colour(Blue)// ... a tiny bit more useful: Roman Numeralssealed abstract class RomanDigit case object I extends RomanDigit case object V extends RomanDigit case object X extends RomanDigit case object L extends RomanDigit case object C extends RomanDigit case object D extends RomanDigit case object M extends RomanDigit type RomanNumeral = List[RomanDigit] List(X,I,M,A)/*I -> 1II -> 2III -> 3IV -> 4V -> 5VI -> 6VII -> 7VIII -> 8IX -> 9X -> 10*/def RomanNumeral2Int(rs: RomanNumeral): Int = rs match { case Nil => 0 case M::r => 1000 + RomanNumeral2Int(r) case C::M::r => 900 + RomanNumeral2Int(r) case D::r => 500 + RomanNumeral2Int(r) case C::D::r => 400 + RomanNumeral2Int(r) case C::r => 100 + RomanNumeral2Int(r) case X::C::r => 90 + RomanNumeral2Int(r) case L::r => 50 + RomanNumeral2Int(r) case X::L::r => 40 + RomanNumeral2Int(r) case X::r => 10 + RomanNumeral2Int(r) case I::X::r => 9 + RomanNumeral2Int(r) case V::r => 5 + RomanNumeral2Int(r) case I::V::r => 4 + RomanNumeral2Int(r) case I::r => 1 + RomanNumeral2Int(r)}RomanNumeral2Int(List(I,V)) // 4RomanNumeral2Int(List(I,I,I,I)) // 4 (invalid Roman number)RomanNumeral2Int(List(V,I)) // 6RomanNumeral2Int(List(I,X)) // 9RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979RomanNumeral2Int(List(M,M,X,V,I,I)) // 2017// expressions (essentially trees)abstract class Expcase class N(n: Int) extends Exp // for numberscase class Plus(e1: Exp, e2: Exp) extends Expcase class Times(e1: Exp, e2: Exp) extends Expdef string(e: Exp) : String = e match { case N(n) => s"$n" case Plus(e1, e2) => s"(${string(e1)} + ${string(e2)})" case Times(e1, e2) => s"(${string(e1)} * ${string(e2)})"}val e = Plus(N(9), Times(N(3), N(4)))e.toStringprintln(string(e))def eval(e: Exp) : Int = e match { case N(n) => n case Plus(e1, e2) => eval(e1) + eval(e2) case Times(e1, e2) => eval(e1) * eval(e2) }println(eval(e))// simplification rules:// e + 0, 0 + e => e // e * 0, 0 * e => 0// e * 1, 1 * e => e//// (....9 ....)def simp(e: Exp) : Exp = e match { case N(n) => N(n) case Plus(e1, e2) => (simp(e1), simp(e2)) match { case (N(0), e2s) => e2s case (e1s, N(0)) => e1s case (e1s, e2s) => Plus(e1s, e2s) } case Times(e1, e2) => (simp(e1), simp(e2)) match { case (N(0), _) => N(0) case (_, N(0)) => N(0) case (N(1), e2s) => e2s case (e1s, N(1)) => e1s case (e1s, e2s) => Times(e1s, e2s) } }val e2 = Times(Plus(N(0), N(1)), Plus(N(0), N(9)))println(string(e2))println(string(simp(e2)))// String interpolations as patternsval date = "2019-11-26"val s"$year-$month-$day" = datedef parse_date(date: String) : Option[(Int, Int, Int)]= date match { case s"$year-$month-$day" => Some((day.toInt, month.toInt, year.toInt)) case s"$day/$month/$year" => Some((day.toInt, month.toInt, year.toInt)) case s"$day.$month.$year" => Some((day.toInt, month.toInt, year.toInt)) case _ => None} parse_date("2019-11-26")parse_date("26/11/2019")parse_date("26.11.2019")// guards in pattern-matchingdef foo(xs: List[Int]) : String = xs match { case Nil => s"this list is empty" case x :: xs if x % 2 == 0 => s"the first elemnt is even" case x :: y :: rest if x == y => s"this has two elemnts that are the same" case hd :: tl => s"this list is standard $hd::$tl"}foo(Nil)foo(List(1,2,3))foo(List(1,2))foo(List(1,1,2,3))foo(List(2,2,2,3))// Tail recursion//================def fact(n: BigInt): BigInt = if (n == 0) 1 else n * fact(n - 1)fact(10) //okfact(10000) // produces a stackoverflowdef factT(n: BigInt, acc: BigInt): BigInt = if (n == 0) acc else factT(n - 1, n * acc)factT(10, 1)println(factT(100000, 1))// there is a flag for ensuring a function is tail recursiveimport scala.annotation.tailrec@tailrecdef factT(n: BigInt, acc: BigInt): BigInt = if (n == 0) acc else factT(n - 1, n * acc)// for tail-recursive functions the Scala compiler// generates loop-like code, which does not need// to allocate stack-space in each recursive// call; Scala can do this only for tail-recursive// functionsdef length(xs: List[Int]) : Int = xs match { case Nil => 0 case _ :: tail => 1 + length(tail)}@tailrecdef lengthT(xs: List[Int], acc : Int) : Int = xs match { case Nil => acc case _ :: tail => lengthT(tail, 1 + acc)}lengthT(List.fill(10000000)(1), 0)// Sudoku//========type Pos = (Int, Int)val emptyValue = '.'val maxValue = 9val allValues = "123456789".toListval indexes = (0 to 8).toListdef empty(game: String) = game.indexOf(emptyValue)def isDone(game: String) = empty(game) == -1 def emptyPosition(game: String) : Pos = (empty(game) % maxValue, empty(game) / maxValue)def get_row(game: String, y: Int) = indexes.map(col => game(y * maxValue + col))def get_col(game: String, x: Int) = indexes.map(row => game(x + row * maxValue))def get_box(game: String, pos: Pos): List[Char] = { def base(p: Int): Int = (p / 3) * 3 val x0 = base(pos._1) val y0 = base(pos._2) for (x <- (x0 until x0 + 3).toList; y <- (y0 until y0 + 3).toList) yield game(x + y * maxValue)} def update(game: String, pos: Int, value: Char): String = game.updated(pos, value)def toAvoid(game: String, pos: Pos): List[Char] = (get_col(game, pos._1) ++ get_row(game, pos._2) ++ get_box(game, pos))def candidates(game: String, pos: Pos): List[Char] = allValues.diff(toAvoid(game, pos))def search(game: String): List[String] = { if (isDone(game)) List(game) else candidates(game, emptyPosition(game)).par. map(c => search(update(game, empty(game), c))).toList.flatten}def search1T(games: List[String]): Option[String] = games match { case Nil => None case game::rest => { if (isDone(game)) Some(game) else { val cs = candidates(game, emptyPosition(game)) search1T(cs.map(c => update(game, empty(game), c)) ::: rest) } }}def pretty(game: String): String = "\n" + (game.sliding(maxValue, maxValue).mkString(",\n"))// tail recursive version that searches // for all solutionsdef searchT(games: List[String], sols: List[String]): List[String] = games match { case Nil => sols case game::rest => { if (isDone(game)) searchT(rest, game::sols) else { val cs = candidates(game, emptyPosition(game)) searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols) } }}searchT(List(game3), List()).map(pretty)// tail recursive version that searches // for a single solutiondef search1T(games: List[String]): Option[String] = games match { case Nil => None case game::rest => { if (isDone(game)) Some(game) else { val cs = candidates(game, emptyPosition(game)) search1T(cs.map(c => update(game, empty(game), c)) ::: rest) } }}search1T(List(game3)).map(pretty)time_needed(10, search1T(List(game3)))// game with multiple solutionsval game3 = """.8...9743 |.5...8.1. |.1....... |8....5... |...8.4... |...3....6 |.......7. |.3.5...8. |9724...5.""".stripMargin.replaceAll("\\n", "")searchT(List(game3), Nil).map(pretty)search1T(List(game3)).map(pretty)// Moral: Whenever a recursive function is resource-critical// (i.e. works with large recursion depth), then you need to// write it in tail-recursive fashion.// // Unfortuantely, Scala because of current limitations in // the JVM is not as clever as other functional languages. It can // only optimise "self-tail calls". This excludes the cases of // multiple functions making tail calls to each other. Well,// nothing is perfect.