Elaborar um programa Python para calcular o fatorial de um número. Porém somente termine o programa quando o usuário não desejar calcular o fatorial para outros números.
Passo 1
O enunciado pede que a gente elabore um programa em Python que calcule o fatorial de um número e que só termine (ou seja, que só pare de pedir números) quando o usuário disser que não deseja calcular o fatorial para outros números. Informações importantes dadas pelo enunciado:
- Precisamos calcular o fatorial de um número fornecido pelo usuário.
- O programa deve ficar em loop, permitindo calcular vários fatoriais, e só deve encerrar quando o usuário indicar que não quer calcular mais.
- Não foi dada restrição explícita sobre formato de entrada, então devemos tratar entradas inválidas (texto, números negativos, etc.) de forma amigável.
Passo 2
Vamos entender o que é fatorial para sabermos exatamente o que o programa deve calcular. O fatorial de um número inteiro não negativo
é definido como:
com a convenção especial
Também existe a definição recursiva (útil para entender):
Condições importantes:
- O domínio natural do fatorial é o conjunto dos inteiros não negativos
. - Se o usuário der um número negativo ou um texto que não represente inteiro, o programa deve avisar e pedir outra entrada.
Passo 3
Escolha do método de cálculo: iteração ou recursão?
- A recursão usa diretamente a relação
, mas para valores grandes pode causar excesso de chamadas recursivas e não é necessário aqui. - A iteração (multiplicar em um laço de 1 até
) é simples de implementar, eficiente e fácil de explicar no contexto de prova/uso sem bibliotecas.
Portanto, usaremos um cálculo iterativo do fatorial: começar com um acumulador igual ae multiplicar por cada inteiro de até .
Passo 4
Algoritmo detalhado (pseudocódigo):
- Entrar num laço infinito (ou laço controlado por uma condição) para permitir múltiplos cálculos.
- Pedir ao usuário que digite um número.
- Tentar converter a entrada para inteiro.
- Se não for possível (ValueError), mostrar mensagem de erro e voltar ao passo 2.
- Se for inteiro e for negativo, mostrar mensagem de erro e voltar ao passo 2.
- Calcular o fatorial de
por iteração: - Iniciar
. - Para
de até : .
- Iniciar
- Mostrar o resultado ao usuário (ex.: “5! = 120”).
- Perguntar ao usuário se deseja calcular outro fatorial (por exemplo, "Deseja calcular outro? (s/n): ").
- Se a resposta for negativa (começando com ‘n’ ou ‘N’), sair do laço e encerrar o programa.
- Se for afirmativa (começando com ‘s’ ou ‘S’), voltar ao passo 2.
- Para respostas ambíguas, perguntar novamente (ou interpretar por primeiro caractere).
Passo 5
Exemplo concreto de cálculo (para aprender a aplicar na prova):
Queremos calcular .
Queremos calcular
- Começamos com
. - Multiplicamos sucessivamente:
- após
: - após
: - após
: - após
: - após
:
Logo,
- após
Passo 6
Tratamento de entradas inválidas e casos extremos — o que dizer na prova:
- Se o usuário digitar algo que não é inteiro (ex.: “3.5”, “abc”), convertemos com int() dentro de um bloco try/except e avisamos do erro.
- Se o usuário digitar um inteiro negativo, avisamos que fatorial não é definido para negativos neste programa e pedimos novamente.
- Para
a regra retorna (tratar esse caso naturalmente no laço iterativo). - Para números muito grandes, o resultado cresce rápido; Python lida com inteiros grandes, mas o tempo de cálculo e o tamanho do número podem ser grandes. Em prova, se pedirem otimização, mencionar uso de memoização ou biblioteca math.factorial, mas aqui usaremos implementação manual simples.
Passo 7
Agora vamos traduzir o algoritmo para Python e explicar linha a linha (explicação didática das partes principais):
- Estrutura de repetição principal: usamos “while True:” para ficar pedindo números até o usuário decidir parar.
- Leitura da entrada: usamos input(…).strip() para remover espaços.
- Validação: tentamos converter com int(entrada). Se der erro, avisamos e continuamos o laço (continue).
- Cálculo do fatorial: inicializamos resultado = 1 e usamos “for i in range(1, n+1): resultado *= i”.
- Pergunta de continuação: pedimos "Deseja calcular outro fatorial? (s/n): " e verificamos a primeira letra em minúsculo; se for ‘n’ saímos com break; se for ‘s’ o laço continua; para qualquer outra entrada, pedimos novamente (ou assumimos continuar).
- Mensagens amigáveis para o usuário e tratamento de casos especiais (0!, negativos, entradas inválidas).
Passo 8
Dicas rápidas para a prova (como justificar suas escolhas):
- Explique que o algoritmo itera de
até multiplicando, mostrando a correspondência direta com a definição de . - Justifique validação de entrada: fatorial só definido aqui para inteiros não negativos; tratar exceções evita crash do programa.
- Mencione alternativas: recursão (mesma definição matemática) ou usar math.factorial para implementação pronta.
Resposta
# Programa interativo para calcular fatorial repetidamente até o usuário sair
def calcular_fatorial(n):
"""Calcula o fatorial de n (n inteiro >= 0) de forma iterativa."""
resultado = 1
for i in range(1, n + 1):
resultado *= i
return resultado
def pedir_inteiro_nao_negativo(prompt):
"""Pede ao usuário um inteiro não negativo; repete até receber um válido."""
while True:
entrada = input(prompt).strip()
try:
n = int(entrada)
if n < 0:
print("Por favor, digite um inteiro não negativo (0, 1, 2, ...).")
continue
return n
except ValueError:
print("Entrada inválida. Digite um número inteiro não negativo.")
def deseja_continuar(prompt):
"""Pergunta ao usuário se deseja continuar; retorna True para sim, False para não."""
while True:
resp = input(prompt).strip().lower()
if resp == '':
print("Resposta vazia. Digite 's' para sim ou 'n' para não.")
continue
primeira = resp[0]
if primeira == 's':
return True
if primeira == 'n':
return False
print("Resposta não entendida. Digite 's' para sim ou 'n' para não.")
def main():
print("Calculadora de fatorial (inteiros não negativos).")
while True:
n = pedir_inteiro_nao_negativo("Digite um inteiro não negativo para calcular o fatorial: ")
f = calcular_fatorial(n)
print(f"{n}! = {f}")
if not deseja_continuar("Deseja calcular outro fatorial? (s/n): "):
print("Programa encerrado. Até mais!")
break
if __name__ == "__main__":
main()