Snaut

-module(hw1).

 

-compile(export_all).

 

 

 

max([]) -> [];

 

max([X]) -> X;

 

max([A|[B|T]]) -> case A>B of

 

                                        true -> max([A|T]);

 

                                        false -> max([B|T])

 

                        end.

 

 

 

min([]) -> [];

 

min([X]) -> X;

 

min([A|[B|T]]) -> case A<B of

 

                                        true -> min([A|T]);

 

                                        false -> min([B|T])

 

                        end.

 

 

 

 

 

min_max([]) -> [];

 

min_max(A) -> {min(A),max(A)}.

 

 

 

 

is_palindrome(A)-> case lists:reverse(A)==A of

 

                                        true when is_list(A) -> true;

 

                                        false -> false

 

                                end.

 

 

 

 

 

product([A|[B|T]])->product([A*B|T]).

 

 

 

all_different(A,B,C)-> (A/=B) and (A/=C) and (B/=C).

 

 

 

 

is_proper_list([_|T])->case is_list(T) of

 

                                        true->is_proper_list(T);

 

                                        false->false

 

                                end.

 

cutlen(A,X) -> move_(A,[],X).

 

slice(A,B,[H|T]) -> case (A>1) of

                                        true -> slice(A-1,B-1,T);

                                        false -> cutlen(B,[H|T])

                                end.

 

 

move_(0,Acc,_) -> lists:reverse(Acc);

move_(A,Acc,[H|T])->move_(A-1,[H|Acc],T).

 

max(X,Y,Z) ->

 

        if

 

                X >= Y andalso X >= Z -> X;

 

                Y >= X andalso Y >= Z -> Y;

 

                true -> Z

 

        end.

 

num_solutions(A,B,C) -> D=B*B-4*A*C,

                                        if D>0 -> 2;

                                                D==0 -> 1;

                                                true -> 0

                                        end.

 

after_tax(Income) -> if Income=<50000 -> Income;

                                                Income=<70000 -> (Income-50000)*0.9+after_tax(50000);

                                                Income=<90000 -> (Income-70000)*0.8+after_tax(70000);

                                                Income=<110000 -> (Income-90000)*0.7+after_tax(90000);

                                                        true -> (Income-110000)*0.6+after_tax(110000)

                                        end.

 

reverse_list_(B,[]) -> B;

reverse_list_(B,[H|T]) -> reverse_list_([H|B],T).

 

reverse_list(A) -> reverse_list_([],A).

 

flatten([]) -> [];

flatten([A]) -> case is_list(A) of

                                true -> flatten(A);

                                false -> [A]

                        end;

flatten([H|T]) -> case is_list(H) of

                                        true -> flatten(H);

                                        false -> [H]

                                end

                        ++

                                case is_list(T) of

                                        true -> flatten(T);

                                        false -> [T]

                                end;

flatten(A) -> A.

 

fast_power_(_,_,0) -> 1;

fast_power_(_,X,1) -> X;

fast_power_(B,X,N) -> fast_power_(B,X*B,N-1).

 

fast_power(0, 0) -> error;

fast_power(X, N) -> case is_integer(N) of

                                                true -> fast_power_(X,X,N);

                                                false -> error

                                        end.

 

 

weekday(Day, Month, Year) -> case calendar:day_of_the_week(Year,

                                                                if Month == january -> 1;

                                                                        Month == february -> 2;

                                                                        Month == march -> 3;

                                                                        Month == april -> 4;

                                                                        Month == may -> 5;

                                                                        Month == june -> 6;

                                                                        Month == jule -> 7;

                                                                        Month == august -> 8;

                                                                        Month == september -> 9;

                                                                        Month == october -> 10;

                                                                        Month == november -> 11;

                                                                        Month == december -> 12

                                                                end,                                                                   

                                                                Day) of

                                                        1 -> monday;

                                                        2 -> tuesday;

                                                        3 -> wednesday;

                                                        4 -> thursday;

                                                        5 -> friday;

                                                        6 -> saturday;

                                                        7 -> sunday

                                                        end.

 

rle([A])->case is_tuple(A) of

                        true -> A;

                        false -> [{A,1}]

                end;

rle([{H1,C}|[H1]])->[{H1,C+1}];

rle([{H1,C}|[H2]])->[{H1,C}|rle([H2])];

rle([{H1,C}|[H1|T]])->rle([{H1,C+1}|T]);

rle([{H1,C}|[H2|T]])->[{H1,C}|rle([H2|T])];

rle([H|T])->rle([{H,1}|T]).

 

rle1([{H1,C}|[H1]])->[{H1,C+1}];

rle1([{H1,C}|[H2]])->[{H1,C}|rle1([H2])];

rle1([{H1,C}|[H1|T]])->rle1([{H1,C+1}|T]);

rle1([{H1,C}|[H2|T]])->[{H1,C}|rle1([H2|T])];

rle1([H1|[H1]])->rle1([{H1,2}]);

rle1([H1|[H1|T]])->rle1([{H1,2}|T]);

rle1([H|T])->[H|rle1(T)].

 

rld([{X,1}])->[X];

rld([{X,C}])->if is_integer(C) and (C > 1) -> [X|rld([{X,C-1}])] end;

rld([A])-> [A];

rld([H|T])->rld([H])++rld(T).