O fatorial de um inteiro positivo é o produto de um inteiro e todos os inteiros abaixo dele, ou seja, o fatorial do número n (representado por n!) Seria dado por
arquitetura mvc em java com diagrama
n! = 1 * 2 * 3 * 4 *. . . . . * n
O fatorial de 0 é definido como 1 e não é definido para inteiros negativos. Existem várias maneiras de encontrá-lo que estão listadas abaixo-
- Programa Fatorial em Cusando loop For
- Programa fatorial usandoFunções
- Programa Fatorialusando recursão
Vamos começar.
Fatorial usando For Loop
É a maneira mais fácil e simples de encontrar o fatorial de um número. Vamos primeiro visitar o código -
#include int main () {int I, num, fact = 1 // definindo o fatorial como 1, pois o valor mínimo é 1 printf (“Insira um número para calcular seu fatorial”) 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 }Resultado-
Fatorial de 5 = 120
Explicação -
O número cujo fatorial deve ser encontrado é tomado como entrada e armazenado em uma variável e é verificado se é negativo ou não. Se o número inteiro inserido for negativo, a mensagem apropriada será exibida. O valor do fatorial é predefinido como 1, pois seu menor valor é 1. O loop for é executado para inteiros positivos (exceto para 0 para o qual a condição de teste é falsa e, portanto, o fato permanece zero). No loop for, o valor do fatorial é multiplicado por cada inteiro e armazenado sucessivamente até que o número de entrada seja alcançado. Por exemplo, para entrada = 5, o fluxo vai para o loop e as etapas seguintes acontecem-
fato = 1, i = 1 -> fato = 1 * 1 = 1 -> i = 2
fato = 1, i = 2 -> fato = 1 * 2 = 2 -> i = 3
fato = 2, i = 3 -> fato = 2 * 3 = 6 -> i = 4
fato = 6, i = 4 -> fato = 6 * 4 = 24 -> i = 5
fato = 24, i = 5 -> fato = 24 * 5 = 120 -> i = 6
Agora 6> 5, portanto, a condição de teste se torna falsa e o loop é encerrado. O valor do fatorial é exibido.
diferença entre c c ++ e java
Fatorial usando funções
Esta abordagem é conhecida como uma abordagem modular e deve ser seguida para a programação por ser bastante eficiente. Uma de suas vantagens é que, quando precisamos fazer alterações no código, em vez de alterar o código completo, podemos apenas modificar a função em questão. O código para encontrar o fatorial de um número usando esta abordagem é mostrado abaixo
#include fatorial longo (int num) // função para calcular o fatorial que leva um valor inteiro como parâmetro e retorna um 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 }
Resultado - Fatorial de 5 = 120
Explicação-
A lógica do programa é a mesma, exceto que uma função diferente é usada para calcular o fatorial e retornar o valor para o método principal de onde a execução começa.
Fatorial usando recursão
Recursão é o processo no qual uma função chama a si mesma e a função correspondente é chamada de função recursiva. Ele consiste em duas partes - uma condição básica e uma chamada recursiva. A solução para a condição de base é fornecida enquanto a solução para o valor maior pode ser resolvida convertendo para valores menores até que a solução de base seja alcançada e usada.
Abaixo está o código para encontrar fatorial usando recursão: -
#include int fact (int) // protótipo de função int main () {int num printf ('Insira o número cujo fatorial deve ser encontrado:') 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 } } Resultado - Fatorial de 5 = 120
Explicação -Suponha que o usuário insira 5 como entrada, então, no método main (), o valor de num é 5. Conforme o fluxo vai na instrução printf (linha 12), uma chamada à função fact (5) é feita. Agora, para fato (5) num é 5, que não é igual a 0, portanto, o fluxo vai para a instrução else, onde na instrução return uma chamada recursiva é feita e o fato (4) é feito. O processo é repetido até que a condição de base, ou seja, num = 0 seja alcançada e 1 seja retornado. Agora o fluxo vai para o fato (1) de onde 1 (quanto ao fato (1) num = 1) * 1 (valor retornado do fato (0)) é retornado. Este processo é repetido até que o valor desejado seja obtido.
Complexidade de tempo e espaço - iteração V / S de recursão
Para recursão-
A respeito de complexidade de tempo , sabemos que o fatorial 0 é a única comparação. Portanto, T (0) = 1. Para fatorial de qualquer outro número, o processo envolve uma comparação, uma multiplicação, uma subtração e uma chamada de função. Portanto
T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k
Como sabemos T (0) = 1 e para k = n, (n-k) = 0
Portanto, T (n) = T (0) + 3n
= 1 + 3n
Portanto, a complexidade de tempo do código é O (n).
A respeito de complexidade do espaço, uma pilha é criada para cada chamada, que será mantida até que seu valor sejacomputado e retornado. Por exemplo, para n = 5 as seguintes pilhas terão que ser mantidas
f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)
Como podemos ver que 5 pilhas terão que ser mantidas até que uma chamada para f (0) seja alcançada, cujo valor éconhecido e é devolvido. Portanto, para n fatorial, n pilhas terão que ser mantidas. Portanto, a complexidade do espaçoé O (n). Também é evidente a partir das imagens acima que para n = 5, 5 pilhas terão que sermantido. Portanto, para n fatorial, n pilhas terão que ser mantidas. Assim, a complexidade do espaço é O (n).
Para Iteração-
A respeito de complexidade de tempo, existem n iterações dentro do loop, portanto, a complexidade do tempo é O (n).
A respeito de complexidade do espaço, para solução iterativa, há apenas uma pilha que precisa ser mantida e uma variável inteira é usada. Portanto, a complexidade do espaço é O (1).
Isso é tudo para este artigo. Espero que você tenha entendido o conceito do programa fatorial em C junto com as complexidades do tempo.
fantoche vs chef vs docker
Se tiver alguma dúvida, fique à vontade para fazer todas as suas perguntas na seção de comentários do “programa fatorial em C” e nossa equipe terá prazer em responder.