1
2
3
4
5
6
7
8
9
object Main {
  def main(args: Array[String]) = {
    println("Hello!")
    val x = 1.+(2) // "+" is just a method on Int
    val y = 1 + 2  // alternate syntax for methods with one parameter
    println(x ++ " " ++ y) // "++" is used for concatenation
    val lst1 = List(1, 2, 3, 4, 5) map (x => x % 2 == 0) // map is a function on iterable types
    val lst2 = List(1, 2, 3, 4, 5) map (_ % 2 == 0) // shorthand function literal when a variable is only used once
    println(lst2)
 ...

1
2
3
4
5
object Main {
  def main(args: Array[String]) = {
    println("Hello!")
  }
}

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  def main(args: Array[String]) {
      var stdin =
         new BufferedReader(new InputStreamReader(System.in));
    var line = stdin.readLine();
    while(false == line.equals("42")) {
      System.out.println(line);
 ...

1
2
3
 object HelloWorld extends App {
   println("Hello, world!")
 }

1
2
3
4
5
6
7
8
9
object Main {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
    println("5! = " + (5 !))
  }
}
 
case class MyInt(i: Int) {
  def ! = {
 ...

1
2
3
4
5
6
7
8
9
object Main {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
    println("5! = " + (5 !))
  }
}
 
case class MyInt(i: Int) {
  def !: Int = {
 ...

1
2
3
4
5
object Main {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
  }
}

1
2
3
4
5
object Test {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
  }
}

1
2
3
class Main(args: Array[String]) {
  println("Hello!")
}

1
2
3
class Main(args: Array[String]) = {
  println("Hello!")
}

1
2
3
object Main(args: Array[String]) = {
  println("Hello!")
}

1
(* 6.4 6.4)

1
2
3
4
5
6
7
8
9
val pi=math.Pi
@annotation.tailrec
def toPi (zaehler: Int = 3, nenner: Int = 1, sofar: Double=1): Unit = {
  if (nenner == 1000000) () 
  else {
    val quotient = 1.0*zaehler/nenner
    val diff = (pi - quotient)
    val adiff= math.abs (diff)
    val next = if (adiff < sofar) {
 ...

1
2
3
4
5
6
7
import math._
def p(z:Int,n:Int,s:Double):Unit=
if(n==1e6)0 else{val q=1.0*z/n
val x=if(abs(Pi-q)<s){println(z+"/"+n)
abs(Pi-q)}else s
if(Pi-q<0)p(z,n+1,x)else p(z+1,n,x)}
p(3,1,1)

1
2
3
4
5
6
object Main {
  def main(args: [String]) = { 
    println("Hello World")
  }
  
  

1
2
3
4
def factorial(n: Int) = {
    def f(n: Int, acc: Int): Int = if (n <= 0) acc else f(n - 1, acc * n)
    f(n, 1)
}

1
2
3
4
def factorial (n: Int) = {
  def f(n: Int, a: Int): Int = if (n <= 0) a else f(n-1, n*a)
  f(n, 1)
}

1
2
3
4
def factorial(n: Int) = {
    def f(n: Int, acc: Int): Int = if (n <= 0) acc else f(n - 1, acc * n)
    f(n, 1)
}

1
2
3
4
def factorial(n: Int) = {
    def loop(n: Int, acc: Int): Int = if (n <= 0) acc else loop(n - 1, acc * n)
    loop(n, 1)
}

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type Door = (Int, Boolean)
  type Doors = List[Door]
 
  def main(args: Array[String]) {
    val doors = List.tabulate(100)(x => (x + 1, false))
    pass(1, 100, doors).filter(_._2).foreach(x => println(x._1))
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type Door = (Int, Boolean)
  type Doors = List[Door]
 
  def main(args: Array[String]) {
    val doors = List.tabulate(100)(x => (x + 1, false))
    pass(1, 100, doors).filter(_._2).foreach(x => println(x._1))
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type Door = (Int, Boolean)
  type Doors = List[Door]
  def main(args: Array[String]) {
    val doors = List.tabulate(100)(x => (x + 1, false))
    pass(1, 100, doors).filter(_._2).foreach(x => println(x._1))
  }
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type Door = (Int, Boolean)
  type Doors = List[Door]
  def main(args: Array[String]) {
    val doors = List.tabulate(100)((_ + 1, false))
    pass(1, 100, doors).filter(_._2).foreach(x => println(x._1))
  }
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type DoorState = Boolean
  type Doors = List[DoorState]
  def main(args: Array[String]) {
    val doors = List.fill(100)(false)
    pass(100, doors).zipWithIndex.filter(_._1).foreach(x => println(x._2))
  }
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type DoorState = Boolean
  type Doors = List[DoorState]
  def main(args: Array[String]) {
    val doors = List.fill(100)(false)
    pass(100, doors).zipWithIndex.filter(_._1).foreach(x => println(x._2))
  }
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
 
object Main {
  type DoorState = Boolean
  type Doors = List[DoorState]
  def main(args: Array[String]) {
    val doors = List.fill(100)(false)
    pass(100, doors).zipWithIndex.filter(_._1).foreach(println(_._2))
  }
 ...

1
2
3
4
5
6
7
8
9
trait X {
  def test = "Hello"
}
case class Y(test: String) extends X
 
object Main {
  def main(args: Array[String]) {
    println(Y("This works!"))
    println(Y())
 ...

1
2
3
4
5
6
7
8
9
trait X(test: String = "Hello")
case class Y(test: String) extends X
 
object Main {
  def main(args: Array[String]) {
    println(Y("This works!"))
    println(Y())
  }
}

1
2
3
4
5
6
7
8
9
case class X(test: String = "Hello")
case class Y(test2: String) extends X(test2)
 
object Main {
  def main(args: Array[String]) {
    println(Y("This works!"))
    println(Y())
  }
}

1
2
3
4
5
6
7
8
9
case class X(test: String = "Hello")
case class Y(test2: String = "Hello") extends X(test2)
 
object Main {
  def main(args: Array[String]) {
    println(Y("This works!"))
    println(Y())
  }
}