Ejercicios Prolog

Ejercicios PROLOG

1- Determina si lo que recibe es una lista

lista([]):-!.

lista([X|Y]):-lista(Y). lista([12,5,3,7,4]).

true.

lista(4).

false.

2- Concatena dos listas

concatenar([],L,L).

concatenar([X|M],L,[X|Z]):-concatenar(M,L,Z). concatenar([a,n,a],[21],A).

A = [a, n, a, 21]

3- Invierte la lista que recibe en el primer nivel

invertir([X],[X]).

invertir([X|M],Z):-invertir(M,S), concatenar(S,[X],Z). invertir([1,2,3,4],A).

A = [4, 3, 2, 1]

4- Calcula la longitud de la lista

long([],0):-!.

long([X|Y],S):-long(Y,T),!, S is T + 1. long([a,n,a],A).

A = 3.

5- Suma los elementos de la lista

suma_elem([X],X):-!.

suma_elem([X|Y],S):-suma_elem(Y,T), S is T + X. suma_elem([1,2,5],A).

A = 8.

6- Devuelve el posición que se encuentra en la enésima posición

posición_n([],N,[]):-¡.

posición_n([X|N],1,X):-¡.

posicion_n([X|R],N,S):-M is N – 1,posicion_n(R,M,S). posicion_n([1,3,6,9],4,A).

A = 9.

7- Dan como resultado el primer y el último elemento de la lista

primer_elem([X|Y],X):-!.

ultimo_elem(L,S):-invertir(L,T),primer_elem(T,S).

primer_elem([2,5,3,7,a],A).

A = 2.

ultimo_elem([2,5,3,7,a],A).

A = a

8- Calcula la primer posición donde aparece el elemento X en la lista

prim_pos(X,[],0):-!.

prim_pos(X,[X|M],1):-!.

prim_pos(X,[Y|M],S):-prim_pos(X,M,T),S is T + prim_pos(3,[1,2,1,3,a],A).

A = 4.

9- Elimina el elemento x de la lista en todos los niveles

elimina_x([],X,[]):-!.

elimina_x([X],X,[]):-!.

elimina_x([X|M],X,S):-elimina_x(M,X,S),!.

elimina_x([R|M],X,S):-lista(R), elimina_x(R,X,T), elimina_x(M,X,P), concatenar([T],P,S).

elimina_x([R|M],X,S):-elimina_x(M,X,T), concatenar([R],T,S).

elimina_x([1,3,4,56,23,12],4,A).

A = [1, 3, 56, 23, 12]

10- Invierte una lista en todos sus niveles

invertir_tot([],[]):-!.

invertir_tot([X|M],S):-lista(X),invertir_tot(X,P),invertir_tot(M,T),concatenar(T,[P],S).

invertir_tot([X|M],S):-invertir_tot(M,T),concatenar(T,[X],S),!. invertir_tot([23,5,3,6,78,4,12],A).

A = [12, 4, 78, 6, 3, 5, 23].

11- Saca los n primeros elementos de una lista y devuelve el resto

sac_n_pri([],N,[]):-!.

sac_n_pri([X|M],1,M):-!.

sac_n_pri([X|M],N,S):-N1 is N-1,sac_n_pri(M,N1,S).

sac_n_pri([1,45,23,45],2,A).

A = [23, 45].

12- Da como resultado los n primeros elementos de una lista

da_n_pri(L,0,[]):-!.

da_n_pri([],N,[]):-!.

da_n_pri([X|M],1,[X]):-!.

da_n_pri([X|M],N,S):-N1 is N - 1,da_n_pri(M,N1,T),concatenar([X],T,S).

da_n_pri([1,4,23,6,4,3,2],3,A).

A = [1, 4, 23] .

13- Muestra los últimos n elementos de la lista

da_n_ultim(L,N,S):-invertir_tot(L,T),da_n_pri(T,N,R),invertir_tot(R,S).

da_n_ultim([a,n,a],2,A).

A = [n, a] .

14- Determina si dos listas son iguales en todos los niveles

lista_igual([],[]):-!.

lista_igual([X|M],[X|R]):-lista_igual(M,R).

lista_igual([X|M],[T|R]):-lista(X), lista(T), lista_igual(X,T),lista_igual(M,R).

