フィボナッチ数列を書くには？
私はもともとそのプログラムを間違ってコーディングしていました。範囲内のフィボナッチ数を返すのではなく（つまりstartNumber 1、endNumber 20 = 1と20の間の数のみ）、範囲内のすべてのフィボナッチ数（つまりstartNumber 1、endNumber 20）を表示するようにプログラムを記述しました。表示=最初の20フィボナッチ数）私は確実なコードを持っていると思った。私はまたなぜこれが起こっているのかわかりません。
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))
誰かが私の第二部で指摘した（それは重複しているため閉鎖されていた - https://stackoverflow.com/questions/504193/how-to-write-the-fibonacci-sequence-in-python-part- ii ）whileループを使ってジェネレータを通してstartNumberとendNumberを渡す必要があること。誰かがこれを行う方法についての方向性を教えてください。どんな助けでも大歓迎です。
私は学習プログラマーですが、ちょっとごちゃごちゃしています。ユーザーが開始番号と終了番号を入力してフィボナッチ数列を計算して表示するプログラムを書くように頼まれました（すなわち、startNumber = 20 endNumber = 100そしてそれはその範囲内の数だけを表示します）。トリックはそれを包括的に使用することです（私はPythonでのやり方がわかりませんか？ - これは包括的範囲を使用することを意味していると思いますか？）。
私がこれまでに持っているのは実際のコーディングではなく、むしろ：
- Fibシーケンス式を無限大に書く
- FibシーケンスからのみstartNumberからendNumberまでを表示します。
どこから始めればよいのか私にはわからないので、これを書く方法についてアイデアや洞察を求めています。私はまたFibシーケンスforumlaを書き込もうとしましたが、私はそれについても迷子になります。
フィボナッチ数列についての情報は wikipedia と wolfram にたくさんあります。あなたが必要としているよりももっとたくさん。とにかく、あなたが必要なものを（可能ならばすぐに）見つけるためにこれらのリソースを使用する方法を学ぶことは良いことです。
Fibシーケンス式を無限大に書く
数学では、それは再帰的な形で与えられます：
プログラミングでは、無限は存在しません。あなたは自分の言語で直接数学の形式を翻訳する再帰的な形式を使うことができます。例えば、Pythonではそれは次のようになります。
def F(n):
if n == 0: return 0
Elif n == 1: return 1
else: return F(n-1)+F(n-2)
好きな言語で試してみて、nが大きくなるにつれて、この形式では多くの時間が必要になることを確認してください。実際、これはO（2n）やがて。
私があなたにリンクしているサイトに進むと、これが表示されます（on wolfram ）：
これは、Pythonでは非常に実装が簡単で、計算も非常に高速です。
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
それをする他の方法は定義に従うことです（ wikipedia から）：
シーケンスの最初の番号は0、2番目の番号は1、それ以降の各番号はシーケンス自体の前の2つの番号の合計に等しく、シーケンス0、1、1、2、3、5、8が得られます。など.
あなたの言語がイテレータをサポートしているなら、あなたは以下のようなことをするかもしれません：
def F():
a,b = 0,1
while True:
yield a
a, b = b, a + b
FibシーケンスからのみstartNumberからendNumberまでを表示します。
フィボナッチ数を生成する方法を知ったら、あなたは数をたどって循環し、彼らが与えられた条件を確かめるかどうかをチェックしなければなりません。
今、フィボナッチ数列のn番目の項を返すf(n)を書いたとしましょう（sqrt（5）のように）。
ほとんどの言語では、次のようなことができます。
def SubFib(startNumber, endNumber):
n = 0
cur = f(n)
while cur <= endNumber:
if startNumber <= cur:
print cur
n += 1
cur = f(n)
Pythonでは、私はイテレータフォームを使用して行きます：
def SubFib(startNumber, endNumber):
for cur in F():
if cur > endNumber: return
if cur >= startNumber:
yield cur
for i in SubFib(10, 200):
print i
私のヒントはあなたが必要なものを読むことを学ぶことです。 Project Euler（グーグル）がそうするようにあなたを訓練するでしょう：P頑張って楽しんでください！
フィボナッチ数列の効率的なPythonicジェネレータ
私はこのシーケンスの最短のPythonic世代を手に入れようとしている間にこの質問を見つけました（後で私は Python Enhancement Proposal に似たものを見たことに気づきました）。具体的な解決策（一番上の答えは近づくがそれほどエレガントではないが）、ここでは最初の反復を説明するコメントを付けている。読者が理解するのに役立つかもしれないので。
def fib():
a, b = 0, 1
while True: # First iteration:
yield a # yield 0 to start with and then
a, b = b, a + b # a will now be 1, and b will also be 1, (0 + 1)
と使用法：
for index, fibonacci_number in Zip(range(10), fib()):
print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number))
プリント：
0: 0
1: 1
2: 1
3: 2
4: 3
5: 5
6: 8
7: 13
8: 21
9: 34
10: 55
（帰属の目的で、私は最近モジュールのPythonドキュメントで 同じような実装 に気づいた、たとえ変数aとbを使っても、私はこの答えを書く前に見たことがある。言語のよりよい用法。）
再帰的に定義された実装
オンライン百科事典整数シーケンス は、フィボナッチ数列を再帰的に次のように定義します。
F [n] = F(n-1) + F(n-2) F(0) = 0およびF(1) = 1
Pythonでこれを再帰的に定義することは、次のようにして行うことができます。
def rec_fib(n):
'''inefficient recursive function as defined, returns Fibonacci number'''
if n > 1:
return rec_fib(n-1) + rec_fib(n-2)
return n
しかし、数学的定義のこの正確な表現は、計算される各数がそれより下のすべての数に対しても計算されなければならないため、30を超える数には非常に非効率的です。以下を使用して、それがどのくらい遅いかを示すことができます。
for i in range(40):
print(i, rec_fib(i))
効率化のための記憶再帰
速度を向上させるためにメモすることができます（この例では、関数が呼び出されるたびにデフォルトのキーワード引数が同じオブジェクトであるという事実を利用していますが、通常はこの理由で可変のデフォルト引数を使用しません）。
def mem_fib(n, _cache={}):
'''efficiently memoized recursive function, returns a Fibonacci number'''
if n in _cache:
return _cache[n]
Elif n > 1:
return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
return n
あなたは覚えられているバージョンがはるかに速いとわかります、そしてあなたがコーヒーのために起きることさえ考えることができる前にすぐにあなたの最大再帰深さを超えるでしょう。これを行うことで、視覚的にどれほど速いのかを見ることができます。
for i in range(40):
print(i, mem_fib(i))
（以下のようにしても構いませんが、setdefaultが呼び出される前に自分自身を呼び出すため、実際にはキャッシュを利用できません。）
def mem_fib(n, _cache={}):
'''don't do this'''
if n > 1:
return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
return n
再帰的に定義されたジェネレータ
私はHaskellを学んできたので、Haskellでこの実装に遭遇しました。
fib@(0:tfib) = 0:1: zipWith (+) fib tfib
現時点でPythonでこれに到達できると最も近いと思います。
from itertools import tee
def fib():
yield 0
yield 1
# tee required, else with two fib()'s algorithm becomes quadratic
f, tf = tee(fib())
next(tf)
for a, b in Zip(f, tf):
yield a + b
これはそれを示しています。
[f for _, f in Zip(range(999), fib())]
ただし、それは再帰の上限に達することしかできません。通常は1000ですが、Haskellバージョンでは最大で何億ものことができますが、ラップトップのメモリ8 GBすべてを使います。
> length $ take 100000000 fib
100000000
単純に以下をしないのはなぜですか？
x = [1,1]
for i in range(2, 10):
x.append(x[-1] + x[-2])
print(', '.join(str(y) for y in x))
フィボナッチ数列の背後にある考え方は、次のPythonコードに示されています。
def fib(n):
if n == 1:
return 1
Elif n == 0:
return 0
else:
return fib(n-1) + fib(n-2)
つまり、fibは3つのうちの1つを実行できる関数です。 fib（1）== 1、fib（0）== 0、fib（n）を次のように定義します。
fib（n-1）+ fib（n-2）
ここで、nは任意の整数です。これは例えばfib（2）が次の算術式に展開されることを意味します。
fib(2) = fib(1) + fib(0)
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(2) = 1 + 0
fib(2) = 1
次に示す算術式を使って、fib（3）を同じように計算できます。
fib(3) = fib(2) + fib(1)
fib(2) = fib(1) + fib(0)
fib(2) = 1
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(3) = 1 + 1 + 0
ここで重要なことは、fib（3）はfib（2）を計算しないと計算できないことです。これは、fib（1）とfib（0）の定義を知ることによって計算されます。 fibonacci関数のように関数呼び出し自体を持つことは再帰と呼ばれ、これはプログラミングの重要なトピックです。
これは宿題の割り当てのように聞こえるので、私はあなたのために開始/終了部分をするつもりはないです。 Pythonはこのための素晴らしく表現力豊かな言語です、それであなたが数学を理解するならば、これは意味を成すべきであり、そしてうまくいけば再帰についてあなたに教えるでしょう。がんばろう！
編集：私のコードに対する1つの潜在的な批判は、それが非常に便利なPython関数yieldを使用していないことであり、それはfib（n）関数をずっと短くする。私の例は、もう少し一般的なものです。Python以外の多くの言語では実際に利回りが得られないからです。
時間の複雑さ：
キャッシング機能は、フィボナッチ数列の再帰ツリーの繰り返しを削除することによって、フィボナッチ数列を計算する通常の方法をO（2 ^ n）からO（n）に減らします。
コード：
import sys
table = [0]*1000
def FastFib(n):
if n<=1:
return n
else:
if(table[n-1]==0):
table[n-1] = FastFib(n-1)
if(table[n-2]==0):
table[n-2] = FastFib(n-2)
table[n] = table[n-1] + table[n-2]
return table[n]
def main():
print('Enter a number : ')
num = int(sys.stdin.readline())
print(FastFib(num))
if __name__=='__main__':
main()
これはO（log n）の基本算術演算を使用して非常に効率的です。
def fib(n):
return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n)
これはO(1)基本的な算術演算を使いますが、中間結果のサイズは大きく、まったく効率的ではありません。
def fib(n):
return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1)
これは、二乗によるべき乗を使って多項式環Z [X] /（X ^ 2 - X - 1）のX ^ nを計算します。その計算の結果は多項式Fib（n）X + Fib（n-1）となり、そこからn番目のフィボナッチ数を読み取ることができます。
繰り返しますが、これはO（log n）算術演算を使用しており、非常に効率的です。
def mul(a, b):
return a[0]*b[1]+a[1]*b[0]+a[0]*b[0], a[0]*b[0]+a[1]*b[1]
def fib(n):
x, r = (1, 0), (0, 1)
while n:
if n & 1: r = mul(r, x)
x = mul(x, x)
n >>= 1
return r[0]
フィボナッチ数列を印刷するための標準的なPythonコード：
a,b=1,1
while True:
print a,
a,b=b,a+b # Could also use b=a+b;a=b-a
「1000桁を超える長さの最初のフィボナッチ数を印刷する」という問題の場合：
a,b=1,1
i=1
while len(str(a))<=1000:
i=i+1
a,b=b,a+b
print i,len(str(a)),a
再帰を使う：
def fib(n):
if n == 0:
return 0
Elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
x=input('which fibonnaci do you want?')
print fib(x)
私達はことを知っています
そしてその行列のn乗は私たちに与えます：
そのため、単純にその行列のパワーをn番目の-1乗に計算する関数を実装できます。
すべてのことがわかっているように、力a ^ nはに等しい
したがって、最後にfibonacci関数はO（n）になります。したがって、x^n * x^n = x^2nおよびx^nの評価を複雑度Oで実行できることがわかっているのでなければ、より簡単な実装と変わりはありません。 log n）
これがSwiftプログラミング言語を使った私のフィボナッチ実装です。
struct Mat {
var m00: Int
var m01: Int
var m10: Int
var m11: Int
}
func pow(m: Mat, n: Int) -> Mat {
guard n > 1 else { return m }
let temp = pow(m: m, n: n/2)
var result = matMultiply(a: temp, b: temp)
if n%2 != 0 {
result = matMultiply(a: result, b: Mat(m00: 1, m01: 1, m10: 1, m11: 0))
}
return result
}
func matMultiply(a: Mat, b: Mat) -> Mat {
let m00 = a.m00 * b.m00 + a.m01 * b.m10
let m01 = a.m00 * b.m01 + a.m01 * b.m11
let m10 = a.m10 * b.m00 + a.m11 * b.m10
let m11 = a.m10 * b.m01 + a.m11 * b.m11
return Mat(m00: m00, m01: m01, m10: m10, m11: m11)
}
func fibonacciFast(n: Int) -> Int {
guard n > 0 else { return 0 }
let m = Mat(m00: 1, m01: 1, m10: 1, m11: 0)
return pow(m: m, n: n-1).m00
}
これは複雑度O（log n）を持ちます。指数n-1を使ってQのべき乗を計算し、それから指数n-1がちょうど欲しいn番目のフィボナッチ数であるFn + 1である要素m00を取ります。
高速のフィボナッチ関数を入手したら、開始番号と終了番号から繰り返して、目的のフィボナッチ数列の一部を取得できます。
let sequence = (start...end).map(fibonacciFast)
もちろん、最初と最後に何らかのチェックを行い、それらが有効な範囲を形成できることを確認します。
私は質問が8歳であることを知っています、しかし私はとにかく答えることを楽しんでいました。 :)
OK ..長い答えすべてを参照するのにうんざりした後は、PythonでFibonacciを実装するための以下のソート＆スウィートでかなり簡単な方法を見つけてください。あなたはそれをあなたが引数を得たりユーザー入力を得たりすることによってあなたが望むようにそれを強化することができます…あるいは10000から限界を変えることができます。
def fibonacci():
start = 0
i = 1
lt = []
lt.append(start)
while start < 10000:
start += i
lt.append(start)
i = sum(lt[-2:])
lt.append(i)
print "The Fibonaccii series: ", lt
このアプローチも優れています。下記のランアナリティクスを見つける
In [10]: %timeit fibonacci
10000000 loops, best of 3: 26.3 ns per loop
それを理解するためのとても簡単な方法があります！
あなたは http://www.learnpython.org/ を使って自由にオンラインでこのコードを実行することができます
# Set the variable brian on line 3!
def fib(n):
"""This is documentation string for function. It'll be available by fib.__doc__()
Return a list containing the Fibonacci series up to n."""
result = []
a = 0
b = 1
while a < n:
result.append(a) # 0 1 1 2 3 5 8 (13) break
tmp_var = b # 1 1 2 3 5 8 13
b = a + b # 1 2 3 5 8 13 21
a = tmp_var # 1 1 2 3 5 8 13
# print(a)
return result
print(fib(10))
# result should be this: [0, 1, 1, 2, 3, 5, 8]
これらはすべて、必要以上に複雑に見えます。私のコードはとてもシンプルで速いです：
def fibonacci(x):
List = []
f = 1
List.append(f)
List.append(f) #because the fibonacci sequence has two 1's at first
while f<=x:
f = List[-1] + List[-2] #says that f = the sum of the last two f's in the series
List.append(f)
else:
List.remove(List[-1]) #because the code lists the fibonacci number one past x. Not necessary, but defines the code better
for i in range(0, len(List)):
print List[i] #prints it in series form instead of list form. Also not necessary
これはマシューヘンリーの答えを改善したものです。
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print b
a = b
b = c
コードは、cを印刷する代わりにbを印刷する必要があります。
出力：1,1,2,3,5 ....
def fib():
a,b = 1,1
num=eval(input("Please input what Fib number you want to be calculated: "))
num_int=int(num-2)
for i in range (num_int):
a,b=b,a+b
print(b)
import time
start_time = time.time()
#recursive solution
def fib(x, y, upperLimit):
return [x] + fib(y, (x+y), upperLimit) if x < upperLimit else [x]
#To test :
print(fib(0,1,40000000000000))
print("run time: " + str(time.time() - start_time))
結果
［０，１，１，２，３，５，８，１３，２１，３４，５５，８９，１４４，２３３，３７７，６１０，９８７，１５９７，２５８４，４１８１，６７６５，１０９４６，１７７１１，２８６５７，４６３６８ 、75025、121393、196418、317811、514229、8362409、2178309、5702887、9227465、14915352、24157817、39088169、63245986、102334155、165580141、267914296、7147137137137137137117137137137137137137137137137137137137137137137がこれと同じです。 、12586269025、20365011074、32951280099、53316291173、86267571272、139583862445、225851433717、365435296162、591286729879、956722026041、1548008755920、2504730781961、4052739537881、6557470319842、10610209857723、17167680177565、27777890035288、44945570212853]
実行時：.04298138618469238
Forループを使って結果だけを表示する
def fib(n:'upto n number')->int:
if n==0:
return 0
Elif n==1:
return 1
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
return b
結果
>>>fib(50)
12586269025
>>>>
>>> fib(100)
354224848179261915075
>>>
すべての数字を含むlistを印刷します。
def fib(n:'upto n number')->int:
l=[0,1]
if n==0:
return l[0]
Elif n==1:
return l
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
l.append(b)
return l
結果
>>> fib(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
フィボナッチ数列は1, 1, 2, 3, 5, 8, ...です。
それはf(1) = 1、f(2) = 1、f(3) = 2、...、f(n) = f(n-1) + f(n-2)です。
私のお気に入りの実装（最もシンプルでありながら、他の実装と比較して軽い速度を達成します）は、次のとおりです。
def fibonacci(n):
a, b = 0, 1
for _ in range(1, n):
a, b = b, a + b
return b
テスト
>>> [fibonacci(i) for i in range(1, 10)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]
タイミング
>>> %%time
>>> fibonacci(100**3)
CPU times: user 9.65 s, sys: 9.44 ms, total: 9.66 s
Wall time: 9.66 s
編集： 視覚化の例 この実装の場合。
それをするもう一つの方法：
a,n=[0,1],10
map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2))
リストを 'a'に割り当て、整数を 'n'に割り当てます。Mapとreduceは、pythonで最も強力な3つの関数のうち2つです。ここでmapは単に 'n-2'回繰り返すために使われます。 a [-2：]は、配列の最後の2つの要素を取得します。 a.append（x + y）は最後の2つの要素を追加して配列に追加します
再帰は時間がかかります。ループを解消するには、まずimport mathを使用します。それから関数でmath.sqrtと黄金比を使います：
#!/usr/bin/env python3
import math
def fib(n):
gr = (1 + math.sqrt(5)) / 2
fib_first = (gr**n - (1 - gr)**n) / math.sqrt(5)
return int(round(fib_first))
fib_final = fib(100)
print(fib_final)
ref： Pythonのフィボナッチ数
def fib(lowerbound, upperbound):
x = 0
y = 1
while x <= upperbound:
if (x >= lowerbound):
yield x
x, y = y, x + y
startNumber = 10
endNumber = 100
for fib_sequence in fib(startNumber, endNumber):
print "And the next number is... %d!" % fib_sequence
これはFibonacciシリーズのpythonで最も単純なものですが、出力配列のappend（）で[0]を調整し、結果リストの2番目の変数はresult.append(second)になります。
def fibo(num):
first = 0
second = 1
result = [0]
print('Fibonacci series is')
for i in range(0,num):
third = first + second
#print(second)
result.append(second)
first = second
second = third
print(result)
return
fibo(7)
出力
Fibonacci series is
[0, 1, 1, 2, 3, 5, 8, 13]
Append関数を使って最初の100個の要素を生成します。
def generate():
series = [0, 1]
for i in range(0, 100):
series.append(series[i] + series[i+1])
return series
print(generate())
基本的にRubyから翻訳：
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print c
a = b
b = c
...
多分これは役立つでしょう
def fibo(n):
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, b + a
return result
ただ通過しています http://projecteuler.net/problem=2 これは私の考えです
# Even Fibonacci numbers
# Problem 2
def get_fibonacci(size):
numbers = [1,2]
while size > len(numbers):
next_fibonacci = numbers[-1]+numbers[-2]
numbers.append(next_fibonacci)
print numbers
get_fibonacci(20)
これはどう？期待される出力を生成するために前の結果の最初の指定を要求するので他の提案ほど空想的ではないと思いますが、私は非常に読みやすいオプションであると感じます。再帰.
#count the number of recursions
num_rec = 0
def fibonacci(num, prev, num_rec, cycles):
num_rec = num_rec + 1
if num == 0 and prev == 0:
result = 0;
num = 1;
else:
result = num + prev
print(result)
if num_rec == cycles:
print("done")
else:
fibonacci(result, num, num_rec, cycles)
#Run the fibonacci function 10 times
fibonacci(0, 0, num_rec, 10)
これが出力です。
0
1
1
2
3
5
8
13
21
34
done
Pythonicの方法では、以下の方法でフィバノニック級数を書くことができます。
a,b = 0,1
while b < 1000:
b = (b, end = ' ', flush = True)
a,b = b , a+b
これは私がKhan AcademyのPython Programming on Salで見た練習課題です： https://www.khanacademy.org/science/computer-science-subject/computer-science/v/exercise ---フィボナッチ関数を書く
彼はおそらく、やるべき仕事としてそれを割り当てた最初の人ではありません。しかし、それは自分でそれを考え出すのは素晴らしいです。私は実際にそれを理解することをたくさん学びました、そしてそれは爆発でした。
宿題のために他人のコードを試してコピーする前に、自分でそれを理解することをお勧めします。
上のビデオでは、講師のサルがフィボナッチ数の背後にある理論全体を示していますが、それを念頭に置いてそれを理解できるはずです。
それは私に約10分かかりました、そして、これは私が作ったコードです（私は3日前からPythonを学んでいます、そしてこれは私が学ぶための私の最初のプログラミング言語です）。それが前のチュートリアルからのビデオ用でなければ、私はコードを書くことができなかったでしょう： https://www.khanacademy.org/science/computer-science-subject/computerこれはSalが再帰的な階乗方程式を実行する例を示し、この問題を解決するための考え方を示しています。-science/v/iterative-and-recursive-factorial-functions .
これが私のコードです：
def fibonacci(num):
if num <= 1: #base case
return num
else:
return fibonacci(num-1) + fibonacci(num-2)
数字が1または0の場合は、単に数字を返すだけです。
Numberが1の場合は1を返し、numberが0の場合は0を返すよりも、このほうがきれいです。
Simple def - これを試してください..
def fib(n):
first = 0
second = 1
holder = 0
array = []
for i in range(0, n):
first = second
second = holder
holder = first + second
array.append(holder)
return array
input -> 10
output -> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
単純なフィボ：
def fibo(start, count):
a = [start, start+1]
for i in range(count-len(a)):
a.append(a[-1]+a[-2])
return a
a = fibo(0, 10)
print 'fibo', a
OUTPUT：[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
ジェネレータとして書かれたフィボナッチ：
# fill in this function
def fib():
a = 1
b = 1
yield(a)
yield(b)
for i in range(2, 10):
c = a+b
a, b = b, c
yield(c)
#pass #this is a null statement which does nothing when executed, useful as a placeholder.
# testing code
import types
if type(fib()) == types.GeneratorType:
print("Good, The fib function is a generator.")
counter = 0
for n in fib():
print(n)
counter += 1
if counter == 10:
break
Functionを呼び出してモジュール化してこの解決策を実行する
def userInput():
number = int(input('Please enter the number between 1 - 40 to find out the
fibonacci :'))
return number
def findFibonacci(number):
if number == 0:
return 0
Elif number == 1:
return 1
else:
return findFibonacci(number - 1) + findFibonacci (number - 2)
def main():
userNumber = userInput()
print(findFibonacci(userNumber))
main()
はるかに短い形式では：
def fibbo(range_, a, b):
if(range_!=0):
a, b = b, a+b
print(a)
return fibbo(range_-1, a, b)
return
fibbo(11, 1, 0)
これは投稿されたものと似ていますが、きれいで、速く、そして読みやすいです。
def fib(n):
# start with first two fib numbers
fib_list = [0, 1]
i = 0
# Create loop to iterate through n numbers, assuming first two given
while i < n - 2:
i += 1
# append sum of last two numbers in list to list
fib_list.append(fib_list[-2] + fib_list[-1])
return fib_list
私がPythonを学ぶときに使ったチュートリアルの15分後、読者に3つの入力番号（最初のフィボナッチ番号、2番目の番号、そしてシーケンスを止める番号）からフィボナッチ数列を計算するプログラムを書くよう依頼した。このチュートリアルでは、if/thensという変数についてのみ説明し、それまでループしました。まだ機能はありません。私は次のようなコードを思い付きました。
sum = 0
endingnumber = 1
print "\n.:Fibonacci sequence:.\n"
firstnumber = input("Enter the first number: ")
secondnumber = input("Enter the second number: ")
endingnumber = input("Enter the number to stop at: ")
if secondnumber < firstnumber:
print "\nSecond number must be bigger than the first number!!!\n"
else:
while sum <= endingnumber:
print firstnumber
if secondnumber > endingnumber:
break
else:
print secondnumber
sum = firstnumber + secondnumber
firstnumber = sum
secondnumber = secondnumber + sum
見てわかるように、それは本当に非効率的です、しかしそれはうまくいきます。
古典的なフィボナッチ数列に基づいており、単なるライナーのために
インデックスの数だけが必要な場合は、reduceを使用できます（reduceこれには最適ではありません）、これは良い方法です。
def fibonacci(index):
return reduce(lambda r,v: r.append(r[-1]+r[-2]) or (r.pop(0) and 0) or r , xrange(index), [0, 1])[1]
完全な配列を取得するには、または（r.pop（0）and 0）を削除するだけです。
reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1])
私は少し対話的なpythonフィボナッチ数列を作りました、それはあなたがそれをあなたがそれがあなたがそれを何回繰り返すことを望むかを尋ねます、そしてそれはあなたにフィボナッチ数列の数を示します。 こちらISコード !!!
while True:
number_1 = 1
number_2 = 1
how_many_times_do_you_want_this_done = input('How Many Times Do You Want This Done: ')
counter = 1
while counter < how_many_times_do_you_want_this_done:
print([number_1])
print([number_2])
number_1 += number_2
number_2 += number_1
counter += 2
次のようにして行うことができます。
n = 0 数= [0] iの範囲（0、11）： print n 、 numbers.append（n） prev = numbers [-2] n == 0の場合： n = 1 else： n = n +前へ
私はこの問題を解決するために再帰関数を避けようとしていたので、私は反復的なアプローチを取りました。私はもともと記憶された再帰的関数をやっていましたが、最大再帰的深度を打っていました。私は厳密なメモリの目標も持っていたので、あなたは私がループ処理の間私がいつでも配列に2-3の値を保持することができるのと同じくらい小さく配列を保つのを見るでしょう。
def fib(n):
fibs = [1, 1] # my starting array
for f in range(2, n):
fibs.append(fibs[-1] + fibs[-2]) # appending the new fib number
del fibs[0] # removing the oldest number
return fibs[-1] # returning the newest fib
print(fib(6000000))
600万回目のフィボナッチ数を取得するのに私のマシンでは282秒かかりますが、600kのフィボナッチ数は2.8秒しかかかりません。記憶されているものであっても、再帰関数でそのような大きなフィボナッチ数を得ることはできませんでした。
def fib(x, y, n):
if n < 1:
return x, y, n
else:
return fib(y, x + y, n - 1)
print fib(0, 1, 4)
(3, 5, 0)
#
def fib(x, y, n):
if n > 1:
for item in fib(y, x + y, n - 1):
yield item
yield x, y, n
f = fib(0, 1, 12)
f.next()
(89, 144, 1)
f.next()[0]
55
リストをメモリに保存してフィボナッチを見つける機能を最適化
def fib(n, a=[0, 1]):
while n > len(a):
a.append(a[-1] + a[-2])
return a[n-1]
print("Fibonacci of 50 - {}".format(fib(50))
Memoizationがフィボナッチ数列に対してどのように機能するかについてのより詳細な説明。
# Fibonacci sequence Memoization
fib_cache = {0:0, 1:1}
def fibonacci(n):
if n < 0:
return -1
if fib_cache.has_key(n):
print "Fibonacci sequence for %d = %d cached" % (n, fib_cache[n])
return fib_cache[n]
else:
fib_cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
return fib_cache[n]
if __== "__main__":
print fibonacci(6)
print fib_cache
# fibonacci(7) reuses fibonacci(6) and fibonacci(5)
print fibonacci(7)
print fib_cache
再帰問題を反復問題に変換する方法を調べてください。そこから計算できるはずです。
それが彼らがあなたに習得させようとしている原則であるかもしれません、特にこれがアルゴリズムコースであるならば。
これを試して：
def nth_fib(n):
if n == 0:
return 1
Elif n == 1:
return 0
else:
return nth_fib(n - 1) + nth_fib(n - 2)
あなたが再帰のファンなら、lru_cacheデコレータ（最も最近使用されたキャッシュデコレータ）を使って結果を簡単にキャッシュすることができます。
from functools import lru_cache
@lru_cache()
def fib(n):
if n == 0:
return 0
Elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
128を超える値をキャッシュする必要がある場合は、maxsizeをlru_cacheの引数として渡すことができます（例：lru_cache(maxsize=500)。maxsize=Noneを設定すると、キャッシュは制限なしに大きくなります）。