与项目欧拉速度比较：C vs Python与Erlang vs Haskell

我从问题＃12 Project
Euler作为编程练习，并比较我在C，Python，Erlang和Haskell中的实现（当然不是最优）实现。为了获得更高的执行时间，我搜索了第一个有1000个以上因子的三角形数字，而不是原始问题中所述的500个。

结果如下：

<强> C：

[email protected]:~/erlang$ gcc -lm -o euler12.bin euler12.c
[email protected]:~/erlang$ time ./euler12.bin
842161320

real    0m11.074s
user    0m11.070s
sys 0m0.000s

<强>的Python：

[email protected]:~/erlang$ time ./euler12.py
842161320

real    1m16.632s
user    1m16.370s
sys 0m0.250s

Python与PyPy：**

[email protected]:~/Downloads/pypy-c-jit-43780-b590cf6de419-linux64/bin$ time ./pypy /home/lorenzo/erlang/euler12.py
842161320

real    0m13.082s
user    0m13.050s
sys 0m0.020s

<强>二郎：

[email protected]:~/erlang$ erlc euler12.erl
[email protected]:~/erlang$ time erl -s euler12 solve
Erlang R13B03 (erts-5.7.4) [source] [64-bit] [smp:4:4] [rq:4] [async-threads:0] [hipe] [kernel-poll:false]

Eshell V5.7.4  (abort with ^G)
1> 842161320

real    0m48.259s
user    0m48.070s
sys 0m0.020s

<强> Haskell中：

[email protected]:~/erlang$ ghc euler12.hs -o euler12.hsx
[1 of 1] Compiling Main             ( euler12.hs, euler12.o )
Linking euler12.hsx ...
[email protected]:~/erlang$ time ./euler12.hsx
842161320

real    2m37.326s
user    2m37.240s
sys 0m0.080s

<强>要点：

• C：100％
• Python：692％（使用PyPy的占118％）
• Erlang：436％（135％感谢RichardC）
• Haskell：1421％

我认为C有一个很大的优势，因为它用了很长的时间来计算，而不是任意长度的整数。另外它不需要首先加载运行时（其他人？）。

问题1： Erlang，Python和Haskell会因为使用任意长度的整数而失去速度，或者只要值小于MAXINT？

问题2： 为什么Haskell这么慢？有没有编译器标志，关闭刹车或是我的实施？ （后者很可能，因为Haskell是一本有七个印章的书。）

问题3： 你可以提供一些提示，如何优化这些实现而不改变我确定因素的方式？以任何方式优化：更好，更快，更“原生”的语言。

**修改

问题4： 我的功能实现是否允许LCO（最后一次调用优化，又名尾递归消除），从而避免在调用堆栈中添加不必要的帧？

尽管我不得不承认我的Haskell和Erlang知识是非常有限的，但我真的试图在四种语言中尽可能地实现相同的算法。

#include <stdio.h>
#include <math.h>

int factorCount (long n)
{
    double square = sqrt (n);
    int isquare = (int) square;
    int count = isquare == square ? -1 : 0;
    long candidate;
    for (candidate = 1; candidate <= isquare; candidate ++)
        if (0 == n % candidate) count += 2;
    return count;
}

int main ()
{
    long triangle = 1;
    int index = 1;
    while (factorCount (triangle) < 1001)
    {
        index ++;
        triangle += index;
    }
    printf ("%ldn", triangle);
}

#! /usr/bin/env python3.2

import math

def factorCount (n):
    square = math.sqrt (n)
    isquare = int (square)
    count = -1 if isquare == square else 0
    for candidate in range (1, isquare + 1):
        if not n % candidate: count += 2
    return count

triangle = 1
index = 1
while factorCount (triangle) < 1001:
    index += 1
    triangle += index

print (triangle)

-module (euler12).
-compile (export_all).

factorCount (Number) -> factorCount (Number, math:sqrt (Number), 1, 0).

factorCount (_, Sqrt, Candidate, Count) when Candidate > Sqrt -> Count;

factorCount (_, Sqrt, Candidate, Count) when Candidate == Sqrt -> Count + 1;

