Procesos Recursivos : Recursividad

750080M - Fundamentos de Programación

Antonio José Vélez Quintero

<antonio.velez@correounivalle.edu.co>
Docente Ocasional - Tecnología en Sistemas de Información
Universidad del Valle - Sede Palmira

Está prohibida la reproducción parcial o total de este material académico sin

la autorización expresa del docente. Ello incluye la prohibición de alojar este
material el servicios de publicación en la nube. Antonio José Vélez Quintero
<antonio.velez@correounivalle.edu.co>
Se permite la descarga deDocente Ocasional
este material por- parte
Tecnoogía en Sistemaspara
del estudiante de Información
su uso
Universidad del Valle - Sede Palmira
personal en su computador.
resolver ( 48 )
Dividir
resolver

resolver 17 31 Combinar la solución

de cada subproblema
Procesos Repetitivos Cotidianos

Problema : Comer Algoritmo ITERATIVO Algoritmo RECURSIVO

Entradas :
comida comer (comida)
cubiertos (opcional) si estoy lleno entonces
Valores válidos terminar
comida en buen estado si no hay comida entonces
terminar
En programación, hay dos formas de
resolver problemas repetitivos: 1. Introducir la comida a la boca
● de manera iterativa (ciclos) - llenar la cuchara o tenedor de comida
● de manera recursiva - llevar la comida a la boca
2. Masticar
3. Tragar la comida
EN NARANJA: Los pasos que se 4. si tengo sed entonces
repiten. Observe que son los mismos consumir líquido
en ambas soluciones 5. comer (menos comida)
volver a llamar el algoritmo,
EN ROJO: La forma de hacer que los pero con el plato menos lleno
pasos (en naranja) se repitan varias
veces
Procesos Repetitivos Cotidianos
Problema : Comer
Entradas :
comida
cubiertos (opcional)
Valores válidos
comida en buen estado
En programación, hay dos formas de
resolver problemas repetitivos:
● de manera iterativa (ciclos)
● de manera recursiva
EN NARANJA: Los pasos que se
repiten. Observe que son los mismos
en ambas soluciones
EN ROJO: La forma de hacer que los
pasos (en naranja) se repitan varias
veces
Algoritmo ITERATIVO Algoritmo RECURSIVO
comer (comida) comer (comida)
mientras haya comida y no este lleno entonces si estoy lleno entonces
1. Introducir la comida a la boca terminar
- llenar la cuchara o tenedor de comida si no hay comida entonces
- llevar la comida a la boca terminar
2. Masticar
3. Tragar la comida 1. Introducir la comida a la boca
4. si tengo sed entonces - llenar la cuchara o tenedor de comida
consumir líquido - llevar la comida a la boca
2. Masticar
3. Tragar la comida
4. si tengo sed entonces
consumir líquido
5. comer (menos comida)
volver a llamar el algoritmo,
EN VERDE: Condiciones para decidir si se repite pero con el plato menos lleno
o no el proceso (en naranja)
Instancia del Problema: Hacer la suma de los números entre 1 y 5
Respuesta: 15

SOLUCIÓN ITERACTIVA SOLUCIÓN RECURSIVA

(a trabajar más adelante : ciclos)
sumaHasta (5) = 1 + 2 + 3 + 4 +5
0+1 sumarHasta (4) +5
1+2
3+3 sumaHasta (4) = 1 + 2 + 3 +4
6+4 sumarHasta (3) +4
10 + 5
15 sumarHasta(3) = 1 + 2 +3
sumarHasta (2) +3
Forma Iterativa de resolver el problema se
implementa en los lenguajes de programación sumarHasta(2) = 1 +2
usando ciclos WHILE / FOR sumarHasta (1) +2

Otra forma de resolver el problema es usando la sumarHasta(1) = 1

fórmula:
suma(n) = n(n+1)/2
Instancia del Problema: Hacer la suma de Problema: Diseñar e implementar un
los números entre 1 y 5 algoritmo para hacer la suma de los números
Respuesta: 15 entre 1 y n

SOLUCIÓN RECURSIVA SOLUCIÓN RECURSIVA

sumarHasta (5) = 1 + 2 + 3 + 4 +5 En términos generales

sumarHasta(4) +5
sumarHasta (n) = 1 + 2 + ….. (n-2) + (n-1) + n
sumarHasta (4) = 1 + 2 + 3 +4 sumarHasta(n-1) + n
sumarHasta(3) +4
sumarHasta(3) = 1 + 2 +3
sumarHasta(2) +3 Cuando el problema es lo suficientemente
sumarHasta(2) = 1 +2 pequeño, tiene solución inmediata.
sumarHasta(1) +2 Respuesta: cuando n es igual a 1

sumarHasta(1) = 1 Problema pequeño La solución al problema para n = 1 es 1.

con solución inmediata
(condiciona de parada)
Problema: Hacer la suma de los números Otra forma de escribir la solución recursiva es:
entre 1 y n
si n es igual a 1 entonces
SOLUCIÓN RECURSIVA devolver 1
sumarHasta(n)
sumarHasta (n) = 1 + 2 + ….. (n-2) + (n-1) + n
sumarHasta(n-1) + n sino
devolver sumarHasta(n-1)+n

Cuando el problema es lo suficientemente

pequeño y tener solución inmediata.
Respuesta: cuando n es igual a 1

La solución al problema para n = 1 es 1.

Encuentre la implementación en:

https://replit.com/@AntonioVelez/750080M-Sesion14-E001-SumarHasta
 Cómo se ejecuta el algoritmo si n es 5 ?
