Erlang : Project Euler 1-9

euler.hrl

-compile(export_all).

-define(even(X), X rem 2 =:= 0).
-define(odd(X),  X rem 2 =/= 0).

main() -> timer:tc(?MODULE, answer, []).

pow(_,0)                      -> 1;
pow(X,Y) when Y > 0, ?even(Y) -> Z = pow(X, Y div 2), Z*Z;
pow(X,Y) when Y > 0           -> Z = pow(X, Y div 2), X*Z*Z.

gcd(A,0) -> A; gcd(A,B) -> gcd(B, A rem B).

combi(M,M) -> 1;
combi(_,0) -> 1;
combi(M,N) -> combi(M,N-1) * (M-N+1) div N.

d2i(L) -> lists:foldl(fun(X,Y) -> 10*Y+X end, 0, L).

i2d(N) -> [list_to_integer([X]) || X <- integer_to_list(N)].

problem1.erl

-module(problem1).
-compile(export_all).

main() -> timer:tc(problem1,answer,[]).

answer() ->
    L = [N || N <- lists:seq(1,999), N rem 3 =:= 0 orelse N rem 5 =:= 0],
    lists:sum(L).

%%%% use umerge

-module(problem1).
-compile(export_all).

main() -> timer:tc(problem1,answer,[]).

answer() ->
    F = fun (X) -> [X*N || N <- lists:seq(1,999 div X)] end,
    lists:sum(lists:umerge(F(3),F(5))).

%%%% lazy evaluation

-module(problem1).
-compile(export_all).

main() -> timer:tc(problem1,answer,[]).

answer() -> solve(num(1)).

solve({1000,_}) -> 0;
solve({N,F})    when N rem 3 =:= 0; N rem 5 =:= 0 -> N + solve(F());
solve({_,F})    -> solve(F()).

num(N) -> {N, fun() -> num(N+1) end}.

problem2.erl

-module(problem2).
-include("euler.hrl").

answer() -> solve(fib(1,2)).

solve({N,_}) when N >= 4000000 -> 0;
solve({N,F}) when ?even(N)     -> N + solve(F());
solve({_,F})                   -> solve(F()).

fib(A,B) -> {A, fun() -> fib(B,A+B) end}.

problem3.erl

-module(problem3).
-include("euler.hrl").

answer() -> lists:max(facts(600851475143)).

facts(N) -> facts(N,2).

facts(N,P) when N < P*P       -> [N];
facts(N,P) when N rem P =:= 0 -> [P|facts(N div P, P)];
facts(N,2)                    -> facts(N, 3);
facts(N,P)                    -> facts(N, P+2).

problem4.erl

-module(problem4).
-include("euler.hrl").

answer() ->
    H = max_heap:new(),
    solve(max_heap:push({999*999,999,999},H)).

solve(H) ->
    {{N,A,B},H1} = max_heap:pop(H),
    Answer = is_answer(N), A1 = A-1, B1 = B-1,
    if
        Answer  -> N;
        A =:= B -> L = [{A1*A1,A1,A1},{A*A1,A,A1}],
                   solve(lists:foldl(fun max_heap:push/2, H1, L));
        A > B   -> solve(max_heap:push({A*B1,A,B1}, H1))
    end.

is_answer(N) -> L = i2d(N), L =:= lists:reverse(L).

problem5.erl

-module(problem5).
-include("euler.hrl").

answer() -> lists:foldl(fun lcm/2, 1, lists:seq(2,20)).

lcm(A,B) -> A*B div gcd(A,B).

problem6.erl

-module(problem6).
-include("euler.hrl").

answer() -> N = 100, X = N*(N+1) div 2, Y = N*(N+1)*(2*N+1) div 6, X*X-Y.

problem7.erl

-module(problem7).
-include("euler.hrl").

answer() -> solve(primes()).

solve({10001,N,_}) -> N;
solve({_,_,F})     -> solve(F()).

primes() -> primes(1,2).
primes(I,N) -> {I, N, fun() -> primes(I+1, next_prime(N)) end}.

next_prime(2) -> 3;
next_prime(N) ->
    N1 = N+2,
    case primes:is_prime(N1) of
        true  -> N1;
        false -> next_prime(N1)
    end.

problem8.erl

-module(problem8).
-include("euler.hrl").

answer() -> solve(0,digits()).

solve(Max,[A,B,C,D,E|T]) -> solve(max(Max,A*B*C*D*E),[B,C,D,E|T]);
solve(Max,_)             -> Max.

digits() -> lists:flatten(lists:map(fun i2d/1,data())).

data() ->
    [73167176531330624919225119674426574742355349194934,
     96983520312774506326239578318016984801869478851843,
     85861560789112949495459501737958331952853208805511,
     12540698747158523863050715693290963295227443043557,
     66896648950445244523161731856403098711121722383113,
     62229893423380308135336276614282806444486645238749,
     30358907296290491560440772390713810515859307960866,
     70172427121883998797908792274921901699720888093776,
     65727333001053367881220235421809751254540594752243,
     52584907711670556013604839586446706324415722155397,
     53697817977846174064955149290862569321978468622482,
     83972241375657056057490261407972968652414535100474,
     82166370484403199890008895243450658541227588666881,
     16427171479924442928230863465674813919123162824586,
     17866458359124566529476545682848912883142607690042,
     24219022671055626321111109370544217506941658960408,
     07198403850962455444362981230987879927244284909188,
     84580156166097919133875499200524063689912560717606,
     05886116467109405077541002256983155200055935729725,
     71636269561882670428252483600823257530420752963450].

problem9.erl

-module(problem9).
-include("euler.hrl").

answer() -> hd([A*B*C || A <- lists:seq(1,1000 div 3),
                         B <- lists:seq(A,(1000-A) div 2),
                         C <- [1000-A-B],
                         A*A + B*B =:= C*C]).