factorCount (Number, Sqrt, Candidate, Count) ->
    case Number rem Candidate of
        0 -> factorCount (Number, Sqrt, Candidate + 1, Count + 2);
        _ -> factorCount (Number, Sqrt, Candidate + 1, Count)
    end.

nextTriangle (Index, Triangle) ->
    Count = factorCount (Triangle),
    if
        Count > 1000 -> Triangle;
        true -> nextTriangle (Index + 1, Triangle + Index + 1)
    end.

solve () ->
    io:format ("~p~n", [nextTriangle (1, 1) ] ),
    halt (0).

factorCount number = factorCount' number isquare 1 0 - (fromEnum $ square == fromIntegral isquare)
    where square = sqrt $ fromIntegral number
          isquare = floor square

factorCount' number sqrt candidate count
    | fromIntegral candidate > sqrt = count
    | number `mod` candidate == 0 = factorCount' number sqrt (candidate + 1) (count + 2)
    | otherwise = factorCount' number sqrt (candidate + 1) count

nextTriangle index triangle
    | factorCount triangle > 1000 = triangle
    | otherwise = nextTriangle (index + 1) (triangle + index + 1)

main = print $ nextTriangle 1 1

在x86_64 Core2 Duo（2.5GHz）机器上使用GHC 7.0.3，gcc 4.4.6，Linux
2.6.29编译使用ghc -O2 -fllvm -fforce-recomp用于Haskell和gcc -O3 -lm用于C。

• 您的C例程运行时间为8.4秒（比运行速度快，可能是因为-O3）
• Haskell解决方案在36秒内运行（由于-O2标志）
• 您的factorCount'代码没有显式键入，并且默认为Integer（感谢Daniel纠正我的错误！使用Int和时间更改为 11.1秒
  提供显式类型签名（这是标准练习） 在 factorCount’中，你有不必要的 fromIntegral
  `。修正后的结果没有改变（编译器很聪明，对你来说很幸运）。
• 您使用了mod，其中rem更快更充分。这会将时间更改为 8.5秒 。
• factorCount'大专栏  与项目欧拉速度比较：C vs Python与Erlang vs Haskellode>不断地应用两个额外的参数（number，sqrt）。工人/包装转换给我们：

$ time ./so
842161320  

real    0m7.954s
user    0m7.944s
sys     0m0.004s

factorCount number = factorCount' number isquare 1 0 - (fromEnum $ square == fromIntegral isquare)
    where square = sqrt $ fromIntegral number
          isquare = floor square

factorCount' :: Int -> Int -> Int -> Int -> Int
factorCount' number sqrt candidate0 count0 = go candidate0 count0
  where
  go candidate count
    | candidate > sqrt = count
    | number `rem` candidate == 0 = go (candidate + 1) (count + 2)
    | otherwise = go (candidate + 1) count

nextTriangle index triangle
    | factorCount triangle > 1000 = triangle
    | otherwise = nextTriangle (index + 1) (triangle + index + 1)

main = print $ nextTriangle 1 1

factorCount (_, Sqrt, Candidate, Count) when Candidate == Sqrt -> Count + 1;

factorCount (N) ->
    Sqrt = math:sqrt (N),
    ISqrt = trunc(Sqrt),
    if ISqrt == Sqrt -> factorCount (N, ISqrt, 1, -1);
       true          -> factorCount (N, ISqrt, 1, 0)
    end.

factorCount (_N, ISqrt, Candidate, Count) when Candidate > ISqrt -> Count;
factorCount ( N, ISqrt, Candidate, Count) ->
    case N rem Candidate of
        0 -> factorCount (N, ISqrt, Candidate + 1, Count + 2);
        _ -> factorCount (N, ISqrt, Candidate + 1, Count)
    end.

$ erlc +native euler12.erl
$ time erl -noshell -s euler12 solve
842161320

real    0m19.468s
user    0m19.450s
sys 0m0.010s

$ time ./a.out
842161320

real    0m12.755s
user    0m12.730s
sys 0m0.020s