Programación 1 · Ingeniería Informática

Recurrencia

cuando una función se llama a sí misma
UADE · Primer año  —  2026
01 · La idea

Una función que se llama a sí misma

La recursión es una técnica en la que una función resuelve un problema llamándose a sí misma con una versión más pequeña del mismo problema.

Cada llamada simplifica un poco el problema… hasta llegar a uno tan simple que se resuelve sin volver a llamarse.

El freno se llama caso base. Sin él, la recursión nunca termina.
f()
f()
base
f llama a f llama a f … hasta el caso base
02 · Anatomía

Toda recursión tiene dos partes

{{ anatomyButtonsEl }}
{{ anatomyCodeEl }}
CASO BASE
La condición de corte. Es tan simple que se resuelve sin recursión. Garantiza que el proceso termine.
CASO RECURSIVO
La función se llama a sí misma, pero con un problema más pequeño — acercándose al caso base.
03 · Profundidad

Muñecas rusas: ¿cuántas hay adentro?

Abrís una muñeca y aparece otra adentro… y otra. No sabés cuántas hay hasta llegar a la más chica, la que ya no contiene ninguna. Esa incertidumbre es la recursión: explorás hacia adentro hasta tocar el caso base.

Antes de abrir, adiviná cuántas hay:
{{ rdGuessChipsEl }}
{{ rdControlsEl }} {{ rdResultEl }}
Muñecas abiertas: {{ rdOpened }}
tenía otra adentro caso base
{{ rdStageEl }}
{{ rdCaption }}
04 · Factorial

El factorial, en código y en fórmula

def factorial(n):
  if n == 0:        # caso base
    return 1
  return n * factorial(n - 1)  # caso recursivo
n = {{ factN }}
Un paso recursivo
Expansión completa
05 · La pila de llamadas

Cómo se desenrollan las llamadas

Cada factorial(n) queda en pausa esperando a la siguiente. Se apilan hasta el caso base; luego se devuelven los valores de adentro hacia afuera.

factorial({{ csN }})
{{ csProgressEl }}
{{ csPhaseEl }}
{{ csCaption }}
Pila de llamadas · la última en entrar es la primera en salir
{{ csFramesEl }}
06 · Otro ejemplo

Sumar una lista, recursivamente

def suma(lista):
  if lista == []:        # caso base
    return 0
  return lista[0] + suma(lista[1:])

La suma de una lista es su primer elemento más la suma del resto. La lista vacía es el caso base: suma 0.

{{ sumLinesEl }}
07 · Fibonacci

Fibonacci: dos llamadas recursivas

n = {{ fibN }}
RESULTADO
fib({{ fibN }}) = {{ fibValue }}
LLAMADAS
{{ fibTotal }}
{{ fibTreeEl }}
llamada que se ramifica caso base · fib(0)=0, fib(1)=1 ↻ {{ fibTopRepeat }} — ¡trabajo repetido!
08 · La pila, en general

Cada llamada guarda su propio estado

Cuando una función llama a otra, la actual se pausa. Python guarda su estado en una “cajita” —el stack frame— con todo lo que necesita para retomar después.

1.Las cajitas se apilan: la última en entrar es la primera en salir (LIFO).
2.Recursión = muchas cajitas de la misma función, una por nivel.
3.Cuantos más niveles, más memoria ocupa la pila.
factorial(3) stack frame
parámetrosn = 3
cálculo pendiente3 × factorial(2)
volver aquien la llamó
▲ una cajita por cada llamada
factorial(2) en pausa
factorial(1) en pausa
09 · El error más común

Sin caso base, no termina nunca

{{ infButtonsEl }}
{{ infCodeEl }} {{ infCaptionEl }}
Pila de llamadas
{{ infEl }}
10 · La receta

Cómo escribir cualquier función recursiva

1
Identificá el caso base
¿Cuál es el caso más simple, que puedo resolver de inmediato y sin volver a llamar a la función?
2
Acercate al caso base
Cada llamada recursiva debe trabajar sobre un problema más chico, un paso más cerca del corte.
3
Confiá en la recursión
El “salto de fe”: asumí que la llamada más chica ya devuelve lo correcto, y combiná ese resultado.
Para llevarse

Un caso base y un paso que se acerca a él.

Si esas dos piezas están bien, la función siempre termina
—y devuelve exactamente lo que tiene que devolver.

Recurrencia · Programación 1 · UADE