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
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
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
4
5
object HelloWorld {
    def main(args: Array[String]) {
      println("Hello, world!")
    }
  }

1
2
3
4
5
6
7
8
9
def sort(xs: Array[Int]) {
def swap(i: Int, j: Int) {
val t = xs(i); xs(i) = xs(j); xs(j) = t
}
def sort1(l: Int, r: Int) {
val pivot = xs((l + r) / 2)
var i = l; var j = r
while (i <= j) {
while (xs(i) < pivot) i += 1
 ...

1
2
3
4
5
6
7
8
9
import java.io.{BufferedReader, InputStreamReader}
def combinations[T](k: Int, list: List[T]) : List[List[T]] = {
     |   list match {
     |     case Nil => Nil
     |     case head :: xs =>
     |       if (k <= 0 || k > list.length) {
     |         Nil
     |       } else if (k == 1) {
     |         list.map(List(_))
 ...

1
2
3
4
5
6
7
8
9
def combinations[T](k: Int, list: List[T]) : List[List[T]] = {
     |   list match {
     |     case Nil => Nil
     |     case head :: xs =>
     |       if (k <= 0 || k > list.length) {
     |         Nil
     |       } else if (k == 1) {
     |         list.map(List(_))
     |       } else {
 ...

1
2
3
4
5
6
7
8
9
def combinations[T](k: Int, list: List[T]) : List[List[T]] = {
        list match {
          case Nil => Nil
          case head :: xs =>
            if (k <= 0 || k > list.length) {
              Nil
            } else if (k == 1) {
              list.map(List(_))
            } else {
 ...

1
2
3
4
5
6
7
8
9
def ints(n: Int): Stream[Int] = Stream.cons(n, ints(n+1)) 
def primes(nums: Stream[Int]): Stream[Int] = Stream.cons(nums.head, 
primes 
((nums tail) filter (x => x % nums.head != 0)) ) 
val allPrimes = primes(ints(2)) 
def goldbach(i: Int) = { 
  val primes = allPrimes.takeWhile(_ < i).toSet 
  val intersection = primes & primes.map(i - _) 
  if (intersection.isEmpty) 
 ...

1
2
3
4
5
6
7
8
9
object S99Int {
  def printGoldbachList(r: Range) {
    printGoldbachListLimited(r, 0)
  }
  
  def printGoldbachListLimited(r: Range, limit: Int) {
    (r filter { n => n > 2 && n % 2 == 0 } map { n => (n, n.goldbach) }
     filter { _._2._1 >= limit } foreach {
       _ match { case (n, (p1, p2)) => println(n + " = " + p1 + " + " + p2) }
 ...

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

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
class S99Int(val start: Int) {
  def isCoprimeTo(n: Int): Boolean = gcd(start, n) == 1
}

1
2
3
4
5
6
7
8
9
import java.util.{Date, Locale}
import java.text.DateFormat
import java.text.DateFormat._
object FrenchDate {
def main(args: Array[String]) {
val now = new Date
val df = getDateInstance(LONG, Locale.FRANCE)
println(df format now)
}
 ...

1
2
3
4
5
6
7
object helloworld
{
        def main(args : Array[String])
        {
                println("hello")
        }
}

1
2
3
4
5
6
7
object helloworld
{
        def main(args:Array[String])
        {
                println("hello")
        }
}

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
var j=0;
i=i*3;
val r=0.until(i);
for(j <- r)
println(j);
println(i);
 ...

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
var j=0;
i=i*3;
for(j <- i)
println(j);
println(i);
println("Hello, world!");
 ...

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
var j=0;
i=i*3;
for(j <- 3)
println(j);
println(i);
println("Hello, world!");
 ...

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
var j=0;
i=i*3;
for(j in 0..3)
println(j);
println(i);
println("Hello, world!");
 ...

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
var j;
i=i*3;
for j in 0..3
println(j);
println(i);
println("Hello, world!");
 ...

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3,j;
i=i*3;
for(j in 0..3)
println(j);
println(i);
println("Hello, world!");
}

1
2
3
4
5
6
7
8
9
object Main {
def main(args: Array[String]) {
var i=3;
i=i*3;
for(var j=0;j<=i;j++)
println(j);
println(i);
println("Hello, world!");
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
int i=3;
i=i*3;
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
var i = (Double)12;
i=i*3;
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
val i = 12;
i=(i).*(3);
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
val i = 12;
i=i*3;
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
var i = 12;
i=i*3;
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
var i = new Integer(12);
i=(i).*(3);
println(i);
println("Hello, world!");
}
}

1
2
3
4
5
6
7
8
object Main {
def main(args: Array[String]) {
var i = new Integer(12);
i=i*3;
println(i);
println("Hello, world!");
}
}