Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Ejercicios Hechos de Prolog
Ejercicios Hechos de Prolog
lista([]):-!.
lista([X|Y]):-lista(Y).
/*------------------------------------------------------------------*/
/*2-Concatena dos listas*/
concatenar([],L,L).
concatenar([X|M],L,[X|Z]):-concatenar(M,L,Z).
/*------------------------------------------------------------------*/
/*3-Invierte la lista que recibe en el primer nivel*/
invertir([X],[X]).
invertir([X|M],Z):-invertir(M,S), concatenar(S,[X],Z).
/*------------------------------------------------------------------*/
/*4-Calcula la longitud de la lista*/
long([],0):-!.
long([X|Y],S):-long(Y,T),!, S is T + 1.
/*------------------------------------------------------------------*/
/*5-Suma los elementos de la lista*/
suma_elem([X],X):-!.
suma_elem([X|Y],S):-suma_elem(Y,T), S is T + X.
/*------------------------------------------------------------------*/
/*6-Devuelve el elemento que se encuentra en la enesima posicion*/
posicion_n([],N,[]):-!.
posicion_n([X|N],1,X):-!.
posicion_n([X|R],N,S):-M is N - 1,posicion_n(R,M,S).
/*------------------------------------------------------------------*/
/*7-Dan como resultado el primer y el ultimo elemento de la lista*/
primer_elem([X|Y],X):-!.
ultimo_elem(L,S):-invertir(L,T),primer_elem(T,S).
/*------------------------------------------------------------------*/
/*8-Calcula la primer posicion 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 + 1.
/*------------------------------------------------------------------*/
/*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).
/*------------------------------------------------------------------*/
/*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),!.
/*------------------------------------------------------------------*/
/*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).
/*------------------------------------------------------------------*/
/*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).
/*------------------------------------------------------------------*/
reversible([]):-!.
reversible(L):-invertir(L,R),lista_igual(L,R).
/*------------------------------------------------------------------*/
/*------------------------------------------------------------------*/
/*43-Elimina el primer elemento X que aparece en la lista*/
elim_prim_pos(X,[],[]):-!.
elim_prim_pos(X,[X|M],M):-!.
elim_prim_pos(X,[R|M],[R|L]):-elim_prim_pos(X,M,L).
/*------------------------------------------------------------------*/
/*44-Determina si un elemento X pertenece a una lista*/
pert(X,[X|M]):-!.
pert(X,[R|M]):-pert(X,M).
/*------------------------------------------------------------------*/
/*45-Genera una lista de tomos a partir de una lista anidada*/
lista_atomos([],[]):-!.
lista_atomos([X|M],[X|Z]):-not lista(X), lista_atomos(M,Z),!.
lista_atomos([X|M],Z):-lista(X),lista_atomos(X,L),lista_atomos(M,M1),!,concatenar(L,M1,Z).
/*------------------------------------------------------------------*/
/*46-Arma dos listas con los elementos que se encuentran a la izquierda*/
/* y a la derecha del elemento x */
izq_der_x(X,[],[],[]):-!.
izq_der_x(X,[X|M],[],M):-!.
izq_der_x(X,[R|M],[R|L],F):-R=\=X,izq_der_x(X,M,L,F).
/*------------------------------------------------------------------*/
/*47-Ordena una lista en orden ascendente*/
ord_ascend([],[]):-!.
ord_ascend(L,R):-maximo(L,X),elim_prim_pos(X,L,L1),ord_ascend(L1,L2),!,concatenar(L2,[X],R).
/*------------------------------------------------------------------*/
/*48-Ordena una lista en orden descendente*/
ord_descend(L,L2):-ord_ascend(L,L3),invertir(L3,L2).
/*------------------------------------------------------------------*/
/*49-Calcula el maximo elemento de una lista*/
maximo([X],X):-!.
maximo([X,Y|M],X):-maximo([Y|M],Z),X>=Z.
maximo([X|M],Z):-maximo(M,Z),Z>X.
/*------------------------------------------------------------------*/
/*50-Elimina las apariciones de X en el primer nivel*/
elimina_x([],X,[]):-!.
elimina_x([X|M],X,Z):-elimina_x(M,X,Z),!.
elimina_x([R|M],X,[R|Z]):-elimina_x(M,X,Z),!.
/*------------------------------------------------------------------*/
/*51-Elimina una sublista L de la lista L1 */
elim_subl([],L,[]):-!.
elim_subl(L1,L,Z):-long(L,N),da_n_pri(L1,N,L2),L2=L,sac_n_pri(L1,N,L3),elim_subl(L3,L,Z),!.
elim_subl([X|Y],L,[X|Z]):-elim_subl(Y,L,Z),!.
/*------------------------------------------------------------------*/
/*52-Determina si dos conjuntos son iguales*/
conj_igual([],[]):-!.
conj_igual([X|Y],L):-pert(X,L),elim_prim_pos(X,L,L1), conj_igual(Y,L1).
conj_igual([X|Y],L):-lista(X), sublista(X,L),elim_subl(X,L,L1),conj_igual(Y,L1).
/*------------------------------------------------------------------*/
/*53-Arma una lista de n elementos, los mayores de la lista*/
n_mayores(L1,N,L):-ord_descend(L1,L2),da_n_pri(L2,N,L).
/*------------------------------------------------------------------*/
/*54-Devuelve una lista con la diferencia entre dos conjuntos*/
dif_conj(L,[],L):-!.
dif_conj([],L,L):-!.
dif_conj([X|Y],L,[X|P]):-not pert(X,L), dif_conj(Y,L,P),!.
dif_conj([X|Y],L,P):-pert(X,L),elim_prim_pos(X,L,L1),dif_conj(Y,L1,P),!.
/*------------------------------------------------------------------*/
/*55-Inserta un elemento en la posicion ensima*/
insertar(L,1,X,[X|L]):-!.
insertar([X|Y],N,R,[X|L]):-N1 is N-1, insertar(Y,N1,R,L).
/*------------------------------------------------------------------*/
/*56-Calcula la posicion del ltimo elemento n*/
posult(L,X,N):-invertir(L,L1), prim_pos(X,L1,T), long(L1,M),N is M-T.
/*------------------------------------------------------------------*/
/*57-Reemplaza el elemento ensimo*/
reemp_n([X|Y],1,L,[L|Y]):-!.
reemp_n([X|Y],N,L,[X|Y1]):-N1 is N-1, reemp_n(Y,N1,L,Y1).
/*------------------------------------------------------------------*/
/*58-Arma una lista de N elementos a partir de la posicin P*/
tomarN_desd_P(L,0,N,L1):-da_n_pri(L,N,L1).
tomarN_desd_P([X|Y],P,N,L1):-P1 is P-1,tomarN_desd_P(Y,P1,N,L1).
/*------------------------------------------------------------------*/
/*59-Determina si un par de elementos son consecutivos*/
consecut([X,Y|M],X,Y):-!.
consecut([R|M],X,Y):-consecut(M,X,Y).
/*------------------------------------------------------------------*/
/*60-Arma una lista con los elementos duplicados que se encuentran en */
/*una lista*/
lista_dup([],[]):-!.
lista_dup([X|L],[X|Y]):-pert(X,L),elim_prim_pos(X,L,L1),lista_dup(L1,Y),!.
lista_dup([X|L],Y):-lista_dup(L,Y),!.
/*------------------------------------------------------------------*/
/*61-Arma una lista con todos los elementos que se encuentran dentro del*/
/*intervalo*/
interval([],N1,N2,[]):-!.
interval([X|Y],N1,N2,[X|L]):-X>=N1,X=<N2,interval(Y,N1,N2,L),!.
interval([X|Y],N1,N2,L):-interval(Y,N1,N2,L),!.
/*------------------------------------------------------------------*/
/*62-Determina si una lista se encuentra ordenada segun, m ximo, mnimo,*/
/*meseta o sin orden*/
identif(X,maximo):- esmaximo(X),!.
identif(X,minimo):- esminimo(X),!.
identif(X,meseta):- esmeseta(X),!.
identif(X,sinorden):-!.
esmaximo([X,Y|Z]):- X<Y,esmaximo([Y|Z]).
esmaximo([X,Y|Z]):- X>Y,decreciente([Y|Z]).
esminimo([X,Y|Z]):- X>Y, esminimo([Y|Z]).
esminimo([X,Y|Z]):- X<Y, creciente([Y|Z]).
esmeseta([X,Y,Z|W]):- X<Y, esmeseta([Y,Z|W]).
esmeseta([X,Y,Z|W]):- X=Y,Y=Z, esmeseta([Y,Z|W]).
esmeseta([X,Y,Z|W]):- X=Y,Y>Z, decreciente([Z|W]).
/*------------------------------------------------------------------*/
/*63-Calcula una dieta, ejercicio que esta en un examen*/
alimento(a,posillo_zucaritas,110).
alimento(b,vegetal,155).
alimento(c,posillo_de_leche,660).
alimento(c,huevo_frito,110).
alimento(c,bife_de_vaca,185).
alimento(c,pechuga_de_pollo,185).
alimento(d,helado,330).
plato([1,B,C]):-alimento(A,B,C).
calorias([A,B,C],C):-!.
pertenece(B,[X|L]):- pertenece1(B,X).
pertenece(B,[X|L]):-pertenece(B,L).
pertenece1([V,B,M],[A,B,C]):-!.
suma([],0):-!.
suma([X|L],S):- suma(L,T), calorias(X,R), S is R+T.
insertar(X,[],[X]):-!.
insertar(X,L,[X|L]):-not pertenece(X,L),!.
insertar(X,L,R):-suma_c(X,L,R).
suma_c(X,[R|L],T):-pertenece1(X,R),suma_caloria(X,R,U),concatenar([U],L,T).
suma_c(X,[R|L],[R|T]):-suma_c(X,L,T).
suma_caloria([A,B,C],[R,B,V],[X,B,N]):-N is V+C, X is R+A.
concatenar([],L,L):-!.
concatenar([X|R],L,[X|T]):-concatenar(R,L,T).
arma_dieta(L,L):-suma(L,T),T>2400,T<2800,!.
arma_dieta(L,L1):-suma(L,T),T<2400,plato(X),insertar(X,L,L2),arma_dieta(L2,L1).
arma_dieta1(L,N):-arma_dieta([],L),suma(L,N).
/*------------------------------------------------------------------*/
/*64-Arma una lista con las funciones que son invocadas por una funcin*/
invoca(a,[b,c,d]):-!.
invoca(b,[e]):-!.
invoca(d,[f,g,h]):-!.
invoca(X,[]):-!.
invocar([],[]):-!.
invocar([X|Y],S):-invoca(X,T), invocar(Y,N), concatenar([X],[T],D), concatenar([D],N,S).
invoca-a([],[]):-!.
invoca-a(X,S):-invoca(X,P), invocar(P,T), concatenar([X],T,S).
/*------------------------------------------------------------------*/
/*65-Planifica las actividades para la semana, ejercicio de examen*/
genera_univ([universidad,[19,24],lunes]).
genera_univ([universidad,[19,24],miercoles]).
genera_dep([tennis,[10,12],lunes]).
genera_dep([tennis,[10,12],jueves]).
genera_dep([jogging,[12.3,13],lunes]).
genera_idio([ingles,[10.3,12],lunes]).
genera_idio([ingles,[10.3,12],miercoles]).
genera_idio([frances,[8,10],lunes]).
genera_idio([frances,[8,10],miercoles]).
act_posb([A,B,C]):-genera_dep(A),genera_univ(B),genera_idio(C).
posible([],N):-!.
posible([[A,[B,C],D]|M],[R,[F,G],D]):-F>=C,posible(M,[R,[F,G],D]).
posible([[A,[B,C],D]|M],[R,[F,G],D]):-G=<B,posible(M,[R,[F,G],D]).
posible([[A,[B,C],D]|M],[R,[F,G],L]):-L\==D,posible(M,[R,[F,G],L]).
compara([A,B,C]):-posible([B,C],A), posible([A,C],B),posible([B,A],C).
plan(A):-act_posb(A),compara(A).
/*------------------------------------------------------------------*/
/*66-Transforma una lista en formato infijo a formato prefijo*/
transforma([Op,Op1,Op2],[A,Op,B]):-lista(Op1),lista(Op2), transforma(Op1,A), transforma(Op2,B).
transforma([A,B,C],[B,A,C]):-not lista(B),not lista(C),!.
/*------------------------------------------------------------------*/
/*67-Ejercicio de examen, decodifica un cdigo*/
diccionario([codigo([a,b,f],[0,1]),codigo([t,h],[1]),codigo([w,w,a],[1,1])]).
buscar_cod(L,[codigo(L,L2)|M],L2):-!.
buscar_cod(L,[X|M],L2):-buscar_cod(L,M,L2),!.
decodifica([],N,[]):-!.
decodifica(L,N,S):-da_n_pri(L,N,L1),diccionario(L5),buscar_cod(L1,L5,L2),
sac_n_pri(L,N,L3),decodifica(L3,1,L4),!,concatenar(L2,L4,S).
decodifica(L,N,S):-N1 is N+1, decodifica(L,N1,S).
/*------------------------------------------------------------------*/
pert_arbol(arbol(A,X,Y),B):-pert_arbol(Y,B),!.
/*------------------------------------------------------------------*/
/*80-Crea un arreglo de mujeres con el requisito de la edad */
arregloMujer(Lis,[Dni|Y],D,L):-mujer(N,Dni),datos(Dni,C,E,T), hombre(Nomb,D),
datos(D,C1,E1,T1), (E >= E1 | E =< E1),concatenar(Lis,[[N,Dni]],L1), arregloMujer(L1,Y,D,L).
arregloMujer(Lis,[],D,Lis).
/*Realiza ejercio */
ejercicio(C,Lista,M):- mujer(Nomb,M),deCiudad([],C,[X|Y]),
soloHombres([],[X|Y],L1),
arregloHombre([],L1,M,L), concatenar([[Nomb,M]],L,Lista).
ejercicio(C,Lista,H):- hombre(Nomb,H),deCiudad([],C,[X|Y]), soloMujeres([],[X|Y],L1),
arregloMujer([],L1,H,L), concatenar([[Nomb,H]],L,Lista).
/*------------------------------------------------------------------------*/
/*Examen Final 24/07/2000*/
/*Obtiene el mayor Puntaje de todos los equipos*/
mayorPuntaje([[X,Y,V,W,Z]],Y):-!.
mayorPuntaje([[X,Y,V,W,Z]|Resto],Y):-mayorPuntaje(Resto,T),Y >= T.
mayorPuntaje([[X,Y,V,W,Z]|Resto],T):-mayorPuntaje(Resto,T),Y < T.
/*Elimina un elemento de la lista*/
eliminarP(Y,[[X,Y,V,W,Z]|Lis],Lis):-!.
eliminarP(R,[[X,Y,V,W,Z]|Lis],[[X,Y,V,W,Z]|Res]):-eliminarP(R,Lis,Res).
/*Toma los Puntaje de los equipos y los ordena en una lista descendente*/
orden([[X,Y,V,W,Z]],[Y]):-!.
orden([X|Y],[R|Res]):- mayorPuntaje([X|Y],R), eliminarP(R,[X|Y],L),orden(L,Res).
/*Encuentra un elemento en la lista y devuelve la lista completa*/
encuentra(Y,[[X,Y,V,W,Z]|R],[X,Y,V,W,Z]):-!.
encuentra(T,[[X,Y,V,W,Z]|R],Res):-encuentra(T,R,Res).
/*Ordena los elementos como pide el enunciado */
orden1([[X,Y,V,W,Z]],[[X,Y,V,W,Z]]):-!.
orden1([X|Y],[R|Res]):- orden([X|Y],[T|L]),encuentra(T,[X|Y],R), eliminarP(T,[X|Y],Lis),orden1(Lis,Res).
/*Resultados*/
encontrar([[X,Y,V,W,Z]|R],X,Punto,[[X,Y1,V1,W,Z]|R]):- Punto = 3,!, V1 is V + 1, Y1 is Punto + Y.
encontrar([[X,Y,V,W,Z]|R],X,Punto,[[X,Y1,V,W,Z1]|R]):- Punto = 1,!, Z1 is Z + 1, Y1 is Punto + Y.
encontrar([[X,Y,V,W,Z]|R],X,Punto,[[X,Y1,V,W1,Z]|R]):- Punto = 0,!, W1 is Z + 1, Y1 is Punto + Y.
encontrar([[X,Y,V,W,Z]|R],Equipo,Punto,[[X,Y,V,W,Z]|Resto]):- encontrar(R,Equipo,Punto,Resto).
/*Adiciona puntaje a los equipos que jugaron un partido*/
adicionar([X|Y],EA,EB,R,Res):- R = 1,!, encontrar([X|Y],EA,3,Res).
adicionar([X|Y],EA,EB,R,Res):- R = 2,!, encontrar([X|Y],EB,3,Res).
adicionar([X|Y],EA,EB,R,Res):- R = 3,!, encontrar([X|Y],EA,1,Res1), encontrar(Res1,EB,1,Res).
/*Actualiza la informacin de todos los equipos*/
/*Ej:resultados([[eA,11,3,0,2],[eC,9,2,1,3],[eD,7,1,,1,4]],eA,eD,3,Resultado).*/
resultados([X|Y],EA,EB,R,Resultado):- adicionar([X|Y],EA,EB,R,Res),
orden1(Res,Resultado).
/***************************************************************************/
conteo(0,N,Aux,[]):-!.
conteo(S,N,Aux,[N|Resul]):- S1 is S - 1, Aux1 is N + Aux, conteo(S1,Aux1,N,Resul).
fibonacci(N,Res):- conteo(N,1,0,Res).
/***************************************************************************/