-module(beust).
-compile(export_all).

to_digits(Number) ->
    to_digits(Number, []).

to_digits(Number, List) when Number div 10 == 0 ->
    [Number | List];
to_digits(Number, List) ->
    to_digits(Number div 10, [Number rem 10 | List]).

in_list(Element, [Element|_T]) ->
    true;
in_list(_Element, []) ->
    false;
in_list(Element, [_H|T]) ->
    in_list(Element, T).

unique_list([]) ->
    true;
unique_list([H|T]) ->
    case in_list(H,T) of
        true ->
            false;
        false ->
            unique_list(T)
    end.

count(From, Max) ->
    Cons = fun(List,Element) -> [Element|List] end,
    count(From, Max + 1, Cons, []).

count(Upto, Upto, _Fun, State) ->
    State;
count(From, Upto, Fun, State) when From < Upto ->
    case unique_list(to_digits(From)) of
        true ->
            count(From + 1, Upto, Fun, Fun(State,From));
        false ->
            count(From + 1, Upto, Fun, State)
    end.

challenge(Max) ->
    Finder = fun({[H|_T]=List,MaxGap,Counter},Element) when Element - H >= MaxGap ->
                     {[Element|List],Element - H,Counter + 1};
                ({List,MaxGap,Counter},Element) ->
                     {[Element|List],MaxGap,Counter + 1}
             end,
    statistics(wall_clock),
    {_,BiggestJump,CountOfNumbers} = count(1,Max+1,Finder,{[],0,0}),
    {_, Elapsed} = statistics(wall_clock),
    io:format("~p ms elapsed to complete count to ~p~n", [Elapsed, Max]),
    {BiggestJump, CountOfNumbers}.

test_challenge() ->
    {1,10} = challenge(10),
    {2,90} = challenge(100),
    {11,738} = challenge(1000),
    {105,5274} = challenge(10000),
    {1047,32490} = challenge(100000).

test() ->
    test_to_digits(),
    test_in_list(),
    test_unique_list(),
    test_count(),
    test_count4(),
    test_challenge(),
    ok.

test_to_digits() ->
    [3] = to_digits(3),
    [1,2] = to_digits(12),
    [1,0,0] = to_digits(100).

test_in_list() ->
    true = in_list(1,[1,2,3]),
    true = in_list(2,[1,2,3]),
    true = in_list(3,[1,2,3]),
    false = in_list(0,[1,2,3]),
    false = in_list(0,[]),
    true = in_list(1,[1]).

test_unique_list() ->
    false = unique_list([1,1]),
    true = unique_list([1,2]),
    true = unique_list([1]),
    false = unique_list([1,2,1]),
    false = unique_list([2,1,1]),
    false = unique_list([1,1,2]),
    true = unique_list([1,2,3]).

test_count() ->
    [3,2,1] = count(1,3),
    [12,10,9] = count(9,12),
    [103,102,98,97] = count(97,103).

test_count4() ->
    Counter = fun({List,Sum},Element) -> {[Element|List],Sum + 1} end,
    {[12,10],2} = count(10,13,Counter,{[],0}),
    4 = count(97,104,fun(Sum,_Element) -> Sum + 1 end,0),
    GapFinder = fun({[H|_T]=List,MaxGap},Element) when Element - H > MaxGap ->
                        {[Element|List],Element - H};
                   ({List,MaxGap},Element) ->
                        {[Element|List],MaxGap}
                end,
    {[103,102,98],4} = count(98,104,GapFinder,{[],0}).