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 é
, o quarto é
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
que representa quantos termos da sequência devem ser mostrados. - A sequência de Fibonacci é definida pelas regras:
- O primeiro termo é
. - O segundo termo é
. - Para
, vale a recursão .
- O primeiro termo é
- Casos especiais que precisamos tratar:
- Se
: não se mostra nenhum número. - Se
: mostra apenas . - Se
: mostra e . - Entrada inválida (não inteiro ou inteiro negativo): devemos avisar o usuário.
- Se
- 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
e , tais que é o termo atual e é o próximo termo. Começamos com e . Depois de mostrar , atualizamos: Isso reproduz exatamente a recursão porque, se no início de uma iteração e , então após a atribuição teremos e . - Exemplo manual para entender o processo (mostrando estado
antes de imprimir): - Inicial:
. Imprime . Atualiza para . - Próxima:
. Imprime . Atualiza para . - Próxima:
. Imprime . Atualiza para . - E assim por diante.
- Inicial:
- Vantagens desse método:
- Complexidade de tempo:
— faz um passo por termo. - Memória:
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).
- Complexidade de tempo:
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
; para 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
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 comint(...). - Colocar essa conversão dentro de um
trypara capturar exceções quando o usuário digitar algo como"dez"ou3,5.
- Usar
- Validação:
- Verificar
n < 0. Se for negativo, imprimir mensagem de erro e encerrar.
- Verificar
- Geração:
- Inicializar
a = 0eb = 1. - Fazer um laço
for i in range(n):- Em cada iteração imprimir
a(o termo atual). - Atualizar
a, b = b, a + bpara avançar ao próximo par.
- Em cada iteração imprimir
- Inicializar
- 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 exatamentevezes, o que corresponde a gerar os primeiros termos 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
termos. - Exemplo de execução (usuário digita
8):- Saída:
0 1 1 2 3 5 8 13
- Saída:
- 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
e a atribuição iterativa repetida 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()