U.A.G.R.M. | Materia: Programacion Logica y Funcional | Docente: Edwin Vargas Yapura | Repositorio: Problemas de Naturaleza Recursiva | Lenguaje: Prolog

Problemas Naturaleza Recursiva.pl

% ---------------------------------------------+          
% GRUPO: 11                                    |   ╔═══╗ ♪
% NOMBRE: FERNANDEZ ORTEGA JHASMANY JHUNNIOR   |   ║███║ ♫ 
% MATERIA: INF 318 - SA                        |   ║ (●) ♫ 
% ---------------------------------------------+   ╚═══╝♪♪ 

%                       |---------------------------------------------+
%                       |PROBLEMAS DE NATURALEZA RECURSIVA.           |
%                       |_____________________________________________+

% Factorial.
fact(0,1):-!.
fact(N,F):- N1 is (N-1),
            fact(N1,F1),
            F is (N*F1).

% Potencia.
pot(_,0,1):-!.
pot(X,N,P):-N1 is (N-1),
            pot(N,N1,P1),
            P is (X*P1).

potencia(X,N,P):-pot(1,X,N,Po),P is Po.
pot(I,_,N,1):-I>N,!.
pot(I,X,N,P):-I1 is I+1,
		pot(I1,X,N,P1),
		P is P1*X.

% Fibonacci.
fibo(1,0):-!.
fibo(2,1):-!.
fibo(N,F):-	N1 is N-1,
			N2 is N-2,
			fibo(N1,F1),
			fibo(N2,F2),
			F is F1+F2.

% Números Combinatorios.
combi(N,N,1):-!.
combi(_,0,1):-!.
combi(N,R,NR):-N1 is (N-1),
               R1 is (R-1),
			   combi(N1,R,N2),
			   combi(N1,R1,N3),
			   NR is N2+N3.

% Al menos 6 problemas adicionales cualesquiera.
%1)
sumaEnteros(N,Sum):-suma(1,N,S),Sum is S.
 
 suma(I,N,0):-I>N,!.
 suma(I,N,S):-I1 is I+1,
		suma(I1,N,S1),
		S is S1+I.	
%2)	
sumaPares(N,Sum):-sumapar(1,N,S),Sum is S.
 
 sumapar(I,N,0):-I>N,!.
 sumapar(I,N,S):-I1 is I+1,
		sumapar(I1,N,S1),
		S is S1+(2*I).	
%3)		
sumaImpares(N,Sum):-sumaimpar(1,N,S),Sum is S.
 
 sumaimpar(I,N,0):-I>N,!.
 sumaimpar(I,N,S):-I1 is I+1,
		sumaimpar(I1,N,S1),
		S is S1+((2*I)-1).
%4)
sumapot(X,N,Sum):-sumpot(X,N,0,S),Sum is S.
sumpot(_,N,I,0):-I>N,!.
sumpot(X,N,I,S):-I1 is I+1,
		  sumpot(X,N,I1,S1),
		  potencia(X,I,P),
		  S is S1+P. 
%5)
sumacoef(N,Sum):-sumcoef(N,0,S),Sum is S.
sumcoef(N,R,0):-R>N,!.
sumcoef(N,R,S):-R1 is R+1,
		 sumcoef(N,R1,S1),
		 combi(N,R,C),
		 S is S1+C.
%6)
pitagoras2(N):-cicloA2(N,1).

cicloA2(N,A):-A>N,!.
cicloA2(N,A):-cicloB2(N,A,A),
		A1 is A+1,
		cicloA2(N,A1).

