pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:018b9c12ee1f
+:f7bcb27d1940
 // Value assignments
 // (their names should be lower case)
 //====================================
 val x = 42
 val y = 3 + 4
 val z = x / y
 // (you cannot reassign values: z = 9 will give an error)
 // Hello World
 // Equality is structural
 //========================
 val a = "Dave"
 val b = "Dave"
-if (a == b) println("equal") else println("unequal")
+if (a == b) println("Equal") else println("Unequal")
 Set(1,2,3) == Set(3,1,2)
 List(1,2,3) == List(3,1,2)
+val n1 = 3 + 7
+val n2 = 5 + 5
+n1 == n2
 // this applies to "concrete" values;
 // you cannot compare functions
 val tst = "This is a " + "test\n"
 println(tst)
 val lst = List(1,2,3,1)
 println(lst.toString)
-println(lst.mkString("\n"))
+println(lst.mkString(","))
 println(lst.mkString(", "))
 // some methods take more than one argument
-println(lst.mkString("[", ",", "]"))
+println(lst.mkString("{", ",", "}"))
 // Conversion methods
 //====================
 List(1,2,3,1).toString
 List(1,2,3,1).toSet
-"hello".toList
+"hello".toList.tail
 1.toDouble
 // useful list methods
 List(1,2,3,4).take(2).sum
 List(1,2,3,4).drop(2).sum
 List(1,2,3,4,3).indexOf(3)
 "1,2,3,4,5".split(",").mkString("\n")
+"1,2,3,4,5".split(",").toList
 "1,2,3,4,5".split(",3,").mkString("\n")
 "abcdefg".startsWith("abc")
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 def square(x: Int) : Int = x * x
+def str(x: Int) : String = x.toString
 square(6)
 // The general scheme for a function: you have to give a type
 // to each argument and a return type of the function
 // BTW: no returns!!
 // "last" line (expression) in a function determines the result
 //
 def silly(n: Int) : Int = {
-n * n
+if (n < 10) n * n
-n + n
+else n + n
 }
 // If-Conditionals
 //=================
 if (n == 1) 1 else fib(n - 1) + fib(n - 2)
 //gcd - Euclid's algorithm
-def gcd(a: Int, b: Int) : Int =
+def gcd(a: Int, b: Int) : Int = {
-if (b == 0) a else gcd(b, a % b)
+if (b == 0) a
+else {
+val foo = 42
+gcd(b, a % b)
+}
+}
 gcd(48, 18)
 def power(x: Int, n: Int) : Int =
 //  Try(something).getOrElse(what_to_do_in_case_of_an_exception)
 //
 import scala.util._
 import io.Source
-val my_url = "https://nms.kcl.ac.uk/christian.urban/"
+val my_url = "https://nms.imperial.ac.uk/christian.urban/"
 Source.fromURL(my_url).mkString
 Try(Source.fromURL(my_url).mkString).getOrElse("")
 Try(Some(Source.fromURL(my_url).mkString)).getOrElse(None)
 // the same for files
-Source.fromFile("test.txt").mkString
+Try(Some(Source.fromFile("text.txt").mkString)).getOrElse(None)
 // function reading something from files...
 def get_contents(name: String) : List[String] =
 Source.fromFile(name).getLines.toList
 get_contents("test.txt")
 // slightly better - return Nil
 def get_contents(name: String) : List[String] =
-Try(Source.fromFile(name).getLines.toList).getOrElse(Nil)
+Try(Source.fromFile(name).getLines.toList).getOrElse(List())
 get_contents("text.txt")
 // much better - you record in the type that things can go wrong
 def get_contents(name: String) : Option[List[String]] =
 // For-Comprehensions (not For-Loops)
 //====================================
-for (n <- (1 to 10).toList) yield square(n)
+for (n <- (1 to 10).toList) yield {
+square(n) + 1
+}
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield m * n
 val mult_table =
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield m * n
+println(mult_table.mkString)
 mult_table.sliding(10,10).mkString("\n")
 // the list/set/... can also be constructed in any
 // other way
-for (n <- List(10,12,4,5,7,8,10)) yield n * n
+for (n <- Set(10,12,4,5,7,8,10)) yield n * n
 // with if-predicates / filters
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
-if (n + m) % 2 == 0) yield (n, m)
+if (n + m) % 2 == 0;
+if (n * m) < 2) yield (n, m)
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
-if ((n + m) % 2 == 0)) yield (n, m)
+if ((((n + m) % 2 == 0)))) yield (n, m)
 // with patterns
 val lst = List((1, 4), (2, 3), (3, 2), (4, 1))
 for (n <- (1 to 10)) println(n)
 // BTW: a roundabout way of printing out a list, say
 val lst = ('a' to 'm').toList
+for (n <- lst) println(n)
 for (i <- (0 until lst.length)) println(lst(i))
 // Why not just? Why making your life so complicated?
 for (c <- lst) println(c)

changeset 202	f7bcb27d1940
parent 200	01ee4b576eb2
child 247	50a3b874008a