Factorial de un entero positivo es el producto de un entero y todos los enteros por debajo de él, es decir, el factorial del número n (¡representado por n!) Estaría dado por
¡norte! = 1 * 2 * 3 * 4 *. . . . . *norte
El factorial de 0 se define como 1 y no se define para enteros negativos. Hay varias formas de encontrarlo que se enumeran a continuación:
- Programa factorial en Cusando For loop
- Programa factorial usandoFunciones
- Programa factorialusando la recursividad
Empecemos.
Factorial con bucle for
Es la forma más fácil y sencilla de encontrar el factorial de un número. Primero visitemos el código -
#include int main () {int I, num, fact = 1 // definiendo factorial como 1 ya que el valor mínimo es 1 printf ('Ingresa un número para calcular su factorial') scanf ('% d', & num) if (num<0) //if the input is a negative integer { printf (“Factorial is not defined for negative numbers.”) } else { for(i=1i0, therefore fact value remains 1 { fact = fact * i // keeps on multiplying and storing in the value of factorial till the input integer is reached } printf(“Factorial of %d = %dn”, num, fact) } return 0 //since we have defined the main() method with a return value of integer type }Salida-
Factorial de 5 = 120
Explicación –
Se toma como entrada el número cuyo factorial se va a encontrar y se almacena en una variable y se comprueba si es negativo o no. Si el número entero ingresado es negativo, se muestra el mensaje correspondiente. El valor de factorial está predefinido para ser 1 ya que su valor mínimo es 1. El ciclo for se ejecuta para enteros positivos (excepto para 0 para el cual la condición de prueba es falsa y por lo tanto el hecho permanece cero). En el ciclo for, el valor de factorial se multiplica por cada número entero y se almacena sucesivamente hasta que se alcanza el número de entrada. Por ejemplo, para la entrada = 5, el flujo va al bucle for y se llevan a cabo los siguientes pasos:
hecho = 1, i = 1 -> hecho = 1 * 1 = 1 -> i = 2
hecho = 1, i = 2 -> hecho = 1 * 2 = 2 -> i = 3
hecho = 2, i = 3 -> hecho = 2 * 3 = 6 -> i = 4
hecho = 6, i = 4 -> hecho = 6 * 4 = 24 -> i = 5
hecho = 24, i = 5 -> hecho = 24 * 5 = 120 -> i = 6
cadena de grupo constante en java
Ahora 6> 5, por lo tanto, la condición de prueba se vuelve falsa y el bucle finaliza. Se muestra el valor del factorial.
Factorial usando funciones
Este enfoque se conoce como enfoque modular y debe seguirse para la programación, ya que es bastante eficiente. Una de sus ventajas es que cuando necesitamos hacer cambios en el código, en lugar de cambiar el código completo, podemos simplemente modificar la función en cuestión. El código para encontrar el factorial de un número utilizando este enfoque se muestra a continuación.
#include long factorial (int num) // función para calcular factorial que toma un valor entero como parámetro y devuelve un valor de tipo int {int i long fact = 1 for (i = 1 i<= num i++) fact = fact * i return fact //returns to function call } int main() //execution begins from main() method { int num printf('Enter a number to calculate its factorialn') scanf('%d', &num) if(num<0) //if the input is a negative integer { printf('Factorial is not defined for negative numbers.') } printf('Factorial of %d = %dn', num, factorial(num)) //call to factorial function passing the input as parameter return 0 }
Salida – Factorial de 5 = 120
Explicación-
copia superficial y copia profunda en java
La lógica del programa es la misma excepto que se usa una función diferente para calcular el factorial y devolver el valor al método principal desde donde comienza la ejecución.
Factorial usando recursividad
La recursividad es el proceso en el que una función se llama a sí misma y la función correspondiente se llama función recursiva. Consta de dos partes: una condición base y una llamada recursiva. Se proporciona la solución a la condición base, mientras que la solución al valor mayor se puede resolver convirtiendo a valores menores hasta que se alcance y se utilice la solución base.
A continuación se muestra el código para encontrar factorial mediante recursividad: -
#include int fact (int) // prototipo de función int main () {int num printf ('Ingrese el número cuyo factorial se va a encontrar:') scanf ('% d', & num) if (num<0) { printf('ERROR. Factorial is not defined for negative integers') } printf('Factorial of %d is %d', num, fact(num)) //first call is made return 0 } int fact(int num) { if(num==0) //base condition { return 1 } else{ return(num*fact(num-1)) //recursive call } } Salida - Factorial de 5 = 120
Explicación –Suponga que el usuario ingresa 5 como entrada, luego en el método main () el valor de num es 5. A medida que avanza el flujo en la instrucción printf (línea 12) se realiza una llamada a la función fact (5). Ahora, para el hecho (5) num es 5 que no es igual a 0, por lo tanto, el flujo va a la instrucción else, donde en la instrucción return se realiza una llamada recursiva y se realiza el hecho (4). El proceso se repite hasta la condición base, es decir, num = 0 se alcanza y se devuelve 1. Ahora el flujo va al hecho (1) desde donde se devuelve 1 (como para el hecho (1) num = 1) * 1 (valor devuelto por el hecho (0)). Este proceso se repite hasta obtener el valor requerido.
Complejidad de tiempo y espacio - Recurrencia V / S iteración
Por recursividad
Respecto a complejidad del tiempo , sabemos que el factorial 0 es la única comparación. Por tanto, T (0) = 1. Para factorial de cualquier otro número, el proceso implica una comparación, una multiplicación, una resta y una llamada de función. Por lo tanto
T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k
Como sabemos T (0) = 1 y para k = n, (n-k) = 0
Por lo tanto T (n) = T (0) + 3n
= 1 + 3n
Por lo tanto, la complejidad temporal del código es O (n).
Respecto a complejidad espacial, Se crea una pila para cada llamada que se mantendrá hasta que su valor seacalculado y devuelto. Por ejemplo, para n = 5, se deberán mantener las siguientes pilas
f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)
Como podemos ver que se tendrán que mantener 5 pilas hasta que se alcance una llamada af (0) cuyo valor esconocido y se devuelve. Por lo tanto, para n factorial, será necesario mantener n pilas. Por lo tanto, la complejidad del espacioEstá encendido). También es evidente a partir de las imágenes anteriores que para n = 5, se tendrán que colocar 5 pilasmantenido. Por lo tanto, para n factorial, será necesario mantener n pilas. Por tanto, la complejidad espacial es O (n).
Para iteración
Respecto a complejidad del tiempo, hay n iteraciones dentro del ciclo, por lo tanto, la complejidad del tiempo es O (n).
finalizar un programa en java
Respecto a complejidad espacial, para la solución iterativa, solo hay una pila que debe mantenerse y se usa una variable entera. Entonces, la complejidad del espacio es O (1).
Eso es todo por este artículo. Espero que hayas entendido el concepto de programa factorial en C junto con las complejidades del tiempo.
Si encuentra alguna pregunta, no dude en hacer todas sus preguntas en la sección de comentarios del “programa factorial en C” y nuestro equipo estará encantado de responder.