Calcular Factorial con JavaScript - Iterativo y Recursivo

En este artículo aprenderás a calcular el factorial de un número entero con JavaScript, usando bucles y recursividad.

Introducción

Un factorial de un número es el producto de ese entero y todos los enteros positivos que son menores o iguales que él. Tiene que ser un número entero positivo; de lo contrario, la lógica se extiende hasta el infinito negativo. En otras palabras, calcular un factorial significa multiplicar todos los números enteros entre un número y 1.

0! es igual a 1, por convención, y no sigue la regla estándar.

Un factorial se denota por el número entero para el que estamos calculando un factorial, seguido de un signo de exclamación.

5! denota un factorial de cinco.

Y para calcular ese factorial, multiplicamos el número por cada número entero menor que él, hasta llegar a 1:

1
2
5! = 5 * 4 * 3 * 2 * 1
5! = 120

En este tutorial, aprenderemos a calcular el factorial de un número entero con JavaScript, usando bucles y recursividad.

Cálculo factorial usando bucles

Podemos calcular factoriales utilizando tanto el bucle while como el bucle for. Por lo general, solo necesitaremos un contador para la terminación del bucle y el número proporcionado para el que estamos calculando un factorial.

Empecemos con el bucle for:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function getFactorialForLoop(n) {
    let result = 1;
    if (n > 1) {
        for (let i = 1; i <= n; i++) {
            result = result * i;
        }
        return result;
    }
    else {
        return "n has to be positive";
    }
}

Probablemente haya podido observar que comenzamos la cuenta en 1, no en n, aunque la definición de un factorial establece que vamos de n a 1 . Aunque, matemáticamente, estas son declaraciones equivalentes:

$$
1 * 2 * 3 * 4 ... * n = n * (n-1) * (n-2) * (n-3) * (n-4) .. * (n - (n-1))
$$

Para simplificar, (n - (n-1)) siempre será igual a 1.

Eso significa que no importa en qué dirección estemos contando. Puede comenzar desde 1 y aumentar hacia n, o puede comenzar desde n y disminuir hacia 1. Ahora que eso está aclarado, echemos un vistazo a lo que sucede en este método.

Acepta n, el número para el que estamos calculando un factorial. Se asigna un valor de 1 a una variable resultado de marcador de posición, que eventualmente se actualizará.

¿Por qué asignar 1 y no 0 u otros espacios en blanco?

Si tuviéramos que asignarle 0, todas las siguientes multiplicaciones serían con 0. Esto termina con solo un 0 al final.

Luego comenzamos nuestro bucle for definiendo i como el contador que comienza desde 1. Tenga en cuenta que la declaración de la condición es i <= n; para incluir también la propia n.

Dentro del ciclo for, multiplicamos el valor actual de resultado con el valor actual de nuestro índice i - realizando la operación desde la definición al revés.

Finalmente, devolvemos el valor final del resultado como salida del método. Probemos nuestra función en la consola de nuestro navegador e imprimamos el resultado. Asegúrese de ingresar la función factorial en la consola del navegador primero:

1
2
3
4
var inp = window.prompt("Enter a number: ");
inp = parseInt(inp);

alert("The result is: " + getFactorialForLoop(inp));

Le pedirá al usuario que dé su entrada. Lo intentaremos con 4. Cuando ejecute el script de alerta, verá una ventana emergente con el resultado:

1
24

Puedes usar una calculadora para verificar el resultado:

4! es 4 * 3 * 2 * 1, lo que da como resultado 24.

Ahora veamos cómo podemos calcular el factorial usando el bucle while. Aquí está nuestra función modificada:

1
2
3
4
5
6
7
8
function getFactorialWhileLoop(n){
    let result = 1;
    while (n > 1) {
        result = result * n;
        n -= 1;
    }
    return result;
}

Esto es bastante similar al bucle for. Excepto por esta vez, nos estamos moviendo de n hacia 1, más cerca de la definición matemática. Probemos nuestra función:

1
2
3
4
var inp = window.prompt("Enter a number: ");
inp = parseInt(inp);

alert("The result is: " + getFactorialWhileLoop(inp));

Como antes, si ingresamos 4 obtenemos 24. El cálculo fue 4*3*2*1 y el resultado final es el mismo que antes.

