pep-material: comparison progs/lecture2.scala

equal deleted inserted replaced

-:029e2862bb4e
+:b84ea52bfd8f
 // the same for files
 Try(Some(Source.fromFile("text.txt").mkString)).getOrElse(None)
-// how to implement a function for reading something from files...
+// how to implement a function for reading
+// (lines) something from files...
+//
 def get_contents(name: String) : List[String] =
 Source.fromFile(name).getLines.toList
+get_contents("text.txt")
 get_contents("test.txt")
 // slightly better - return Nil
 def get_contents(name: String) : List[String] =
 Try(Source.fromFile(name).getLines.toList).getOrElse(List())
 // Higher-Order Functions
 //========================
 // functions can take functions as arguments
+// and produce functions as result
 def even(x: Int) : Boolean = x % 2 == 0
 def odd(x: Int) : Boolean = x % 2 == 1
 val lst = (1 to 10).toList
 lst.map(x => (double(x), square(x)))
 lst.map(square)
-// this is actually how for-comprehensions
+// this is actually how for-comprehensions are
-// defined as in Scala
+// defined in Scala
 lst.map(n => square(n))
 for (n <- lst) yield square(n)
 // this can be iterated
 // same function using pattern matching: a kind
 // of switch statement on steroids (see more later on)
-def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = lst match {
+def my_map_int(lst: List[Int], f: Int => Int) : List[Int] =
+lst match {
 case Nil => Nil
 case x::xs => f(x)::my_map_int(xs, f)
 }
 // sometimes it is needed that you specify the type.
 (1 to 100).filter((x: Int) => x % 2 == 0).sum
-// in this case it is clear that x mist be an Int
+// in this case it is clear that x must be an Int
 (1 to 100).filter(x => x % 2 == 0).sum
-// As each parameter (only x in this case) is passed only once
+// When each parameter (only x in this case) is used only once
 // you can use the wizardy placeholder syntax
 (1 to 100).filter(_ % 2 == 0).sum
 val facsMap2 = facsMap + (1 -> List(1,2,3,4,5))
 facsMap.get(1)
 facsMap2.get(1)
-// groupBy function on maps
+// groupBy function on Maps
 val ls = List("one", "two", "three", "four", "five")
 ls.groupBy(_.length)
 ls.groupBy(_.length).get(3)
 //       ...
 //       case patternN => expressionN
 //    }
+// recall
-// remember?
 val lst = List(None, Some(1), Some(2), None, Some(3)).flatten
 def my_flatten(xs: List[Option[Int]]): List[Int] = xs match {
 case Nil => Nil
 case None::rest => my_flatten(rest)
 case Some(v)::rest => v :: my_flatten(rest)
 }
+my_flatten(List(None, Some(1), Some(2), None, Some(3)))
 // another example with a default case
 def get_me_a_string(n: Int): String = n match {
 case 0 | 1 | 2 => "small"
+// Jumping Towers
+//================
+def moves(xs: List[Int], n: Int) : List[List[Int]] = (xs, n) match {
+case (Nil, _) => Nil
+case (xs, 0) => Nil
+case (x::xs, n) => (x::xs) :: moves(xs, n - 1)
+}
+moves(List(5,1,0), 1)
+moves(List(5,1,0), 2)
+moves(List(5,1,0), 5)
+// checks whether a jump tour exists at all
+def search(xs: List[Int]) : Boolean = xs match {
+case Nil => true
+case (x::xs) =>
+if (xs.length < x) true else moves(xs, x).exists(search(_))
+}
+search(List(5,3,2,5,1,1))
+search(List(3,5,1,0,0,0,1))
+search(List(3,5,1,0,0,0,0,1))
+search(List(3,5,1,0,0,0,1,1))
+search(List(3,5,1))
+search(List(5,1,1))
+search(Nil)
+search(List(1))
+search(List(5,1,1))
+search(List(3,5,1,0,0,0,0,0,0,0,0,1))
+// generate *all* jump tours
+//    if we are only interested in the shortes one, we could
+//    shortcircut the calculation and only return List(x) in
+//    case where xs.length < x, because no tour can be shorter
+//    than 1
+//
+def jumps(xs: List[Int]) : List[List[Int]] = xs match {
+case Nil => Nil
+case (x::xs) => {
+val children = moves(xs, x)
+val results = children.map(cs => jumps(cs).map(x :: _)).flatten
+if (xs.length < x) List(x) :: results else results
+}
+}
+jumps(List(3,5,1,2,1,2,1))
+jumps(List(3,5,1,2,3,4,1))
+jumps(List(3,5,1,0,0,0,1))
+jumps(List(3,5,1))
+jumps(List(5,1,1))
+jumps(Nil)
+jumps(List(1))
+jumps(List(5,1,2))
+moves(List(1,2), 5)
+jumps(List(1,5,1,2))
+jumps(List(3,5,1,0,0,0,0,0,0,0,0,1))
+jumps(List(5,3,2,5,1,1)).minBy(_.length)
+jumps(List(1,3,5,8,9,2,6,7,6,8,9)).minBy(_.length)
+jumps(List(1,3,6,1,0,9)).minBy(_.length)
+jumps(List(2,3,1,1,2,4,2,0,1,1)).minBy(_.length)

changeset 319	b84ea52bfd8f
parent 318	029e2862bb4e
child 320	cdfb2ce30a3d