Project Euler解题汇总 001 ~ 012

EDIT: 2010.5.7，添加关于Scala版本的说明，添加Scala2.8的实现代码

　　前日在网上闲逛，发现了这个有意思的网站Project Euler。这个网站给出了一系列数学相关的题目，你可以使用编程去解答。

引用

What is Project Euler?

　　Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.

　　The motivation for starting Project Euler, and its continuation, is to provide a platform for the inquiring mind to delve into unfamiliar areas and learn new concepts in a fun and recreational context.

　　蛮有趣的，我准备在空余时间依次做做这些题。这系列帖子用于列出我所做出的题（每个贴包括5~15道问题的答案）：对于简单的题，直接给出程序代码及答案；对于我认为比较复杂的题目，只在该贴给出答案，然后另开新帖给出详细点的解答。
　　对于解题所用的编程语言，那些简单的题可能只给出Scala代码（可以直接使用Scala控制台运行，最后一行的运行结果即为答案）；复杂一些的题可能会使用Java/C/Mathmatica/Matlab（注：Mathmatica与Matlab是两个常用的数学工具）。
　　对于所写的代码，在能够解决问题的前提下，尽量做到简单&漂亮，所以所给的代码效率上未必是最佳的，能够解决问题足矣。


问题1:
Add all the natural numbers below one thousand that are multiples of 3 or 5.
求小于1000的自然数中3或5的倍数之和。
答案:233168

Stream.range(0,1000).filter{ n => n%3==0||n%5==0 }.foldLeft(0){ _+_ }

(0 until 1000).filter{ n => n%3==0||n%5==0 }.sum

问题2:
Find the sum of all the even-valued terms in the Fibonacci sequence which do not exceed four million.
对于数列f(n):
　　f(1) =1,f(2) =2
　　f(n) =f(n-1)+f(n-2) (n>2)
求数列f(n)中不大于4000,000且为偶数项数之和。
答案:4613732

    var fib:Stream[Int] = Stream.cons(1,Stream.cons(2,
                              fib.zip(fib.tail).map{case(x,y) => x+y}
                          ))
    fib.takeWhile{_<=4000000}.filter{_%2==0}.foldLeft(0){_+_}

Stream.iterate((1,2)){ case(x,y) => (y,x+y) }.map{ _._1 }
      .takeWhile{ _ <= 4000000 }.filter{ _%2 == 0 }.sum

问题3:Find the largest prime factor of a composite number.
求600851475143的最大质因数。
答案:6857

   
    var num = 600851475143L
    var res = 2
    while(res != num) if(num%res == 0) num = num/res else res += 1
    res

Stream.iterate((600851475143L,2)){ case(n,p) => if(n%p == 0) (n/p,p) else (n,p+1) }
      .takeWhile{ case(n,p) => n>=p }.last._1

问题4:
Find the largest palindrome made from the product of two 3-digit numbers.
求能分解为两个三位数乘积的最大回文数。
答案:906609

  
    def isPalin(n:Int):Boolean = {
        var inv =0
        var tmp =n
        while(tmp != 0){
            inv = inv*10 + tmp%10
            tmp = tmp/10
        }
        inv == n
    }
    var res =0
    for(i <- 100 to 999;j <- 100 to 999;if isPalin(i*j))
        if(i*j > res) res = i*j
    res

 (for(x <- 100 to 999;y <- 100 to 999;s = "" + x*y;if s == s.reverse) yield x*y).max

问题5:What is the smallest number divisible by each of the numbers 1 to 20?
求1,2,..,19,20的最小公倍数。
答案:232792560

    
    def gcd(a:Long,b:Long):Long = if(a==0) b else gcd(b%a,a)
    1.to(20).foldLeft(1L){ (a,b) => a*b/gcd(a,b)}

问题6:Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
求1至100和的平方与1至100的平方和之差。
答案:25164150

 
    var sumOfSquare = 1.to(100).foldLeft(0){ (a,b) => a+b*b }
    var sum = 1.to(100).foldLeft(0){ _+_ }
    var squareOfSum = sum*sum
    squareOfSum-sumOfSquare

 (for(x <- 1 to 100;y <- 1 to 100;if x != y) yield x*y).sum

问题7:Find the 10001st prime.
求第10001个素数（质数）。
答案:104743

    
    var ps:Stream[Int] = Stream.cons(2,
                             Stream.from(3).filter{ n =>
                                 ps.takeWhile(p => p*p <= n).forall(n%_ !=0)
                             })
    ps(10000)

