-module(ficha2).

-

export([start/0,new/0,destroy/1,write/3,delete/2,read/2,match/2,newR/0,destroyR/1,writeR/

3,deleteR/2,readR/2,matchR/2,newNo/0,insert/3,heigth/1,find/2,max/1,soma/1,novoNo/0,ins

ertR/3,heigthR/1,findR/2,maxR/1,somaR/1,verificaMenor/1,sequencia/0,merge/0,sumInt/1,di

v3/0,isInt/1,inter/2,simetrico/2]).

-record(registo,{nome,cidade}).

-record(arvore,{chave,elemento,esquerda,direita}).

%1.

start() -> writeDate(getDate()).

getDate() -> {dia(),mes(),ano()}.

writeDate({D,M,A}) -> io:format("~p de ~p de ~p ~n",[D,convert(M),A]).

dia() -> element(2,io:read("Dia:")).

mes() -> element(2,io:read("Mes:")).

ano() -> element(2,io:read("Ano:")).

convert(Mes) ->

case Mes of

1 -> "Janeiro";

2 -> "Fevereiro";

3 -> "Março";

4 -> "Abril";

5 -> "Maio";

6 -> "Junho";

7 -> "Julho";

8 -> "Agosto";

9 -> "Setembro";

10 -> "Outubro";

11 -> "Novembro";

12 -> "Dezembro"

end.

%2.

new() -> [].

destroy(Db) -> ok.

write(Key,Element,Db) -> [{Key,Element}|Db].

delete(Key,[]) -> [];

delete(Key,[{Key,Val}|T]) -> T;

delete(Key,[H|T]) -> [H|delete(Key,T)].

read(_,[]) -> {error};

read(Key,[{Key,Element}|T]) -> {ok,Element};

read(Key,[{_,_}|T]) -> read(Key,T).

match(Element,[]) -> [];

match(Element,[{Key,Element}|T]) -> [Key|match(Element,T)];

match(Element,[H|T]) -> match(Element,T).

%3.

newR()->[].

destroyR(Db) -> ok.

writeR(Key,Element,Db) -> [#registo{nome=Key,cidade=Element}|Db].

deleteR(_,[]) -> [];

deleteR(Key,[#registo{nome=Key}|T]) -> T;

deleteR(Key,[H|T]) -> [H|deleteR(Key,T)].

readR(_,[]) -> [];

readR(Key,[#registo{nome=Key,cidade=Val}|T]) -> {ok,Val};

readR(Key,[H|T]) -> readR(Key,T).

matchR(Element,[]) -> [];

matchR(Element,[#registo{nome=Key,cidade=Element}|T])-> [Key|matchR(Element,T)];

matchR(Element,[H|T])-> matchR(Element,T).

%4.

newNo() -> null.

insert(K,Val,null) -> {K,Val,null,null};

insert(K,Val,{Key,Element,Esq,Dir}) when K < Key -> {Key,Element,insert(K,Val,Esq),Dir};

insert(K,Val,{Key,Element,Esq,Dir}) when K >= Key -> {Key,Element,Esq,insert(K,Val,Dir)}.

heigth(null) -> 0;

heigth({Key,Element,Esq,Dir}) -> 1 + max(heigth(Esq),heigth(Dir)).

find(_,null) -> {};

find(X,{Key,Element,_,_}) -> {ok,Element};

find(X,{Key,Element,Esq,Dir}) when X < Key -> find(X,Esq);

find(X,{Key,Element,Esq,Dir}) when X >= Key -> find(X,Dir).

max(null) -> 0;

max({Key,Element,Esq,Dir}) -> max(max(Key,max(Esq)),max(Key,max(Dir))).

soma(null) -> 0;

soma({Key,Element,null,null}) -> Key;

soma({Key,Element,Esq,Dir}) -> Key + soma(Esq) + soma(Dir).

%4.1

novoNo() -> null.

insertR(K,Val,null) -> #arvore{chave=K,elemento=Val,esquerda=null,direita=null};

insertR(K,Val,#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) when Key < K -

> {arvore,Key,Element,insertR(K,Val,Esq),Dir};

insertR(K,Val,#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) when Key >= K

-> {arvore,Key,Element,Esq,insertR(K,Val,Dir)};

insertR(K,_,#arvore{chave=Key}) when Key==K -> {chave_ja_existente}.

heigthR(null) -> 0;

heigthR(#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) -> 1 +

max(heigthR(Esq),heigthR(Dir)).

findR(_,null) -> {};

findR(X,#arvore{chave=Key,elemento=Element}) -> {ok,Element};

findR(X,#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) when X < Key ->

findR(X,Esq);

findR(X,#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) when X >= Key ->

findR(X,Dir).

maxR(null) -> 0;

maxR(#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) ->

max(max(Key,maxR(Esq)),max(Key,maxR(Dir))).

somaR(null) ->0;

somaR(#arvore{chave=Key,elemento=Element,esquerda=null,direita=null}) -> Key;

somaR(#arvore{chave=Key,elemento=Element,esquerda=Esq,direita=Dir}) -> Key + somaR(Esq)

+somaR(Dir).

%6.

verificaMenor(X) -> fun([]) -> [];

(L) -> verificar(X,L) end.

verificar(X,[]) -> [];

verificar(X,[H|T]) when H < X -> [H|verificar(X,T)];

verificar(X,[H|T]) -> verificar(X,T).

%7.

sequencia() -> fun(N) -> lists:seq(1,N) end.

%8.

merge() -> fun(L) -> lists:merge(L) end.

%9.

sumInt(L) -> lists:foldl(fun(X, Sum) -> X + Sum end, 0, L).

%10.

div3() -> [X || X <- lists:seq(1,10), X rem 3 ==0].

%11.

isInt(L) -> [X*X || X <- L, integer(X)].

%12.

inter(L1,L2) -> [X || X <- L1, lists:member(X,L2)].

%13.

simetrico(L1,L2) -> [X|| X <- L1, lists:member(X,L2)==false] ++ [Y || Y<- L2,

lists:member(Y,L1)==false].