Compile and Execute Scala Online

object HelloWorld {  // tail recursion optimisation, inak tiez Tail calls

  def add(a:Int, b: Int):Int = {  // klasicka rekurzivna funkcia
    if (a == 0) b;                // return nemusime pisat, sme vo funckionalnom svete, posledny vyraz je vystupna hodnota
    else add(a-1, b)+1;
  }
  def add1(a:Int, b: Int):Int = {  // iterativna verzia
    if (a == 0) b;
    else add1(a-1, b+1);          // po tomto volani sa nerobi nic, takze je to goto
  }
  def fib(n : Int) : Int = {      // sucin cisel 1.2. ... n
     if (n < 2) 1 
     else fib(n-2) + fib(n-1);
  }    
  def fact(n: Int): Int = {
      def fact(n: Int, acc: Int): Int =
         if (n <= 0) acc
         else fact(n-1, n*acc)
      fact(n, 1)
  }
  def sum(n: Int): Int = {      // sucet cisel 1+2+3+ ... +n
     @annotation.tailrec
     def sum(n: Int, acc: Int): Int =
        if (n <= 0) acc
        else sum(n-1, n+acc)    // akumulatorova technika
     sum(n, 0)
  }    
  def collatz(n : Int): Int = {  // vrati dlzku collatzovej postupnosti zacinajucej od n
    if (n == 1) 0
    else if (n % 2 == 0) 1+collatz(n/2)
    else 1+collatz(3*n+1)
  }
  def collatz1(n : Int): Int = {  // vrati dlzku collatzovej postupnosti zacinajucej od n
    @annotation.tailrec
    def collatz1(n : Int, count : Int): Int = {  // vrati dlzku collatzovej postupnosti zacinajucej od n
      if (n == 1) count
      else if (n % 2 == 0) collatz1(n/2, count+1)
      else collatz1(3*n+1, count+1)
    }
    collatz1(n, 0)
  }

  def main(args: Array[String]) {
     println(add(10000, 10000))  // toto padne na stacku
     // println(add(100000, 100000))  // toto padne na stacku
     val milion = 1000000000
     println(add1(milion , milion) + "=" + (2*milion))  // Gaussov vzorec)
     println("fibs=" + List.range(1, 20).map { fib })
     println("facts=" + List.range(1, 20).map { fact  })
     println("sums=" + List.range(1, 20).map { sum  })
     val stoLitrov = milion/10
     println(sum(stoLitrov) + "=" +  (stoLitrov*(stoLitrov+1)/2))  // Gaussov vzorec
     
     println(List.range(1,1000).map { n => collatz(n) })
     val desatLitrov = 10000
     //println(List.range(1,desatLitrov).map { n => collatz(n) }.max) // OutOfMemoryError: GC overhead limit exceeded
     // println(List.range(1,desatLitrov).map { n => collatz1(n) }.max)
     var max = -1
     for(i <- 1 to stoLitrov) {
       val len = collatz1(i)
       if (len > max)
         max = len
     }
     println(max)
    }
}