Problema : Hacer la suma de los números
entre 1 y n sumarHasta (n=5) = 15
sumarHasta(n=4) + 5 = 10 + 5
sumarHasta(n=3) + 4 = 6 + 4 = 10
si n == 1 entonces
sumarHasta(n=2) + 3 = 3+3=6
sumarHasta(n) devolver 1
sumarHasta(n=1) + 2 = 1+2
else sumarHasta(n=1) = 1
devolver sumarHasta(n-1) + n
 Propósito :
Problema: hacer la suma de los primeros n números pares
(número entero)
Hacer la suma de los primeros Salida :
n número pares (sin incluir el La suma de los primeros n número pares (número
cero). Los primeros 4 entero)
Entrada(s):
números pares son: La cantidad de números pares a sumar (n:entero)
2 + 4 + 6 + 8 + ... Valores Válidos:
n >= 0

Instancia del problema: Nombre Algoritmo : sumarPares

Hacer la suma de los primero 7

número pares. Hacer la suma de los primeros 7 número pares

NOTA: Lo anterior es diferente a sumarPares(7) = 2 + 4 + 6 + 8 + 10 + 12 + 14

“Hacer la suma de los número entre
1 y 7”
Hacer la suma de los primeros 7 número pares sumarPares(7) = sumarPares(6) + 14 = 42 + 14 = 56

sumarPares(6) = 2 + 4 + 6 + 8 + 10 + (6*2)
sumarPares(7) = 2 + 4 + 6 + 8 + 10 + 12 + 14 sumarPares(5) + 12 = 30 + 12 = 42

Tomar el problema original y hacerlo un poco más

sumarPares(5) = 2 + 4 + 6 + 8 + 10
pequeño (quitando el último elemento del sumarPares(4) + (5*2) = 20 + 10 = 30
problema, para el ejemplo es 14)
sumarPares(4) = 2+4+6 +8
sumarPares(3) +8 = 12 + 8 = 20
sumarPares(7) = (2 + 4 + 6 + 8 + 10 + 12) + 14
sumarPares(3) = 2+4 + (3*2)
El problema más pequeño se resuelve haciendo el sumarPares(2) +6 = 6 + 6 = 12
llamado recursivo (llamado a la misma función
sumarPares(2) = 2 + (2*2)
que resuelve el problema) sumarPares(1) +4 =2+4=6

sumarPares(7) = sumarPares(6) + 14 sumarPares(1) = sumaPares(0) + (2*1) =0+2=2

sumarPares(0) = 0 Condición de parada

Cuando el problema tiene
tamaño cero (0)
Hacer la suma de los primeros n número pares

sumarPares(7) = 2 + 4 + 6 + …. 2*(n-1) + (2*n)

PSEUDOCÓDIGO

Condición de parada
si n es igual a cero entonces sumarPares (n)
devolver 0 si n == 0 entonces
devolver 0
sumarPares(n) sino
devolver sumarPares(n-1) + 2*n

Llamados recursivos (llamar a la misma función

para resolver un subproblema más pequeño)
sino
devolver sumaPares(n-1) + 2*n
# Propósito : Para que el estudiante se concentre en pensar la solución
# Hacer la suma de los primeros n números recursiva, en este tema no se pedirá implementar la
# pares (número entero) verificación de valores válidos
# Entrada(s):
# La cantidad de números pares a sumar # Programa principal
# (n:entero) def main() :
# Valores Válidos: # Lectura de datos
# n >= 0 n = int(input("Ingrese la cantidad de
números pares a sumar ... "))
# Resolver el problema
def sumarPares (n) : suma = sumarPares(n)
if (n == 0) :
return 0 # Mostrar resultados
else : print("La suma de los primero " , n , "
return sumarPares(n-1) + 2*n número pares es ... " , suma)
# fin de la función
# fin del programa principal
# casos de prueba
print(sumarPares (0)) # Devuelve 0
print(sumarPares (2)) # Devuelve 2
...

Código completo : https://replit.com/@AntonioVelez/750080M-Sesion12-E002-sumarPares

 Propósito :
Problema: Hacer la suma de los números pares entre 1 y n
(número entero)
Hacer la suma de número Entrada(s):
pares entre 1 y n El límite superior (n:entero)
Valores Válidos:
n >= 0

Nombre Algoritmo : sumarParesHasta

Hacer la suma de los número pares entre 1 y 7

sumarParesHasta(7) = 2 + 4 + 6

Hacer la suma de los número pares entre 1 y 7
sumarParesHasta(7) = 2 + 4 + 6
sumarParesHasta(7) = 1 + 2 + 3 + 4 + 5 + 6 + 7
sumarParesHasta(7) = sumarParesHasta(6)
NO SE SUMA 7
sumarParesHasta(6) = sumarParesHasta(5) + 6
def sumar_pares_hasta(n):
if n == 0:
return 0
else:
if n % 2 == 0:
return sumar_pares_hasta(n-2) + n
else:
return sumar_pares_hasta(n-1)
sumarParesHasta(6) = 2 + 4 + 6
sumarParesHasta(7) = 2 + 4 + 6
sumarParesHasta(8) = 2 + 4 + 6 + 8
sumarParesHasta(9) = 2 + 4 + 6 + 8
sumarParesHasta(6) = 2 + 4 + 6
= sumarPares(3)
= sumarPares(6//2)
sumarParesHasta(7) = 2 + 4 + 6
= sumarPares(3)
= sumarPares(7//2)
sumarParesHasta(8) = 2 + 4 + 6 + 8
= sumarPares(4)
= sumarPares(8//2)
sumarParesHasta(9) = 2 + 4 + 6 + 8
= sumarPares(4)
= sumarPares(9//2)
Se puede resolver el problema haciendo el llamado a la
función implementada para el porblema anterior
def sumarParesHasta (n) :
# Llamado a la función del problema anterior
return sumarPares ( n // 2)