diff -r 736a60afedbc -r fc9394f4f0ea pre_testing1/collatz.scala
--- a/pre_testing1/collatz.scala	Sun Nov 15 13:10:43 2020 +0000
+++ b/pre_testing1/collatz.scala	Tue Nov 17 00:34:55 2020 +0000
@@ -1,50 +1,54 @@
-// Basic Part about the 3n+1 conjecture
-//==================================
-
-// generate jar with
-//   > scala -d collatz.jar  collatz.scala
+object CW6a {
 
-object CW6a { // for purposes of generating a jar
+//(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 auxiliary function that
+//    performs the recursion. The function should expect
+//    arguments in the range of 1 to 1 Million.
 
-def collatz(n: Long): Long =
-  if (n == 1) 0 else
-    if (n % 2 == 0) 1 + collatz(n / 2) else 
-      1 + 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( n * 3 + 1);
 
 
-def collatz_max(bnd: Long): (Long, Long) = {
-  val all = for (i <- (1L to bnd)) yield (collatz(i), i)
-  all.maxBy(_._1)
-}
+//(2) Complete the collatz_max function below. It should
+//    calculate how many steps are needed for each number
+//    from 1 up to a bound and then calculate the maximum number of
+//    steps and the corresponding number that needs that many
+//    steps. Again, you should expect bounds in the range of 1
+//    up to 1 Million. The first component of the pair is
+//    the maximum number of steps and the second is the
+//    corresponding number.
 
-//collatz_max(1000000)
-//collatz_max(10000000)
-//collatz_max(100000000)
-
-/* some test cases
-val bnds = List(10, 100, 1000, 10000, 100000, 1000000)
+def collatz_max(bnd: Long) : (Long, Long) =
+     ((1.toLong to bnd).toList.map
+        (n => collatz(n)).max ,
+            (1.toLong to bnd).toList.map
+                (n => collatz(n)).indexOf((1.toLong to bnd).toList.map
+                    (n => collatz(n)).max) + 1);
 
-for (bnd <- bnds) {
-  val (steps, max) = collatz_max(bnd)
-  println(s"In the range of 1 - ${bnd} the number ${max} needs the maximum steps of ${steps}")
-}
-
-*/
+//(3) Implement a function that calculates the last_odd
+//    number in a collatz series.  For this implement an
+//    is_pow_of_two function which tests whether a number
+//    is a power of two. The function is_hard calculates
+//    whether 3n + 1 is a power of two. Again you can
+//    assume the input ranges between 1 and 1 Million,
+//    and also assume that the input of last_odd will not
+//    be a power of 2.
+//idk
+ def is_pow_of_two(n: Long) : Boolean =
+    if ( n & ( n - 1) == 0) true;
+    else false;
 
-def is_pow(n: Long) : Boolean = (n & (n - 1)) == 0
-
-def is_hard(n: Long) : Boolean = is_pow(3 * n + 1)
-
-def last_odd(n: Long) : Long = 
-  if (is_hard(n)) n else
-    if (n % 2 == 0) last_odd(n / 2) else 
-      last_odd(3 * n + 1)
+def is_hard(n: Long) : Boolean =
+    if ( (3*n + 1) & 3*n == 0) true;
+    else false;
 
 
-//for (i <- 130 to 10000) println(s"$i: ${last_odd(i)}")
-//for (i <- 1 to 100) println(s"$i: ${collatz(i)}")
-
-}
+def last_odd(n: Long) : Long = ???
 
 
 
+}