Erlang : Project Euler 40-49

problem40.erl

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

answer() -> prod([digit(N) || N <- [1,10,100,1000,10000,100000,1000000]]).

digit(N) -> digit(N,0,0).

digit(N,0,0) when N < 10 -> N;
digit(N,D,T) ->
    X = 9 * trunc(math:pow(10,D)),
    D1 = D+1,
    T1 = T+X*D1,
    case N > T1 of
        true  -> digit(N,D1,T1);
        false -> T2 = N-T,
                 N1 = trunc(math:pow(10,D)) + T2 div D1,
                 R = T2 rem D1,
                 N1 div trunc(math:pow(10,D1-R)) rem 10
    end.

prod(L) -> lists:foldl(fun (X,Y) -> X*Y end, 1, L).

problem41.erl

-module(problem41).
-include("euler.hrl").
-define(digits, [7,6,5,4,3,2,1]).

answer() -> try solve(tree([])) catch N -> N end.

tree(L) -> {L, [fun () -> tree(L++[H]) end || H <- ?digits--L]}.

solve({L,_}) when length(L) =:= 7 ->
    N = d2i(L),
    case primes:is_prime(N) of
        true  -> throw(N);
        false -> false
    end;
solve({_,Fs}) -> [solve(F()) || F <- Fs].

problem42.erl

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

answer() ->
    {_,File} = file:open("words.txt", [read]),
    {_,Str}  = file:read_line(File),
    file:close(File),
    solve([string:strip(W, both, $") || W <- string:tokens(Str, ",")]).

solve(Str) -> length([N || N <- [value(S) || S <- Str], triangle(N)]).

value(Str) -> lists:foldl(fun(X,Y) -> X-$A+1+Y end, 0, Str).

triangle(N) -> N1 = 2*N, R = trunc(math:sqrt(N1)), N1 =:= R*(R+1).

problem43.erl

-module(problem43).
-include("euler.hrl").
-define(DS, [0,1,2,3,4,5,6,7,8,9]).

answer() -> solve(tree([])).

tree(L) -> {L, [fun() -> tree(X) end || X <- [L++[T] || T <- ?DS--L], check(X)]}.

check([_,_,_,C]) -> C rem 2 =:= 0;
check([_,_,A,B,C]) -> (A+B+C) rem 3 =:= 0;
check([_,_,_,_,_,C]) -> C rem 5 =:= 0;
check([_,_,_,_,A,B,C]) -> d2i([A,B,C]) rem 7 =:= 0;
check([_,_,_,_,_,A,B,C]) -> d2i([A,B,C]) rem 11 =:= 0;
check([_,_,_,_,_,_,A,B,C]) -> d2i([A,B,C]) rem 13 =:= 0;
check([_,_,_,_,_,_,_,A,B,C]) -> d2i([A,B,C]) rem 17 =:= 0;
check(_) -> true.

solve({L,_})  when length(L) =:= 10 -> d2i(L);
solve({_,Fs}) -> lists:sum([solve(F()) || F <- Fs]).

problem44.erl

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

answer() -> solve(pent()).

solve({N,L,F}) ->
    case answer(N,L) of
        false -> solve(F());
        D     -> D
    end.

pent() -> pent(1,[]).

pent(N,L) ->
    X = N*(3*N-1) div 2,
    {X, L, fun () -> pent(N+1,[X|L]) end}.

answer(_,[])    -> false;
answer(N,[D|T]) ->
    case is_pent(N-D) andalso is_pent(2*N-D) of
        true  -> D;
        false -> answer(N,T)
    end.

is_pent(N) -> X = 1+24*N, Y = trunc(math:sqrt(X)),
              X =:= Y*Y andalso Y rem 6 =:= 5.

problem45.erl

-module(problem45).
-include("euler.hrl").
-record(polygon, {pn,lazy}).

answer() -> solve(p(166), h(143)).

p(N) -> #polygon{pn = N*(3*N-1) div 2, lazy = fun() -> p(N+1) end}.
h(N) -> #polygon{pn = N*(2*N-1),       lazy = fun() -> h(N+1) end}.

force(#polygon{lazy=F}) -> F().

comp(#polygon{pn=X},#polygon{pn=Y}) ->
    if X < Y -> 1; X =:= Y -> 0; X > Y -> -1 end.

solve(X,Y) ->
    case comp(X,Y) of
        1  -> solve(force(X), Y);
        0  -> X#polygon.pn;
        -1 -> solve(X, force(Y))
    end.

problem46.erl

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

answer() -> try solve(3) after erase() end.

solve(N) ->
    case is_answer(N) of
        true  -> N;
        false -> solve(N+2)
    end.

is_answer(N) -> not lists:any(fun is_prime/1, seq(N)).

seq(N) -> seq(N,0,[]).

seq(X,Y,L) ->
    case X - 2*Y*Y of
        N when N < 2 -> L;
        N -> seq(X,Y+1,[N|L])
    end.

is_prime(N) ->
    case get({is_prime,N}) of
        undefined -> is_prime(N,3);
        true      -> true;
        false     -> false
    end.

is_prime(N,P) when N < P*P       -> put({is_prime,N},true), true;
is_prime(N,P) when N rem P =:= 0 -> put({is_prime,N},false), false;
is_prime(N,P)                    -> is_prime(N,P+2).

problem47.erl

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

answer() -> solve(647,[]).

solve(N,[4,4,4,4|_]) -> N-4;
solve(N,L)           -> solve(N+1, [count(N,2,[])|L]).

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

problem48.erl

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

answer() -> mod(lists:sum([pow10(N,N) || N <- lists:seq(1,1000)])).

mod(N) -> N rem trunc(math:pow(10,10)).

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

problem49.erl

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

answer() ->
    G = digraph:new(),
    make(G),
    try
        find(G)
    catch
        X -> X
    after
        digraph:delete(G)
    end.

make(G) ->
    F = fun (N) ->
        D = lists:sort(i2d(N)),
        digraph:add_vertex(G,D),
        digraph:add_edge(G,D,D,N)
    end,
    [F(N) || N <- primes:list(9999), N >= 1000].

find(G) ->
    F = fun (V) ->
        Es = [digraph:edge(G,E) || E <- digraph:in_edges(G,V)],
        Ls = [Label || {_,_,_,Label} <- Es],
        [throw(100000000*A+10000*B+C) ||
            A <- Ls, B <- Ls, C <- Ls,
            A =/= 1487, A < B, B < C, 2*B-A =:= C]
    end,
    [F(V) || V <- digraph:vertices(G)].