Ответ 1

Существует много информации о последовательности Фибоначчи на 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)

Попробуйте на своем любимом языке и посмотрите, что для этой формы требуется больше много. Фактически, это O (2 ⁿ) во времени.

Перейдите на сайты, которые я связал с вами, и увидим это (на wolfram):

Это довольно легко реализовать и очень, очень быстро вычислить в Python:

from math import sqrt
def F(n):
    return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))

Другой способ сделать это - следовать определению (из wikipedia):

Первое число последовательности равно 0, второе число равно 1, и каждый последующее число равно сумме предыдущих двух номеров самой последовательности, приводящей последовательность 0, 1, 1, 2, 3, 5, 8 и т.д.

Если ваш язык поддерживает итераторы, вы можете сделать что-то вроде:

def F():
    a,b = 0,1
    while True:
        yield a
        a, b = b, a + b

Показывать startNumber для endNumber только из последовательности Fib.

Как только вы знаете, как генерировать числа Фибоначчи, вам просто нужно прокручивать числа и проверять, проверяют ли они данные условия.

Предположим теперь, что вы написали f (n), который возвращает 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 (google для него) научит вас делать это: P Удачи и получайте удовольствие!

Ответ 2

Эффективный питоновский генератор последовательности Фибоначчи

Я нашел этот вопрос, пытаясь получить самое короткое Pythonic поколение этой последовательности (позже понял, что видел подобное в предложении Python Enhancement), и я не заметил, чтобы кто-нибудь еще придумал мое конкретное решение (хотя главный ответ становится ближе, но все же менее изящно), так что вот, с комментариями, описывающими первую итерацию, потому что я думаю, что это может помочь читателям понять:

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:

[email protected](0:tfib) = 0:1: zipWith (+) fib tfib

Наиболее близким, я думаю, я могу добраться до этого в Python на данный момент:

from itertools import tee

def fib():
    yield 0
    yield 1
    # tee required, else with two fib() 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 ГБ памяти моего ноутбука:

> length $ take 100000000 fib 
100000000

Ответ 3

Почему бы просто не сделать следующее?

x = [1,1]
for i in range(2, 10):  
    x.append(x[-1] + x[-2]) 
print(', '.join(str(y) for y in x))

Ответ 4

Идея последовательности Fibonacci показана в следующем коде Python:

def fib(n):
   if n == 1:
      return 1
   elif n == 0:   
      return 0            
   else:                      
      return fib(n-1) + fib(n-2)         

Это означает, что fib - это функция, которая может выполнять одну из трех задач. Он определяет 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). Наличие вызова функции, подобного функции фибоначчи, называется рекурсией, и это важный вопрос в программировании.

Это звучит как домашнее задание, поэтому я не собираюсь делать стартовую/конечную часть для вас. Python - это удивительно выразительный язык для этого, так что это должно иметь смысл, если вы понимаете математику и, надеюсь, научите вас рекурсии. Удачи!

Редактирование: одна потенциальная критика моего кода заключается в том, что он не использует супер-удобный результат функции Python, что делает функцию fib (n) намного короче. Мой пример немного более общий, поскольку, поскольку не много языков вне Python действительно имеют доходность.

Ответ 5

Сложность времени:

Функция кэширования уменьшает нормальный способ вычисления рядов Фибоначчи от 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()

Ответ 6

Это довольно эффективно, используя базовые арифметические операции 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)

Это вычисляет X ^ n в полиномиальном кольце Z [X]/(X ^ 2 - X - 1), используя возведение в степень по квадрату. Результатом этого вычисления является многочлен 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]

Ответ 7

Канонический код 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

Ответ 8

использовать рекурсию:

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)

Ответ 9

Мы знаем это

И что n-я сила этой матрицы дает нам:

Таким образом, мы можем реализовать функцию, которая просто вычисляет мощность этой матрицы в n-й степени -1.

как все мы знаем, сила а ^ п равна

Таким образом, в конце функция Фибоначчи была бы 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). Мы вычисляем величину мощности Q с показателем n -1, а затем берем элемент m00, равный Fn + 1, который при показателе степени n -1 является именно тем n-м числом Фибоначчи, которое мы хотели.

Если у вас есть функция быстрого Фибоначчи, вы можете перебирать начальный и конечный номера, чтобы получить интересующую вас часть последовательности Фибоначчи.

let sequence = (start...end).map(fibonacciFast)

Конечно, сначала выполните проверку начала и конца, чтобы убедиться, что они могут сформировать допустимый диапазон.

Я знаю, что этому вопросу 8 лет, но мне все равно было весело отвечать. :)

