11 // - Datatypes 

    12 // - Countdown Game

    13 // - String interpolations

    14 

   143 

   144 season("November")

   145 season("abcd")

   393 // Countdown Game using Powerset

   394 //===============================

   395 

   396 

   397 def powerset(xs: Set[Int]) : Set[Set[Int]] = {

   398   if (xs == Set()) Set(Set())

   399   else {

   400     val ps = powerset(xs.tail)  

   401     ps ++ ps.map(_ + xs.head)

   402   }

   403 }  

   404 

   405 powerset(Set(1,2,3)).mkString("\n")

   406 

   407 // proper subsets

   408 def psubsets(xs: Set[Int]) = 

   409   powerset(xs) -- Set(Set(), xs) 

   410 

   411 psubsets(Set(1,2,3)).mkString("\n")

   412 

   413 def splits(xs: Set[Int]) : Set[(Set[Int], Set[Int])] =

   414   psubsets(xs).map(s => (s, xs -- s))

   415 

   416 splits(Set(1,2,3,4)).mkString("\n")

   417 

   418 

   419 enum Tree {

   420   case Num(i: Int)

   421   case Add(l: Tree, r: Tree)

   422   case Mul(l: Tree, r: Tree)

   423   case Sub(l: Tree, r: Tree)

   424   case Div(l: Tree, r: Tree)

   425 }

   426 import Tree._

   427 

   428 //pretty printing

   429 def pp(tr: Tree) : String = tr match {

   430   case Num(n) => s"$n"

   431   case Add(l, r) => s"(${pp(l)} + ${pp(r)})"

   432   case Mul(l, r) => s"(${pp(l)} * ${pp(r)})"

   433   case Sub(l, r) => s"(${pp(l)} - ${pp(r)})"

   434   case Div(l, r) => s"(${pp(l)} / ${pp(r)})"

   435 }

   436 

   437 

   438 def eval(tr: Tree) : Option[Int] = tr match {

   439   case Num(n) => Some(n)

   440   case Add(l, r) => 

   441     for (ln <- eval(l); rn <- eval(r)) yield ln + rn

   442   case Mul(l, r) => 

   443     for (ln <- eval(l); rn <- eval(r)) yield ln * rn 

   444   case Sub(l, r) => 

   445     for (ln <- eval(l); rn <- eval(r)) yield ln - rn

   446   case Div(l, r) => 

   447     for (ln <- eval(l); rn <- eval(r); if rn != 0) 

   448       yield ln / rn 

   449 }

   450 

   451 

   452 

   453 def search(nums: Set[Int]) : Set[Tree] = nums.size match {

   454   case 0 => Set()

   455   case 1 => Set(Num(nums.head))

   456   case 2 => {

   457     val ln = Num(nums.head)

   458     val rn = Num(nums.tail.head)

   459     Set(Add(ln, rn), Mul(ln, rn),

   460         Sub(ln, rn), Sub(rn, ln),

   461         Div(ln, rn), Div(rn, ln))

   462   }

   463   case n => {

   464     val spls = splits(nums)

   465     val res = 

   466       for ((ls, rs) <- spls) yield {

   467       for (lt <- search(ls);

   468            rt <- search(rs)) yield {

   469             Set(Add(lt, rt), Mul(lt, rt),

   470                 Sub(lt, rt), Sub(rt, lt),

   471                 Div(lt, rt), Div(rt, lt))

   472            }

   473     }

   474     res.flatten.flatten

   475   }

   476 }

   477 

   478 Set(Set(1,2), Set(2,3), Set(4,5)).flatten

   479 

   480 search(Set(1))

   481 search(Set(1, 2)).mkString("\n")

   482 search(Set(1, 2,3)).map(pp).mkString("\n")

   483 search(Set(1, 2,3)).map(pl).mkString("\n")

   484 search(Set(1, 2,3)).map(tr => s"${pp(tr)} = ${eval(tr)}").mkString("\n")

   485 

   486 

   487 def search(nums: Set[Int]) : Set[Tree] = nums.size match {

   488   case 0 => Set()

   489   case 1 => Set(Num(nums.head))

   490   case xs => {

   491     val spls = splits(nums)

   492     val subtrs = 

   493       for ((lspls, rspls) <- spls;

   494             lt <- search(lspls); 

   495             rt <- search(rspls)) yield {

   496         Set(Add(lt, rt), Mul(lt, rt))

   497     } 

   498     subtrs.flatten

   499   }

   500 }

   501 

   502 println(search(Set(1,2,3,4)).mkString("\n"))

   503 

   504 def pp(tr: Tree) : String = tr match {

   505   case Num(n) => s"$n"

   506   case Add(l, r) => s"(${pp(l)} + ${pp(r)})"

   507   case Mul(l, r) => s"(${pp(l)} * ${pp(r)})"

   508 }

   509 

   510 

   511 

   512 def eval(tr: Tree) : Int = tr match {

   513   case Num(n) => n

   514   case Add(l, r) => eval(l) + eval(r) 

   515   case Mul(l, r) => eval(l) * eval(r)

   516 }

   517 

   518 

   519 

   520 

   521 

   522 def search(nums: Set[Int]) : Set[Tree] =  nums.size match {

   523   case 0 => Set()

   524   case 1 => Set(Num(nums.head))

   525   case 2 => {

   526     val l = nums.head

   527     val r = nums.tail.head

   528     Set(Add(Num(l), Num(r)), 

   529         Mul(Num(l), Num(r)))

   530         ++ Option.when(l <= r)(Sub(Num(r), Num(l)))

   531         ++ Option.when(l > r)(Sub(Num(l), Num(r)))

   532         ++ Option.when(r > 0 && l % r == 0)(Div(Num(l), Num(r)))

   533         ++ Option.when(l > 0 && r % l == 0)(Div(Num(r), Num(l)))

   534   }

   535   case xs => {

   536     val spls = splits(nums)

   537     val subtrs = 

   538       for ((lspls, rspls) <- spls;

   539            lt <- search(lspls); 

   540           rt <- search(rspls)) yield {

   541         Set(Add(lt, rt), Sub(lt, rt),

   542             Mul(lt, rt), Div(lt, rt))

   543     } 

   544     subtrs.flatten

   545   }

   546 }

   547 

   548 println(search(Set(1,2,3,4)).mkString("\n"))

   549 

   550 def eval(tr: Tree) : Option[Int] = tr match {

   551   case Num(n) => Some(n)

   552   case Add(l, r) => 

   553     for (rl <- eval(l); rr <- eval(r)) yield rl + rr

   554   case Mul(l, r) => 

   555     for (rl <- eval(l); rr <- eval(r)) yield rl * rr  

   556   case Sub(l, r) => 

   557     for (rl <- eval(l); rr <- eval(r);

   558          if 0 <= rl - rr) yield rl - rr   

   559   case Div(l, r) => 

   560     for (rl <- eval(l); rr <- eval(r);

   561          if rr > 0 && rl % rr == 0) yield rl / rr          

   562 }

   563 

   564 eval(Add(Num(1), Num(2)))

   565 eval(Mul(Add(Num(1), Num(2)), Num(4)))

   566 eval(Sub(Num(3), Num(2)))

   567 eval(Sub(Num(3), Num(6)))

   568 eval(Div(Num(6), Num(2)))

   569 eval(Div(Num(6), Num(4)))

   570 

   571 def time_needed[T](n: Int, code: => T) = {

   572   val start = System.nanoTime()

   573   for (i <- (0 to n)) code

   574   val end = System.nanoTime()

   575   (end - start) / 1.0e9

   576 }

   577 

   578 def check(xs: Set[Int], target: Int) =

   579   search(xs).find(eval(_) == Some(target))

   580 

   581 for (sol <- check(Set(50, 5, 4, 9, 10, 8), 560)) {

   582   println(s"${pp(sol)} => ${eval(sol)}")

   583 }

   584 

   585 

   586 

   587 time_needed(1, check(Set(50, 5, 4, 9, 10, 8), 560))

   588 

   589 

   590 println(check(Set(25, 5, 2, 10, 7, 1), 986).mkString("\n"))

   591 

   592 for (sol <- check(Set(25, 5, 2, 10, 7, 1), 986)) {

   593   println(s"${pp(sol)} => ${eval(sol)}")

   594 }

   595 

   596 for (sol <- check(Set(25, 5, 2, 10, 7, 1), -1)) {

   597   println(s"${pp(sol)} => ${eval(sol)}")

   598 }

   599 

   600 for (sol <- check(Set(100, 25, 75, 50, 7, 10), 360)) {

   601   println(s"${pp(sol)} => ${eval(sol)}")

   602 }

   603 time_needed(1, check(Set(100, 25, 75, 50, 7, 10), 360))

   604 

   605 

   606 

   607 time_needed(1, check(Set(25, 5, 2, 10, 7, 1), 986))

   608 time_needed(1, check(Set(25, 5, 2, 10, 7, 1), -1))

   609 

   610 

   611 def generate(nums: Set[Int]) : Set[(Tree, Int)] =  nums.size match {

   612   case 0 => Set()

   613   case 1 => Set((Num(nums.head), nums.head))

   614   case xs => {

   615     val spls = splits(nums)

   616     val subtrs =

   617       for ((lspls, rspls) <- spls;

   618            (lt, ln) <- generate(lspls); 

   619            (rt, rn) <- generate(rspls)) yield {

   620         Set((Add(lt, rt), ln + rn),

   621             (Mul(lt, rt), ln * rn))

   622         ++ Option.when(ln <= rn)((Sub(rt, lt), rn - ln)) 

   623         ++ Option.when(ln > rn)((Sub(lt, rt), ln - rn))

   624         ++ Option.when(rn > 0 && ln % rn == 0)((Div(lt, rt), ln / rn))

   625         ++ Option.when(ln > 0 && rn % ln == 0)((Div(rt, lt), rn / ln))

   626     } 

   627     subtrs.flatten

   628   }

   629 }

   630 

   631 def check2(xs: Set[Int], target: Int) =

   632   generate(xs).find(_._2 == target)

   633 

   634 for ((sol, ev) <- check2(Set(50, 5, 4, 9, 10, 8), 560)) {

   635   println(s"${pp(sol)} => ${eval(sol)} / $ev")

   636 }

   637 

   638 time_needed(1, check(Set(50, 5, 4, 9, 10, 8), 560))

   639 time_needed(1, check2(Set(50, 5, 4, 9, 10, 8), 560))

   640 

   641 time_needed(1, check(Set(50, 5, 4, 9, 10, 8), -1))

   642 time_needed(1, check2(Set(50, 5, 4, 9, 10, 8), -1))

   643 

   644 

   645 // Sudoku 

   646 //========

   647 

   648 // THE POINT OF THIS CODE IS NOT TO BE SUPER

   649 // EFFICIENT AND FAST, just explaining exhaustive

   650 // depth-first search

   651 

   652 //> using dep org.scala-lang.modules::scala-parallel-collections:1.0.4

   653 import scala.collection.parallel.CollectionConverters.*

   654 

   655 

   656 val s1 = "s\n"

   657 val s2 = """s\n"""

   658 

   659 val game0 = """.14.6.3..

   660               |62...4..9

   661               |.8..5.6..

   662               |.6.2....3

   663               |.7..1..5.

   664               |5....9.6.

   665               |..6.2..3.

   666               |1..5...92

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

   668 

   669 type Pos = (Int, Int)

   670 val EmptyValue = '.'

   671 val MaxValue = 9

   672 

   673 def pretty(game: String): String = 

   674   "\n" + (game.grouped(MaxValue).mkString("\n"))

   675 

   676 pretty(game0)

   677 

   678 

   679 val allValues = "123456789".toList

   680 val indexes = (0 to 8).toList

   681 

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

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

   684 def emptyPosition(game: String) : Pos = {

   685   val e = empty(game)

   686   (e % MaxValue, e / MaxValue)

   687 }

   688 

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

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

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

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

   693 

   694 //get_row(game0, 0)

   695 //get_row(game0, 1)

   696 //get_col(game0, 0)

   697 

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

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

   700     val x0 = base(pos._1)

   701     val y0 = base(pos._2)

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

   703     (x0 until x0 + 3).toList

   704       .flatMap(x => ys.map(y => game(x + y * MaxValue)))

   705 }

   706 

   707 

   708 //get_box(game0, (3, 1))

   709 

   710 

   711 // this is not mutable!!

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

   713   game.updated(pos, value)

   714 

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

   716   (get_col(game, pos._1) ++ 

   717    get_row(game, pos._2) ++ 

   718    get_box(game, pos))

   719 

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

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

   722 

   723 //candidates(game0, (0,0))

   724 

   725 

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

   727   if (isDone(game)) List(game)

   728   else {

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

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

   731   }

   732 }

   733 

   734 pretty(game0)

   735 search(game0).map(pretty)

   736 

   737 val game1 = """23.915...

   738               |...2..54.

   739               |6.7......

   740               |..1.....9

   741               |89.5.3.17

   742               |5.....6..

   743               |......9.5

   744               |.16..7...

   745               |...329..1""".stripMargin.replaceAll("\\n", "")

   746 

   747 search(game1).map(pretty)

   748 

   749 // a game that is in the hard category

   750 val game2 = """8........

   751               |..36.....

   752               |.7..9.2..

   753               |.5...7...

   754               |....457..

   755               |...1...3.

   756               |..1....68

   757               |..85...1.

   758               |.9....4..""".stripMargin.replaceAll("\\n", "")

   759 

   760 search(game2).map(pretty)

   761 

   762 // game with multiple solutions

   763 val game3 = """.8...9743

   764               |.5...8.1.

   765               |.1.......

   766               |8....5...

   767               |...8.4...

   768               |...3....6

   769               |.......7.

   770               |.3.5...8.

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

   772 

   773 search(game3).map(pretty).foreach(println)

   774 

   775 // for measuring time

   776 def time_needed[T](i: Int, code: => T) = {

   777   val start = System.nanoTime()

   778   for (j <- 1 to i) code

   779   val end = System.nanoTime()

   780   s"${(end - start) / 1.0e9} secs"

   781 }

   782 

   783 time_needed(2, search(game2))

   784 

   785 

   786 // concurrency 

   787 // scala-cli --extra-jars scala-parallel-collections_3-1.0.4.jar 

   788 // import scala.collection.parallel.CollectionConverters._

   789 

   790 

   791 

   792 

   793 // String Interpolations

   794 //=======================

   795 

   796 def cube(n: Int) : Int = n * n * n

   797 

   798 val n = 3

   799 println("The cube of " + n + " is " + cube(n) + ".")

   800 

   801 println(s"The cube of $n is ${cube(n)}.")

   802 

   803 // or even

   804 

   805 println(s"The cube of $n is ${n * n * n}.")

   806 

   807 // helpful for debugging purposes

   808 //

   809 //     "The most effective debugging tool is still careful 

   810 //          thought, coupled with judiciously placed print 

   811 //                                             statements."

   812 //       — Brian W. Kernighan, in Unix for Beginners (1979)

   813 

   814 

   815 def gcd_db(a: Int, b: Int) : Int = {

   816   println(s"Function called with $a and $b.")

   817   if (b == 0) a else gcd_db(b, a % b)

   818 }

   819 

   820 gcd_db(48, 18)

   821 

   822 

   823 

   824 

   825 // Recursion Again ;o)

   826 //====================

   827 

   828 

   829 // another well-known example: Towers of Hanoi

   830 //=============================================

   831 

   832 def move(from: Char, to: Char) =

   833   println(s"Move disc from $from to $to!")

   834 

   835 def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = {

   836   if (n == 0) ()

   837   else {

   838     hanoi(n - 1, from, to, via)

   839     move(from, to)

   840     hanoi(n - 1, via, from, to)

   841   }

   842 } 

   843 

   844 hanoi(4, 'A', 'B', 'C')

   845 

   846 

   847 

   848 

   849