4 // adding two binary strings very, very lazy manner

     4 // Pattern Matching

     5 //==================

     6 

     7 // A powerful tool which is supposed to come to Java in a few years

     8 // time (https://www.youtube.com/watch?v=oGll155-vuQ)...Scala already

     9 // has it for many years. Other functional languages have it for

    10 // decades. I think I would refuse to program in a language that

    11 // does not have pattern matching....its is just so elegant. ;o)

    12 

    13 // The general schema:

    14 //

    15 //    expression match {

    16 //       case pattern1 => expression1

    17 //       case pattern2 => expression2

    18 //       ...

    19 //       case patternN => expressionN

    20 //    }

    21 

    22 

    23 // remember

    24 val lst = List(None, Some(1), Some(2), None, Some(3)).flatten

    25 

    26 

    27 def my_flatten(xs: List[Option[Int]]): List[Int] = {

    28   ...?

    29 }

    30 

    31 

    32 

    33 

    34 

    35 def my_flatten(lst: List[Option[Int]]): List[Int] = lst match {

    36   case Nil => Nil

    37   case None::xs => my_flatten(xs)

    38   case Some(n)::xs => n::my_flatten(xs)

    39 }

    40 

    41 

    42 // another example including a catch-all pattern

    43 def get_me_a_string(n: Int): String = n match {

    44   case 0 => "zero"

    45   case 1 => "one"

    46   case 2 => "two"

    47   case _ => "many"

    48 }

    49 

    50 get_me_a_string(0)

    51 

    52 // you can also have cases combined

    53 def season(month: String) = month match {

    54   case "March" | "April" | "May" => "It's spring"

    55   case "June" | "July" | "August" => "It's summer"

    56   case "September" | "October" | "November" => "It's autumn"

    57   case "December" | "January" | "February" => "It's winter"

    58 }

    59  

    60 println(season("November"))

    61 

    62 // What happens if no case matches?

    63 

    64 println(season("foobar"))

    65 

    66 

    67 // Collatz function on binary strings

    68 

    69 // adding two binary strings in a very, very lazy manner

    24 def conv(c: Char) : Int = c match {

    89 

    25   case '0' => 0

    90 

    26   case '1' => 1

    91 

    27 }

    92 // User-defined Datatypes

    28 

    93 //========================

    29 def badds(s1: String, s2: String, carry: Int) : String = (s1, s2, carry) match {

    94 

    30   case ("", "", 1) => "1"

    95 abstract class Colour

    31   case ("", "", 0) => ""

    96 case class Red() extends Colour 

    32   case (cs1, cs2, carry) => (conv(cs1.last) + conv(cs2.last) + carry) match {

    97 case class Green() extends Colour 

    33     case 3 => badds(cs1.dropRight(1), cs2.dropRight(1), 1) + '1'

    98 case class Blue() extends Colour

    34     case 2 => badds(cs1.dropRight(1), cs2.dropRight(1), 1) + '0'

    99 

    35     case 1 => badds(cs1.dropRight(1), cs2.dropRight(1), 0) + '1'

   100 def fav_colour(c: Colour) : Boolean = c match {

    36     case 0 => badds(cs1.dropRight(1), cs2.dropRight(1), 0) + '0'

   101   case Red()   => false

    37   }

   102   case Green() => true

    38 } 

   103   case Blue()  => false 

    39 

   104 }

    40 def bcollatz2(s: String) : Long = (s.dropRight(1), s.last) match {

   105 

    41   case ("", '1') => 1                                          // we reached 1

   106 

    42   case (rest, '0') => 1 + bcollatz2(rest)                      // even number => divide by two

   107 // actually colors can be written with "object",

    43   case (rest, '1') => 1 + bcollatz2(badds(s + '1', '0' + s, 0))   // odd number => s + '1' is 2 * s + 1

   108 // because they do not take any arguments

    44                                                                   //         add another s gives 3 * s + 1  

    45 } 

    46 

    47 bcollatz2(9.toBinaryString)

    48 bcollatz2(837799.toBinaryString)

    49 bcollatz2(100000000000000000L.toBinaryString)

    50 bcollatz2(BigInt("1000000000000000000000000000000000000000000000000000000000000000000000000000").toString(2))

   114 fact(10000)                        // produces a stackoverflow

   199 fact(10)              //ok

   200 fact(10000)           // produces a stackoverflow

   201 

   202 def factT(n: BigInt, acc: BigInt): BigInt =

   203   if (n == 0) acc else factT(n - 1, n * acc)

   204 

   205 factT(100000, 1)

   206 

   207 // there is a flag for ensuring a function is tail recursive

   208 import scala.annotation.tailrec

   121 println(factT(10000, 1))

   215 

   122 

   216 // for tail-recursive functions the Scala compiler

   123 // the functions my_contains and factT are tail-recursive 

   124 // you can check this with 

   125 

   126 import scala.annotation.tailrec

   127 

   128 // and the annotation @tailrec

   129 

   130 // for tail-recursive functions the scala compiler

   133 // call; scala can do this only for tail-recursive

   219 // call; Scala can do this only for tail-recursive

   136 // consider the following "stupid" version of the

   222 

   137 // coin exchange problem: given some coins and a

   223 

   138 // total, what is the change can you get?

   224 // sudoku again

   139 

   225 

   140 val coins = List(4,5,6,8,10,13,19,20,21,24,38,39,40)

   226 val game0 = """.14.6.3..

   141 

   227               |62...4..9

   142 def first_positive[B](lst: List[Int], f: Int => Option[B]): Option[B] = lst match {

   228               |.8..5.6..

   229               |.6.2....3

   230               |.7..1..5.

   231               |5....9.6.

   232               |..6.2..3.

   233               |1..5...92

   234               |..7.9.41.""".stripMargin.replaceAll("\\n", "")

   235 

   236 type Pos = (Int, Int)

   237 val EmptyValue = '.'

   238 val MaxValue = 9

   239 

   240 val allValues = "123456789".toList

   241 val indexes = (0 to 8).toList

   242 

   243 

   244 def empty(game: String) = game.indexOf(EmptyValue)

   245 def isDone(game: String) = empty(game) == -1 

   246 def emptyPosition(game: String) = 

   247   (empty(game) % MaxValue, empty(game) / MaxValue)

   248 

   249 

   250 def get_row(game: String, y: Int) = 

   251   indexes.map(col => game(y * MaxValue + col))

   252 def get_col(game: String, x: Int) = 

   253   indexes.map(row => game(x + row * MaxValue))

   254 

   255 def get_box(game: String, pos: Pos): List[Char] = {

   256     def base(p: Int): Int = (p / 3) * 3

   257     val x0 = base(pos._1)

   258     val y0 = base(pos._2)

   259     val ys = (y0 until y0 + 3).toList

   260     (x0 until x0 + 3).toList.flatMap(x => ys.map(y => game(x + y * MaxValue)))

   261 }

   262 

   263 // this is not mutable!!

   264 def update(game: String, pos: Int, value: Char): String = 

   265   game.updated(pos, value)

   266 

   267 def toAvoid(game: String, pos: Pos): List[Char] = 

   268   (get_col(game, pos._1) ++ get_row(game, pos._2) ++ get_box(game, pos))

   269 

   270 def candidates(game: String, pos: Pos): List[Char] = 

   271   allValues.diff(toAvoid(game,pos))

   272 

   273 //candidates(game0, (0,0))

   274 

   275 def pretty(game: String): String = 

   276   "\n" + (game sliding (MaxValue, MaxValue) mkString "\n")

   277 

   278 // not tail recursive 

   279 def search(game: String): List[String] = {

   280   if (isDone(game)) List(game)

   281   else {

   282     val cs = candidates(game, emptyPosition(game))

   283     cs.map(c => search(update(game, empty(game), c))).toList.flatten

   284   }

   285 }

   286 

   287 // tail recursive version that searches 

   288 // for all solution

   289 def searchT(games: List[String], sols: List[String]): List[String] = games match {

   290   case Nil => sols

   291   case game::rest => {

   292     if (isDone(game)) searchT(rest, game::sols)

   293     else {

   294       val cs = candidates(game, emptyPosition(game))

   295       searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols)

   296     }

   297   }

   298 }

   299 

   300 // tail recursive version that searches 

   301 // for a single solution

   302 def search1T(games: List[String]): Option[String] = games match {

   144   case x::xs => 

   304   case game::rest => {

   145     if (x <= 0) first_positive(xs, f)

   305     if (isDone(game)) Some(game)

   147       val fx = f(x)

   307       val cs = candidates(game, emptyPosition(game))

   148       if (fx.isDefined) fx else first_positive(xs, f)

   308       search1T(cs.map(c => update(game, empty(game), c)) ::: rest)

   309     }

   152 

   313 // game with multiple solutions

   153 import scala.annotation.tailrec

   314 val game3 = """.8...9743

   154 

   315               |.5...8.1.

   155 def search(total: Int, coins: List[Int], cs: List[Int]): Option[List[Int]] = {

   316               |.1.......

   156   if (total < cs.sum) None 

   317               |8....5...

   157   else if (cs.sum == total) Some(cs) 

   318               |...8.4...

   158   else first_positive(coins, (c: Int) => search(total, coins, c::cs))

   319               |...3....6

   159 }

   320               |.......7.

   160 

   321               |.3.5...8.

   161 search(11, coins, Nil)

   322               |9724...5.""".stripMargin.replaceAll("\\n", "")

   162 search(111, coins, Nil)

   323 

   163 search(111111, coins, Nil)

   324 searchT(List(game3), List()).map(pretty)

   164 

   325 search1T(List(game3)).map(pretty)

   165 val junk_coins = List(4,-2,5,6,8,0,10,13,19,20,-3,21,24,38,39, 40)

   166 search(11, junk_coins, Nil)

   167 search(111, junk_coins, Nil)

   168 

   169 

   170 import scala.annotation.tailrec

   171 

   172 @tailrec

   173 def searchT(total: Int, coins: List[Int], 

   174             acc_cs: List[List[Int]]): Option[List[Int]] = acc_cs match {

   175   case Nil => None

   176   case x::xs => 

   177     if (total < x.sum) searchT(total, coins, xs)

   178     else if (x.sum == total) Some(x) 

   179     else searchT(total, coins, coins.filter(_ > 0).map(_::x) ::: xs)

   180 }

   181 

   182 val start_acc = coins.filter(_ > 0).map(List(_))

   183 searchT(11, junk_coins, start_acc)

   184 searchT(111, junk_coins, start_acc)

   185 searchT(111111, junk_coins, start_acc)

   191 // Unfortuantely, the Scala is because of current limitations in 

   331 // Unfortuantely, Scala because of current limitations in 

   192 // the JVM not as clever as other functional languages. It can 

   332 // the JVM is not as clever as other functional languages. It can 

   233 // polymorphic classes

   373 

   234 //(trees with some content)

   374 // Cool Stuff

   235 

   375 //============

   236 abstract class Tree[+A]

   376 

   237 case class Node[A](elem: A, left: Tree[A], right: Tree[A]) extends Tree[A]

   377 

   238 case object Leaf extends Tree[Nothing]

   378 

   239 

   379 

   240 val t0 = Node('4', Node('2', Leaf, Leaf), Node('7', Leaf, Leaf))

   380 // Implicits 

   241 

   381 //===========

   242 def insert[A](tr: Tree[A], n: A): Tree[A] = tr match {

   382 //

   243   case Leaf => Node(n, Leaf, Leaf)

   383 // For example adding your own methods to Strings:

   244   case Node(m, left, right) => 

   384 // Imagine you want to increment strings, like

   245     if (n == m) Node(m, left, right) 

   385 //

   246     else if (n < m) Node(m, insert(left, n), right)

   386 //     "HAL".increment

   247     else Node(m, left, insert(right, n))

   387 //

   248 }

   388 // you can avoid ugly fudges, like a MyString, by

   249 

   389 // using implicit conversions.

   250 

   390 

   251 // the A-type needs to be ordered

   391 

   252 

   392 implicit class MyString(s: String) {

   253 abstract class Tree[+A <% Ordered[A]]

   393   def increment = for (c <- s) yield (c + 1).toChar 

   254 case class Node[A <% Ordered[A]](elem: A, left: Tree[A], 

   394 }

   255                                  right: Tree[A]) extends Tree[A]

   395 

   256 case object Leaf extends Tree[Nothing]

   396 "HAL".increment

   257 

   397 

   258 

   259 def insert[A <% Ordered[A]](tr: Tree[A], n: A): Tree[A] = tr match {

   260   case Leaf => Node(n, Leaf, Leaf)

   261   case Node(m, left, right) => 

   262     if (n == m) Node(m, left, right) 

   263     else if (n < m) Node(m, insert(left, n), right)

   264     else Node(m, left, insert(right, n))

   265 }

   266 

   267 

   268 val t1 = Node(4, Node(2, Leaf, Leaf), Node(7, Leaf, Leaf))

   269 insert(t1, 3)

   270 

   271 val t2 = Node('b', Node('a', Leaf, Leaf), Node('f', Leaf, Leaf))

   272 insert(t2, 'e')

   281 case object ZERO extends Rexp

   405 case object ZERO extends Rexp                       // nothing

   282 case object ONE extends Rexp

   406 case object ONE extends Rexp                        // the empty string

   283 case class CHAR(c: Char) extends Rexp

   407 case class CHAR(c: Char) extends Rexp               // a character c

   285 case class SEQ(r1: Rexp, r2: Rexp) extends Rexp     // sequence     r1 r2  

   409 case class SEQ(r1: Rexp, r2: Rexp) extends Rexp     // sequence     r1 o r2  

   400 // concise, readable code

   467 // concise, readable code.

   401 

   468