week218.erl

-module(week218).
-export([test/0]).
% -compile(export_all).
-include_lib("eunit/include/eunit.hrl").

test() ->
    ?assertEqual((double([])), []),
    ?assertEqual((double([1, 2])), [1, 4]),
    ?assertEqual((evens([4, 6, 7, 8])), [4, 6, 8]),
    ?assertEqual((evens([])), []),
    ?assertEqual((evens([1, 2, 3, 4])), [2, 4]),
    ?assertEqual((evens_1([])), []),
    ?assertEqual((evens_1([1, 2, 3, 4])), [2, 4]),
    ?assertEqual((evens_2([])), []),
    ?assertEqual((evens_2([1, 2, 3, 4])), [2, 4]),
    ?assertEqual((median([1,5,3,4,2])), 3),
    ?assertEqual((median([1,2,3,4])), 2.5),
    ?assertEqual((median([])), []),
    ok.

%% Transforming list elements
%% Define an Erlang function double/1 to double the elements of a list of numbers.

double([]) -> [];
double([X | Xs]) -> [X * X | double(Xs)].

%% Filtering lists
%% Define a function evens/1 that extracts the even numbers from a list of integers.

evens(R) ->
    lists:filter(fun (X) -> X rem 2 == 0 end, R).

is_even(X) -> X rem 2 == 0.

evens_1([]) -> [];
evens_1([X | Xs]) ->
    case is_even(X) of
      true -> [X | evens_1(Xs)];
      false -> evens_1(Xs)
    end.

evens_2(L) -> [X || X <- L, X rem 2 == 0].

%% the median of a list of numbers: this is the middle element when the list is ordered
%% (if the list is of even length you should average the middle two)

median(L) ->
    Length = length(L),
    case Length > 0 of
        true ->
            Sorted_list = sort(L, asc),
            case is_even(Length) of
                false ->
                    To = Length div 2,
                    lists:nth(To + 1, Sorted_list);
                    %traverse_till(1, To + 1, Sorted_list);
                true ->
                    To = Length div 2,
                    Sum = lists:nth(To, Sorted_list) + lists:nth(To + 1, Sorted_list),
                    Sum/2
                    %(traverse_till(1, To, Sorted_list) + traverse_till(1, To + 1, Sorted_list))/ 2
            end;
        false ->
            []
    end.

% traverse_till(From, From, [X | _Xs]) -> X;
% traverse_till(From, To, [_X | Xs]) ->
%     traverse_till(From + 1, To, Xs).

sort(L, Type) ->
    case Type of
      asc -> lists:reverse(bsort(L));
      desc -> bsort(L)
    end.

bsort(L) -> bsortworker(L, []).

bsortworker([], Result) -> Result;  
bsortworker([H], Result) -> [H | bsort(Result)];
bsortworker([H1, H2 | T], Result) ->
    case H1 < H2 of
      true -> bsortworker([H2 | T], [H1 | Result]);
      false -> bsortworker([H1 | T], [H2 | Result])
    end.