lista_igual([1,2,3],[1,2,3]).

true.

15- Determina si la primer lista es prefijo de la segunda

prefijo([],M):-!.

prefijo([X],[X|M]):-!.

prefijo([X|L],[X|M]):-prefijo(L,M).

prefijo([X|T],[L|M]):-lista(X),prefijo(X,L),prefijo(T,M).

prefijo([a],[na,n,b]).

false.

16-Determina si la primer lista es sub-lista de la segunda

sublista([],L):-!.

sublista(L,[X|M]):-prefijo(L,[X|M]).

sublista(L,[X|M]):-lista(X), sublista(L,X).

sublista(L,[X|M]):-sublista(L,M).

sublista(A,[1,23,45,23,45,23]).

A = [].

17- Elimina todos los elementos de la lista 1 que están en la 2

elim_l1_de_l2([],L,L):-!.

elim_l1_de_l2([X|M],L,S):-elimina_x(L,X,T),elim_l1_de_l2(M,T,S)

elim_l1_de_12([1,3,24,5,6,7,3],B,A).

B = A, A = [].

18- Elimina los elementos repetidos que están en una lista

elim_repet([],[]):-!.

elim_repet([X|M],S):-not lista(X), elimina_x(M,X,T),elim_repet(T,Y),

concatenar([X],Y,S).

elim_repet([X|M],S):-lista(X), elim_l1_de_l2(X,M,T),elim_repet(X,Y),

elim_repet(T,J),concatenar([Y],J,S).

elim_repet([1,3,24,5,6,7,3],A).

A = [1, 3, 24, 5, 6, 7]

19- Arma una lista con todos los elementos que se encuentran antes de elemento x en la lista

hasta_x([X|M],X,[]):-!.

hasta_x([Y|M],X,[Y|S]):-hasta_x(M,X,S).

hasta_x([1,3,2,4,2,5,3,6,5],2,A).

A = [1, 3].

20- Arma una lista con todos los elementos que se encuentran después del elemento x

desde_x([Y|M],X,S):-X=\=Y,desde_x(M,X,S),!.

desde_x([X,Y|M],X,[Y|M]):-X=\=Y,!.

desde_x([Y|M],X,S):-desde_x(M,X,S),!.

desde_x([1,3,2,4,2,5,3,6,5],2,A).

A = [4, 2, 5, 3, 6, 5].

21- Determina si una lista se encuentra en orden creciente o decreciente

creciente([X,Y|Z]):- X<Y,

creciente([Y|Z]).

creciente([X]).

decreciente([X,Y|Z]):- X>Y,

decreciente([Y|Z]).

decreciente([X]).

creciente([1,2,3,4,5,6,7]).

true.

decreciente([7,6,5,4,3,2]).

true.

22- Cuenta la ocurrencia de una lista atómica en otra lista

secuencia([],L,L):-!.

secuencia([X|Y],[X|L],[X|L]):-secuencia(Y,L,L).

cta_ocurr(L,[],0):-!.

cta_ocurr([X|Y],[X|M],N):-secuencia(Y,M,L1), cta_ocurr([X|Y],L1,T), N is T + 1.

cta_ocurr([X|Y],[R|M],N):-cta_ocurr([X|Y],M,N),!.

cta_ocurr([1,2,3],[1,2,3],A).

A = 1

23- Determina si una lista puede analizarse del derecho o del revés

reversible([]):-!.

reversible(L):-invertir(L,R),lista_igual(L,R).

reversible([a,n,a]).

true.

24- Calcula la cantidad de elementos que se encuentran en la misma posición en dos listas

orden(L,[],0):-¡.

Orden([],L,0):-¡.

Orden([X],[X],1):-¡.

Orden([X|Y],[X|Z],S):-orden(Y,Z,T),!, S is T+1.

Orden([X|Y],[R|Z],S):-orden(Y,Z,S).

orden([3,2,5],[1,2,4],A).

A = 1.

25- Arma una lista con todas las posiciones del elemento X en la lista

list_posic(X,[],N,[]):-!.

list_posic(X,[X|M],N,L):-N1 is N + 1,list_posic(X,M,N1,G),P is N + 1,

concatenar([P],G,L).

list_posic(X,[Y|M],N,L):-N1

...