Ответ 10

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)

Ответ 11

Все они выглядят немного сложнее, чем им нужно. Мой код очень прост и быстр:

def fibonacci(x):

    List = []
    f = 1
    List.append(f)
    List.append(f) #because the fibonacci sequence has two 1 at first
    while f<=x:
        f = List[-1] + List[-2]   #says that f = the sum of the last two f 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

Ответ 12

Другой способ сделать это:

a,n=[0,1],10
map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2))

Назначение списка 'a', присваивая целое число 'n' Карта и сокращение - две из трех самых мощных функций в python. Здесь карта используется только для повторения "n-2" раз. a [-2:] получит последние два элемента массива. a.append(x + y) добавит последние два элемента и добавит к массиву

Ответ 13

OK.. после того, как вы устали отсылать все длинные ответы, теперь найдите нижерасположенный вид и сладостный, довольно прямой путь для реализации Fibonacci в python. Вы можете улучшить его так, как вы хотите, чтобы получить аргумент или получить пользовательский ввод... или изменить пределы с 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

Ответ 14

Последовательность Фибоначчи: 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

Test

>>> [fibonacci(i) for i in range(1, 10)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]

Timing

>>> %%time
>>> fibonacci(100**3)
CPU times: user 9.65 s, sys: 9.44 ms, total: 9.66 s
Wall time: 9.66 s

Изменить: пример визуализации для этой реализации.

Ответ 15

это улучшение ответа Мэтью Генри:

def fib(n):
    a = 0
    b = 1
    for i in range(1,n+1):
            c = a + b
            print b
            a = b
            b = c

код должен печатать b вместо печати c

: 1,1,2,3,5....

Ответ 16

Есть очень простой способ понять это!

Вы можете бесплатно запустить этот код в Интернете с помощью 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]

Ответ 17

Использование для цикла и печати только результата

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]

Ответ 18

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))

Результаты

[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, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853]

время выполнения: 0.04298138618469238

Ответ 19

В основном переведен с Ruby:

def fib(n):
    a = 0
    b = 1
    for i in range(1,n+1):
            c = a + b
            print c
            a = b
            b = c

...

Ответ 20

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

Ответ 21

Рекурсия добавляет время. Чтобы устранить петли, сначала 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

Ответ 22

Это самый простой в python для серии Fibonacci, но отредактированный [0] в выходном массиве append(), чтобы получить вторую переменную списка результатов, которая 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]

Ответ 23

Использование функции append для генерации первых 100 элементов.

def generate():
    series = [0, 1]
    for i in range(0, 100):
        series.append(series[i] + series[i+1])

    return series


print(generate())

Ответ 24

Начните с чтения хорошей книги Python. Одна из таких книг - "Как думать, как компьютерный ученый", особенно глава 5 в вашем случае.

Ответ 25

Go узнайте, как преобразовать рекурсивную проблему в итеративную. Должен иметь возможность рассчитывать оттуда.

Это могут быть принципы, которые они пытаются вас научить, особенно если это курс алгоритмов.

Ответ 26

15 минут в учебное пособие, которое я использовал при изучении Python, он попросил читателя написать программу, которая будет вычислять последовательность Фибоначчи из 3 входных чисел (первый номер Фибоначчи, второе число и число, на котором останавливать последовательность). В учебнике были рассмотрены только переменные, если /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

Как вы можете видеть, это действительно неэффективно, но оно работает.

Ответ 27

Просто пройдя 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)

Ответ 28

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

Ответ 29

Это было практическое задание, которое я увидел в Khan Academy Sal на Python Programming: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/exercise---write-a-fibonacci-function

Он, вероятно, не первый человек, который назначил это как часть работы. Но это удивительно, если вы сами это выясните. Я многому научился этому, и это был взрыв.

Я рекомендую вам самому разобраться, прежде чем пытаться скопировать код другого пользователя для домашней работы.

В вышеприведенном видео Саль-инструктор показывает всю теорию за номером Фибоначчи, и с учетом этого вы должны быть в состоянии понять это.

Мне потребовалось около 10 минут, и это код, который я сделал (я изучаю Python, начиная 3 дня назад, и это мой первый язык программирования для изучения). Я бы не смог написать код, если раньше не было видео из учебника: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/comparing-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, вы просто возвращаете номер.

Я нахожу это чище, чем говорить, если число равно 1 return 1, а если число равно 0, возвращаем 0.

Ответ 30

Возможно, это поможет

def fibo(n):
    result = []
    a, b = 0, 1
    while b < n:
            result.append(b)
            a, b = b, b + a
    return result