
saudavel(X) :-
      comida(X),
      \+ processada(X).
      
processada(pizza).
processada(hamburger).

natural(alface).
natural(morango).

comida(X) :- processada(X).
comida(X) :- natural(X).

/*Defina o predicado intersecao/3, tal que intersecao(L1, L2, I), em que
L1 e L2 são listas de inteiros, significa que I é a lista com os elementos comuns
a L1 e L2. Use a negação e o operador de corte sempre que tal melhorar o seu
programa. O seu programa não deve permitir que o pedido de múltiplas respostas
origine respostas erradas.*/

intersecao([], _, []) :- !.
intersecao(_, [], []) :- !.

intersecao([P | R], L, [P | IRL]) :-
     member(P, L),
     write("MEMBER:"),
     writeln(P),!,
     intersecao(R, L, IRL).

intersecao([P | R], L, IRL) :-
     not(member(P, L)),
     write("NON_MEMBER:"),
     writeln(P),
     intersecao(R, L, IRL).

/*Disjuntas(L1,L2), em que L1 e L2 são
listas de inteiros, significa que L1 e L2 são disjuntas, isto é, não têm elementos em
comum.*/
/*Cut -> Stop, do not try anything*/
disjuntas([], _) :- !.
/*If it is a member do not try disjuntas through recursion and then fail*/
disjuntas([P1 | _], L2) :- write("P1="), writeln(P1), write("L2="), writeln(L2),nl, 
                        member(P1,L2), ! ,fail. 
/*if it was not a member, then recursion*/
disjuntas([_ | R1], L2) :-  write("R1="), writeln(R1),write("L2="), writeln(L2),nl,
                         disjuntas(R1, L2).



disjuntas2(L1,L2) :- not((member(E,L1),member(E,L2))).

/*somaDigitos(N, S), em que
N é um inteiro positivo, significa que S é a soma dos dígitos de N.*/
/* whole division, without remnder is used beside mod 10*/

/*Recursivo*/
somaDigitos(N, N) :- N < 10.
somaDigitos(N, S) :-
    N >= 10,
    DigDireita is N mod 10,
    NSemDigDireita is N // 10,
    somaDigitos(NSemDigDireita, S1),
    S is S1 + DigDireita.

/*Processo iterativo*/
somaDigitos(N, S) :- somaDigitos(N, S, 0).
somaDigitos(0, S, S).
somaDigitos(N, S, Aux) :-
            N > 0,
            DigDireita is N mod 10,
            NSemDigDireita is N // 10,
            NAux is Aux + DigDireita,
            somaDigitos(NSemDigDireita, S, NAux).


/*inverte(N, Inv), em que N é um inteiro positivo, significa que Inv 
é o resultado de inverter os dígitos de N*/

inverte(N, Inv) :- inverte(N, Inv, 0).
inverte(0, Inv, Inv).
inverte(N, Inv, Aux) :- N > 0,
                    DigDireita is N mod 10,
                    NSemDigDireita is N // 10,
                    NAux is Aux * 10 + DigDireita,
                    inverte(NSemDigDireita, Inv, NAux).