问题8:
Discover the largest product of five consecutive digits in the 1000-digit number.
在给定的1000个数中，求出连续5个数的最大乘积。
答案:40824

    var nums ="""73167176531330624919225119674426574742355349194934
                96983520312774506326239578318016984801869478851843
                85861560789112949495459501737958331952853208805511
                12540698747158523863050715693290963295227443043557
                66896648950445244523161731856403098711121722383113
                62229893423380308135336276614282806444486645238749
                30358907296290491560440772390713810515859307960866
                70172427121883998797908792274921901699720888093776
                65727333001053367881220235421809751254540594752243
                52584907711670556013604839586446706324415722155397
                53697817977846174064955149290862569321978468622482
                83972241375657056057490261407972968652414535100474
                82166370484403199890008895243450658541227588666881
                16427171479924442928230863465674813919123162824586
                17866458359124566529476545682848912883142607690042
                24219022671055626321111109370544217506941658960408
                07198403850962455444362981230987879927244284909188
                84580156166097919133875499200524063689912560717606
                05886116467109405077541002256983155200055935729725
                71636269561882670428252483600823257530420752963450""".replaceAll("\\s+","").map{ _.asDigit }
     var max =0
     for(i <- 0 until nums.size-5){
         var value =nums.slice(i,i+5).foldLeft(1){ (a,b) => a*b }
         if(value>max) max =value
     }
     max

(for(i <- 0 until nums.size-5) yield nums.slice(i,i+5).product).max

问题9:
Find the only Pythagorean triplet, {a, b, c}, for which a + b + c = 1000.
求满足a+b+c = 1000的勾股数的积。（注：勾股数指满足a^2+b^2=c^2的自然数a,b,c）
答案:31875000

    for{a <- 1 until 500
        b <- a until 500
        if a*a + b*b == (1000-a-b)*(1000-a-b)
    } yield a*b*(1000-a-b)

问题10:
Calculate the sum of all the primes below two million.
求2,000,000以内所有素数的和。
答案:142913828922

    //这里用的求素数算法同题7一样
    //但这个问题数据量稍大了点，该代码需要运行15秒左右
    //如果遇到更大的数据，我会采用稍复杂一点的算法，会快很多（快一到两个数量级）
    var ps:Stream[Int] = Stream.cons(2,
                           Stream.from(3).filter(n =>
                             ps.takeWhile(p => p*p <= n).forall(n%_ !=0)
                           )
                         )
    ps.takeWhile(_ < 2000000).foldLeft(0L){ _+_ }

问题11:What is the greatest product of four numbers on the same straight line in the 20 by 20 grid?
对于给定的20×20的数字方阵，求相邻4个数之积的最大值。（相邻数包括同一行、同一列或同一对角线上的连续相邻4个数）
答案:70600674

    
    var src ="""08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
                49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
                81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
                52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
                22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
                24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
                32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
                67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
                24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
                21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
                78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
                16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
                86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
                19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
                04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
                88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
                04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
                20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
                20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
                01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48""" 
        def getValue(array:Array[Int],row:Int,col:Int):Int ={
            var res =0
            if(col+4 <= 20){
                var pc = array.slice(row*20+col,row*20+col+4).foldLeft(1){ _*_ }
                res =res max pc
            }
            if(row+4 <= 20){
                var pr =1
                for(n <- 0 until 4) pr = pr*array((row+n)*20+col)
                res =res max pr
            }
            if(row+4<=20 && col+4<=20){
                var pd1 =1
                var pd2 =1
                for(n <-0 until 4){
                    pd1 = pd1*array((row+n)*20+col+n)
                    pd2 = pd2*array((row+n)*20+col+3-n)
                }
                res =res max pd1 max pd2
            }
            res
        }
        var nums =src.split("\\s+").map{ _.foldLeft(0){ (a,b) => a*10+b-'0' } }
        var res  =0
        for(row <- 0 until 20;col <- 0 until 20)
            res =res max getValue(nums,row,col)
        res

object Euler11 extends Application {    
   val src = """08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
                49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
                81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
                52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
                22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
                24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
                32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
                67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
                24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
                21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
                78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
                16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
                86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
                19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
                04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
                88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
                04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
                20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
                20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
                01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48""" 

   val nms = src.lines.toArray.map{ line => line.trim.split("\\s+").map{ _.toInt } }
   
   def valueAt(row: Int,col: Int): Int = 
       if(row >= 0 && row < nms.size &&
          col >= 0 && col < nms(row).size) nms(row)(col)
       else 0 
   
   val ots = (0,1)::(1,0)::(1,1)::(1,-1)::Nil
   
   val res = (for(row <- 0 until nms.size; col <- 0 until nms(row).size; (x,y) <- ots) 
                 yield (for(s <- 0 until 4) yield valueAt(row+s*x,col+s*y)).product 
             ).max
   println(res)
}

问题12:What is the value of the first triangle number to have over five hundred divisors?
求第一个因子个数超过500的三角数。(三角数t(n) =n*(n+1)/2)
答案:76576500

    var ts = Stream.cons(0,Stream.from(1).map{ n =>
                 var t =n*(n+1)/2
                 var f =0
                 var k =1
                 while(k*k<t){
                    if(t%k ==0) f +=2
                    k +=1
                 }
                 if(t == k*k) f+1 else f
             })
    var len =ts.takeWhile{_<=500}.length
    len*(len+1)/2

