Questão 7: Crie uma função fatorial (n) que receba um número n e retorne o seu fatorial (ex: 5!=5 \times 4 \times 3 \times 2 \times 1 ). Use um laço while.
Exemplo: fatorial (5) deve retornar 120.

Passo 1

O enunciado pede que eu crie uma função chamada fatorial(n) que receba um número n e retorne o fatorial de n. O enunciado dá como exemplo que 5! = 5 \times 4 \times 3 \times 2 \times 1 e que fatorial(5) deve retornar 120. Informações relevantes fornecidas:
  • A função deve chamar-se fatorial e aceitar um parâmetro, aqui chamado n.
  • A operação pedida é o fatorial: produto dos inteiros positivos até n.
  • É obrigatório usar um laço while.
  • Exemplo: fatorial(5) 120.
Observação que vou assumir (pois o enunciado não trata casos raros): n é um inteiro não-negativo ( n \in \{0,1,2,\dots\}).

Passo 2

O que é fatorial? Definição e regra básica:
  • Para todo inteiro n \ge 1,
n! = n \times (n-1) \times (n-2) \times \cdots \times 2 \times 1.
  • Por convenção, o fatorial de zero é
0! = 1.
Explicação intuitiva: o fatorial é um produto acumulado. Se eu quero 5!, multiplico 5 por 4, depois por 3, e assim por diante até 1. Para 0 não há nenhum número para multiplicar, então adotamos 0! = 1 para manter propriedades combinatórias e algébricas consistentes.

Passo 3

Estratégia para implementar com while (sem resolver ainda): vamos manter uma variável que guarda o produto acumulado (vou chamar de resultado) e um contador que percorre os multiplicadores. Cada iteração do while multiplica resultado pelo valor atual do contador e depois atualiza o contador até que a condição de término seja atingida. Essa é uma abordagem iterativa direta e fácil de executar na prova sem complicação.

Passo 4

Escolha do sentido do laço e inicializações (detalhe prático): duas opções comuns
  • Decrementar: começar com um contador i = n e enquanto i>1 fazer resultado = resultado * i e i = i - 1.
  • Incrementar: começar com i = 1 e enquanto i \le n fazer resultado = resultado * i e i = i + 1.
Vou usar a opção de decrementar (contador começando em n) porque é ligeiramente mais intuitiva aqui: não precisamos testar i <= n (já inicializado) e o laço termina quando chegamos a 1.

Passo 5

Explicação passo a passo das variáveis que usaremos:
  • n é o parâmetro de entrada, o inteiro cujo fatorial queremos.
  • resultado armazena o produto acumulado; inicializamos com 1 porque 1 é o elemento neutro da multiplicação (multiplicar por 1 não altera o produto).
  • i será o contador que começa em n e vai decrescendo até 1.
Fluxo do algoritmo:
  1. Se desejarmos, validar que n é inteiro e n >= 0 (opcional, mas recomendado).
  2. Inicializar resultado = 1.
  3. Inicializar i = n.
  4. Enquanto i > 1, fazer:
    • resultado = resultado * i
    • i = i - 1
  5. Quando o laço terminar, resultado contém n!. Retornar resultado.

Passo 6

Vou demonstrar com o exemplo n=5 (passo a passo das iterações). Inicialmente:
  • resultado = 1, i = 5.
Iterações (cada linha mostra o par \text{(i, resultado)} depois de executar o corpo do laço naquela iteração):
  • Iteração 1: antes: (i,resultado)=(5,1). Executa resultado *= 5resultado = 5. Depois i -= 1i = 4. Agora (4,5).
  • Iteração 2: antes: (4,5). resultado *= 4resultado = 20. i = 3. Agora (3,20).
  • Iteração 3: antes: (3,20). resultado *= 3resultado = 60. i = 2. Agora (2,60).
  • Iteração 4: antes: (2,60). resultado *= 2resultado = 120. i = 1. Agora (1,120).
  • O laço para porque i > 1 já não é verdade. Retornamos resultado = 120.
Portanto, para n=5 o algoritmo devolve 120, como exigido.

Passo 7

Complexidade e cuidados rápidos (útil na prova):
  • Tempo: a rotina faz aproximadamente n-1 multiplicações para n\ge1, então é O(n).
  • Memória: usa um número fixo de variáveis auxiliares, então é O(1).
  • Casos especiais: se n=0 o código acima retorna 1 corretamente. Se n for negativo ou não inteiro, o fatorial clássico não está definido; numa implementação prática devemos tratar isso (lançar erro ou converter explicitamente), mas como o enunciado pressupõe um n apropriado, manteremos a exigência de inteiro não-negativo.

Passo 8

Código final da função em Python (usa while e segue exatamente a lógica acima):
def fatorial(n):
if not isinstance(n, int):
raise TypeError(“n deve ser inteiro”)
if n < 0:
raise ValueError(“n deve ser não-negativo”)
resultado = 1
i = n
while i > 1:
resultado *= i
i -= 1
return resultado

Resposta

def fatorial(n):
if not isinstance(n, int):
raise TypeError(“n deve ser inteiro”)
if n < 0:
raise ValueError(“n deve ser não-negativo”)
resultado = 1
i = n
while i > 1:
resultado *= i
i -= 1
return resultado

Exercícios relacionados