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 n é definido como:
n! = n \cdot (n-1) \cdot (n-2) \cdots 2 \cdot 1
com a convenção especial
0! = 1.
Também existe a definição recursiva (útil para entender):
n! = n \cdot (n-1)!\quad\text{para }n\ge 1.
Condições importantes:
  • O domínio natural do fatorial é o conjunto dos inteiros não negativos 0,1,2,\dots.
  • 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 n! = n\cdot (n-1)!, 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é n) é 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 a 1 e multiplicar por cada inteiro de 1 até n.

Passo 4

Algoritmo detalhado (pseudocódigo):
  1. Entrar num laço infinito (ou laço controlado por uma condição) para permitir múltiplos cálculos.
  2. Pedir ao usuário que digite um número.
  3. 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.
  4. Calcular o fatorial de n por iteração:
    • Iniciar resultado \leftarrow 1.
    • Para i de 1 até n: resultado \leftarrow resultado \times i.
  5. Mostrar o resultado ao usuário (ex.: “5! = 120”).
  6. 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 5!.
  • Começamos com resultado = 1.
  • Multiplicamos sucessivamente:
    • após i=1: resultado = 1 \times 1 = 1
    • após i=2: resultado = 1 \times 2 = 2
    • após i=3: resultado = 2 \times 3 = 6
    • após i=4: resultado = 6 \times 4 = 24
    • após i=5: resultado = 24 \times 5 = 120
      Logo,
5! = 120.

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 0 a regra retorna 0! = 1 (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 1 até n multiplicando, mostrando a correspondência direta com a definição de n!.
  • 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()

Exercícios relacionados