Fatorial de um Número Crie um algoritmo que receba um número inteiro positivo N e calcule o seu fatorial (N!). O fatorial de um número é o produto de todos os inteiros positivos menores ou iguais a ele.
  • Lembrete Matemático:
    -5!=5 \times 4 \times 3 \times 2 \times 1=120
    -0!=1 (por definição)
  • Desafio: Tente implementar utilizando uma estrutura de repetição (loop) que acumule o produto.

Passo 1

O que o problema pede e as informações que temos:
  • Pede-se criar um algoritmo que receba um número inteiro positivo N e calcule o fatorial N!.
  • Definição importante (dada no enunciado): o fatorial é o produto de todos os inteiros positivos menores ou iguais ao número.
  • Anotações úteis que o enunciado lembrou:
    • Para N=0 vale por definição 0!=1.
    • Para N>0 temos N!=1\times2\times3\times\cdots\times N.
  • Condição implícita: o algoritmo deve lidar com números inteiros não-negativos. Se a entrada for negativa o fatorial não é definido (para este exercício devemos tratar como erro ou indicar entrada inválida).
  • O desafio extra: implementar usando uma estrutura de repetição (loop) que acumule o produto — é exatamente o que vamos fazer.

Passo 2

Ideia geral do método (sem calcular ainda): usar um acumulador e um loop.
  • Conceito do acumulador: é uma variável que guarda o resultado parcial à medida que repetimos passos. Para produto usamos um acumulador inicializado em 1 (porque multiplicar por 1 não altera o resultado).
  • Estrutura de repetição: vamos percorrer os inteiros de 1 até N e multiplicar o acumulador pelo índice atual em cada iteração.
  • Vantagem: este método é simples, fácil de implementar na prova e funciona em O(N) multiplicações.

Passo 3

Regras e fórmula que vamos usar (explicando cada símbolo):
  • A definição do fatorial para N\ge 1 é
N! = 1 \times 2 \times 3 \times \cdots \times N.
Aqui:
  • N é o número inteiro de entrada.
  • N! é o resultado pedido.
  • O produto começa em 1 porque é o menor inteiro positivo e serve como identidade multiplicativa.
  • Caso especial:
0! = 1.
  • Se a entrada for N<0 então o fatorial, para este contexto, será tratado como inválido.

Passo 4

Descrição passo a passo do algoritmo (versão verbal que dá para escrever na prova):
  1. Ler o inteiro N.
  2. Se N<0, devolver um erro ou mensagem “entrada inválida” (porque fatorial não está definido aqui).
  3. Se N=0, devolver 1 (caso especial).
  4. Caso N\ge 1:
    • Inicializar produto \leftarrow 1.
    • Para i variando de 1 até N (isto é, i=1,2,\dots,N):
      • Atualizar produto \leftarrow produto \times i.
    • Ao final do loop, produto contém N!. Retornar produto.
Explicando cada linha de lógica para você entender na prova:
  • Por que iniciar produto em 1? Porque 1 é a identidade da multiplicação: multiplicar por 1 não altera o valor inicial e permite acumular corretamente.
  • Por que o loop vai de 1 até N? Porque a definição do fatorial multiplica exatamente esses inteiros.
  • O teste N=0 vem antes para evitar que o loop rode de modo inútil (o loop de 1 a 0 não faria sentido) e para aplicar a definição 0!=1.

Passo 5

Exemplo passo a passo com N=5 (fazendo as contas como se estivesse na prova):
  • Inicialmente produto = 1.
  • Iteração i=1: produto \leftarrow 1 \times 1 = 1.
  • Iteração i=2: produto \leftarrow 1 \times 2 = 2.
  • Iteração i=3: produto \leftarrow 2 \times 3 = 6.
  • Iteração i=4: produto \leftarrow 6 \times 4 = 24.
  • Iteração i=5: produto \leftarrow 24 \times 5 = 120.
  • Resultado: 5! = 120.
Isso mostra como “acumular o produto” passo a passo — decorre naturalmente do loop.

Passo 6

Exemplo com N=0:
  • Verificamos N=0 e, por definição, devolvemos 0! = 1. Sem loop.

Passo 7

Cuidados e observações práticas (ótimas para você lembrar na prova):
  • Entrada inválida: se N for negativo, indique “entrada inválida”.
  • Crescimento rápido: N! cresce muito rápido; para valores grandes ele fica enorme. Em implementações reais, pode estourar o tipo inteiro da linguagem (overflow). Na prova, se pedirem apenas o algoritmo, basta mencionar isso; se pedirem cálculo manual, normalmente N será pequeno.
  • Complexidade: tempo O(N) (fazemos N multiplicações). Memória O(1) adicional (apenas o acumulador e o índice).
  • Alternativa: existe solução recursiva (definida por N! = N \times (N-1)! com 0!=1), mas a versão iterativa evita profundidade de pilha e é preferida em provas quando pedem loop.

Passo 8

Pseudocódigo didático (escreva isso na prova ou implemente em qualquer linguagem):
  • Entrada: inteiro N.
  • Saída: valor de N! ou mensagem de erro se N<0.
Algoritmo em palavras formais:
  • Ler N.
  • Se N<0 então escrever “Entrada inválida” e terminar.
  • Se N=0 então escrever 1 e terminar.
  • produto \leftarrow 1.
  • Para i de 1 até N faça:
    • produto \leftarrow produto \times i.
  • Escrever produto.
Exemplo rápido de implementação em Python (só para referência; na prova costuma pedir pseudocódigo):
def fatorial(N):
    if N < 0:
        raise ValueError("Entrada inválida: N deve ser não-negativo")
    produto = 1
    for i in range(1, N+1):
        produto *= i
    return produto

Resposta

  • Entrada: N (inteiro).
  • Se N<0 então “Entrada inválida”.
  • Se N=0 então retorne 1.
  • Caso contrário:
    • produto \leftarrow 1
    • Para i=1 até N: produto \leftarrow produto \times i
    • Retorne produto

Exercícios relacionados