cicloB2(N,_,B):-B>N,!.
cicloB2(N,A,B):-cicloC2(A,B,B),
		B1 is B +1,
		cicloB2(N,A,B1).
		
 %----------------------------------------------------------------+
 %		TAREA GRUPAL.                                     |
 %	Implementar al menos 6 problemas con naturaleza recursiva |
 %----------------------------------------------------------------+


 % #1)-------------------------------------------------+  
 %  cuadrado(N,R) : Devuelve el cuadrado de un numero  |
 % ----------------------------------------------------+ 
 
 cuadrado(1,1).
 
 cuadrado(N,C):-N1 is N-1,
		cuadrado(N1,C1),
		C is C1+2*N1+1.



 % #2)-------------------------------------------+
 % invertir(N,R) : Devuelve el numero invertido  |
 % ----------------------------------------------+
 
 invertir(N,R):-N<10,R is N.

 invertir(N,R):-D is N mod 10,
		N1 is N//10,
		invertir(N1,R1), 
		candig(R1,C),
		R is (10**C)*D+R1.


	
 % #3)----------------------------------------------------------+
 % candig(N,R) : Devuelve la cantidad de digitos de un numero   |
 % -------------------------------------------------------------+

 candig(N,R):-N<10,R is 1.
 
 candig(N,R):-N1 is N//10,
		candig(N1,R1),
		R is R1+1.	



 % #4)----------------------------------------------------+
 % suma(N,R) : Devuelve la suma de  0 a N numeros dados   |
 % -------------------------------------------------------+

 suma(0,0).
 
 suma(N,R):-N1 is N-1,
		suma(N1,R1),
		R is R1+N.	



 % #5)-------------------------------------------------------+
 % sumapar(N,R) : Devuelve la suma de  0 a N numeros pares   |
 % ----------------------------------------------------------+

 sumapar(0,0).
 
 sumapar(N,S):-	N mod 2 =:= 0,
		N1 is N - 1,
		sumapar(N1,S1),
		S is S1 + N.

 sumapar(N,S):- N1 is N - 1,sumapar(N1,S).



 % #6)-----------------------------------------------------+
 % frecuencia(N,D,R): Devuelve frecunecia de un digito     |
 % --------------------------------------------------------+

 frecuencia(N,D,F):-N<10, N=:=D, F is 1.
 frecuencia(N,D,F):-N<10, N=\=D, F is 0.

 frecuencia(N,D,F):-D1 is N mod 10, D1=:=D,
			N1 is N//10,
			frecuencia(N1,D,F1),
			F is F1+1.

 frecuencia(N,D,F):-N1 is N//10,  frecuencia(N1,D,F).



 % #7)--------------------------------------------------+
 % eliminar(N,D,R) : Elimina un digito de un numero     |
 % -----------------------------------------------------+

 eliminar(0,_,0).
 
 eliminar(N,D,R):-D1 is N mod 10,
		N1 is N // 10,
		D =\= D1,
		eliminar(N1,D,R1),
		R is R1*10+D1.

  eliminar(N,D,R1):-N1 is N // 10,eliminar(N1,D,R1).



 % #8)----------------------------------------------------------+ 
 % sumdig(N,R) : Devuelve la suma de los digitos de un numero   |
 % -------------------------------------------------------------+
 
 sumadig(N,R):-N<10,R is N.

 sumadig(N,R):-D is N mod 10,
		N1 is N//10,
		sumadig(N1,R1),
		R is R1+D.



 % #9)------------------------------------------------------------------+
 % sumdigpar(N,R): Devuelve al suma de los digitos pares de un numero   | 
 % ---------------------------------------------------------------------+
 sumdigpar(0,0).

 sumdigpar(N,R):-D is N mod 10,
		N1 is N//10,
		D mod 2=:=0, 
		sumdigpar(N1,R1),
		R is R1+D.

 sumdigpar(N,R):-N1 is N//10, sumdigpar(N1,R).



 % #10)----------------------------------------------------+
 % multlip(A,B,R): Devuelve la multiplicion de 2 numeros   |
 %---------------------------------------------------------+

 multip(_,0,0).
 multip(0,_,0).
 multip(A,1,A).
 multip(1,B,B).

 multip(A,B,R):-B1 is B-1,
		multip(A,B1,R1),
		R is R1+A.

 % #11)---------------------------------------------------------+
 % mcd(A,B,C) : Devuelve el maximo comun divisor de 2 numeros   |
 % -------------------------------------------------------------+

 mcd(A,B,R):-A mod B=:=0, R is B.

 mcd(A,B,R):-B1 is A mod B,
		mcd(B,B1,R).
		


 % #12)-----------------------------------------------------+
 % decabin(A,[]) : Convierte un numero decimal a binario    |
 % ---------------------------------------------------------+

 decabin(N,[]):-N<2, C is N+48, put(C).

 decabin(N,[]):-M is (N mod 2)+48, 
		N1 is N//2,
		decabin(N1,[]),
		put(M).		

%-------------------------- FIN TAREA RECURSIVIDAD ----------------------*