--- a/progs/collatz.scala	Mon Nov 07 12:58:00 2016 +0000
+++ b/progs/collatz.scala	Tue Nov 08 10:30:42 2016 +0000
@@ -1,29 +1,23 @@
-// Part 1
+// Part 1 about the 3n+1 conceture
+//=================================
 
 
-//(1)
-def collatz(n: Long): List[Long] =
-  if (n == 1) List(1) else
-    if (n % 2 == 0) (n::collatz(n / 2)) else 
-      (n::collatz(3 * n + 1))
+//(1) Complete the collatz function below. It should
+//    recursively calculate the number of steps needed 
+//    until the collatz series reaches the number 1.
+//    If needed you can use an auxilary function that
+//    performs the recursion. The function should expect
+//    arguments in the range of 1 to 10 Million.
 
-// an alternative that calculates the steps directly
-def collatz1(n: Long): Int =
-  if (n == 1) 1 else
-    if (n % 2 == 0) (1 + collatz1(n / 2)) else 
-      (1 + collatz1(3 * n + 1))
+def collatz(n: Long): Int = ...
 
 
-//(2)
-def collatz_max(bnd: Int): Int = {
-  (for (i <- 1 to bnd) yield collatz(i).length).max
-}
+//(2)  Complete the collatz bound function below. It should
+//     calculuate how many steps are needed for each number 
+//     from 1 upto a bound and return the maximum number of
+//     steps. You should expect bounds in the range of 1
+//     upto 10 million. 
+
+def collatz_max(bnd: Int): Int = ...
 
 
-val bnds = List(10, 100, 1000, 10000, 100000, 1000000, 10000000)
-
-for (bnd <- bnds) {
-  val max = collatz_max(bnd)
-  println(s"In the range of 1 - ${bnd} the maximum steps are ${max}")
-}
-

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/progs/collatz_.scala	Tue Nov 08 10:30:42 2016 +0000
@@ -0,0 +1,29 @@
+// Part 1
+
+
+//(1)
+def collatz(n: Long): List[Long] =
+  if (n == 1) List(1) else
+    if (n % 2 == 0) (n::collatz(n / 2)) else 
+      (n::collatz(3 * n + 1))
+
+// an alternative that calculates the steps directly
+def collatz1(n: Long): Int =
+  if (n == 1) 1 else
+    if (n % 2 == 0) (1 + collatz1(n / 2)) else 
+      (1 + collatz1(3 * n + 1))
+
+
+//(2)
+def collatz_max(bnd: Int): Int = {
+  (for (i <- 1 to bnd) yield collatz(i).length).max
+}
+
+
+val bnds = List(10, 100, 1000, 10000, 100000, 1000000, 10000000)
+
+for (bnd <- bnds) {
+  val max = collatz_max(bnd)
+  println(s"In the range of 1 - ${bnd} the maximum steps are ${max}")
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/progs/collatz_sol.scala	Tue Nov 08 10:30:42 2016 +0000
@@ -0,0 +1,31 @@
+// Part 1 about the 3n+1 conceture
+//=================================
+
+
+//(1) Complete the collatz function below. It should
+//recursively calculates the number of steps needed 
+//number until a series ends with 1
+
+def collatz(n: Long): List[Long] = ...
+
+
+// an alternative that calculates the steps directly
+def collatz1(n: Long): Int =
+  if (n == 1) 1 else
+    if (n % 2 == 0) (1 + collatz1(n / 2)) else 
+      (1 + collatz1(3 * n + 1))
+
+
+//(2)
+def collatz_max(bnd: Int): Int = {
+  (for (i <- 1 to bnd) yield collatz(i).length).max
+}
+
+
+val bnds = List(10, 100, 1000, 10000, 100000, 1000000, 10000000)
+
+for (bnd <- bnds) {
+  val max = collatz_max(bnd)
+  println(s"In the range of 1 - ${bnd} the maximum steps are ${max}")
+}
+

--- a/progs/lecture1.scala	Mon Nov 07 12:58:00 2016 +0000
+++ b/progs/lecture1.scala	Tue Nov 08 10:30:42 2016 +0000
@@ -1,8 +1,4 @@
-// toList, toSet, toDouble
-// function definition
-// smart strings
-// maps
-// recursion
+
 // webpages
 
 
@@ -27,6 +23,8 @@
 //====================
 
 println("test")
+
+
 val tst = "This is a " + "test" 
 println(tst)
 
@@ -82,6 +80,9 @@
   if (n == 0) 1 else n * fact(n - 1)
 
 
+
+
+
 def fact2(n: BigInt): BigInt = 
   if (n == 0) 1 else n * fact2(n - 1)
 
@@ -93,6 +94,8 @@
 //a recursive function
 def gcd(x: Int, y: Int): Int = 2 //??? 
 
+//**String Interpolations**
+//=========================
 
 
 //**Assert/Testing**