Erlang : Project Euler 50-59

problem50.erl

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

answer() ->
    F = fun(L) -> longest(lists:reverse(L)) end,
    element(2, lists:max(lists:map(F, tails(primes())))).

longest([]) -> {0,0};
longest([H|T]) ->
    X = lists:sum([H|T]),
    case primes:is_prime(X) of
        true -> {length([H|T]),X};
        _ -> longest(T)
    end.

primes() ->
    Arr = primes(0, 1000, primes:array(1000)),
    F = fun
        (N,true,L)  -> [N|L];
        (_,false,L) -> L
    end,
    array:foldr(F, [], Arr).

primes(Min,Max,Arr) when Min =:= Max   -> Arr;
primes(Min,Max,Arr) when Min+1 =:= Max -> array:resize(Min,Arr);
primes(Min,Max,Arr) ->
    X = sum_array(Arr),
    if
        X < 1000000 ->
            primes(Min,Max*2,primes:array(Max*2));
        true ->
            Mid = (Min+Max) div 2,
            Y = sum_array(array:resize(Mid, Arr)),
            if
                Y < 1000000 -> primes(Mid, Max, Arr);
                true -> primes(Min, Mid, array:resize(Mid, Arr))
            end
    end.

sum_array(Arr) ->
    F = fun
        (N,true,X)  -> X+N;
        (_,false,X) -> X
    end,
    array:foldl(F,0,Arr).

tails([])    -> [];
tails([H|T]) -> [[H|T]|tails(T)].

problem52.erl

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

answer() -> solve(100002).

solve(N) ->
    case trunc(math:log10(N*6)) > trunc(math:log10(N)) of
        true ->
            solve(trunc(math:pow(10, trunc(math:log10(N))+1)) + 2);
        false ->
            case is_answer(N) of
                true  -> N;
                false -> solve(N+3)
            end
    end.

is_answer(N) ->
    L = lists:sort(i2d(N)),
    F = fun (X) -> X =:= L end,
    lists:all(F, [lists:sort(i2d(X)) || X <- [2*N,3*N,4*N,5*N,6*N]]).

problem53.erl

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

answer() -> solve(triangle()).

solve({[_,101|_],_}) -> 0;
solve({Xs,F}) -> length([X || X <- Xs, X > 1000000]) + solve(F()).

triangle()  -> {[0], fun() -> triangle([1,1]) end}.
triangle(L) -> {L, fun () -> triangle(join(L)) end}.

join(L) -> join(L,[0|L]).
join([],L) -> L; join([X|Xs],[Y|Ys]) -> [X+Y|join(Xs,Ys)].

problem55.erl

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

answer() ->
    length([X || X <- [i2d(N) || N <- lists:seq(1,9999)], lychrel(X)]).

lychrel(L) -> lychrel(1, add(L,lists:reverse(L))).

lychrel(51,_) -> true;
lychrel(N,L) ->
    L1 = lists:reverse(L),
    case L =/= L1 of true -> lychrel(N+1, add(L,L1)); false -> false end.

add(Xs,Ys) -> add(Xs,Ys,0).

add([X|Xs],[Y|Ys],N) -> Z = X+Y+N, [Z rem 10|add(Xs,Ys,Z div 10)];
add([],[],0)         -> [];
add([],[],N)         -> [N].

problem56.erl

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

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

solve(1,_,Max) -> Max;
solve(A,B,Max) ->
    case math:log10(pow(A,B)) < Max/9 of
        true ->
            solve(A-1,99,Max);
        _ ->
            X = sum(pow(A,B)),
            if X > Max -> solve(A,B-1,X); true -> solve(A,B-1,Max) end
    end.

sum(N) -> lists:sum(i2d(N)).

problem58.erl

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

answer() -> solve({0,1},layer(3)).

layer(N) ->
    D = N*N, N1 = N-1,
    {N, ratio([D,D-N1,D-2*N1,D-3*N1]), fun () -> layer(N+2) end}.

ratio(L) ->
    L1 = lists:filter(fun primes:is_prime/1, tl(L)),
    {length(L1), length(L)}.

solve({X,Y},{N,{X1,Y1},_}) when (X+X1) / (Y+Y1) < 0.1 -> N;
solve({X,Y},{_,{X1,Y1},F}) -> solve({X+X1,Y+Y1},F()).