Changed class names to match file name zero prefixing.

Euler001.scala

@@ -1,3 +1,3 @@
-object Euler1 extends EulerApp {
+object Euler001 extends EulerApp {
   println(List.range(0, 1000).filter((a) => (a % 3 == 0 || a % 5 == 0)).sum);
 }

Euler002.scala

@@ -1,4 +1,4 @@
-object Euler2 extends Application {
+object Euler002 extends Application {
   def fibby (a :Int, b :Int) :Int = {
     val next = a + b;
     return (if (b % 2 == 0) b else 0) + (if (next > 1000000) 0 else fibby(b, next));

Euler003.scala

@@ -1,4 +1,4 @@
-object Euler3 extends Application {
+object Euler003 extends Application {
   def lpf (divis :Long, divid :Long) :Long = {
     if (divid % divis == 0) lpf(2, divid/divis)
     else if (divis > Math.sqrt(divid)) divid 

Euler004.scala

@@ -1,4 +1,4 @@
-object Euler4 extends Application 
+object Euler004 extends Application 
 {
   def palindrome (value :String) :Boolean = {
     val half :Int = value.length()/2;

Euler005.scala

@@ -1,4 +1,4 @@
-object Euler5 extends Application {
+object Euler005 extends Application {
   val divisors = List(20, 19, 18, 17, 16, 15, 14, 13, 12, 11);
   def check (value :Int) :Int = {
     if (divisors.exists((a) => (value % a != 0))) return check(20+value)

Euler006.scala

@@ -1,4 +1,4 @@
-object Euler6 extends EulerApp {
+object Euler006 extends EulerApp {
   val first100sum = List.range(1,101).max
   val first100sumsq = List.range(1,101).foldLeft(0)((b, a) => (b + a*a))
   println(first100sum * first100sum - first100sumsq)

Euler007.scala

@@ -1,4 +1,4 @@
-object Euler7 extends Application {
+object Euler007 extends Application {
   var numbers = List.range(2,110000);
   var primes = List(2);
   while (primes.length < 10001) {

Euler008.scala

@@ -1,4 +1,4 @@
-object Euler8 extends Application {
+object Euler008 extends Application {
   val number = ("73167176531330624919225119674426574742355349194934" +
                 "96983520312774506326239578318016984801869478851843" +
                 "85861560789112949495459501737958331952853208805511" +

Euler009.scala

@@ -1,4 +1,4 @@
-object Euler9 extends Application {
+object Euler009 extends Application {
   for (a <- List.range(1, 1000);
        b <- List.range(a, 1000);
        c <- List.range(b, 1000);

Euler010.scala

@@ -1,3 +1,3 @@
-object Euler10 extends EulerApp {
+object Euler010 extends EulerApp {
   println(genprimes(2000000).foldLeft(0L)(_+_))
 }

Euler011.scala

@@ -1,4 +1,4 @@
-object Euler11 extends Application {
+object Euler011 extends Application {
   val data = Array( 8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8,
                    49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0,
                    81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65,

Euler012.scala

@@ -1,4 +1,4 @@
-object Euler12 extends Application {
+object Euler012 extends Application {
   def findnum (i :Int, x :Int) :Int = {
     val divs = List.range(1, Math.sqrt(x)).filter(n => x % n == 0).flatMap(
       n => List(n, x/n).removeDuplicates);

Euler013.scala

@@ -1,4 +1,4 @@
-object Euler13 extends Application {
+object Euler013 extends Application {
   val data = List("37107287533902102798797998220837590246510135740250",
                   "46376937677490009712648124896970078050417018260538",
                   "74324986199524741059474233309513058123726617309629",

Euler014.scala

@@ -1,6 +1,6 @@
 import scala.collection.mutable.Map;
 
-object Euler14 extends Application {
+object Euler014 extends Application {
   var seen :Map[Long,Int] = Map();
 
   def iterate (value :Long) :Int = {

Euler015.scala

@@ -1,4 +1,4 @@
-object Euler15 extends Application {
+object Euler015 extends Application {
   val size = 20;
   def fact (n: BigInt): BigInt = if (n == 0) 1 else n * fact(n - 1)
   println(fact(size * 2) / (fact(size) * fact(size)))

Euler016.scala

@@ -1,3 +1,3 @@
-object Euler16 extends Application {
+object Euler016 extends Application {
   println(BigInt(2).pow(1000).toString().foldRight(0)((a, b) => (b + (a - '0'))));
 }

Euler017.scala

@@ -1,4 +1,4 @@
-object Euler17 extends Application {
+object Euler017 extends Application {
   val ones = Array("", "one", "two", "three", "four",
                    "five", "six", "seven", "eight", "nine");
 

Euler018.scala

@@ -1,4 +1,4 @@
-object Euler18 extends Application {
+object Euler018 extends Application {
   val triangle = List(
      4, 62, 98, 27, 23,  9, 70, 98, 73, 93, 38, 53, 60,  4, 23,
       63, 66,  4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31,

Euler019.scala

@@ -1,4 +1,4 @@
-object Euler19 extends Application {
+object Euler019 extends Application {
   def norm (days :Int) :Function1[Int,Int] = ((year :Int) => (days));
   def leap (days :Int) :Function1[Int,Int] = ((year :Int) => {
     if ((year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)) days+1;

Euler020.scala

@@ -1,4 +1,4 @@
-object Euler20 extends Application {
+object Euler020 extends Application {
   def fact (n: BigInt): BigInt = if (n == 0) 1 else n * fact(n - 1)
   println(fact(100).toString().foldRight(0)((a, b) => (b + (a - '0'))));
 }

Euler021.scala

@@ -1,4 +1,4 @@
-object Euler21 extends EulerApp {
+object Euler021 extends EulerApp {
   def sumdiv (n :Int) = List.range(1, n/2+1).filter(div => n % div == 0).sum
   println(List.range(1, 10000).filter(n => {
     val sdn = sumdiv(n); (n == sumdiv(sdn) && n != sdn && sdn < 10000)

Euler022.scala

@@ -1,4 +1,4 @@
-object Euler22 extends EulerApp {
+object Euler022 extends EulerApp {
   val names = readwords("names.txt");
   def score (name :String) = name.foldLeft(0)((s, l) => (s + (l - 'A' + 1)))
   println(List.range(0, names.length).map(i => ((i+1) * score(names(i)))).sum);

Euler023.scala

@@ -1,6 +1,6 @@
 import scala.collection.mutable.Set
 
-object Euler23 {
+object Euler023 {
   def divisors (x :Int) = Set(1) ++
     (2 to (math.sqrt(x).toInt) filter(x%_ == 0) flatMap(n => List(n, x/n)))
 

Euler024.scala

@@ -1,4 +1,4 @@
-object Euler24 extends Application {
+object Euler024 extends Application {
   def fact (n: Int): Int = if (n == 0) 1 else n * fact(n - 1)
   def nthperm (target :Int, nums :List[Int]) :String = {
     if (nums.length == 1) return nums(0).toString;

Euler025.scala

@@ -1,4 +1,4 @@
-object Euler25 extends Application {
+object Euler025 extends Application {
   var prev2 :BigInt = 1;
   var prev1 :BigInt = 1;
   var value :BigInt = prev2 + prev1;

Euler026.scala

@@ -1,4 +1,4 @@
-object Euler26 extends Application {
+object Euler026 extends Application {
   def divcycle (numer :Int, denom :Int, rlist :List[Int]) :Int = {
     val remain = numer % denom;
     if (remain == 0) return 0;

Euler027.scala

@@ -1,4 +1,4 @@
-object Euler27 extends EulerApp {
+object Euler027 extends EulerApp {
   val MAX_N = 80;
   val primes = genprimes(MAX_N*MAX_N + MAX_N*1000 + 1000);
   def polyprimes (primes :Array[Int], a :Int, b :Int, n :Int) :Int =

Euler028.scala

@@ -1,4 +1,4 @@
-object Euler28 extends Application {
+object Euler028 extends Application {
   def spiral (size :Int) :Int = {
     if (size == 1) return 1;
     val smaller = size-2;

Euler029.scala

@@ -1,4 +1,4 @@
-object Euler29 extends Application {
+object Euler029 extends Application {
   println((for {
     a <- List.range(2, 101)
     b <- List.range(2, 101)

Euler030.scala

@@ -1,4 +1,4 @@
-object Euler30 extends Application {
+object Euler030 extends Application {
   def digits (n :Int) = n.toString.toList.map(c => c - '0');
   def issum5 (n :Int) = digits(n).map(a => Math.pow(a, 5).intValue()).foldRight(0)(_+_) == n;
   println(List.range(2, 200000).filter(issum5).foldRight(0)(_+_));

Euler031.scala

@@ -1,4 +1,4 @@
-object Euler31 extends EulerApp {
+object Euler031 extends EulerApp {
   def perms (remain :Int, coins :List[Int]) :Int =
     if (remain == 0) 1 else coins match {
       case Nil => 0

Euler032.scala

@@ -1,4 +1,4 @@
-object Euler32 extends Application {
+object Euler032 extends Application {
   def digits (n :Int) = n.toString.toList.map(c => c - '0');
   def ispan (a :Int, b :Int, n :Int) :Boolean =
     (digits(a) ::: digits(n) ::: digits(b)).sort(_<_).equals(List.range(1,10));

Euler033.scala

@@ -1,4 +1,4 @@
-object Euler33 extends Application {
+object Euler033 extends Application {
   def equal (ratio :Double, rnum :Int, rdenom :Int) :Boolean = {
     (rdenom > 0) && (ratio == rnum/rdenom.doubleValue());
   }

Euler034.scala

@@ -1,4 +1,4 @@
-object Euler34 extends Application {
+object Euler034 extends Application {
   val facts = Array(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880);
   def digfact (sum :Int, n :Int) :Int =
     if (n == 0) sum else digfact(facts(n % 10) + sum, n/10);

Euler035.scala

@@ -1,4 +1,4 @@
-object Euler35 extends EulerApp {
+object Euler035 extends EulerApp {
   val primes = genprimes(1000000);
   def digits (value :Int) :Int = if (value == 0) 0 else 1 + digits(value/10);
   def rotate (value :Int, turns :Int) :Int = {

Euler036.scala

@@ -1,4 +1,4 @@
-object Euler36 extends Application {
+object Euler036 extends Application {
   def ispal (n :String) = n.reverse.sameElements(n)
   def bothpal (n :Int) = ispal(n.toString) && ispal(n.toBinaryString)
   println(List.range(1, 1000000, 2).filter(bothpal).foldRight(0)(_+_));

Euler037.scala

@@ -1,4 +1,4 @@
-object Euler37 extends EulerApp {
+object Euler037 extends EulerApp {
   val primes = genprimes(1000000);
   def isrtrunc (prime :Int) :Boolean =
     (prime == 0) || ((primes(prime) != 0) && isrtrunc(prime/10));

Euler038.scala

@@ -1,4 +1,4 @@
-object Euler38 extends Application {
+object Euler038 extends Application {
   def ispan (n :String) = n.toList.sort(_<_).mkString == "123456789";
   println(List.range(9182,9876).reverse.map(n => n+""+(2*n)).filter(ispan).head);
   // or

Euler039.scala

@@ -1,4 +1,4 @@
-object Euler39 extends EulerApp {
+object Euler039 extends EulerApp {
   def sols (perim :Int) = perim + 1000 * (for {
     a <- List.range(1, perim/2);
     b <- List.range(1, (perim-a)/2+1);

Euler040.scala

@@ -1,4 +1,4 @@
-object Euler40 extends Application {
+object Euler040 extends Application {
   val digits = List.range(1, 200000).flatMap(n => n.toString.toList).map(_-'0');
   println(List.range(0, 6).foldRight(1)((idx, b) => b * digits(Math.pow(10, idx).intValue-1)));
 }

Euler041.scala

@@ -1,4 +1,4 @@
-object Euler41 extends EulerApp {
+object Euler041 extends EulerApp {
   def perms (d :List[Char], n :List[Char]) :List[Int] = d match {
     case Nil => n.mkString.toInt :: Nil
     case _ => d.flatMap(digit => perms(d.filter(digit.!=), digit :: n))

Euler042.scala

@@ -1,4 +1,4 @@
-object Euler42 extends EulerApp {
+object Euler042 extends EulerApp {
   def wvalue (word :Seq[Char]) = word.foldLeft(0)((s, l) => (s + (l - 'A' + 1)))
   def tri (n :Int) = (n*(n+1))/2
   println(readwords("words.txt").map(wvalue).filter(v => (v == tri(Math.sqrt(2*v)))).length);

Euler043.scala

@@ -1,4 +1,4 @@
-object Euler43 extends Application {
+object Euler043 extends Application {
   def compsum (n :Long, digits :List[Int], divs :List[Int], sum :Long) :Long = {
     if (digits.isEmpty) n + sum
     else (for { d <- digits; val nn = n*10 + d; if ((nn%1000) % divs.head == 0) }

Euler044.scala

@@ -1,4 +1,4 @@
-object Euler44 extends Application {
+object Euler044 extends Application {
   def pent (n :Int) = n*(3*n-1)/2
   val pents = Set() ++ List.range(1, 3000).map(pent)
   def find (a :Int, b :Int) :Int = {

Euler045.scala

@@ -1,4 +1,4 @@
-object Euler45 extends Application {
+object Euler045 extends Application {
   def findh (pent :Long, h :Long) :Long = {
     val hex = h*(2*h-1)
     if (hex > pent) findh(pent, h-1)

Euler046.scala

@@ -1,4 +1,4 @@
-object Euler46 extends EulerApp {
+object Euler046 extends EulerApp {
   def isgold (n :Int) = 1.to(Math.sqrt(n/2)).exists(s => isprime(n-2*s*s))
   def check (n :Int) :Int = if (isprime(n) || isgold(n)) check(n+2) else n
   println(check(3))

Euler047.scala

@@ -1,4 +1,4 @@
-object Euler47 extends Application {
+object Euler047 extends Application {
   val factors = Array.make(150000, 0)
   var idx = 2
   while (idx < factors.length) {

Euler048.scala

@@ -1,3 +1,3 @@
-object Euler48 extends Application {
+object Euler048 extends Application {
   println(1.to(1000).map(a => BigInt(a).pow(a)).reduceRight(_+_) % BigInt(10).pow(10))
 }

Euler049.scala

@@ -1,4 +1,4 @@
-object Euler49 extends EulerApp {
+object Euler049 extends EulerApp {
   def sort (n :Int) = n.toString.toList.sort(_<_).mkString.toInt
   def ismem (n :Int, nn :Int) = isprime(nn) && sort(nn) == sort(n)
   def isseq (n :Int) = ismem(n, n+3330) && ismem(n, n+6660)

Euler050.scala

@@ -1,4 +1,4 @@
-object Euler50 extends EulerApp {
+object Euler050 extends EulerApp {
   case class PSum (sum :Int, length :Int) {
     def add (prime :Int) = PSum(sum+prime, length+1)
   }

Euler051.scala

@@ -1,4 +1,4 @@
-object Euler51 extends EulerApp {
+object Euler051 extends EulerApp {
   def cprimes (n :String)(d :Char) = {
     val variants = "0123456789".toList.map(nd => n.replace(d, nd))
     variants.filter(!_.startsWith("0")).map(Integer.parseInt).filter(isprime).length

Euler052.scala

@@ -1,4 +1,4 @@
-object Euler52 extends Application {
+object Euler052 extends Application {
   def sort (n :Int) = n.toString.toList.sortWith(_<_).mkString.toInt
   def g (n :Int, sn :Int) = (2 to 6).forall(m => sort(n*m) == sn)
   def f (n :Int) = g(n, sort(n))

Euler053.scala

@@ -1,4 +1,4 @@
-object Euler53 extends Application {
+object Euler053 extends Application {
   def fact (n :BigInt) :BigInt = if (n < 2) 1 else n * fact(n-1)
   def choose (n :BigInt, r :BigInt) = fact(n)/(fact(r)*fact(n-r))
   println((for (n <- 1 to 100; r <- 1 to n; if (choose(n, r) > 1000000)) yield 1).sum)

Euler054.scala

@@ -1,4 +1,4 @@
-object Euler54 extends EulerApp {
+object Euler054 extends EulerApp {
   class Card (s :String) {
     val suit :Char = s.charAt(1)
     val rank :Int = "23456789TJQKA".indexOf(s.charAt(0))

Euler055.scala

@@ -1,4 +1,4 @@
-object Euler55 extends EulerApp {
+object Euler055 extends EulerApp {
   def ispal (n :String) = n.take(n.length/2) == n.takeRight(n.length/2).reverse
   def islychrel (n :BigInt, iter :Int = 0) :Int =
     if (iter > 0 && ispal(n.toString)) 0

Euler056.scala

@@ -1,4 +1,4 @@
-object Euler56 extends EulerApp {
+object Euler056 extends EulerApp {
   def answer = (for { a <- 90 to 100; b <- 90 to 100 }
                 yield BigInt(a).pow(b).toString.map(_-'0').sum) max
 }

Euler057.scala

@@ -1,4 +1,4 @@
-object Euler57 extends EulerApp {
+object Euler057 extends EulerApp {
   case class Frac (numer :BigInt, denom :BigInt) {
     def add (n :BigInt) = Frac(n * denom + numer, denom)
     def invert = Frac(denom, numer)

Euler058.scala

@@ -1,4 +1,4 @@
-object Euler58 extends EulerApp {
+object Euler058 extends EulerApp {
   def checkring (r :Int, primes :Int, nums :Int) :Int = {
     if (primes*10/nums < 1) 2*r-1
     else {

Euler059.scala

@@ -1,4 +1,4 @@
-object Euler59 extends EulerApp {
+object Euler059 extends EulerApp {
   val cipher = readline("cipher1.txt") split(',') map(_.toInt)
   def decode (cipher :Array[Int], key :Array[Char]) =
     (0 until cipher.length) map(ii => cipher(ii) ^ key(ii%key.length))

Euler060.scala

@@ -1,4 +1,4 @@
-object Euler60 extends EulerApp {
+object Euler060 extends EulerApp {
   val primes = genprimes(10000) filter(0.!=)
   val ppairs = Set() ++
     (for { ii <- 0 until primes.length-1; jj <- ii until primes.length;

Euler061.scala

@@ -1,4 +1,4 @@
-object Euler61 extends EulerApp {
+object Euler061 extends EulerApp {
   case class Pn (card :Int, value :Int) {
     def valid = (value < 10000) && (value > 999)
     def ab = value / 100

Euler062.scala

@@ -1,4 +1,4 @@
-object Euler62 extends EulerApp {
+object Euler062 extends EulerApp {
   val cubes = new scala.collection.mutable.HashMap[Long,List[Long]]
   def search (n :Long) :Long = {
     val cube = n*n*n

Euler063.scala

@@ -1,4 +1,4 @@
-object Euler63 extends EulerApp {
+object Euler063 extends EulerApp {
   def count (n :Int, p :Int, c :Int) :Int =
     if (n == 10) c
     else if (BigInt(n).pow(p).toString.length < p) count(n+1, 1, c)

Euler064.scala

@@ -1,4 +1,4 @@
-object Euler64 extends EulerApp {
+object Euler064 extends EulerApp {
   case class Root (root :Int, add :Int, div :Int) {
     def expand = {
       val term = ((Math.sqrt(root.toDouble) + add)/div).toInt

Euler065.scala

@@ -1,4 +1,4 @@
-object Euler65 extends EulerApp {
+object Euler065 extends EulerApp {
   case class Frac (numer :BigInt, denom :BigInt) {
     def add (n :BigInt) = Frac(n * denom + numer, denom)
     def invert = Frac(denom, numer)

Euler066.scala

@@ -1,4 +1,4 @@
-object Euler66 extends EulerApp {
+object Euler066 extends EulerApp {
   val maxx = Math.sqrt(Math.MAX_LONG).toLong
   println("MAX " + maxx)
   def solve (d :Int, x :Int) :Pair[Int,Int] = {