diff -r 39c6b93718f0 -r 371acb50643d progs/lecture3.scala --- a/progs/lecture3.scala Fri Nov 24 01:26:01 2017 +0000 +++ b/progs/lecture3.scala Fri Nov 24 03:10:23 2017 +0000 @@ -1,7 +1,72 @@ // Scala Lecture 3 //================= -// adding two binary strings very, very lazy manner +// Pattern Matching +//================== + +// A powerful tool which is supposed to come to Java in a few years +// time (https://www.youtube.com/watch?v=oGll155-vuQ)...Scala already +// has it for many years. Other functional languages have it for +// decades. I think I would refuse to program in a language that +// does not have pattern matching....its is just so elegant. ;o) + +// The general schema: +// +// expression match { +// case pattern1 => expression1 +// case pattern2 => expression2 +// ... +// case patternN => expressionN +// } + + +// remember +val lst = List(None, Some(1), Some(2), None, Some(3)).flatten + + +def my_flatten(xs: List[Option[Int]]): List[Int] = { + ...? +} + + + + + +def my_flatten(lst: List[Option[Int]]): List[Int] = lst match { + case Nil => Nil + case None::xs => my_flatten(xs) + case Some(n)::xs => n::my_flatten(xs) +} + + +// another example including a catch-all pattern +def get_me_a_string(n: Int): String = n match { + case 0 => "zero" + case 1 => "one" + case 2 => "two" + case _ => "many" +} + +get_me_a_string(0) + +// you can also have cases combined +def season(month: String) = month match { + case "March" | "April" | "May" => "It's spring" + case "June" | "July" | "August" => "It's summer" + case "September" | "October" | "November" => "It's autumn" + case "December" | "January" | "February" => "It's winter" +} + +println(season("November")) + +// What happens if no case matches? + +println(season("foobar")) + + +// Collatz function on binary strings + +// adding two binary strings in a very, very lazy manner def badd(s1: String, s2: String) : String = (BigInt(s1, 2) + BigInt(s2, 2)).toString(2) @@ -21,33 +86,26 @@ bcollatz(100000000000000000L.toBinaryString) bcollatz(BigInt("1000000000000000000000000000000000000000000000000000000000000000000000000000").toString(2)) -def conv(c: Char) : Int = c match { - case '0' => 0 - case '1' => 1 + + + +// User-defined Datatypes +//======================== + +abstract class Colour +case class Red() extends Colour +case class Green() extends Colour +case class Blue() extends Colour + +def fav_colour(c: Colour) : Boolean = c match { + case Red() => false + case Green() => true + case Blue() => false } -def badds(s1: String, s2: String, carry: Int) : String = (s1, s2, carry) match { - case ("", "", 1) => "1" - case ("", "", 0) => "" - case (cs1, cs2, carry) => (conv(cs1.last) + conv(cs2.last) + carry) match { - case 3 => badds(cs1.dropRight(1), cs2.dropRight(1), 1) + '1' - case 2 => badds(cs1.dropRight(1), cs2.dropRight(1), 1) + '0' - case 1 => badds(cs1.dropRight(1), cs2.dropRight(1), 0) + '1' - case 0 => badds(cs1.dropRight(1), cs2.dropRight(1), 0) + '0' - } -} -def bcollatz2(s: String) : Long = (s.dropRight(1), s.last) match { - case ("", '1') => 1 // we reached 1 - case (rest, '0') => 1 + bcollatz2(rest) // even number => divide by two - case (rest, '1') => 1 + bcollatz2(badds(s + '1', '0' + s, 0)) // odd number => s + '1' is 2 * s + 1 - // add another s gives 3 * s + 1 -} - -bcollatz2(9.toBinaryString) -bcollatz2(837799.toBinaryString) -bcollatz2(100000000000000000L.toBinaryString) -bcollatz2(BigInt("1000000000000000000000000000000000000000000000000000000000000000000000000000").toString(2)) +// actually colors can be written with "object", +// because they do not take any arguments @@ -88,108 +146,190 @@ RomanNumeral2Int(List(M,M,X,V,I,I)) // 2017 -// Tail recursion -//================ + +// another example +//================= + +// Once upon a time, in a complete fictional country there were persons... -def my_contains(elem: Int, lst: List[Int]): Boolean = lst match { - case Nil => false - case x::xs => - if (x == elem) true else my_contains(elem, xs) +abstract class Person +case class King() extends Person +case class Peer(deg: String, terr: String, succ: Int) extends Person +case class Knight(name: String) extends Person +case class Peasant(name: String) extends Person + + +def title(p: Person): String = p match { + case King() => "His Majesty the King" + case Peer(deg, terr, _) => s"The ${deg} of ${terr}" + case Knight(name) => s"Sir ${name}" + case Peasant(name) => name } -my_contains(4, List(1,2,3)) -my_contains(2, List(1,2,3)) -my_contains(1000000, (1 to 1000000).toList) -my_contains(1000001, (1 to 1000000).toList) +def superior(p1: Person, p2: Person): Boolean = (p1, p2) match { + case (King(), _) => true + case (Peer(_,_,_), Knight(_)) => true + case (Peer(_,_,_), Peasant(_)) => true + case (Peer(_,_,_), Clown()) => true + case (Knight(_), Peasant(_)) => true + case (Knight(_), Clown()) => true + case (Clown(), Peasant(_)) => true + case _ => false +} + +val people = List(Knight("David"), + Peer("Duke", "Norfolk", 84), + Peasant("Christian"), + King(), + Clown()) + +println(people.sortWith(superior(_, _)).mkString(", ")) -//factorial V0.1 -import scala.annotation.tailrec + + +// Tail recursion +//================ def fact(n: Long): Long = if (n == 0) 1 else n * fact(n - 1) -fact(10000) // produces a stackoverflow +fact(10) //ok +fact(10000) // produces a stackoverflow + +def factT(n: BigInt, acc: BigInt): BigInt = + if (n == 0) acc else factT(n - 1, n * acc) + +factT(100000, 1) + +// there is a flag for ensuring a function is tail recursive +import scala.annotation.tailrec @tailrec def factT(n: BigInt, acc: BigInt): BigInt = if (n == 0) acc else factT(n - 1, n * acc) -println(factT(10000, 1)) -// the functions my_contains and factT are tail-recursive -// you can check this with - -import scala.annotation.tailrec - -// and the annotation @tailrec - -// for tail-recursive functions the scala compiler +// 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 +// call; Scala can do this only for tail-recursive // functions -// consider the following "stupid" version of the -// coin exchange problem: given some coins and a -// total, what is the change can you get? + + +// sudoku again + +val game0 = """.14.6.3.. + |62...4..9 + |.8..5.6.. + |.6.2....3 + |.7..1..5. + |5....9.6. + |..6.2..3. + |1..5...92 + |..7.9.41.""".stripMargin.replaceAll("\\n", "") -val coins = List(4,5,6,8,10,13,19,20,21,24,38,39,40) +type Pos = (Int, Int) +val EmptyValue = '.' +val MaxValue = 9 + +val allValues = "123456789".toList +val indexes = (0 to 8).toList + + +def empty(game: String) = game.indexOf(EmptyValue) +def isDone(game: String) = empty(game) == -1 +def emptyPosition(game: String) = + (empty(game) % MaxValue, empty(game) / MaxValue) + -def first_positive[B](lst: List[Int], f: Int => Option[B]): Option[B] = lst match { - case Nil => None - case x::xs => - if (x <= 0) first_positive(xs, f) - else { - val fx = f(x) - if (fx.isDefined) fx else first_positive(xs, f) +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) + val ys = (y0 until y0 + 3).toList + (x0 until x0 + 3).toList.flatMap(x => ys.map(y => game(x + y * MaxValue))) +} + +// this is not mutable!! +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)) + +//candidates(game0, (0,0)) + +def pretty(game: String): String = + "\n" + (game sliding (MaxValue, MaxValue) mkString "\n") + +// not tail recursive +def search(game: String): List[String] = { + if (isDone(game)) List(game) + else { + val cs = candidates(game, emptyPosition(game)) + cs.map(c => search(update(game, empty(game), c))).toList.flatten } } - -import scala.annotation.tailrec - -def search(total: Int, coins: List[Int], cs: List[Int]): Option[List[Int]] = { - if (total < cs.sum) None - else if (cs.sum == total) Some(cs) - else first_positive(coins, (c: Int) => search(total, coins, c::cs)) +// tail recursive version that searches +// for all solution +def 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) + } + } } -search(11, coins, Nil) -search(111, coins, Nil) -search(111111, coins, Nil) - -val junk_coins = List(4,-2,5,6,8,0,10,13,19,20,-3,21,24,38,39, 40) -search(11, junk_coins, Nil) -search(111, junk_coins, Nil) - - -import scala.annotation.tailrec - -@tailrec -def searchT(total: Int, coins: List[Int], - acc_cs: List[List[Int]]): Option[List[Int]] = acc_cs match { +// tail recursive version that searches +// for a single solution +def search1T(games: List[String]): Option[String] = games match { case Nil => None - case x::xs => - if (total < x.sum) searchT(total, coins, xs) - else if (x.sum == total) Some(x) - else searchT(total, coins, coins.filter(_ > 0).map(_::x) ::: xs) + 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) + } + } } -val start_acc = coins.filter(_ > 0).map(List(_)) -searchT(11, junk_coins, start_acc) -searchT(111, junk_coins, start_acc) -searchT(111111, junk_coins, start_acc) +// game with multiple solutions +val 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), List()).map(pretty) +search1T(List(game3)).map(pretty) // Moral: Whenever a recursive function is resource-critical // (i.e. works with large recursion depths), then you need to // write it in tail-recursive fashion. // -// Unfortuantely, the Scala is because of current limitations in -// the JVM not as clever as other functional languages. It can +// 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. @@ -230,59 +370,43 @@ def first[A, B](xs: List[A], f: A => Option[B]): Option[B] = ... -// polymorphic classes -//(trees with some content) - -abstract class Tree[+A] -case class Node[A](elem: A, left: Tree[A], right: Tree[A]) extends Tree[A] -case object Leaf extends Tree[Nothing] -val t0 = Node('4', Node('2', Leaf, Leaf), Node('7', Leaf, Leaf)) +// Cool Stuff +//============ -def insert[A](tr: Tree[A], n: A): Tree[A] = tr match { - case Leaf => Node(n, Leaf, Leaf) - case Node(m, left, right) => - if (n == m) Node(m, left, right) - else if (n < m) Node(m, insert(left, n), right) - else Node(m, left, insert(right, n)) -} + -// the A-type needs to be ordered - -abstract class Tree[+A <% Ordered[A]] -case class Node[A <% Ordered[A]](elem: A, left: Tree[A], - right: Tree[A]) extends Tree[A] -case object Leaf extends Tree[Nothing] +// Implicits +//=========== +// +// For example adding your own methods to Strings: +// Imagine you want to increment strings, like +// +// "HAL".increment +// +// you can avoid ugly fudges, like a MyString, by +// using implicit conversions. -def insert[A <% Ordered[A]](tr: Tree[A], n: A): Tree[A] = tr match { - case Leaf => Node(n, Leaf, Leaf) - case Node(m, left, right) => - if (n == m) Node(m, left, right) - else if (n < m) Node(m, insert(left, n), right) - else Node(m, left, insert(right, n)) +implicit class MyString(s: String) { + def increment = for (c <- s) yield (c + 1).toChar } +"HAL".increment -val t1 = Node(4, Node(2, Leaf, Leaf), Node(7, Leaf, Leaf)) -insert(t1, 3) - -val t2 = Node('b', Node('a', Leaf, Leaf), Node('f', Leaf, Leaf)) -insert(t2, 'e') // Regular expressions - the power of DSLs in Scala //================================================== - abstract class Rexp -case object ZERO extends Rexp -case object ONE extends Rexp -case class CHAR(c: Char) extends Rexp +case object ZERO extends Rexp // nothing +case object ONE extends Rexp // the empty string +case class CHAR(c: Char) extends Rexp // a character c case class ALT(r1: Rexp, r2: Rexp) extends Rexp // alternative r1 + r2 -case class SEQ(r1: Rexp, r2: Rexp) extends Rexp // sequence r1 r2 +case class SEQ(r1: Rexp, r2: Rexp) extends Rexp // sequence r1 o r2 case class STAR(r: Rexp) extends Rexp // star r* @@ -326,63 +450,6 @@ val number = sign ~ digit ~ digit.% -//implement print_re - - - -// Lazyness with style -//===================== - -// The concept of lazy evaluation doesn’t really exist in -// non-functional languages, but it is pretty easy to grasp. -// Consider first - -def square(x: Int) = x * x - -square(42 + 8) - -// this is called strict evaluation - - -def expensiveOperation(n: BigInt): Boolean = expensiveOperation(n + 1) -val a = "foo" -val b = "bar" - -val test = if ((a == b) || expensiveOperation(0)) true else false - -// this is called lazy evaluation -// you delay compuation until it is really -// needed; once calculated though, does not -// need to be re-calculated - -// a useful example is -def time_needed[T](i: Int, code: => T) = { - val start = System.nanoTime() - for (j <- 1 to i) code - val end = System.nanoTime() - ((end - start) / i / 1.0e9) + " secs" -} - - -// streams (I do not care how many) -// primes: 2, 3, 5, 7, 9, 11, 13 .... - -def generatePrimes (s: Stream[Int]): Stream[Int] = - s.head #:: generatePrimes(s.tail filter (_ % s.head != 0)) - -val primes: Stream[Int] = generatePrimes(Stream.from(2)) - -primes.take(10).toList - -primes.filter(_ > 100).take(2000).toList - -time_needed(1, primes.filter(_ > 100).take(2000).toList) -time_needed(1, primes.filter(_ > 100).take(2000).toList) - - - -// streams are useful for implementing search problems ;o) - @@ -397,5 +464,5 @@ // You can be productive on Day 1, but the language is deep. // I like best about Scala that it lets me write -// concise, readable code +// concise, readable code.