¿Cómo escribir la secuencia de fibonacci?

Originalmente había codificado el progtwig incorrectamente. En lugar de devolver los números de Fibonacci entre un rango (es decir, startNumber 1, endNumber 20 debe = solo esos números entre 1 y 20), he escrito para el progtwig que muestre todos los números de Fibonacci entre un rango (es decir, startNumber 1, endNumber 20 muestra = primeros 20 números de Fibonacci). Pensé que tenía un código de fuego seguro. Tampoco veo por qué está sucediendo esto.

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

Alguien señaló en mi Parte II (que estaba cerrada por ser un duplicado – https://stackoverflow.com/questions/504193/how-to-write-the-fibonacci-sequence-in-python-part-ii ) que debe pasar el startNumber y el endNumber a través de un generador usando un bucle while. ¿Alguien por favor me puede indicar la dirección de cómo hacer esto? Cualquier ayuda es bienvenida.


Soy un progtwigdor de aprendizaje y me he encontrado con un poco de confusión. Se me pide que escriba un progtwig que calcule y muestre la Secuencia de Fibonacci mediante un número de inicio y un número final ingresados ​​por el usuario (es decir, número de inicio = 20 número de final = 100 y mostrará solo los números entre ese rango). El truco es usarlo de manera inclusiva (¿qué no sé cómo hacerlo en Python? ¿Supongo que esto significa usar un rango inclusivo?).

Lo que tengo hasta ahora no es una encoding real sino más bien:

  • Escribe la fórmula de la secuencia de Fib a infinito
  • Muestra startNumber para terminarNumber solo desde la secuencia de Fib.

No tengo idea de por dónde empezar y estoy pidiendo ideas o ideas sobre cómo escribir esto. También he tratado de escribir la secuencia de Fib de forumla pero me pierdo en eso también.

    Hay mucha información sobre la secuencia de Fibonacci en wikipedia y en wolfram . Mucho más de lo que pueda necesitar. De todos modos, es bueno aprender a usar estos recursos para encontrar (rápidamente si es posible) lo que necesita.

    Escribe la fórmula de la secuencia de Fib a infinito

    En matemáticas, se da en forma recursiva:

    fibonacci de wikipedia

    En la progtwigción, el infinito no existe. Puede usar un formulario recursivo para traducir el formulario matemático directamente en su idioma, por ejemplo, en Python se convierte en:

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

    Pruébelo en su idioma favorito y vea que este formulario requiere mucho tiempo a medida que n crece. De hecho, esto es O (2 n ) en el tiempo.

    Continúa en los sitios que he enlazado contigo y veré esto (en wolfram ):

    Ecuación de Fibonacci

    Este es bastante fácil de implementar y muy, muy rápido de calcular, en Python:

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

    Otra forma de hacerlo es siguiendo la definición (de wikipedia ):

    El primer número de la secuencia es 0, el segundo número es 1, y cada número subsiguiente es igual a la sum de los dos números anteriores de la secuencia en sí misma, dando como resultado la secuencia 0, 1, 1, 2, 3, 5, 8 , etc.

    Si su idioma admite iteradores, puede hacer algo como:

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

    Muestra startNumber para terminarNumber solo desde la secuencia de Fib.

    Una vez que sepa cómo generar los números de Fibonacci, solo tiene que alternar entre los números y verificar si verifican las condiciones dadas.

    Supongamos que ahora escribiste af (n) que devuelve el n-ésimo término de la secuencia de Fibonacci (como el que tiene sqrt (5))

    En la mayoría de los idiomas puedes hacer algo como:

     def SubFib(startNumber, endNumber): n = 0 cur = f(n) while cur <= endNumber: if startNumber <= cur: print cur n += 1 cur = f(n) 

    En python usaría la forma de iterador e iría por:

     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 

    Mi consejo es aprender a leer lo que necesitas. El proyecto Euler (Google for it) lo capacitará para hacerlo: P ¡Buena suerte y diviértase!

    Generador pythonico eficiente de la secuencia de Fibonacci.

    Encontré esta pregunta al intentar obtener la generación Pythonic más corta de esta secuencia (luego me di cuenta de que había visto una similar en una Propuesta de mejora de Python ), y no he notado que alguien más haya encontrado mi solución específica (aunque la respuesta más importante se acerca, pero aún menos elegante), así que aquí está, con comentarios que describen la primera iteración, porque creo que eso puede ayudar a los lectores a comprender:

     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) 

    y uso:

     for index, fibonacci_number in zip(range(10), fib()): print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number)) 

    huellas dactilares:

      0: 0 1: 1 2: 1 3: 2 4: 3 5: 5 6: 8 7: 13 8: 21 9: 34 10: 55 

    (Con fines de atribución, recientemente noté una implementación similar en la documentación de Python en los módulos, incluso utilizando las variables a y b , que ahora recuerdo haber visto antes de escribir esta respuesta. Pero creo que esta respuesta demuestra un mejor uso del lenguaje).

    Implementación recursivamente definida

    La enciclopedia en línea de secuencias enteras define la secuencia de Fibonacci recursivamente como

    F (n) = F (n-1) + F (n-2) con F (0) = 0 y F (1) = 1

    La definición sucinta de esto recursivamente en Python se puede hacer de la siguiente manera:

     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 

    Pero esta representación exacta de la definición matemática es increíblemente ineficiente para números mucho mayores que 30, porque cada número que se calcula también debe calcularse para cada número debajo de él. Puedes demostrar lo lento que es usando lo siguiente:

     for i in range(40): print(i, rec_fib(i)) 

    Recursión memorizada para la eficiencia.

    Se puede memorizar para mejorar la velocidad (este ejemplo aprovecha el hecho de que un argumento de palabra clave predeterminado es el mismo objeto cada vez que se llama a la función, pero normalmente no usaría un argumento predeterminado mutable exactamente por este motivo):

     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 

    Encontrará que la versión memoized es mucho más rápida y superará rápidamente su máxima profundidad de recursión antes de que pueda siquiera pensar en levantarse para tomar un café. Puedes ver cuánto más rápido es visualmente haciendo esto:

     for i in range(40): print(i, mem_fib(i)) 

    (Puede parecer que podemos hacer lo siguiente, pero en realidad no nos permite aprovechar la memoria caché, ya que se llama a sí mismo antes de que se llame a 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 

    Generador recursivamente definido:

    Como he estado aprendiendo Haskell, encontré esta implementación en Haskell:

     fib@(0:tfib) = 0:1: zipWith (+) fib tfib 

    Lo más cerca que creo que puedo llegar a esto en Python en este momento es:

     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 

    Esto lo demuestra:

     [f for _, f in zip(range(999), fib())] 

    Sin embargo, solo puede ir hasta el límite de recursión. Por lo general, 1000, mientras que la versión de Haskell puede llegar hasta los cientos de millones, aunque utiliza los 8 GB de memoria de mi computadora portátil para hacerlo:

     > length $ take 100000000 fib 100000000 

    ¿Por qué no simplemente hacer lo siguiente?

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

    La idea detrás de la secuencia de Fibonacci se muestra en el siguiente código de Python:

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

    Esto significa que la fib es una función que puede hacer una de tres cosas. Define fib (1) == 1, fib (0) == 0, y fib (n) como:

    fib (n-1) + fib (n-2)

    Donde n es un entero arbitrario. Esto significa que fib (2), por ejemplo, se expande a la siguiente aritmética:

     fib(2) = fib(1) + fib(0) fib(1) = 1 fib(0) = 0 # Therefore by substitution: fib(2) = 1 + 0 fib(2) = 1 

    Podemos calcular fib (3) de la misma manera con la aritmética que se muestra a continuación:

     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 

    Lo importante a tener en cuenta aquí es que la fib (3) no se puede calcular sin calcular fib (2), que se calcula al conocer las definiciones de fib (1) y fib (0). Hacer que una función se llame a sí misma como lo hace la función fibonacci se llama recursión, y es un tema importante en la progtwigción.

    Esto suena como una tarea, así que no voy a hacer la parte inicial / final por ti. Sin embargo, Python es un lenguaje maravillosamente expresivo para esto, por lo que debería tener sentido si entiendes las matemáticas y, con suerte, te enseñará sobre la recursión. ¡Buena suerte!

    Edición: Una crítica potencial de mi código es que no utiliza el rendimiento de función de Python super práctico, lo que hace que la función fib (n) sea mucho más corta. Sin embargo, mi ejemplo es un poco más genérico, ya que no muchos de los lenguajes fuera de Python realmente tienen rendimiento.

    Complejidad del tiempo:

    La función de almacenamiento en caché reduce la forma normal de calcular la serie de Fibonacci de O (2 ^ n) a O (n) al eliminar las repeticiones en el árbol recursivo de la serie de Fibonacci:

    introduzca la descripción de la imagen aquí

    Código:

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

    Esto es bastante eficiente, usando operaciones aritméticas básicas O (log n).

     def fib(n): return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n) 

    Este utiliza operaciones aritméticas básicas O (1), pero el tamaño de los resultados intermedios es grande y, por lo tanto, no es del todo eficiente.

     def fib(n): return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1) 

    Éste calcula X ^ n en el anillo polinomial Z [X] / (X ^ 2 - X - 1) utilizando la exponenciación mediante la cuadratura. El resultado de ese cálculo es el polinomio Fib (n) X + Fib (n-1), desde donde se puede leer el número n de Fibonacci.

    Nuevamente, esto usa operaciones aritméticas O (log n) y es muy eficiente.

     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] 

    Código canónico de Python para imprimir la secuencia de Fibonacci:

     a,b=1,1 while(True): print a, a,b=b,a+b # Could also use b=a+b;a=ba 

    Para el problema “Imprima el primer número de Fibonacci de más de 1000 dígitos”:

     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 

    usar recursion

     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) 

    Lo sabemos

    introduzca la descripción de la imagen aquí

    Y que el n-ésimo poder de esa matriz nos da:

    introduzca la descripción de la imagen aquí

    Así que podemos implementar una función que simplemente calcula la potencia de esa matriz a la potencia n-th-1.

    como todos sabemos, el poder a ^ n es igual a

    introduzca la descripción de la imagen aquí

    Entonces, al final, la función de fibonacci sería O (n) … nada realmente diferente a una implementación más fácil si no fuera por el hecho de que también sabemos que x^n * x^n = x^2n y la evaluación de x^n puede por lo tanto hacerse con complejidad O (log n)

    Aquí está mi implementación de fibonacci usando el lenguaje de progtwigció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 } 

    Esto tiene complejidad O (log n). Calculamos la potencia de Q con el exponente n-1 y luego tomamos el elemento m00 que es Fn + 1, que en el exponente de potencia n-1 es exactamente el n-ésimo número de Fibonacci que queríamos.

    Una vez que tenga la función rápida de fibonacci, puede iterar desde el número de inicio y el final hasta obtener la parte de la secuencia de Fibonacci en la que está interesado.

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

    por supuesto, primero realice algunas verificaciones de inicio y fin para asegurarse de que puedan formar un rango válido.

    Sé que la pregunta tiene 8 años, pero me divertí respondiendo de todos modos. 🙂

     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) 

    Todos estos parecen un poco más complicados de lo que necesitan ser. Mi código es muy simple y rápido:

     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 

    Otra forma de hacerlo:

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

    Asignar lista a ‘a’, asignar entero a ‘n’ Mapa y reducir son 2 de las tres funciones más poderosas en python. Aquí el mapa se usa solo para iterar ‘n-2’ veces. a [-2:] obtendrá los dos últimos elementos de una matriz. a.append (x + y) agregará los dos últimos elementos y se agregará a la matriz

    Bien … después de estar cansado de recomendar todas las respuestas extensas, ahora encuentre la forma más sencilla y sencilla a continuación para implementar Fibonacci en python. Puede mejorarlo de la forma que desee al obtener un argumento o al usuario … o cambiar los límites desde 10000. Cuando lo necesite …

     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 

    Este enfoque también funciona bien. Encuentra el análisis de ejecución a continuación

     In [10]: %timeit fibonacci 10000000 loops, best of 3: 26.3 ns per loop 

    Usando para loop e imprimir solo el resultado.

     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=ba return b 

    Resultado

     >>>fib(50) 12586269025 >>>> >>> fib(100) 354224848179261915075 >>> 

    Imprime la list contiene todos los números.

     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=ba l.append(b) return l 

    Resultado

     >>> fib(10) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 
     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)) 

    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 , 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 1346269, 2178309, 3524578, 5702887, 9227465; 14930352; , 12586269025, 20365011074, 32951280099, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 288, 31620, 36583529616, y el número de teléfono.

    tiempo de ejecución: 0.04298138618469238

    ¡Hay un método muy fácil para darse cuenta de eso!

    puede ejecutar este código en línea libremente utilizando 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] 

    Básicamente traducido de 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 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 

    La secuencia de Fibonacci es: 1, 1, 2, 3, 5, 8, ...

    Eso es f(1) = 1 , f(2) = 1 , f(3) = 2 , ... , f(n) = f(n-1) + f(n-2) .

    Mi implementación favorita (la más sencilla y, sin embargo, alcanza una velocidad de luz en comparación con otras implementaciones) es la siguiente:

     def fibonacci(n): a, b = 0, 1 for _ in range(1, n): a, b = b, a + b return b 

    Prueba

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

    Sincronización

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

    Edición: una visualización de ejemplo para estas implementaciones.

    La recursión añade tiempo. Para eliminar los bucles, primero import math . Luego usa math.sqrt y la proporción de oro en una función:

     #!/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: Números de Fibonacci en Python

    Esta es una mejora de la respuesta de Mathew Henry:

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

    el código debe imprimir b en lugar de imprimir c

    Salida: 1,1,2,3,5 ….

    Este es el más simple en python para la serie de Fibonacci, pero se ajusta [0] en la matriz de salida con append () para obtener la segunda variable de la lista de resultados que es 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) 

    SALIDA

     Fibonacci series is [0, 1, 1, 2, 3, 5, 8, 13] 

    Función optimizada de encontrar Fibonacci manteniendo una lista en la memoria

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

    Vaya a descubrir cómo convertir un problema recursivo en uno iterativo. Debería poder calcular desde allí.

    Estos podrían ser los principios que intentan que aprendas, especialmente si se trata de un curso de Algoritmos.

    Luego de 15 minutos de un tutorial que usé cuando aprendía Python, le pidió al lector que escribiera un progtwig que calcularía una secuencia de Fibonacci a partir de 3 números de entrada (primer número de Fibonacci, segundo número y número en el que detener la secuencia). El tutorial solo había cubierto las variables, if / thens, y los bucles hasta ese punto. No hay funciones todavía. Se me ocurrió el siguiente código:

     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 

    Como puede ver, es realmente ineficiente, pero SÍ funciona.

    Simplemente revisando http://projecteuler.net/problem=2 esta fue mi opinión.

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

    Esta fue una tarea de práctica que vi en la Progtwigción de Sal en Python de Khan Academy: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/exercise—write-a-fibonacci- función

    Probablemente no sea la primera persona en asignar eso como algo de trabajo por hacer. Pero es increíble descubrirlo por ti mismo. Aprendí mucho a entenderlo en realidad y fue una maravilla.

    Te recomiendo que lo averigües por ti mismo antes de intentar copiar el código de otra persona para la tarea.

    En el video de arriba, Sal, el instructor, muestra la teoría completa detrás del número de Fibonacci, y con eso en mente, debería poder averiguarlo.

    Me tomó aproximadamente 10 minutos y este es el código que hice (estoy aprendiendo Python desde hace 3 días y este es mi primer lenguaje de progtwigción para aprender). No hubiera podido escribir el código si no fuera por el video del tutorial anterior: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/comparing-iterative- y las funciones factoriales recursivas que uno da un ejemplo de Sal haciendo una ecuación factorial recursiva y le da la mentalidad para resolver este problema.

    Aquí está mi código:

     def fibonacci(num): if num <= 1: #base case return num else: return fibonacci(num-1) + fibonacci(num-2) 

    Puede ver que si el número es 1 o 0, simplemente devuelve el número.

    Encuentro esto más limpio que decir si el número es 1 devuelve 1 y si el número es 0 devuelve 0

    Tal vez esto ayude

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

    Prueba esto:

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