Escreva uma função int fat ( int n ) que recebe n e retorna o fatorial de n.

Passo 1

O enunciado pede uma função com a assinatura \texttt{int fat ( int n )} que recebe um inteiro n e retorna o fatorial de n.
Informações dadas e o que precisa ser entregue:
  • A função deve receber um inteiro n.
  • A função deve retornar o fatorial de n, isto é n!.
  • Não foram especificadas restrições sobre valores negativos ou limites superiores; preciso definir um comportamento razoável para esses casos.

Passo 2

O que é fatorial? Vou explicar devagar e com exemplos.
  • Por definição, para um inteiro não negativo n:
n! = n \times (n-1) \times (n-2) \times \cdots \times 2 \times 1
  • Caso especial: 0! = 1.
    Exemplo concreto: 5! = 5\times4\times3\times2\times1 = 120.

Passo 3

Decisão do método de implementação (iterativo ou recursivo) — vou justificar:
  • Recursão usa a relação n! = n \times (n-1)!. É elegante, mas em C pode causar estouro de pilha para n grande e tem overhead de chamadas de função.
  • Iterativo (laço) é simples, rápido, fácil de entender e não sofre com profundidade de chamada. Para um exercício básico e uma função que retorna um \texttt{int}, iterativo é a escolha mais prática.
    Portanto vou implementar de forma iterativa.

Passo 4

Tratamento de casos especiais e limites:
  • Para n<0: o fatorial não está definido em inteiros negativos. Vou escolher um indicador de erro simples: retornar 0. (Explicação: como um fator positivo mínimo é 1, retornar 0 sinaliza erro; poderia também lançar erro, usar unsigned ou errno, mas o enunciado pede apenas uma função simples.)
  • Para n=0: retorno 1 (pela definição).
  • Observação sobre overflow: tipo \texttt{int} em C normalmente tem 32 bits com máximo 2\,147\,483\,647. O maior n com n! cabendo num \texttt{int} é 12, pois 12! = 479\,001\,600 e 13! = 6\,227\,020\,800 já extrapola o limite. Vou adicionar uma verificação simples: se n>12 retorno 0 para indicar que o resultado não cabe num \texttt{int}.

Passo 5

Algoritmo passo a passo (em linguagem natural) para n não negativo e n\le 12:
  1. Inicializar \texttt{resultado} = 1.
  2. Para cada inteiro i de 2 até n (inclusive), fazer \texttt{resultado} = \texttt{resultado} \times i.
  3. Ao final, retornar \texttt{resultado}.
Esse procedimento calcula exatamente n!, porque multiplica todos os inteiros de 1 a n (com 1 já multiplicado ao inicializar com 1).

Passo 6

Complexidade e comportamento:
  • Complexidade de tempo: O(n) multiplicações.
  • Complexidade de espaço: O(1), uso constante de memória extra.
  • Para n fora do intervalo tratado (negativos ou n>12), a função retorna 0 para sinalizar erro/overflow.

Passo 7

Exemplo manual (para checar mentalmente): calcular 5! com o algoritmo iterativo:
  • iniciar \texttt{resultado}=1
  • i=2: \texttt{resultado}=1\times2=2
  • i=3: \texttt{resultado}=2\times3=6
  • i=4: \texttt{resultado}=6\times4=24
  • i=5: \texttt{resultado}=24\times5=120
  • retorna 120, que é 5!. Isso confirma o procedimento.

Passo 8

Observações finais antes do código:
  • A função abaixo segue a assinatura pedida \texttt{int fat ( int n )}.
  • Ela trata n<0 e n>12 retornando 0 como indicação de erro/overflow.
  • Para usos em que se deseja suportar n maiores, usar tipos maiores ( \texttt{long long} ou bibliotecas de inteiros grandes) ou retornar outro sinalizador de erro seria necessário.

Resposta

int fat ( int n ) {
if (n < 0) return 0; /* fatorial indefinido para negativos -> sinaliza erro /
if (n > 12) return 0; /
evita overflow do int (13! não cabe em 32-bit signed) */
int resultado = 1;
for (int i = 2; i <= n; ++i) {
resultado *= i;
}
return resultado;
}

Exercícios relacionados