--- a/progs/collatz_sol.scala	Sun Nov 05 12:56:55 2017 +0000
+++ b/progs/collatz_sol.scala	Tue Nov 07 13:08:18 2017 +0000
@@ -1,53 +1,31 @@
-// Part 1 about the 3n+1 conceture
-//=================================
+// Part 1 about the 3n+1 conjecture
+//==================================
 
-
+object CW6a {
 
-//(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 1 Million.
-
-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))
+def collatz(n: Long): Long =
+  if (n == 1) 1 else
+    if (n % 2 == 0) 1 + collatz(n / 2) else 
+      1 + 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)  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 and the corresponding number that needs that many 
-//     steps. You should expect bounds in the range of 1
-//     upto 1 million. 
-
-def collatz_max(bnd: Int): (Int, Int) = {
-  val all = for (i <- (1 to bnd).toList) yield collatz(i).length
+def collatz_max(bnd: Long): (Long, Long) = {
+  val all = for (i <- (1 to bnd.toInt).toList) yield collatz(i)
   val max = all.max
-  (all.indexOf(max) + 1, max)
+  (max, all.indexOf(max) + 1)
 }
 
 
-// some testing harness
-val bnds = List(2, 10, 100, 1000, 10000, 100000, 77000, 90000, 1000000, 5000000)
+// some testing harness...5 Mio pushes the envelope
+
+val bnds = List(2, 10, 100, 1000, 10000, 100000, 
+		77000, 90000, 1000000, 5000000)
 
 for (bnd <- bnds) {
-  val (max, steps) = collatz_max(bnd)
+  val (steps, max) = collatz_max(bnd)
   println(s"In the range of 1 - ${bnd} the number ${max} needs the maximum steps of ${steps}")
 }
 
 
-//val all = for (i <- (1 to 100000).toList) yield collatz1(i)
-//println(all.sorted.reverse.take(10))
+}
 
-
-