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