Ejercicios de recursividad

MANUAL DE RECURSIVIDAD
Cuando se analiza un problema y se descubre que se puede resolver por partes,
en las cuales se vuelve a plantear el problema original pero de forma más
reducida, entonces se puede decir que el problema se puede resolver por
recursión.
Características:
 Implementación intuitiva. La traducción de la solución recursiva de un
problema a código Lisp es prácticamente inmediata.
 Útil para optimizar cálculos.
 Útil cuando hay varios niveles de anidamiento. La solución para un nivel
es válida para el resto.
Ejemplos de recursividad:
1. Cálculo de la potencia de un número
(defun potencia (x n)
(cond ((= n 0) 1) ((evenp n)
(expt (potencia x (/ n 2)) 2)
)
(t (* x (potencia x (- n 1)))))
)
potencia(2 3)  8
2. Contar los átomos de cualquier expresión LISP
(defun cuenta-atomos (expr)
(cond ((null expr) 0)
((atom expr) 1)
(t ( +
(cuenta-atomos (first expr))
(cuenta-atomos (rest expr))))
)
)
3. Función de Fibbonacci
Fib(n) = Fib(n-1) + Fib(n-2) si n>1,
Fib(n)=1 si n <= 1
Ejemplo: Fibonacci 5 = 1 2 3 5 8  Se mostrara el último elemento.
(defun fibo (x)
( if ( <= x 1) 1
(+ (fibo (- x 1)) (fibo (- x 2)))
)
)
(fibo 5)  8
4. Producto Escalar
(defun producto (vector1 vector2)
(if (or (null vector1) (null vector2)) 0
(+ (* (first vector1) (first vector2))
(producto (rest vector1) (rest vector2)))
)
)
(producto ‘(2 3) ‘(4 5))  23
5. Algoritmo de Euclides
m.c.d. (a , b) = m.c.d. (b , a mod b) si b>0
m.c.d. (a , b) = a
si b=0
Ejemplo: m.c.d. (57, 23) = m.c.d. (23, 1) = m.c.d. (1,0) = 1
(defun mcd(a b)
(if (> b 0)
(mcd b (mod a b)) a)
)
)
(mcd 57 23)  1
6. Cálculo de un factorial
(defun factorial (n)
(if (zerop n) 1
(* n (factorial (1- n)))
)
)
(factorial 4)  24
7. Función para saber si un número es primo
(defun es_primo (numero)
(es_primo_recursivo numero 2)
)
(defun es_primo_recursivo (numero divisor)
(if (>= divisor numero) t
(if (= 0 (mod numero divisor)) nil
(es_primo_recursivo numero (+ 1 divisor))
)
)
)
(es_primo 5)  T
Ejemplos de recursividad con listas:
1. Verificar si un elemento pertenece a una lista.
(defun pertenece (x lista)
(if (endp lista)
nil
(if (= x (car lista))
lista
(pertenece x (cdr lista))
)
)
)
(pertenece 5 ‘(1 2 5))  (5)
2. Función que cuenta cuantos números pares hay en una lista
(defun cuenta-pares (lista)
(cond ((null lista) 0)
((numberp lista)
(if (evenp lista) 1 0))
((cdr lista) (+ (cuenta-pares (car lista))
(cuenta-pares (cdr lista))))
(t (cuenta-pares (car lista))
)
)
)
(cuenta-pares ‘(1 2 3 4))  2
3. Función que suma los elementos impares de una lista
(defun suma_impares( lista )
(cond ((null lista) 0)
((oddp (car lista)) (+ (car lista) (suma_impares
(cdr lista))))
(t (suma_impares (cdr lista)))
)
)
(suma_impares '(1 2 3 4 5 6))  9
4. Contar el número de sublistas que hay en una lista
(defun sublistas (expresion)
(cond ((or (null expresion) (atom expresion)) 0)
(t (+ (if (atom (first expresion)) 0 1)
(sublistas (first expresion))
(sublistas (rest expresion))))
)
)
(sublistas ‘(a (b c) ((d e) f)))  3