Los factoriales son recursivos por naturaleza, y usar la recursividad es un enfoque más natural para repetir una operación como esta varias veces.

Cálculo factorial mediante recursión

Una función recursiva es una función que se llama a sí misma. Puede parecer un poco intimidante al principio, pero ten paciencia con nosotros y verás que las funciones recursivas son fáciles de entender.

En general, toda función recursiva tiene dos componentes principales: un caso base y un paso recursivo.

Los casos base son las instancias más pequeñas del problema, eso es lo que se repite. También una ruptura, un caso que devolverá un valor y saldrá de la recursividad. En términos de funciones factoriales, el caso base es cuando devolvemos el elemento final del factorial, que es 1.

Sin un caso base o con un caso base incorrecto, su función recursiva puede ejecutarse infinitamente, provocando un desbordamiento.

Los pasos recursivos, como su nombre lo indica, son la parte recursiva de la función, donde todo el problema se transforma en algo más pequeño. Si el paso recursivo no logra reducir el problema, entonces nuevamente la recursividad puede ejecutarse infinitamente.

Considere la parte recurrente de los factoriales:

  • 5! es 5 * 4 * 3 * 2 * 1.

Pero también sabemos que:

  • 4 * 3 * 2 * 1 es 4!.

En otras palabras, 5! es 5 * 4! y 4! es 4 * 3! y así sucesivamente.

Entonces podemos decir que n! = n * (n-1)!. ¡Este será el paso recursivo de nuestro factorial!

Una recursividad factorial termina cuando llega a 1. Este será nuestro caso base. Devolveremos 1 si n es 1 o menos, cubriendo la entrada cero.

Echemos un vistazo a nuestra función factorial recursiva:

1
2
3
4
5
6
7
8
function getFactorialRecursively(n){
    if (n <= 1){
        return 1;
    }
    else{
        return n * getFactorialRecursively(n-1);
    }
}

Como puede ver, el bloque if encarna nuestro caso base, mientras que el bloque else cubre el paso recursivo.

Probemos nuestra función:

1
2
3
4
var inp = window.prompt("Enter a number: ");
inp = parseInt(inp);

alert("The result is: " + getFactorialRecursively(inp));

Ingresaremos 3 como entrada esta vez, y la alerta imprimirá 6 como resultado.

Obtenemos el mismo resultado. Pero esta vez, lo que pasa bajo el capó es bastante interesante:

Verá, cuando ingresamos la entrada, la función verificará con el bloque si, y dado que 3 es mayor que 1, saltará al bloque else. En este bloque, vemos la línea return n * getFactorialRecursively(n-1);.

Sabemos el valor actual de n por el momento, es 3, pero getFactorialRecursively(n-1) todavía está por calcular.

Luego, el programa llama a la misma función una vez más, pero esta vez nuestra función toma 2 como parámetro. Verifica el bloque if y salta al bloque else y nuevamente se encuentra con la última línea. Ahora, el valor actual de n es 2 pero el programa todavía debe calcular getFactorialRecursively(n-1).

Entonces llama a la función una vez más, pero esta vez el bloque if, o más bien, la clase base logra devolver 1 y sale de la recursividad.

Siguiendo el mismo patrón hacia arriba, devuelve el resultado de cada función, multiplicando el resultado actual con la n anterior y devolviéndolo para la llamada de función anterior. En otras palabras, nuestro programa primero llega al final del factorial (que es 1), luego va aumentando, mientras se multiplica en cada paso.

También eliminando la función de la pila de llamadas una por una, hasta que se devuelva el resultado final de n * (n-1).

Así es generalmente como funcionan las funciones recursivas. Algunos problemas más complicados pueden requerir recursiones más profundas con más de un caso base o más de un paso recursivo. ¡Pero por ahora, esta simple recursión es lo suficientemente buena para resolver nuestro problema factorial!

Conclusión

En este artículo, cubrimos cómo calcular factoriales usando bucles for y while. También aprendimos qué es la recursión y cómo calcular el factorial usando la recursión.

Si te ha gustado la recursividad y quieres practicar más, ¡intenta calcular la sucesión de Fibonacci con la recursividad! Y si tiene alguna pregunta o comentario sobre nuestro artículo, no dude en compartirlo en la sección de comentarios.