--- 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.