pep-material: comparison progs/lecture2.scala

equal deleted inserted replaced

-:ed7543c5d317
+:90aed247c8cf
 for (x <- lst) yield x.getOrElse(0)
 // a function that turns strings into numbers (similar to .toInt)
-Integer.parseInt("1234")
+Integer.parseInt("12u34")
 def get_me_an_int(s: String) : Option[Int] =
 Try(Some(Integer.parseInt(s))).getOrElse(None)
 List(5,6,7,8,9).indexOf(7)
 List(5,6,7,8,9).indexOf(10)
 List(5,6,7,8,9)(-1)
+Try({
+val x = 3
+val y = 0
+Some(x / y)
+}).getOrElse(None)
 // Higher-Order Functions
 //========================
 // functions can take functions as arguments
 def even(x: Int) : Boolean = x % 2 == 0
 def odd(x: Int) : Boolean = x % 2 == 1
 val lst = (1 to 10).toList
+lst.reverse.sorted
 lst.filter(even)
-lst.count(even)
+lst.count(odd)
 lst.find(even)
+lst.exists(even)
-lst.filter(x => x % 2 == 0)
+lst.filter(_ < 4)
+lst.filter(x => x % 2 == 1)
 lst.filter(_ % 2 == 0)
-lst.sortWith(_ > _)
+lst.sortWith((x, y) => x > y)
 lst.sortWith(_ < _)
 // but this only works when the arguments are clear, but
 // not with multiple occurences
 lst.find(n => odd(n) && n > 2)
 def lex(x: (Int, Int), y: (Int, Int)) : Boolean =
 if (x._1 == y._1) x._2 < y._2 else x._1 < y._1
 ps.sortWith(lex)
-ps.sortBy(_._1)
+ps.sortBy(x => x._1)
 ps.sortBy(_._2)
 ps.maxBy(_._1)
 ps.maxBy(_._2)
 // this can be iterated
 lst.map(square).filter(_ > 4)
-lst.map(square).filter(_ > 4).map(square)
+(lst.map(square)
+.filter(_ > 4)
+.map(square))
 // lets define our own higher-order functions
 // type of functions is for example Int => Int
+0 :: List(3,4,5,6)
 def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = {
 if (lst == Nil) Nil
 else f(lst.head) :: my_map_int(lst.tail, f)
 // f1: (Int, Int) => Int
 // f2: List[String] => Option[Int]
 // ...
 val lst = (1 to 10).toList
-def sumOf(f: Int => Int, lst: List[Int]): Int = lst match {
+lst.sum
+val lst = List(1,2,3,4)
+lst.head
+lst.tail
+def sumOf(f: Int => Int, lst: List[Int]): Int =
+lst match {
 case Nil => 0
-case x::xs => f(x) + sumOf(f, xs)
+case x::foo => f(x) + sumOf(f, foo)
 }
 def sum_squares(lst: List[Int]) = sumOf(square, lst)
 def sum_cubes(lst: List[Int])   = sumOf(x => x * x * x, lst)
 lst.flatMap(get_me_an_int).sum
 // maps on Options
-get_me_an_int("1234").map(even)
+get_me_an_int("12345").map(even)
 get_me_an_int("12u34").map(even)
+def my_map_option(o: Option[Int], f : Int => Int) : Option[Int] = {
+o match {
+case None => None
+case Some(foo) => Some(f(foo))
+}}
+my_map_option(Some(4), square)
+my_map_option(None, square)
 // Map type (upper-case)
 //=======================
 // Note the difference between map and Map
+val ascii = ('a' to 'z').map(c => (c, c.toInt)).toList
+val ascii_Map = ascii.toMap
 def factors(n: Int) : List[Int] =
 (2 until n).toList.filter(n % _ == 0)
 var ls = (1 to 10).toList
 val facs = ls.map(n => (n, factors(n)))
 // works for lists of pairs
 facs.toMap
-facs.toMap.get(4)
+facs.toMap.get(40)
 facs.toMap.getOrElse(42, Nil)
 val facsMap = facs.toMap
 val facsMap0 = facsMap + (0 -> List(1,2,3,4,5))
 // groupBy function on Maps
 val ls = List("one", "two", "three", "four", "five")
 ls.groupBy(_.length)
-ls.groupBy(_.length).get(3)
+ls.groupBy(_.length).get(5)
 // Pattern Matching
 // recall
 val lst = List(None, Some(1), Some(2), None, Some(3)).flatten
-def my_flatten(xs: List[Option[Int]]): List[Int] = xs match {
+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)
 }
 // another example with a default case
 def get_me_a_string(n: Int): String = n match {
 case 0 | 1 | 2 => "small"
-case _ => "big"
+}
-}
+get_me_a_string(3)
-get_me_a_string(0)
 // you can also have cases combined
 def season(month: String) : String = month match {
 case "March" | "April" | "May" => "It's spring"
 Combinations of length 3:
 aaa, baa, caa, and so on......
 */
+def combs(cs: List[Char], n: Int) : List[String] = {
+if (n == 0) List("")
+else for (c <- cs; s <- combs(cs, n - 1)) yield s"$c$s"
+}
+combs(List('a', 'b', 'c'), 3)
 def combs(cs: List[Char], l: Int) : List[String] = {
 if (l == 0) List("")
 else for (c <- cs; s <- combs(cs, l - 1)) yield s"$c$s"
 }
 combs("abc".toList, 2)
-// another well-known example
-def move(from: Char, to: Char) =
-println(s"Move disc from $from to $to!")
-def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = {
-if (n == 0) ()
-else {
-hanoi(n - 1, from, to, via)
-move(from, to)
-hanoi(n - 1, via, from, to)
-}
-}
-hanoi(4, 'A', 'B', 'C')
 // A Recursive Web Crawler / Email Harvester
 //===========================================
 //

changeset 320	90aed247c8cf
parent 319	ed7543c5d317
child 323	93b6c16dded8