1 object CW6a {

     2 

     3 //(1) Complete the collatz function below. It should

     4 //    recursively calculate the number of steps needed 

     5 //    until the collatz series reaches the number 1.

     6 //    If needed, you can use an auxiliary function that

     7 //    performs the recursion. The function should expect

     8 //    arguments in the range of 1 to 1 Million.

     9 def stepsCounter(n: Long, s: Long) : Long = n match{

    10     case 1 => s

    11     case n if(n%2==0) => stepsCounter(n/2,s+1)

    12     case _ => stepsCounter(3*n+1, s+1)

    13 }

    14 

    15 def collatz(n: Long) : Long = n match {

    16     case n if(n>0) => stepsCounter(n,0)

    17     case n if(n<=0) => stepsCounter(1,0)

    18 }

    19 

    20 

    21 

    22 //(2) Complete the collatz_max function below. It should

    23 //    calculate how many steps are needed for each number 

    24 //    from 1 up to a bound and then calculate the maximum number of

    25 //    steps and the corresponding number that needs that many 

    26 //    steps. Again, you should expect bounds in the range of 1

    27 //    up to 1 Million. The first component of the pair is

    28 //    the maximum number of steps and the second is the 

    29 //    corresponding number.

    30 

    31 def collatz_max(bnd: Long) : (Long, Long) =  {

    32     val allCollatz = for(i<-1L until bnd) yield collatz(i)

    33     val pair = (allCollatz.max, (allCollatz.indexOf(allCollatz.max) +1).toLong)

    34     pair

    35 }

    36 

    37 }