pep-material: comparison progs/lecture2.scala

equal deleted inserted replaced

-:9e0216756771
+:e43f7e92ba26
 val list = (1 to 1000000).toList
 time_needed(10, for (n <- list) yield n + 42)
 time_needed(10, for (n <- list.par) yield n + 42)
-// (ONLY WORKS OUT-OF-THE-BOX IN SCALA 2.11.8, not in SCALA 2.12)
+// (needs a library and 'magic' option -Yrepl-class-based)
-// (would need to have this wrapped into a function, or
-//  REPL called with scala -Yrepl-class-based)
 // Just for Fun: Mutable vs Immutable
 //====================================
 //
 lst.map(x => (double(x), square(x)))
 lst.map(square)
-// this is actually what for is defined at in Scala
+// this is actually how for-comprehensions
+// defined as in Scala
 lst.map(n => square(n))
 for (n <- lst) yield square(n)
 // this can be iterated
 ls.groupBy(_.length).get(2)
-// Option type
+// Option type (again)
-//=============
+//=====================
-//in Java if something unusually happens, you return null;
+// remember, in Java if something unusually happens,
+// you return null;
 //
-//in Scala you use Option
+// in Scala you use Option
 //   - if the value is present, you use Some(value)
 //   - if no value is present, you use None
 List(7,2,3,4,5,6).find(_ < 4)
 Try(Some(Integer.parseInt(s))).getOrElse(None)
 val lst = List("12345", "foo", "5432", "bar", "x21", "456")
 for (x <- lst) yield get_me_an_int(x)
-// summing all the numbers
+// summing up all the numbers
 lst.map(get_me_an_int).flatten.sum
 lst.map(get_me_an_int).flatten.sum
 }
 fav_colour(Green)
-// ... a bit more useful: Roman Numerals
+// ... a tiny bit more useful: Roman Numerals
 abstract class RomanDigit
 case object I extends RomanDigit
 case object V extends RomanDigit
 case object X extends RomanDigit
 type RomanNumeral = List[RomanDigit]
 List(X,I)
+/*
 I -> 1
 II -> 2
 III  -> 3
 IV -> 4
 V -> 5
 VI -> 6
 VII -> 7
 VIII -> 8
 IX -> 9
 X -> X
+*/
 def RomanNumeral2Int(rs: RomanNumeral): Int = rs match {
 case Nil => 0
 case M::r    => 1000 + RomanNumeral2Int(r)
 case C::M::r => 900 + RomanNumeral2Int(r)
 King,
 Clown)
 println(people.sortWith(superior).mkString("\n"))
-print("123\\n456")
+// Tail Recursion
-// Tail recursion
 //================
 def fact(n: Long): Long =
 if (n == 0) 1 else n * fact(n - 1)
 // regex for URLs and emails
 val http_pattern = """"https?://[^"]*"""".r
 val email_pattern = """([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})""".r
+//test case:
 //email_pattern.findAllIn
 //  ("foo bla christian@kcl.ac.uk 1234567").toList
 // drops the first and last character from a string
 |..6.2..3.
 |1..5...92
 |..7.9.41.""".stripMargin.replaceAll("\\n", "")
 type Pos = (Int, Int)
-val EmptyValue = '.'
+val emptyValue = '.'
-val MaxValue = 9
+val maxValue = 9
 val allValues = "123456789".toList
 val indexes = (0 to 8).toList
+def empty(game: String) = game.indexOf(emptyValue)
-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 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_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
+for (x <- (x0 until x0 + 3).toList;
-(x0 until x0 + 3).toList.flatMap(x => ys.map(y => game(x + y * MaxValue)))
+y <- (y0 until y0 + 3).toList) yield game(x + y * maxValue)
 }
 //get_row(game0, 0)
 //get_row(game0, 1)
 //get_box(game0, (3,1))
-def update(game: String, pos: Int, value: Char): String = game.updated(pos, value)
+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 candidates(game: String, pos: Pos): List[Char] =
+allValues.diff(toAvoid(game, pos))
-//candidates(game0, (0,0))
+//candidates(game0, (0, 0))
-def pretty(game: String): String = "\n" + (game sliding (MaxValue, MaxValue) mkString "\n")
+def pretty(game: String): String =
+"\n" ++ (game.sliding(maxValue, maxValue).mkString("\n"))
 def search(game: String): List[String] = {
 if (isDone(game)) List(game)
 else
-candidates(game, emptyPosition(game)).map(c => search(update(game, empty(game), c))).toList.flatten
+candidates(game, emptyPosition(game)).
-}
+map(c => search(update(game, empty(game), c))).flatten
+}
+// an easy game
 val game1 = """23.915...
 |...2..54.
 |6.7......
 |..1.....9
 |89.5.3.17
 |......9.5
 |.16..7...
 |...329..1""".stripMargin.replaceAll("\\n", "")
-// game that is in the hard category
+// a game that is in the sligtly harder category
 val game2 = """8........
 |..36.....
 |.7..9.2..
 |.5...7...
 |....457..
 |...1...3.
 |..1....68
 |..85...1.
 |.9....4..""".stripMargin.replaceAll("\\n", "")
-// game with multiple solutions
+// a game with multiple solutions
 val game3 = """.8...9743
 |.5...8.1.
 |.1.......
 |8....5...
 |...8.4...
 // for measuring time
 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"
+s"${(end - start) / i / 1.0e9} secs"
 }
 search(game2).map(pretty)
 search(game3).distinct.length
 time_needed(3, search(game2))

changeset 268	e43f7e92ba26
parent 266	ca48ac1d3c3e
child 278	0c2481cd8b1c