评论

12 楼 wantdrink 2008-08-19  

这贴很不错，楼主辛苦了！！！！

11 楼 csf178 2008-06-21  

楼主不如逛逛国内高校的ACM题

10 楼 albertlee 2008-06-16  

Haskell有个重要的特性就是 lazy evaluation  ， ghc 在编译的时候是会把函数调用展开，具体细节我没深入研究，总之在这里是不会有多余的调用和计算的。纯函数式语言性能也可以很好哦：） 而且在多核上通过适当的程序，打开多核支持，进行并行计算，性能可以更方便的提升。我在四核的服务器上测试过一个例子，几乎可以接近线性提高。

9 楼 Eastsun 2008-06-16  

albertlee 写道

$ cat euler.hs
module Main where
import List

sieve (p:ns) = p:(sieve [n | n <- ns, n `mod` p /= 0])
primes = sieve [2..]

q7 = primes !! 10001

main = print q7

$ ghc -O2 euler.hs -o euler

$ time ./euler
104759

real 0m3.981s
user 0m3.945s
sys 0m0.033s

这个结果太让我感到意外了
我不太确定我写的Scala代码与你的Haskell代码是否是一回事。
按我的理解，那段Scala求第n个素数时需要要调用filter n次，粗略估计，时间复杂度至少是O(n^2)级的。
PS：函数式语言有个很大的问题，就是写的代码不方便计算时间复杂度，不像命令式语言的直观。

8 楼 wxb_love 2008-06-16  

大学的时候就没有学好算法,看到楼主写的这些,也就哪些简单的会做,还好不是开发算法的,收藏了,以后要是用到拿来用.谢谢了 继续上传~~~

7 楼 albertlee 2008-06-16  

$ cat euler.hs
module Main where
import List

sieve (p:ns) = p:(sieve [n | n <- ns, n `mod` p /= 0])
primes = sieve [2..]

q7 = primes !! 10000

main = print q7

$ ghc -O2 euler.hs -o euler

time ./euler
104743

real 0m3.376s
user 0m3.380s
sys 0m0.000s

ps: 更正下， 应该是 !! 10000 ，列表0-based

6 楼 Eastsun 2008-06-16  

albertlee 写道

sieve (p:ns) = p:(sieve [n | n <- ns, n `mod` p /= 0])
primes = sieve [2..]

q7 = primes !! 10001

够偷懒的～～

够简单~
相比而言，虽然Scala也能类似的实现；但由于Scala中没有对List语言层次上的支持，实现起来会啰嗦些。

//Scala
def sieve(s: Stream[Int]): Stream[Int] =
     Stream.cons(s.head, sieve(s.tail filter { _ % s.head != 0 }))
sieve(Stream.from(2))(10000)

但是Scala中这个实现的性能及其低下，在默认设置下上述代码会抛出java.lang.OutOfMemoryError异常。


albertlee，你的这段Haskell代码执行需要多少时间？

5 楼 albertlee 2008-06-16  

在 haskell.org 的wiki上面专门有一个页就是收集 euler 题目的 haskell 解法的，我没有参考那里，你有兴趣可以看看上面的代码，应该是更正，我的很多是靠蛮力计算，尤其是素数和公因数一类的问题，涉及太多数学的知识了。
楼主看这里吧，我就不现宝了
http://www.haskell.org/haskellwiki/Euler_problems

你的代码里很多 filter, takeWhile 之类的看着和 haskell很像啊

4 楼 Eastsun 2008-06-16  

期待楼上的后续代码，虽然是第一次看到haskell代码:-)
主要想对比一下我的代码和正真的函数式代码还有那些差距。
我使用Scala代码来解题就是想尝试下函数式语言，也努力的去转变思维方式了。
但感觉写的代码总是很别扭，有点“画虎不成反类犬”了。

3 楼 albertlee 2008-06-16  

q5 = foldr1 lcm [1..20]

sieve (p:ns) = p:(sieve [n | n <- ns, n `mod` p /= 0])
primes = sieve [2..]

q7 = primes !! 10001

够偷懒的～～

2 楼 albertlee 2008-06-16  

module Main where
import List

q1 = sum $ nub ([3, 6 .. 999] ++ [5, 10 .. 995])

fibs = 1 : scanl (+) 1 fibs
q2 = sum [ i | i <- takeWhile (< 4000000) fibs, i `mod` 2 == 0]

头两个的，先吃饭去了。

1 楼 albertlee 2008-06-16  

我去年的时候做了几天，搞定了三十多个，后来换工作等一忙乱就放下了。

下面我给出相应的 haskell的解法吧，当作磨刀了