Eu originalmente codifiquei o programa de maneira errada. Em vez de retornar os números de Fibonacci entre um intervalo (por exemplo, startNumber 1, endNumber 20 deve = apenas aqueles números entre 1 e 20), escrevi para o programa exibir todos os números de Fibonacci entre um intervalo (por exemplo, startNumber 1, endNumber 20 exibe = 20 primeiros números de Fibonacci). Eu pensei que tinha um código infalível. Também não vejo por que isso está acontecendo.
startNumber = int(raw_input("Enter the start number here "))
endNumber = int(raw_input("Enter the end number here "))
def fib(n):
if n < 2:
return n
return fib(n-2) + fib(n-1)
print map(fib, range(startNumber, endNumber))
Alguém apontou na minha Parte II (que foi fechada por ser uma duplicata - /programming/504193/how-to-write-the-fibonacci-sequence-in-python-part-ii ) que eu precisa passar o startNumber e endNumber através de um gerador usando um loop while. Alguém pode me indicar a direção de como fazer isso? Qualquer ajuda é bem vinda.
Sou um programador de aprendizado e me deparei com um pouco de confusão. Foi-me pedido que escrevesse um programa que computasse e exibisse a Sequência de Fibonacci por um número inicial e número final introduzidos pelo usuário (ou seja, startNumber = 20 endNumber = 100 e exibirá apenas os números entre esse intervalo). O truque é usá-lo inclusivamente (o que eu não sei fazer em Python? - Estou assumindo que isso significa usar um intervalo inclusivo?).
O que tenho até agora não é uma codificação real, mas sim:
- Escreva a fórmula da sequência Fib para infinito
- Exiba startNumber para endNumber apenas da sequência Fib.
Não tenho idéia por onde começar e estou pedindo idéias ou insights sobre como escrever isso. Eu também tentei escrever o fórum da sequência Fib, mas também me perco nisso.
int(((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5)))
, alguma idéia? @AndreaAmbun
está acima de 70 e explode com umOverflowError
quandon
está um pouco acima de 600. Outras abordagens podem lidar com uman
de 1000 ou mais sem soprar aumentando ou perdendo a precisão.Gerador Python eficiente da sequência de Fibonacci
Encontrei essa pergunta ao tentar obter a geração Pythonic mais curta dessa sequência (depois percebendo que havia visto uma semelhante em uma Proposta de aprimoramento do Python ) e não notei mais ninguém surgindo com minha solução específica (embora a resposta principal fica perto, mas ainda menos elegante), então aqui está, com comentários descrevendo a primeira iteração, porque acho que isso pode ajudar os leitores a entender:
e uso:
impressões:
(Para fins de atribuição, observei recentemente uma implementação semelhante na documentação do Python sobre módulos, mesmo usando as variáveis
a
eb
, que agora me lembro de ter visto antes de escrever esta resposta. Mas acho que essa resposta demonstra melhor uso da linguagem.)Implementação definida recursivamente
A Enciclopédia Online de Sequências Inteiras define a Sequência de Fibonacci recursivamente como
Definir sucintamente isso recursivamente em Python pode ser feito da seguinte maneira:
Mas essa representação exata da definição matemática é incrivelmente ineficiente para números muito maiores que 30, porque cada número calculado também deve ser calculado para cada número abaixo dela. Você pode demonstrar como é lento usando o seguinte:
Recursão memorizada para eficiência
Ele pode ser memorizado para melhorar a velocidade (este exemplo aproveita o fato de que um argumento de palavra-chave padrão é o mesmo objeto toda vez que a função é chamada, mas normalmente você não usaria um argumento padrão mutável exatamente por esse motivo):
Você verá que a versão memorizada é muito mais rápida e rapidamente excederá sua profundidade máxima de recursão antes que você possa pensar em se levantar para tomar um café. Você pode ver o quanto mais rápido é visualmente, fazendo o seguinte:
(Pode parecer que podemos fazer o que está abaixo, mas na verdade não nos permite tirar proveito do cache, porque ele se chama antes que o setdefault seja chamado.)
Gerador definido recursivamente:
Enquanto eu aprendia Haskell, me deparei com essa implementação em Haskell:
O mais próximo que eu acho que posso chegar disso em Python no momento é:
Isso demonstra:
Só pode ir até o limite de recursão. Geralmente, 1000, enquanto a versão Haskell pode chegar a centenas de milhões, embora use todos os 8 GB de memória do meu laptop para fazer isso:
Consumindo o iterador para obter o enésimo número de fibonacci
Um comentarista pergunta:
A documentação do itertools tem uma receita para isso:
e agora:
fonte
setdefault
chamada é avaliada antes desetdefault
.Por que não simplesmente fazer o seguinte?
fonte
A ideia por trás da sequência de Fibonacci é mostrada no seguinte código Python:
Isso significa que fib é uma função que pode fazer uma de três coisas. Ele define fib (1) == 1, fib (0) == 0 e fib (n) como:
fib (n-1) + fib (n-2)
Onde n é um número inteiro arbitrário. Isso significa que fib (2), por exemplo, se expande para a seguinte aritmética:
Podemos calcular fib (3) da mesma maneira com a aritmética mostrada abaixo:
O importante a entender aqui é que fib (3) não pode ser calculado sem o cálculo de fib (2), que é calculado conhecendo as definições de fib (1) e fib (0). Ter uma chamada de função em si, como a função fibonacci, é chamada recursão, e é um tópico importante na programação.
Parece uma tarefa de casa, então não vou fazer a parte inicial / final para você. O Python é uma linguagem maravilhosamente expressiva para isso, portanto, isso deve fazer sentido se você entender matemática e, esperançosamente, ensinar sobre recursão. Boa sorte!
Edit: Uma crítica em potencial ao meu código é que ele não usa o super útil rendimento da função Python, o que torna a função fib (n) muito mais curta. No entanto, meu exemplo é um pouco mais genérico, já que muitas linguagens fora do Python realmente produzem.
fonte
Complexidade do tempo:
O recurso de armazenamento em cache reduz a maneira normal de calcular a série Fibonacci de O (2 ^ n) para O (n) , eliminando as repetições na árvore recursiva da série Fibonacci:
Código:
fonte
Isso é bastante eficiente, usando operações aritméticas básicas O (log n).
Este usa operações aritméticas básicas O (1), mas o tamanho dos resultados intermediários é grande e, portanto, não é de todo eficiente.
Este calcula X ^ n no anel polinomial Z [X] / (X ^ 2 - X - 1) usando exponenciação por quadratura. O resultado desse cálculo é o polinômio Fib (n) X + Fib (n-1), a partir do qual o enésimo número de Fibonacci pode ser lido.
Novamente, isso usa operações aritméticas O (log n) e é muito eficiente.
fonte
n -= 1
funcionar corretamente e também não funcionan = 0
. De qualquer forma, realmente me ajudaria se um monte de contexto fosse adicionado para explicar como eles estão funcionando, especialmente a primeira técnica. Vejo que você tem um post em paulhankin.github.io/FibonacciCódigo Python canônico para imprimir a sequência de Fibonacci:
Para o problema "Imprima o primeiro número de Fibonacci com mais de 1000 dígitos":
fonte
Nós sabemos isso
E que o n-ésimo poder dessa matriz nos dá:
Portanto, podemos implementar uma função que simplesmente calcula a potência dessa matriz com a potência n-ésima -1.
como todos sabemos o poder a ^ n é igual a
Portanto, no final, a função fibonacci seria O (n) ... nada realmente diferente de uma implementação mais fácil se não fosse pelo fato de também sabermos isso
x^n * x^n = x^2n
e a avaliação de,x^n
portanto, poder ser feita com complexidade O (log n )Aqui está minha implementação de fibonacci usando linguagem de programação rápida:
Isso tem complexidade O (log n). Calculamos a potência de Q com o expoente n-1 e, em seguida, pegamos o elemento m00, que é Fn + 1, que no expoente de potência n-1 é exatamente o n-ésimo número de Fibonacci que desejávamos.
Depois de ter a função rápida de fibonacci, você pode iterar do número inicial e final para obter a parte da sequência de Fibonacci em que está interessado.
é claro que primeiro faça uma verificação no início e no fim para garantir que eles possam formar um intervalo válido.
Eu sei que a pergunta tem 8 anos, mas me diverti respondendo de qualquer maneira. :)
fonte
Sequência de Fibonacci é:
1, 1, 2, 3, 5, 8, ...
.Isto é
f(1) = 1
,f(2) = 1
,f(3) = 2
,...
,f(n) = f(n-1) + f(n-2)
.Minha implementação favorita (mais simples e, no entanto, atinge uma velocidade leve em comparação com outras implementações) é a seguinte:
Teste
Cronometragem
Editar: um exemplo de visualização para essas implementações.
fonte
use recursão:
fonte
Outra maneira de fazer isso:
Atribuir lista a 'a', atribuir número inteiro a 'n' Map e reduzir são duas das três funções mais poderosas em python. Aqui, o mapa é usado apenas para iterar 'n-2' vezes. a [-2:] obterá os dois últimos elementos de uma matriz. a.append (x + y) adicionará os dois últimos elementos e será anexado à matriz
fonte
Todos eles parecem um pouco mais complicados do que precisam. Meu código é muito simples e rápido:
fonte
OK .. depois de se cansar de se referir a todas as respostas longas, agora encontre o tipo abaixo e o caminho bastante simples para implementar Fibonacci em python. Você pode aprimorá-lo da maneira que desejar, obtendo um argumento ou recebendo informações do usuário ... ou altere os limites de 10000. Conforme necessário ...
Essa abordagem também funciona bem. Encontre a análise de execução abaixo
fonte
Esta é uma melhoria na resposta de Matthew Henry:
o código deve imprimir b em vez de imprimir c
Saída: 1,1,2,3,5 ....
fonte
Usando for loop e imprimir apenas o resultado
Resultado
Imprimir o
list
contendo todos os númerosResultado
fonte
Resultados
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368 R $ 1.200,00 (Bruto mensal) .Período Integral: R $ 2.000,00 (Bruto mensal) .Período Integral: R $ 2.000,00 (Bruto mensal) .Período Integral. , 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781975515575573755751557557575757575757575757575757575757565756575657565757756756756756756756756756756756756756755 em
tempo de execução: 0.04298138618469238
fonte
existe um método muito fácil de perceber isso!
você pode executar esse código on-line livremente usando http://www.learnpython.org/
fonte
Isso pode ser feito da seguinte maneira.
fonte
Apenas por diversão, no Python 3.8+ você pode usar uma expressão de atribuição (também conhecida como operador morsa) em uma compreensão de lista, por exemplo:
Uma expressão de atribuição permite atribuir um valor a uma variável e retorná-lo na mesma expressão. Portanto, a expressão
é equivalente a executar
e retornando o valor de
b
.fonte
Após 15 minutos de um tutorial que usei ao aprender Python, ele solicitou ao leitor que escrevesse um programa que calculasse uma sequência de Fibonacci a partir de 3 números de entrada (primeiro número de Fibonacci, segundo número e número no qual interromper a sequência). O tutorial cobriu apenas variáveis, se / então e loops até esse ponto. Ainda não há funções. Eu vim com o seguinte código:
Como você pode ver, é realmente ineficiente, mas funciona.
fonte
fonte
eval(input())
não é necessário aqui; Eu acho queint(input())
no caso é melhor.Apenas passando por http://projecteuler.net/problem=2, essa foi minha opinião
fonte
fonte
Talvez isso ajude
fonte
baseado na sequência clássica de fibonacci e apenas por uma questão de uma linha
se você precisar apenas do número do índice, poderá usar o reduzir (mesmo que reduzir não seja mais adequado para isso, pode ser um bom exercício)
e para obter a matriz completa, basta remover o ou (r.pop (0) e 0)
fonte
Que tal este? Eu acho que não é tão chique quanto as outras sugestões, porque exige a especificação inicial do resultado anterior para produzir a saída esperada, mas eu sinto que é uma opção muito legível, ou seja, tudo o que faz é fornecer o resultado e o resultado anterior para a recursão.
Aqui está a saída:
fonte
Traduzido basicamente de Ruby:
...
fonte
fonte
Uma explicação mais detalhada de como funciona a memorização para a sequência de Fibonacci.
fonte
Eu estava tentando evitar uma função recursiva para resolver esse problema, então tomei uma abordagem iterativa. Eu estava originalmente fazendo uma função recursiva memorizada, mas continuava atingindo a profundidade recursiva máxima. Eu também tinha objetivos rígidos de memória, para que você me veja mantendo o array o menor possível durante o processo de loop, mantendo apenas 2-3 valores no array a qualquer momento.
Obter o sexto milionésimo número de fibonacci leva cerca de 282 segundos na minha máquina, enquanto o 600k fibonacci leva apenas 2,8 segundos. Não consegui obter números tão grandes de fibonacci com uma função recursiva, mesmo memorizada.
fonte