Factorial en C: ejercicio resuelto

Si buscas factorial en C ejercicio resuelto, aquí tienes tres implementaciones con análisis de desbordamiento: la versión recursiva clásica, la iterativa y una tabla precalculada para consultas O(1).

El factorial es el primer ejercicio donde el desbordamiento de enteros se vuelve un problema real: 13! ya supera el rango de int de 32 bits, y 21! supera el de long long.

Enunciado

Implementa tres versiones de la función factorial:

fact_recursivo(n): usando recursión.
fact_iterativo(n): usando un bucle.
Una tabla fact_tabla[21] precalculada para consultas instantáneas.

Imprime los factoriales de 0 a 20 con cada versión.

Solución en C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>

/* Recursiva */
long long fact_recursivo(int n) {
    if (n <= 1) return 1;
    return n * fact_recursivo(n - 1);
}

/* Iterativa */
long long fact_iterativo(int n) {
    long long r = 1;
    for (int i = 2; i <= n; i++) r *= i;
    return r;
}

/* Tabla precalculada (válida hasta 20!) */
static long long fact_tabla[21];

void precalcular(void) {
    fact_tabla[0] = 1;
    for (int i = 1; i <= 20; i++)
        fact_tabla[i] = fact_tabla[i - 1] * i;
}

int main(void) {
    precalcular();
    printf("%-5s %-20s %-20s %-20s\n", "n", "Recursivo", "Iterativo", "Tabla");
    for (int i = 0; i <= 20; i++) {
        printf("%-5d %-20lld %-20lld %-20lld\n",
               i, fact_recursivo(i), fact_iterativo(i), fact_tabla[i]);
    }
    return 0;
}

Resultado esperado

1
2
3
4
5
6
7
n     Recursivo            Iterativo            Tabla               
0     1                    1                    1                   
1     1                    1                    1                   
2     2                    2                    2                   
3     6                    6                    6                   
...
20    2432902008176640000  2432902008176640000  2432902008176640000 

Errores frecuentes

Usar int en lugar de long long: 13! = 6.227.020.800, que supera los 2.147.483.647 del int de 32 bits. El resultado se trunca silenciosamente dando un valor negativo o incorrecto.
No tratar el caso n = 0: por definición 0! = 1; sin el caso base la función devuelve 0.
Calcular factoriales de números negativos sin validar: el comportamiento es indefinido con la implementación recursiva.
Confiar en la versión recursiva para n grande: la profundidad de pila crece linealmente y puede causar stack overflow en sistemas con pila pequeña.

Aplicación práctica

El factorial aparece en combinatoria (número de permutaciones, coeficientes binomiales), en la función gamma, en el análisis de algoritmos de fuerza bruta y en la generación de permutaciones. La tabla precalculada es el patrón estándar cuando el dominio es pequeño y las consultas son frecuentes.

Siguiente ejercicio recomendado

Práctica guiada y libro completo

Si quieres una ruta completa con progresión real de dificultad:

FAQ

¿Por qué 13! da un número negativo si uso `int`?

Porque 13! = 6.227.020.800 supera el valor máximo de un int de 32 bits (2.147.483.647). El desbordamiento de enteros con signo es comportamiento indefinido en C, pero en la práctica los bits más significativos se descartan, produciendo un valor negativo.

¿Qué pasa con 21! en `long long`?

21! = 51.090.942.171.709.440.000 supera el rango de long long (9.223.372.036.854.775.807). Para factoriales mayores se necesita aritmética de precisión arbitraria (__int128 en GCC llega hasta 33!) o una biblioteca de big integers.

¿La versión recursiva o la iterativa es más eficiente?

La iterativa: no genera marcos de pila adicionales y el compilador puede optimizarla con facilidad. La recursiva es equivalente en complejidad O(n) pero tiene sobrecarga de llamadas. Para factoriales, la diferencia es insignificante en la práctica dado el pequeño dominio válido (0–20 con long long).

Factorial en C: ejercicio resuelto