pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:2403c931a32f
+:0e6ca70496c1
 // Scala Lecture 1
 //=================
-// - List, Sets, Strings, ...
+// - List, Sets, Ints, Strings, ...
 // - Value assignments (val vs var)
 // - How to define functions? (What is returned?)
 // - If-Conditions
 // - For-Comprehensions (guards, with/without yield)
 // - String-Interpolations
 val x = 42
 val y = 3 + 4
 val z = x / y
-val x = 70
+val x = 0
 println(z)
 // (you cannot reassign values: z = 9 will give an error)
-//var z = 9
+var z = 9
-//z = 10
+z = 10
-// Hello World
-//=============
-// an example of a stand-alone Scala file
-// (in the assignments you must submit a plain Scala script)
-object Hello extends App {
-println("hello world")
-}
-// can then be called with
-//
-// $> scalac hello-world.scala
-// $> scala Hello
-//
-// $> java -cp /usr/local/src/scala/lib/scala-library.jar:. Hello
 // Collections
 //=============
 List(1,2,3,1)
 Set(1,2,3,1)
 // picking an element in a list
 val lst = List(1, 2, 3, 1)
 lst(0)
 lst(2)
 // head and tail
 (1 until 10).toList
 // Equality in Scala is structural
 //=================================
-val a = "Dave"
+val a = "Dave2"
 val b = "Dave"
 if (a == b) println("Equal") else println("Unequal")
 Set(1,2,3) == Set(3,1,2)
 "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")
 // Types (see slide)
 //===================
 // type to each argument and a return type of the function
 //
 //  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
 //     ....
 //  }
+// > LENGTH OF LIST EXAMPLE
+def len(xs: List[Int], acc: Int) : Int = {
+if (xs == Nil) acc
+else foo(xs.tail, acc + 1)
+}
+def len(xs: List[Int]) : Int = foo(xs, 0)
+len(List(1,2,3,4,1))
+def len(xs: List[Int]) : Int = {
+if (xs == Nil) 0
+else (1 + len(xs.tail))
+}
+len(List(1,2,3,4,1))
+def len(xs: List[Int]) : Int = xs match {
+case Nil => 0
+case x :: xs => 1 + len(xs)
+}
+len(List(1,2,3,4,1))
 // If-Conditionals
 //=================
 for (n <- lst) yield {
 square(n) + double(n)
 }
 for (n <- (1 to 10).toList;
-m <- (1 to 5).toList) yield (n, m, n * m)
+m <- (1 to 5).toList) yield (n, m)
 // you can assign the result of a for-comprehension
 // to a value
 val mult_table =
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield n * m
-println(mult_table.mkString)
+println(mult_table.mkString(","))
-mult_table.sliding(10,10).mkString("\n")
+mult_table.sliding(10,10).toList
+.mkString("\n")
 // for-comprehensions also work for other
 // collections
 for (n <- Set(10,12,4,5,7,8,10)) yield n * n
 for (n <- (1 to 10)) yield {
 n * n
 }
 // with if-predicates / filters
+val xs = for (n <- (1 to 3).toList;
+m <- (1 to 3).toList) yield (n,m)
+xs.filter{case (m, n) => (n + m) % 2 == 0}
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
 if (n + m) % 2 == 0) yield (n, m)
 // with patterns
 val lst = List((1, 4), (2, 3), (3, 2), (4, 1))
-for ((m, n) <- lst) yield m + n
+` yield m + n
 for (p <- lst) yield p._1 + p._2
 // general pattern of for-yield
 //===================
 // with only a side-effect (no list is produced),
 // has no "yield"
-for (n <- (1 to 10).toList) println(n * n)
+val xs = for (n <- (1 to 10).toList) yield println(n * n)
-for (n <- (1 to 10).toList) yield n * n
+xs.tail
+val foo = for (n <- (1 to 10).toList) yield n * n
 // BTW: a roundabout way of printing out a list, say
 val lst = ('a' to 'm').toList
 // Remember:
 // - no vars, no ++i, no +=
 // - no mutable data-structures (no Arrays, no ListBuffers)
 // But what the heck....lets try to count to 1 Mio in parallel
+//
+// requires
+// scala-cli --extra-jars scala- parallel-collections_3-1.0.4.jar
 import scala.collection.parallel.CollectionConverters._
-var cnt = 0
+def test() = {
+var cnt = 0
-for(i <- (1 to 100_000).par) cnt += 1
+for(i <- (1 to 100_000)) cnt += 1
-println(s"Should be 100000: $cnt")
+println(s"Should be 100000: $cnt")
+}
+test()
 // Or
 // Q: Count how many elements are in the intersections of
 //    two sets?
 // A; IMPROPER WAY (mutable counter)

changeset 478	0e6ca70496c1
parent 468	c71ae4477e55
child 491	2a30c7dfe3ed