Escreva um script que calcule e mostre uma quantidade de números da sequência de Fibonacci escolhida pelo usuário. Cada número da sequencia de Fibonacci é igual a soma dos dois últimos números da sequencia. O primeiro e o segundo números da sequência são 0 e 1 (logo, o terceiro é 0+1=1, o quarto é 1+1=2 e assim por diante).

Passo 1

O que o enunciado pede e as informações que temos:
  • O objetivo é escrever um script que calcule e mostre uma quantidade de números da sequência de Fibonacci escolhida pelo usuário.
  • O usuário fornece um número inteiro n que representa quantos termos da sequência devem ser mostrados.
  • A sequência de Fibonacci é definida pelas regras:
    • O primeiro termo é F_1 = 0.
    • O segundo termo é F_2 = 1.
    • Para n \ge 3, vale a recursão F_n = F_{n-1} + F_{n-2}.
  • Casos especiais que precisamos tratar:
    • Se n = 0: não se mostra nenhum número.
    • Se n = 1: mostra apenas 0.
    • Se n = 2: mostra 0 e 1.
    • Entrada inválida (não inteiro ou inteiro negativo): devemos avisar o usuário.
  • Requisitos práticos (implícitos):
    • O script deve pedir a quantidade ao usuário (interação).
    • O script deve ser simples de entender e eficiente para uso em prova/estudo.

Passo 2

Ideia do método que vamos usar (explicação didática passo a passo):
  • Método escolhido: iteração com duas variáveis que guardam os dois últimos termos. Esse é o método mais simples e eficiente para fazer na mão ou em prova.
  • Conceito central: em cada passo mantém-se duas variáveis, por exemplo a e b, tais que a é o termo atual e b é o próximo termo. Começamos com a=0 e b=1. Depois de mostrar a, atualizamos: (a,b) \leftarrow (b,\, a+b).Isso reproduz exatamente a recursão F_n = F_{n-1} + F_{n-2} porque, se no início de uma iteração a = F_k e b = F_{k+1}, então após a atribuição teremos a = F_{k+1} e b = F_k + F_{k+1} = F_{k+2}.
  • Exemplo manual para entender o processo (mostrando estado (a,b) antes de imprimir):
    • Inicial: (a,b)=(0,1). Imprime a=0. Atualiza para (1,1).
    • Próxima: (a,b)=(1,1). Imprime a=1. Atualiza para (1,2).
    • Próxima: (a,b)=(1,2). Imprime a=1. Atualiza para (2,3).
    • E assim por diante.
  • Vantagens desse método:
    • Complexidade de tempo: \mathcal{O}(n) — faz um passo por termo.
    • Memória: \mathcal{O}(1) se apenas imprimimos à medida que geramos (não guardamos toda a sequência).
    • Evita a explosão de chamadas recursivas de uma implementação recursiva simples (que seria exponencial sem memoização).

Passo 3

Decisões de implementação e tratamento de entradas (explicação do que cada peça fará):
  • Ler entrada do usuário com uma função que retorna string e converter para inteiro com verificação de erros (em Python: usar try/except para capturar valores que não são inteiros).
  • Validar se o inteiro é não-negativo: aceitar n \ge 0; para n < 0 mostrar mensagem de erro.
  • Mostrar os termos separados por espaços (ou uma por linha) — aqui mostramos separados por espaço para ficar compacto.
  • Implementação em Python 3 porque é curta, clara e comum em provas/listas de programação.
  • Comentário sobre limites: Python usa inteiros de precisão arbitrária, então para valores grandes de n os números ficam grandes mas o código ainda funciona (apenas fica mais lento por causa do tamanho dos inteiros).

Passo 4

Explicação linha a linha do script (antes de ver o script em si):
  • Leitura:
    • Usar input() para pedir ao usuário a quantidade; input() retorna texto, então convertemos com int(...).
    • Colocar essa conversão dentro de um try para capturar exceções quando o usuário digitar algo como "dez" ou 3,5.
  • Validação:
    • Verificar n < 0. Se for negativo, imprimir mensagem de erro e encerrar.
  • Geração:
    • Inicializar a = 0 e b = 1.
    • Fazer um laço for i in range(n):
      • Em cada iteração imprimir a (o termo atual).
      • Atualizar a, b = b, a + b para avançar ao próximo par.
  • Saída:
    • Imprimir os termos separados por espaços e terminar com uma nova linha ao final.
  • Porque usar for i in range(n):
    • range(n) itera exatamente n vezes, o que corresponde a gerar os n primeiros termos F_1, F_2, \dots, F_n conforme o enunciado.

Passo 5

Script final comentado (em palavras rápidas sobre cada bloco) e exemplo de execução:
  • O script abaixo pede ao usuário a quantidade, valida e imprime os primeiros n termos.
  • Exemplo de execução (usuário digita 8):
    • Saída: 0 1 1 2 3 5 8 13
  • Observação final: na prova, se pedirem “escreva um script”, essa versão clara e comentada costuma ser aceita. Se quiser apenas a lógica, bastaria descrever a inicialização a=0,b=1 e a atribuição iterativa (a,b)\leftarrow(b,a+b) repetida n vezes.

Resposta

#!/usr/bin/env python3

def fibonacci_print(n):
    """
    Imprime os primeiros n termos da sequência de Fibonacci,
    separados por espaço. Para n = 0 nada é impresso.
    """
    a, b = 0, 1
    for i in range(n):
        # imprime o termo atual; no final evita espaço extra
        end_char = ' ' if i != n - 1 else '\n'
        print(a, end=end_char)
        a, b = b, a + b

def main():
    try:
        s = input("Digite a quantidade de números da sequência de Fibonacci: ")
        n = int(s)
        if n < 0:
            print("Erro: insira um número inteiro não-negativo.")
            return
    except Exception:
        print("Erro: insira um número inteiro válido.")
        return

    fibonacci_print(n)

if __name__ == "__main__":
    main()

Exercícios relacionados