¿Qué es el factorial?

El factorial de un número entero no negativo n se define como el producto de todos los enteros positivos menores o iguales a n:

n! = n × (n‑1) × (n‑2) × … × 2 × 1

Por convención, 0! = 1. Esta operación es fundamental en combinatoria, probabilidad, análisis de algoritmos y áreas como la criptografía.

Implementaciones clásicas en Python

def factorial_iterativo(n: int) -> int:
    """Calcula n! usando un bucle for.
    Complejidad: O(n) tiempo, O(1) espacio.
    """
    if n < 0:
        raise ValueError("El factorial no está definido para números negativos")
    resultado = 1
    for i in range(2, n + 1):
        resultado *= i
    return resultado

def factorial_recursivo(n: int) -> int:
    """Calcula n! mediante recursión directa.
    Complejidad: O(n) tiempo, O(n) espacio (pila de llamadas).
    """
    if n < 0:
        raise ValueError("El factorial no está definido para números negativos")
    if n in (0, 1):
        return 1
    return n * factorial_recursivo(n - 1)

Optimizaciones avanzadas

import functools
@functools.lru_cache(maxsize=None)
def factorial_tail(n: int, acc: int = 1) -> int:
    """Versión de recursión de cola con memoización.
    La caché evita recomputaciones en llamadas repetidas.
    """
    if n < 0:
        raise ValueError("El factorial no está definido para números negativos")
    if n == 0:
        return acc
    return factorial_tail(n - 1, acc * n)

import functools
import operator
def factorial_reduce(n: int) -> int:
    if n < 0:
        raise ValueError("El factorial no está definido para números negativos")
    return functools.reduce(operator.mul, range(1, n + 1), 1)

Comparativa de rendimiento

En Python puro, la versión iterativa suele ser la más rápida porque evita la sobrecarga de la pila de llamadas. A continuación, una tabla con resultados típicos (Python 3.11, CPU Intel i7‑12700H, 10 000 iteraciones):

Para valores muy grandes (n > 10 000) la sobrecarga de la recursión puede provocar RecursionError. En esos casos, se recomiendan librerías de precisión arbitraria.

Manejo de números gigantes

Python soporta enteros de precisión arbitraria, pero para cálculos extremadamente intensivos (p.ej., n! > 10^6) es más eficiente usar gmpy2, una interfaz a la biblioteca GMP.

import gmpy2
def factorial_gmpy2(n: int) -> gmpy2.mpz:
    if n < 0:
        raise ValueError("El factorial no está definido para números negativos")
    return gmpy2.fac(n)  # Implementación en C altamente optimizada

Benchmarks (n = 100 000):

• Implementación pura (iterativa): ≈ 1.8 s
• gmpy2.fac: ≈ 0.12 s

Aplicaciones prácticas del factorial

• Combinatoria: Cálculo de n choose k → C(n,k) = n! / (k!·(n‑k)!).
• Distribuciones de probabilidad: Distribución binomial, Poisson y multinomial.
• Criptografía: Algoritmos que requieren factoriales grandes para pruebas de primalidad.
• Algoritmos de generación de permutaciones: El número total de permutaciones de n elementos es n!.

Ejemplo completo: cálculo de combinaciones sin desbordamiento

import math
def combinaciones(n: int, k: int) -> int:
    """Devuelve C(n, k) usando la fórmula basada en factoriales.
    Utiliza math.comb en Python 3.8+ para mayor eficiencia.
    """
    if not (0 <= k <= n):
        raise ValueError("k debe estar entre 0 y n inclusive")
    # Opción 1: usar la función incorporada (recomendado)
    return math.comb(n, k)
    # Opción 2: cálculo manual con reducción de overflow
    # numerador = math.prod(range(n, n-k, -1))
    # denominador = math.factorial(k)
    # return numerador // denominador

Esta función es segura para n del orden de cientos de miles gracias a la optimización interna de math.comb.

Buenas prácticas y troubleshooting

• Validación de entradas: siempre verifica que n sea entero no negativo.
• Control de recursión: aumenta sys.setrecursionlimit solo si sabes que la pila del proceso lo permite; de lo contrario, prefiere la versión iterativa.
• Memoria: para factoriales gigantes, usa tipos de datos de librerías externas (gmpy2, numpy con object dtype) para evitar consumo excesivo.
• Pruebas unitarias: cubre casos límite (0, 1, valores grandes) y verifica que factorial_iterativo(5) == 120.
• Profiling: emplea cProfile o timeit para comparar versiones en tu entorno concreto.

Comparación con otros lenguajes

En C o Rust, el factorial se implementa normalmente con bucles y tipos de entero de ancho fijo, lo que obliga a gestionar overflow manualmente. Python simplifica el desarrollo al ofrecer enteros de precisión arbitraria, aunque a costa de rendimiento. Si el rendimiento es crítico, una extensión C (cython o ctypes) o la librería gmpy2 suele ser la mejor opción.

Conclusión

El algoritmo factorial es una herramienta esencial en computación. En Python dispones de múltiples formas de implementarlo, desde la sencilla versión iterativa hasta soluciones altamente optimizadas con gmpy2. Elegir la implementación adecuada depende del rango de n, los requisitos de rendimiento y la necesidad de mantener el código legible y mantenible.